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 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 _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 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 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 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 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)