def contentfilter(self, filename):
""" Get a filter for content of filename and return unicode content. """
import mimetypes
from MoinMoin import wikiutil
request = self.request
mimetype, encoding = mimetypes.guess_type(filename)
if mimetype is None:
mimetype = 'application/octet-stream'
def mt2mn(mt): # mimetype to modulename
return mt.replace("/", "_").replace("-","_").replace(".", "_")
try:
_filter = mt2mn(mimetype)
execute = wikiutil.importPlugin(request.cfg, 'filter', _filter)
except wikiutil.PluginMissingError:
try:
_filter = mt2mn(mimetype.split("/", 1)[0])
execute = wikiutil.importPlugin(request.cfg, 'filter', _filter)
except wikiutil.PluginMissingError:
try:
_filter = mt2mn('application/octet-stream')
execute = wikiutil.importPlugin(request.cfg, 'filter', _filter)
except wikiutil.PluginMissingError:
raise ImportError("Cannot load filter %s" % binaryfilter)
try:
data = execute(self, filename)
request.log("Filter %s returned %d characters for file %s" % (_filter, len(data), filename))
except (OSError, IOError), err:
data = ''
request.log("Filter %s threw error '%s' for file %s" % (_filter, str(err), filename))
def execute(self, macro_name, args):
""" Get and execute a macro
Try to get a plugin macro, or a builtin macro or a language
macro, or just raise ImportError.
"""
self.name = macro_name
try:
str(macro_name)
except UnicodeEncodeError:
_ = self._
return self.formatter.text(
_('<<%(macro_name)s: invalid macro name>>') % {
'macro_name': macro_name,
})
try:
call = wikiutil.importPlugin(self.cfg,
'macro',
macro_name,
function='macro_%s' % macro_name)
execute = lambda _self, _args: wikiutil.invoke_extension_function(
_self.request, call, _args, [_self])
except wikiutil.PluginAttributeError:
# fall back to old execute() method, no longer recommended
execute = wikiutil.importPlugin(self.cfg, 'macro', macro_name)
except wikiutil.PluginMissingError:
try:
call = getattr(self, 'macro_%s' % macro_name)
execute = lambda _self, _args: wikiutil.invoke_extension_function(
_self.request, call, _args, [])
except AttributeError:
if macro_name in i18n.wikiLanguages():
execute = self.__class__._m_lang
else:
raise ImportError("Cannot load macro %s" % macro_name)
try:
return execute(self, args)
except Exception, err:
# we do not want that a faulty macro aborts rendering of the page
# and makes the wiki UI unusable (by emitting a Server Error),
# thus, in case of exceptions, we just log the problem and return
# some standard text.
try:
page_spec = " (page: '%s')" % self.formatter.page.page_name
except:
page_spec = ""
logging.exception("Macro %s%s raised an exception:" %
(self.name, page_spec))
_ = self.request.getText
return self.formatter.text(
_('<<%(macro_name)s: execution failed [%(error_msg)s] (see also the log)>>'
) %
{
'macro_name': self.name,
'error_msg': err.args[
0], # note: str(err) or unicode(err) does not work for py2.4/5/6
})
import traceback
logging.info("Stack:\n" + traceback.format_stack())
def setProcessor(self, name):
""" Set processer to either processor or parser named 'name' """
cfg = self.request.cfg
try:
self.processor = wikiutil.importPlugin(cfg, "processor", name, "process")
self.processor_is_parser = 0
except wikiutil.PluginMissingError:
try:
self.processor = wikiutil.importPlugin(cfg, "parser", name, "Parser")
self.processor_is_parser = 1
except wikiutil.PluginMissingError:
self.processor = None
def execute(self, macro_name, args):
""" Get and execute a macro
Try to get a plugin macro, or a builtin macro or a language
macro, or just raise ImportError.
"""
self.name = macro_name
try:
str(macro_name)
except UnicodeEncodeError:
_ = self._
return self.formatter.text(_("<<%(macro_name)s: invalid macro name>>") % {"macro_name": macro_name})
try:
call = wikiutil.importPlugin(self.cfg, "macro", macro_name, function="macro_%s" % macro_name)
execute = lambda _self, _args: wikiutil.invoke_extension_function(_self.request, call, _args, [_self])
except wikiutil.PluginAttributeError:
# fall back to old execute() method, no longer recommended
execute = wikiutil.importPlugin(self.cfg, "macro", macro_name)
except wikiutil.PluginMissingError:
try:
call = getattr(self, "macro_%s" % macro_name)
execute = lambda _self, _args: wikiutil.invoke_extension_function(_self.request, call, _args, [])
except AttributeError:
if macro_name in i18n.wikiLanguages():
execute = self.__class__._m_lang
else:
raise ImportError("Cannot load macro %s" % macro_name)
try:
return execute(self, args)
except Exception, err:
# we do not want that a faulty macro aborts rendering of the page
# and makes the wiki UI unusable (by emitting a Server Error),
# thus, in case of exceptions, we just log the problem and return
# some standard text.
try:
page_spec = " (page: '%s')" % self.formatter.page.page_name
except:
page_spec = ""
logging.exception("Macro %s%s raised an exception:" % (self.name, page_spec))
_ = self.request.getText
return self.formatter.text(
_("<<%(macro_name)s: execution failed [%(error_msg)s] (see also the log)>>")
% {
"macro_name": self.name,
"error_msg": err.args[0], # note: str(err) or unicode(err) does not work for py2.4/5/6
}
)
import traceback
logging.info("Stack:\n" + traceback.format_stack())
def setProcessor(self, name):
""" Set processer to either processor or parser named 'name' """
cfg = self.request.cfg
try:
self.processor = wikiutil.importPlugin(cfg, "processor", name,
"process")
self.processor_is_parser = 0
except wikiutil.PluginMissingError:
try:
self.processor = wikiutil.importPlugin(cfg, "parser", name,
"Parser")
self.processor_is_parser = 1
except wikiutil.PluginMissingError:
self.processor = None
def execute(pagename, request):
# Strip non-ascii chars in header
pagename_header = '%s.csv' % (pagename)
pagename_header = pagename_header.encode('ascii', 'ignore')
request.content_type = 'text/csv; charset=UTF-8'
request.headers['Content-Disposition'] = \
'attachment; filename="%s"' % pagename_header
GetMeta = wikiutil.importPlugin(request.cfg, 'xmlrpc', 'GetMeta', 'do_action')
form = values_to_form(request.values)
try:
args = form['args'][0]
except (KeyError, IndexError):
args = u''
table = GetMeta(request, args, keysonly=False)
table = getmeta_to_table(table)
if 0:
print '--', table, '--'
print 'args', args
print 'pagename', pagename
writer = csv.writer(request, delimiter=';')
for row in table:
writer.writerow(map(encode_page, row))
def execute(pagename, request):
enter_page(request, pagename, "Group Editor")
macro = wikiutil.importPlugin(request.cfg, "macro", "GroupEditor", "do_macro")
request.write(macro(request))
page = Page(request, pagename)
request.write(page.link_to(request, text=request.getText("back")))
exit_page(request, pagename)
def execute(pagename, request):
# Strip non-ascii chars in header
pagename_header = '%s.csv' % (pagename)
pagename_header = pagename_header.encode('ascii', 'ignore')
request.content_type = 'text/csv; charset=UTF-8'
request.headers['Content-Disposition'] = \
'attachment; filename="%s"' % pagename_header
GetMeta = wikiutil.importPlugin(request.cfg, 'xmlrpc', 'GetMeta',
'do_action')
form = values_to_form(request.values)
try:
args = form['args'][0]
except (KeyError, IndexError):
args = u''
table = GetMeta(request, args, keysonly=False)
table = getmeta_to_table(table)
if 0:
print '--', table, '--'
print 'args', args
print 'pagename', pagename
writer = csv.writer(request, delimiter=';')
for row in table:
writer.writerow(map(encode_page, row))
def _handle_submission(request):
""" Handle GET and POST requests of preferences forms.
Return error msg_class, msg tuple or None, None.
"""
_ = request.getText
sub = request.form.get('handler', [None])[0]
if sub in request.cfg.userprefs_disabled:
return None, None
try:
cls = wikiutil.importPlugin(request.cfg, 'userprefs', sub, 'Settings')
except wikiutil.PluginMissingError:
# we never show this plugin to click on so no need to
# give a message here
return None, None
obj = cls(request)
if not obj.allowed():
return None, None
res = obj.handle_form()
if isinstance(res, tuple):
return res
# backward compatibility for userprefs plugins,
# they just get 'dialog'-style messages.
return None, res
def execute(pagename, request):
macro_action = wikiutil.importPlugin(request.cfg, "macro", pagename, "action_" + pagename)
result = macro_action(request)
request.write(result)
request.close()
def _handle_submission(request):
""" Handle GET and POST requests of preferences forms.
Return error msg_class, msg tuple or None, None.
"""
_ = request.getText
sub = request.values.get('handler')
if sub in request.cfg.userprefs_disabled:
return None, None
try:
cls = wikiutil.importPlugin(request.cfg, 'userprefs', sub, 'Settings')
except wikiutil.PluginMissingError:
# we never show this plugin to click on so no need to
# give a message here
return None, None
obj = cls(request)
if not obj.allowed():
return None, None
res = obj.handle_form()
if isinstance(res, tuple):
return res
# backward compatibility for userprefs plugins,
# they just get 'dialog'-style messages.
return None, res
def get_dependencies(self, macro_name):
if macro_name in self.Dependencies:
return self.Dependencies[macro_name]
try:
return wikiutil.importPlugin(self.request.cfg, "macro", macro_name, "Dependencies")
except wikiutil.PluginError:
return self.defaultDependency
def send_page_content(self, request, notparser, body, format_args='',
do_cache=0, **kw):
self.parser = importPlugin(request.cfg, "parser",
'link_collect', "Parser")
kw['format_args'] = format_args
kw['do_cache'] = 0
apply(Page.send_page_content, (self, request, self.parser, body), kw)
def get_dependencies(self, macro_name):
if macro_name in self.Dependencies:
return self.Dependencies[macro_name]
try:
return wikiutil.importPlugin(self.request.cfg, 'macro', macro_name,
'Dependencies')
except wikiutil.PluginError:
return self.defaultDependency
def execute(pagename, request):
enter_page(request, pagename, "Group Editor")
macro = wikiutil.importPlugin(request.cfg, "macro", "GroupEditor",
"do_macro")
request.write(macro(request))
page = Page(request, pagename)
request.write(page.link_to(request, text=request.getText("back")))
exit_page(request, pagename)
def format(self, formatter):
if len(self.args) <= 0:
from MoinMoin.wikiutil import importPlugin
sqlparser = importPlugin(self.request.cfg, 'parser', 'sql', 'Parser')
sqlparser(self.query, self.request).format(formatter)
else:
try:
self.validate()
self.__run_n_format(formatter)
except Exception as inst:
from MoinMoin.wikiutil import importPlugin
sqlparser = importPlugin(self.request.cfg, 'parser', 'sql', 'Parser')
sqlparser(self.query, self.request).format(formatter)
self.request.write(u'<pre>%s</pre>' % str(inst))
import traceback, sys
traceback.print_exc(file=sys.stdout)
def createParser(self, format, text):
if format == "wiki":
format = "text_moin_wiki"
try:
Parser = wikiutil.importPlugin(self.request.cfg, "parser", format, "Parser")
except wikiutil.PluginMissingError:
from MoinMoin.parser.text import Parser
parser = Parser(text, self.request)
return parser
def get_dependencies(self, macro_name):
if self.Dependencies.has_key(macro_name):
return self.Dependencies[macro_name]
result = wikiutil.importPlugin(self.request.cfg, 'macro', macro_name,
'Dependencies')
if result != None:
return result
else:
return ["time"]
def processor(self, processor_name, lines, is_parser=0):
""" processor_name MUST be valid!
writes out the result instead of returning it!
"""
if not is_parser:
processor = wikiutil.importPlugin(self.request.cfg, "processor",
processor_name, "process")
processor(self.request, self, lines)
else:
parser = wikiutil.importPlugin(self.request.cfg, "parser",
processor_name, "Parser")
args = self._get_bang_args(lines[0])
if args is not None:
lines = lines[1:]
p = parser('\n'.join(lines), self.request, format_args=args)
p.format(self)
del p
return ''
def createFormatter(self, format):
try:
Formatter = wikiutil.importPlugin(self.request.cfg, "formatter", format, "Formatter")
except wikiutil.PluginMissingError:
from MoinMoin.formatter.text_plain import Formatter
formatter = Formatter(self.request)
self.request.formatter = formatter
formatter.page = self.page
return formatter
def testSyntaxReferenceDomXml(self):
f_name = 'dom_xml'
try:
formatter = wikiutil.importPlugin(self.request.cfg, "formatter", f_name, "Formatter")
except wikiutil.PluginAttributeError:
pass
else:
print "Formatting using %r" % formatter
self.formatPage("SyntaxReference", formatter)
print "Done."
def createParser(self, format, text):
if format == "wiki":
format = 'text_moin_wiki'
try:
Parser = wikiutil.importPlugin(self.request.cfg, 'parser', format,
'Parser')
except wikiutil.PluginMissingError:
from MoinMoin.parser.text import Parser
parser = Parser(text, self.request)
return parser
def macro(self, macro_obj, name, args, markup=None):
try:
# plugins that are defined in the macro class itself
# can't generate headings this way, but that's fine
gen_headings = wikiutil.importPlugin(self.request.cfg, 'macro',
name, 'generates_headings')
return FormatterBase.macro(self, macro_obj, name, args, markup)
except (wikiutil.PluginMissingError, wikiutil.PluginAttributeError):
pass
return ''
def attachment_drawing(self, url, text, **kw):
# Todo get it to start the drawing editor on a click
try:
drawing_action = AttachFile.get_action(self.request, url, do='modify')
assert drawing_action is not None
attachment_drawing = wikiutil.importPlugin(self.request.cfg, 'action',
drawing_action, 'gedit_drawing')
return attachment_drawing(self, url, text, **kw)
except (wikiutil.PluginMissingError, wikiutil.PluginAttributeError, AssertionError):
return url
def importPlugin(cfg, kind, name, function="execute"):
""" Import plugin supporting both new and old error handling
To port old plugins to new moin releases, copy this into your plugin
and use it instead of wikiutil.importPlugin. Your code would run on
both 1.3 and later.
"""
if hasattr(wikiutil, 'PluginMissingError'):
# New error handling: missing plugins ignored, other errors in
# plugin code will be raised.
try:
Plugin = wikiutil.importPlugin(cfg, kind, name, function)
except wikiutil.PluginMissingError:
Plugin = None
else:
# Old error handling: most errors in plugin code will be hidden.
Plugin = wikiutil.importPlugin(cfg, kind, name, function)
return Plugin
def macro(self, macro_obj, name, args, markup=None):
try:
# plugins that are defined in the macro class itself
# can't generate headings this way, but that's fine
gen_headings = wikiutil.importPlugin(self.request.cfg, 'macro',
name, 'generates_headings')
return FormatterBase.macro(self, macro_obj, name, args, markup)
except (wikiutil.PluginMissingError, wikiutil.PluginAttributeError):
pass
return ''
def getHandler(request, action, identifier="execute"):
# check for excluded actions
if action in request.cfg.excluded_actions:
return None
handler = wikiutil.importPlugin(request.cfg, "action", action, identifier)
if handler is None:
handler = globals().get('do_' + action)
return handler
def attachment_drawing(self, url, text, **kw):
# Todo get it to start the drawing editor on a click
try:
drawing_action = AttachFile.get_action(self.request, url, do='modify')
assert drawing_action is not None
attachment_drawing = wikiutil.importPlugin(self.request.cfg, 'action',
drawing_action, 'gedit_drawing')
return attachment_drawing(self, url, text, **kw)
except (wikiutil.PluginMissingError, wikiutil.PluginAttributeError, AssertionError):
return url
def execute(macro, args):
formatter = macro.formatter
macro.request.page.formatter = formatter
request = macro.request
_ = request.getText
# Import the plugin action to print out the graph html form
graphshower = wikiutil.importPlugin(request.cfg, 'action', 'ShowGraph',
'execute')
if not args:
return ""
uri, args = uri_params(args.strip())
if not args:
return ""
# Legacy fix
args['action'] = ['ShowGraph']
pagename = uri
# Check out if the start page exists, if not, we'll just bail out
if not request.user.may.read(pagename):
return _("InlineGraph: User may not read page %s" %
form_escape(pagename))
old_page = request.page
old_values = request.values
old_url = getattr(request, 'url', '')
request.page = Page(request, pagename)
request.formatter.page = request.page
request.values = CombinedMultiDict([MultiDict(args)])
req_url = url_construct(request, args, pagename)
urladd = '?' + req_url.split('?')[1]
request.url = req_url
request.write(u'<div class="inlinegraph">')
graphshower(request.page.page_name,
request,
urladd=urladd,
app_page=request.page.page_name,
inline=1)
request.page = old_page
request.formatter.page = old_page
request.values = old_values
del request.url
if old_url:
request.url = old_url
return u'<a href="%s" class="graph-link">[%s]</a>\n' % \
(req_url, _('examine')) + u'</div>'
def testSyntaxReferenceDomXml(self):
py.test.skip("domxml <p> generation is broken")
f_name = 'dom_xml'
try:
formatter = wikiutil.importPlugin(self.request.cfg, "formatter", f_name, "Formatter")
except wikiutil.PluginAttributeError:
pass
else:
print "Formatting using %r" % formatter
self.formatPage("HelpOnMoinWikiSyntax", formatter)
print "Done."
def testSyntaxReferenceDocBook(self):
py.test.skip("docbook is broken")
f_name = 'text_docbook'
try:
formatter = wikiutil.importPlugin(self.request.cfg, "formatter", f_name, "Formatter")
except wikiutil.PluginAttributeError:
pass
else:
print "Formatting using %r" % formatter
self.formatPage("HelpOnMoinWikiSyntax", formatter)
print "Done."
def createFormatter(self, format):
try:
Formatter = wikiutil.importPlugin(self.request.cfg, 'formatter',
format, 'Formatter')
except wikiutil.PluginMissingError:
from MoinMoin.formatter.text_plain import Formatter
formatter = Formatter(self.request)
self.request.formatter = formatter
formatter.page = self.page
return formatter
def processor(self, processor_name, lines, is_parser = 0):
""" processor_name MUST be valid!
prints out the result insted of returning it!
"""
if not is_parser:
Dependencies = wikiutil.importPlugin(self.request.cfg, "processor",
processor_name, "Dependencies")
else:
Dependencies = wikiutil.importPlugin(self.request.cfg, "parser",
processor_name, "Dependencies")
if Dependencies == None:
Dependencies = ["time"]
if self.__is_static(Dependencies):
return self.formatter.processor(processor_name, lines, is_parser)
else:
return self.__insert_code('%s%s.processor(%r, %r, %r)' %
(self.__adjust_formatter_state(),
self.__formatter,
processor_name, lines, is_parser))
def getHandler(request, action, identifier="execute"):
""" return a handler function for a given action or None """
# check for excluded actions
if action in request.cfg.actions_excluded:
return None
try:
handler = wikiutil.importPlugin(request.cfg, "action", action, identifier)
except wikiutil.PluginMissingError:
handler = globals().get('do_' + action)
return handler
def testSyntaxReferenceDomXml(self):
py.test.skip("domxml <p> generation is broken")
f_name = 'dom_xml'
try:
formatter = wikiutil.importPlugin(self.request.cfg, "formatter",
f_name, "Formatter")
except wikiutil.PluginAttributeError:
pass
else:
print "Formatting using %r" % formatter
self.formatPage("HelpOnMoinWikiSyntax", formatter)
print "Done."
def execute(macro, args):
formatter = macro.formatter
macro.request.page.formatter = formatter
request = macro.request
_ = request.getText
# Import the plugin action to print out the graph html form
graphshower = wikiutil.importPlugin(request.cfg,
'action', 'ShowGraph',
'execute')
if not args:
return ""
uri, args = uri_params(args.strip())
if not args:
return ""
# Legacy fix
args['action'] = ['ShowGraph']
pagename = uri
# Check out if the start page exists, if not, we'll just bail out
if not request.user.may.read(pagename):
return _("InlineGraph: User may not read page %s" %
form_escape(pagename))
old_page = request.page
old_values = request.values
old_url = getattr(request, 'url', '')
request.page = Page(request, pagename)
request.formatter.page = request.page
request.values = CombinedMultiDict([MultiDict(args)])
req_url = url_construct(request, args, pagename)
urladd = '?' + req_url.split('?')[1]
request.url = req_url
request.write(u'<div class="inlinegraph">')
graphshower(request.page.page_name, request,
urladd=urladd, app_page=request.page.page_name, inline=1)
request.page = old_page
request.formatter.page = old_page
request.values = old_values
del request.url
if old_url:
request.url = old_url
return u'<a href="%s" class="graph-link">[%s]</a>\n' % \
(req_url, _('examine')) + u'</div>'
def testSyntaxReferenceDocBook(self):
py.test.skip("docbook is broken")
f_name = 'text_docbook'
try:
formatter = wikiutil.importPlugin(self.request.cfg, "formatter",
f_name, "Formatter")
except wikiutil.PluginAttributeError:
pass
else:
print "Formatting using %r" % formatter
self.formatPage("HelpOnMoinWikiSyntax", formatter)
print "Done."
def execute(macro, args):
formatter = macro.formatter
macro.request.page.formatter = formatter
request = macro.request
_ = request.getText
# Import the plugin action to print out the graph html form
dotviewer = wikiutil.importPlugin(request.cfg,
'action', 'ViewDot',
'execute')
arglist = [x.strip() for x in args.split(',') if x]
kw = {}
for arg in arglist:
data = arg.split('=')
key = data[0]
val = '='.join(data[1:])
if key in ['height', 'width']:
kw[str(key)] = str(val)
if not arglist:
return ""
uri, args = uri_params(arglist[0])
if not args:
return ""
pagename = url_unquote(uri)
old_page = request.page
old_values = request.values
old_url = getattr(request, 'url', '')
request.page = Page(request, pagename)
req_url = url_construct(request, args, pagename)
request.values = CombinedMultiDict([MultiDict(args)])
request.url = req_url
request.write(u'<div class="viewdot">')
dotviewer(pagename, request, **kw)
request.page = old_page
request.values = old_values
del request.url
if old_url:
request.url = old_url
return '<a href="%s&view=View" class="graph-link">[%s]</a>\n</div>' % \
(req_url, _('View'))
def execute(pagename, request):
request.content_type = "application/json"
form = values_to_form(request.values)
args = form.get('args', [None])[0]
if not args:
args = pagename
handle = form.get('handle', [None])[0]
if handle:
handle = str(handle)
getvalues = form.get('getvalues', [None])[0]
if getvalues:
args = "%s=/.+/" % getvalues
inc_get_metas = wikiutil.importPlugin(request.cfg, "xmlrpc", "IncGetMeta",
"inc_get_metas")
out = inc_get_metas(request, args, handle)
if getvalues:
changed = out[2][1]
filtered = dict()
for page, metas in changed.items():
for key, vals in metas.items():
if key == getvalues:
filtered[page] = {key: vals}
out[2] = (out[2][0], filtered)
if form.get('formatted', [None])[0]:
formatted = dict()
for page, metas in out[2][1].items():
vals = list()
for key, values in metas.items():
vals.append(key)
vals.extend(values[1])
request.page = Page(request, page)
for val in vals:
f = format_wikitext(request, val)
if val != f:
formatted[val] = f
out.append(formatted)
json.dump(out, request, indent=2)
def _processor_repl(self, word):
"""Handle processed code displays."""
if word[:3] == '{{{': word = word[3:]
self.processor = None
self.processor_name = None
self.processor_is_parser = 0
s_word = word.strip()
if s_word == '#!':
# empty bang paths lead to a normal code display
# can be used to escape real, non-empty bang paths
word = ''
self.in_pre = 3
return self._closeP() + self.formatter.preformatted(1)
elif s_word[:2] == '#!':
# first try to find a processor for this (will go away in 1.4)
processor_name = s_word[2:].split()[0]
self.processor = wikiutil.importPlugin(
self.request.cfg, "processor", processor_name, "process")
# now look for a parser with that name
if self.processor is None:
self.processor = wikiutil.importPlugin(
self.request.cfg, "parser", processor_name, "Parser")
if self.processor:
self.processor_is_parser = 1
if self.processor:
self.processor_name = processor_name
self.in_pre = 2
self.colorize_lines = [word]
return ''
elif s_word:
self.in_pre = 3
return self._closeP() + self.formatter.preformatted(1) + \
self.formatter.text(s_word + ' (-)')
else:
self.in_pre = 1
return ''
def getHandler(request, action, identifier="execute"):
# check for excluded actions
if action in request.cfg.actions_excluded:
return None
from MoinMoin.formatter.text_html import Formatter
request.formatter = Formatter(request)
try:
handler = wikiutil.importPlugin(request.cfg, "action", action,
identifier)
except wikiutil.PluginMissingError:
handler = globals().get('do_' + action)
return handler
def execute(self, macro_name, args):
""" Get and execute a macro
Try to get a plugin macro, or a builtin macro or a language
macro, or just raise ImportError.
"""
self.name = macro_name
try:
call = wikiutil.importPlugin(self.cfg, 'macro', macro_name,
function='macro_%s' % macro_name)
execute = lambda _self, _args: _self._wrap(call, _args, [self])
except wikiutil.PluginAttributeError:
# fall back to old execute() method, no longer recommended
execute = wikiutil.importPlugin(self.cfg, 'macro', macro_name)
except wikiutil.PluginMissingError:
try:
call = getattr(self, 'macro_%s' % macro_name)
execute = lambda _self, _args: _self._wrap(call, _args)
except AttributeError:
if macro_name in i18n.wikiLanguages():
execute = self.__class__._m_lang
else:
raise ImportError("Cannot load macro %s" % macro_name)
return execute(self, args)
def execute(self, macro_name, args):
macro = wikiutil.importPlugin(self.request.cfg, 'macro', macro_name)
if macro:
return macro(self, args)
builtins = vars(self.__class__)
# builtin macro
if builtins.has_key('_macro_' + macro_name):
return builtins['_macro_' + macro_name](self, args)
# language pseudo macro
if i18n.languages.has_key(macro_name):
return self._m_lang(macro_name, args)
raise ImportError("Cannot load macro %s" % macro_name)
def createSlideParser(self):
""" Import plugin and return parser class
If plugin is not found, and format is not defaultFormat, raise an error.
For defaultFormat, use builtin defaultParser in this module.
"""
format = self.pi['format']
plugin = 'slideshow_' + format
try:
Parser = wikiutil.importPlugin(self.request.cfg, 'parser', plugin,
'SlideParser')
except wikiutil.PluginMissingError:
if format != self.defaultFormat:
raise Error('SlideShow does not support %s format.' % format)
Parser = self.defaultParser
return Parser()
def getHandler(request, action, identifier="execute"):
""" return a handler function for a given action or None.
TODO: remove request dependency
"""
cfg = request.cfg
# check for excluded actions
if action in cfg.actions_excluded:
return None
try:
handler = wikiutil.importPlugin(cfg, "action", action, identifier)
except wikiutil.PluginMissingError:
handler = globals().get('do_' + action)
return handler
def execute(pagename, request):
silent = False
form = values_to_form(request.values)
if "gwikisilent" in form:
silent = True
editlink = True
if "noeditlink" in form:
editlink = False
args = form.get('args', [""])[0]
macro = wikiutil.importPlugin(request.cfg, "macro", "MetaTable",
"do_macro")
request.write(macro(request, args, silent=silent, editlink=editlink))
def get_revisions(request, page, checkAccess=True):
pagename = page.page_name
if checkAccess and not request.user.may.read(pagename):
return [], []
parse_text = importPlugin(request.cfg, 'action', 'savegraphdata',
'parse_text')
alldata = dict()
revisions = dict()
for rev in page.getRevList():
revlink = '%s-gwikirevision-%d' % (pagename, rev)
# Data about revisions is now cached to the graphdata
# at the same time this is used.
if request.graphdata.has_key(revlink):
revisions[rev] = revlink
continue
# If not cached, parse the text for the page
revpage = Page(request, pagename, rev=rev)
text = revpage.get_raw_body()
alldata = parse_text(request, revpage, text)
if alldata.has_key(pagename):
alldata[pagename].setdefault('meta',
dict())[u'gwikirevision'] = \
[unicode(rev)]
# Do the cache.
request.graphdata.cacheset(revlink, alldata[pagename])
# Add revision as meta so that it is shown in the table
revisions[rev] = revlink
pagelist = [
revisions[x]
for x in sorted(revisions.keys(), key=ordervalue, reverse=True)
]
metakeys = set()
for page in pagelist:
for key in request.graphdata.get_metakeys(page):
metakeys.add(key)
metakeys = sorted(metakeys, key=ordervalue)
return pagelist, metakeys
def test_sanitize_to_id_idempotent(self):
def _verify(formatter, id):
origid = formatter.sanitize_to_id(id)
id = origid
for i in xrange(3):
id = formatter.sanitize_to_id(id)
assert id == origid
formatters = wikiutil.getPlugins("formatter", self.request.cfg)
try:
from xml.dom import getDOMImplementation
dom = getDOMImplementation("4DOM")
except ImportError:
# if we don't have 4suite installed, the docbook formatter would just raise an exception
formatters.remove('text_docbook')
testids = [
r"tho/zeequeen&angu\za",
r"quuirahz\iphohsaij,i",
r"ashuifa+it[ohchieque",
r"ohyie-lakoo`duaghaib",
r"eixaepumuqu[ie\ba|eh",
r"theegieque;zahmeitie",
r"pahcooje&rahkeiz$oez",
r"ohjeeng*iequao%fai?p",
r"ahfoodahmepooquepee;",
r"ubed_aex;ohwebeixah%",
r"eitiekicaejuelae=g^u",
r"",
r' ',
r'--123',
r'__$$',
r'@@',
u'\xf6\xf6llasdf\xe4',
]
for f_name in formatters:
try:
formatter = wikiutil.importPlugin(self.request.cfg,
"formatter", f_name,
"Formatter")
f = formatter(self.request)
for id in testids:
yield _verify, f, id
except wikiutil.PluginAttributeError:
pass
def doit(request, pagename, indata):
template = indata.get('template')
createpage = indata.get('createpage')
action = indata.get('action', 'add')
inmetas = indata.get('metas')
category_edit = inmetas.get('category_edit', 'add')
catlist = inmetas.get('catlist', [])
do_action = wikiutil.importPlugin(request.cfg, "xmlrpc", "SetMeta",
"do_action")
try:
return do_action(request, pagename, inmetas, action, createpage,
category_edit, catlist, template)
except ValueError, e:
if len(tuple(e)) > 1 and type(e[0]) == int:
sendfault(request, e[0], e[1])
else:
raise ValueError(e)
def testSyntaxReferenceOthers(self):
formatters = wikiutil.getPlugins("formatter", self.request.cfg)
# we have separate tests for those:
formatters.remove('text_docbook')
formatters.remove('dom_xml')
for f_name in formatters:
try:
formatter = wikiutil.importPlugin(self.request.cfg,
"formatter", f_name,
"Formatter")
except wikiutil.PluginAttributeError:
pass
else:
print "Formatting using %r" % formatter
self.formatPage("HelpOnMoinWikiSyntax", formatter)
print "Done."
def _create_prefs_page(request, sel=None):
_ = request.getText
plugins = wikiutil.getPlugins('userprefs', request.cfg)
ret = html.P()
ret.append(html.Text(_("Please choose:")))
ret.append(html.BR())
items = html.UL()
ret.append(items)
for sub in plugins:
if sub in request.cfg.userprefs_disabled:
continue
cls = wikiutil.importPlugin(request.cfg, 'userprefs', sub, 'Settings')
obj = cls(request)
if not obj.allowed():
continue
url = request.page.url(request, {'action': 'userprefs', 'sub': sub})
lnk = html.LI().append(html.A(href=url).append(html.Text(obj.title)))
items.append(lnk)
return unicode(ret)
def execute(pagename, request):
request.content_type = "application/json"
form = values_to_form(request.values)
args = form.get('args', [None])[0]
key = form.get('getvalues', [None])[0]
formatted = form.get('formatted', [None])[0]
do_action = wikiutil.importPlugin(request.cfg, "xmlrpc", "GetMetaStruct",
"do_action")
if not args:
if key:
results = do_action(request, "%s=/.+/" % key)
metas = dict()
for page in results:
values = results[page].get(key, [])
if values:
metas.setdefault(page, list())
metas[page].extend(values)
else:
metas = do_action(request, pagename)
else:
metas = do_action(request, args)
if formatted:
formatted = {}
values = []
for page, vals in metas.items():
values.extend(vals.keys())
for val in vals.values():
values.extend(val)
for value in values:
f = format_wikitext(request, value)
if f != value and value not in formatted:
formatted[value] = f
metas = {'metas': metas, 'formatted': formatted}
json.dump(metas, request, indent=2)
def testSyntaxReferenceDocBook(self):
py.test.skip("docbook is broken")
try:
from xml.dom import getDOMImplementation
dom = getDOMImplementation("4DOM")
except ImportError:
# if we don't have 4suite installed, the docbook formatter would just raise an exception
py.test.skip(
"not testing docbook formatter because no 4suite installed")
else:
f_name = 'text_docbook'
try:
formatter = wikiutil.importPlugin(self.request.cfg,
"formatter", f_name,
"Formatter")
except wikiutil.PluginAttributeError:
pass
else:
print "Formatting using %r" % formatter
self.formatPage("HelpOnMoinWikiSyntax", formatter)
print "Done."
def dispatch(self, method, params):
"""
call dispatcher - for method==xxx it either locates a method called
xmlrpc_xxx or loads a plugin from plugin/xmlrpc/xxx.py
"""
method = method.replace(".", "_")
try:
fn = getattr(self, 'xmlrpc_' + method)
except AttributeError:
try:
fn = wikiutil.importPlugin(self.request.cfg, 'xmlrpc', method,
'execute')
except wikiutil.PluginMissingError:
response = xmlrpclib.Fault(1, "No such method: %s." % method)
else:
response = fn(self, *params)
else:
response = fn(*params)
return response
def get_handlers(cfg):
"""Create a list of available event handlers.
Each handler is a handle() function defined in a plugin,
pretty much like in case of actions.
TODO: maybe make it less dumb? ;-)
"""
event_handlers = []
names = wikiutil.getPlugins("events", cfg)
for name in names:
try:
handler = wikiutil.importPlugin(cfg, "events", name, "handle")
except PluginAttributeError:
handler = None
if handler is not None:
event_handlers.append(handler)
return event_handlers
def contentfilter(self, filename):
""" Get a filter for content of filename and return unicode content.
@param filename: name of the file
"""
request = self.request
mt = wikiutil.MimeType(filename=filename)
for modulename in mt.module_name():
try:
execute = wikiutil.importPlugin(request.cfg, 'filter', modulename)
break
except wikiutil.PluginMissingError:
pass
else:
logging.info("Cannot load filter for mimetype %s" % modulename)
try:
data = execute(self, filename)
logging.debug("Filter %s returned %d characters for file %s" % (modulename, len(data), filename))
except (OSError, IOError), err:
data = ''
logging.exception("Filter %s threw error '%s' for file %s" % (modulename, str(err), filename))
def renderInPage(self):
# return immediately if getting links for the current page
if self.macro.request.mode_getpagelinks:
return ''
if self.text is None: # macro call without parameters
return ''
# get an exception? for moin before 1.3.2 use the following line instead:
# L = wikiutil.importPlugin('parser', 'latex', 'Parser', self.macro.cfg.data_dir)
L = wikiutil.importPlugin(self.macro.cfg, 'parser', 'latex', 'Parser')
if L is None:
return self.formatter.text("<<please install the latex parser>>")
l = L('', self.macro.request)
tmp = splitre.split(self.text, 1)
if len(tmp) == 3:
prologue, p2, tex = tmp
prologue += p2
else:
prologue = ''
tex = tmp[0]
return l.get(self.formatter, tex, prologue)
