def __init__(self, raw, request, **kw):
XsltParser.__init__(self, raw, request)
# relative path to docbook.xsl and compiled_xsl
docbook_html_directory = request.cfg.docbook_html_dir
self.db_xsl = os.path.join(docbook_html_directory, 'docbook.xsl')
self.db_compiled_xsl = os.path.join(docbook_html_directory,
'db_compiled.dat')
self.wikiParser = WikiParser(raw=self.raw,
request=self.request,
pretty_url=1)
self.key = 'docbook'
def __init__(self, formatter, request):
html4css1.Writer.__init__(self)
self.formatter = formatter
self.request = request
# Add our wiki unknown_reference_resolver to our list of functions to
# run when a target isn't found
self.unknown_reference_resolvers = [self.wiki_resolver]
# We create a new parser to process MoinMoin wiki style links in the
# reST.
self.wikiparser = WikiParser('', self.request)
self.wikiparser.formatter = self.formatter
self.wikiparser.hilite_re = None
self.nodes = []
# Make sure it's a supported docutils version.
required_version = (0, 3, 10)
current_version = tuple([int(i) for i in (docutils.__version__.split('.') + ['0', '0'])[:3]])
if current_version < required_version:
err = 'ERROR: The installed docutils version is %s;' % ('.'.join([str(i) for i in current_version]))
err += ' version %s or later is required.' % ('.'.join([str(i) for i in required_version]))
raise RuntimeError, err
def parse(self, body):
"""Parse body and return html
Create a page with body, then parse it and format using html formatter
"""
request = self.request
assert body is not None
request.reset()
page = Page(request, PAGENAME)
page.hilite_re = None
page.set_raw_body(body)
formatter = HtmlFormatter(request)
formatter.setPage(page)
page.formatter = formatter
request.formatter = formatter
parser = WikiParser(body, request, line_anchors=False)
formatter.startContent('') # needed for _include_stack init
output = request.redirectedOutput(parser.format, formatter)
formatter.endContent('')
return output
def formatMarkup(self, request, text, percent):
""" Formats the text using the wiki parser/formatter.
This raises an exception if a text needs itself to be translated,
this could possibly happen with macros.
@param request: the request object
@param text: the text to format
@param percent: True if result is used as left-side of a % operator and
thus any GENERATED % needs to be escaped as %%.
"""
logging.debug("formatting: %r" % text)
from MoinMoin.Page import Page
from MoinMoin.parser.text_moin_wiki import Parser as WikiParser
if percent:
from MoinMoin.formatter.text_html_percent import Formatter
else:
from MoinMoin.formatter.text_html import Formatter
out = StringIO()
request.redirect(out)
parser = WikiParser(text, request, line_anchors=False)
formatter = Formatter(request, terse=True)
reqformatter = None
if hasattr(request, 'formatter'):
reqformatter = request.formatter
request.formatter = formatter
p = Page(request, "$$$$i18n$$$$")
formatter.setPage(p)
parser.format(formatter)
text = out.getvalue()
if reqformatter is None:
del request.formatter
else:
request.formatter = reqformatter
request.redirect()
text = text.strip()
return text
def execute(pagename, request):
from MoinMoin import wikiutil
from MoinMoin.Page import Page
_ = request.getText
thispage = Page(request, pagename)
if request.user.valid:
username = request.user.name
else:
username = ''
if not username:
request.theme.add_msg(_('Please log in first.'), "error")
return thispage.send_page()
userhomewiki = request.cfg.user_homewiki
if userhomewiki != 'Self' and userhomewiki != request.cfg.interwikiname:
interwiki = wikiutil.getInterwikiHomePage(request, username=username)
wikitag, wikiurl, wikitail, wikitag_bad = wikiutil.resolve_interwiki(
request, *interwiki)
wikiurl = wikiutil.mapURL(request, wikiurl)
homepageurl = wikiutil.join_wiki(wikiurl, wikitail)
request.http_redirect('%s?action=MyPages' % homepageurl)
homepage = Page(request, username)
if not homepage.exists():
request.theme.add_msg(
_('Please first create a homepage before creating additional pages.'
), "error")
return homepage.send_page()
pagecontent = _("""\
You can add some additional sub pages to your already existing homepage here.
You can choose how open to other readers or writers those pages shall be,
access is controlled by group membership of the corresponding group page.
Just enter the sub page's name and click on the button to create a new page.
Before creating access protected pages, make sure the corresponding group page
exists and has the appropriate members in it. Use HomepageGroupsTemplate for creating
the group pages.
||'''Add a new personal page:'''||'''Related access control list group:'''||
||<<NewPage(HomepageReadWritePageTemplate,read-write page,%(username)s)>>||[[%(username)s/ReadWriteGroup]]||
||<<NewPage(HomepageReadPageTemplate,read-only page,%(username)s)>>||[[%(username)s/ReadGroup]]||
||<<NewPage(HomepagePrivatePageTemplate,private page,%(username)s)>>||%(username)s only||
""")
pagecontent = pagecontent % locals()
pagecontent = pagecontent.replace('\n', '\r\n')
from MoinMoin.parser.text_moin_wiki import Parser as WikiParser
# This action generate data using the user language
request.setContentLanguage(request.lang)
request.theme.send_title(_('MyPages management'), page=homepage)
parser = WikiParser(pagecontent, request)
p = Page(request, "$$$")
request.formatter.setPage(p)
parser.format(request.formatter)
# Start content - IMPORTANT - without content div, there is no direction support!
request.write(request.formatter.startContent("content"))
request.write(request.formatter.endContent())
request.theme.send_footer(homepage.page_name)
request.theme.send_closing_html()