def handle_macro(self, elem, page): logging.debug("handle_macro elem: %r" % elem) type = elem.get(moin_page.content_type) alt = elem.get(moin_page.alt) if not type: return type = Type(type) if not (type.type == 'x-moin' and type.subtype == 'macro'): logging.debug("not a macro, skipping: %r" % (type, )) return name = type.parameters['name'] context_block = elem.tag == moin_page.part args = elem[0] if len(elem) else None elem_body = context_block and moin_page.body( ) or moin_page.inline_body() elem_error = moin_page.error() try: cls = plugins.importPlugin(app.cfg, 'macros', name, function='Macro') macro = cls() ret = macro((), args, page, alt, context_block) elem_body.append(ret) except PluginMissingError: elem_error.append('<<%s>> %s' % (name, _('Error: invalid macro name.'))) except Exception as e: # 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. logging.exception("Macro {0} raised an exception:".format(name)) elem_error.append( _( '<<%(macro_name)s: execution failed [%(error_msg)s] (see also the log)>>', macro_name=name, error_msg=str(e), )) if len(elem_body): elem.append(elem_body) if len(elem_error): elem.append(elem_error)
def __call__(self, rev, contenttype=None, arguments=None): try: item_name = rev.item.name or rev.meta['name'][0] except IndexError: # item is deleted message = _( 'This deleted item must be restored before it can be viewed or downloaded, ItemID = {itemid}' ).format(itemid=rev.item.itemid) admonition = moin_page.div( attrib={moin_page.class_: 'error'}, children=[moin_page.p(children=[message])]) body = moin_page.body(children=(admonition, )) return moin_page.page(children=(body, )) attrib = { xlink.href: Iri(scheme='wiki', authority='', path='/' + item_name, query='do=get&rev={0}'.format(rev.revid)), } a = moin_page.a(attrib=attrib, children=["Download {0}.".format(item_name)]) body = moin_page.body(children=(a, )) return moin_page.page(children=(body, ))
def parse_block(self, iter_content, arguments): attrib = {} if arguments: for key, value in arguments.keyword.items(): if key in ('style', 'class', ): attrib[moin_page(key)] = value body = moin_page.body(attrib=attrib) stack = _Stack(body, iter_content=iter_content) for line in iter_content: data = dict(((str(k), v) for k, v in self.indent_re.match(line).groupdict().items() if v is not None)) self.indent_repl(iter_content, stack, line, **data) return body
def __call__(self, rev, contenttype=None, arguments=None): item_name = rev.item.fqname.fullname attrib = { xlink.href: Iri(scheme='wiki', authority='', path='/' + item_name, query='do=modify'), } a = moin_page.a(attrib=attrib, children=[ _("%(item_name)s does not exist. Create it? ", item_name=item_name) ]) body = moin_page.body(children=(a, )) return moin_page.page(children=(body, ))
def __call__(self, rev, contenttype=None, arguments=None): fqname = CompositeName(rev.meta[NAMESPACE], NAME_EXACT, rev.meta[NAME][0]) self.fullname = fqname.fullname try: contents = self.list_contents(rev.data) contents = [(self.process_size(size), self.process_datetime(dt), self.process_name(name), ) for size, dt, name in contents] table = self.build_dom_table(contents, head=[_("Size"), _("Timestamp"), _("Name")], cls='zebra') body = moin_page.body(children=(table, )) return moin_page.page(children=(body, )) except ArchiveException as err: logging.exception("An exception within archive file handling occurred:") # XXX we also use a table for error reporting, could be # something more adequate, though: return self.build_dom_table([[str(err)]])
def parse_block(self, iter_content, arguments): attrib = {} if arguments: for key, value in arguments.keyword.iteritems(): if key in ('style', ): attrib[moin_page(key)] = value body = moin_page.body(attrib=attrib) stack = _Stack(body, iter_content=iter_content) # Please note that the iterator can be modified by other functions for line in iter_content: match = self.block_re.match(line) self._apply(match, 'block', iter_content, stack) return body
def __call__(self, rev, contenttype=None, arguments=None): item_name = rev.item.name attrib = { moin_page.type_: str(self.input_type), xlink.href: Iri(scheme='wiki', authority='', path='/' + item_name, query='do=get&rev={0}'.format(rev.revid)), } obj = moin_page.object_( attrib=attrib, children=[ 'Your Browser does not support HTML5 audio/video element.', ]) body = moin_page.body(children=(obj, )) return moin_page.page(children=(body, ))
def __call__(self, data, contenttype=None, arguments=None): text = decode_data(data, contenttype) content = normalize_split_text(text) dialect = csv.Sniffer().sniff(content[0]) reader = csv.reader(content, dialect) rows = list(reader) head = None cls = None try: # fragile function, throws errors when csv file is incorrectly formatted if csv.Sniffer().has_header('\n'.join(content)): head = rows[0] rows = rows[1:] cls = 'moin-sortable' except csv.Error as e: head = [_('Error parsing CSV file:'), str(e)] table = self.build_dom_table(rows, head=head, cls=cls) body = moin_page.body(children=(table, )) return moin_page.page(children=(body, ))
def __call__(self, rev, contenttype=None, arguments=None): item_name = rev.item.fqname.fullname attrib = { moin_page.type_: str(self.input_type), xlink.href: Iri(scheme='wiki', authority='', path='/' + item_name, query='do=get&rev={0}'.format(rev.revid)), } if arguments and html.alt in arguments: attrib[html.alt] = arguments[html.alt] elif rev.meta.get(SUMMARY): attrib[html.alt] = rev.meta[SUMMARY] obj = moin_page.object_( attrib=attrib, children=[ 'Your Browser does not support HTML5 audio/video element.', ]) body = moin_page.body(children=(obj, )) return moin_page.page(children=(body, ))
def parse_block(self, iter_content, arguments): attrib = {} if arguments: for key, value in arguments.keyword.items(): if key in ('style', ): attrib[moin_page(key)] = value elif key == '_old': attrib[moin_page.class_] = value.replace('/', ' ') body = moin_page.body(attrib=attrib) stack = _Stack(body, iter_content=iter_content) for line in iter_content: match = self.indent_re.match(line) if match: data = dict(((str(k), v) for k, v in match.groupdict().items() if v is not None)) self.indent_repl(iter_content, stack, line, **data) else: self.indent_repl(iter_content, stack, line, '', line) return body
def __call__(self, data, contenttype=None, arguments=None): """ Convert markdown to moin DOM. data is a pointer to an open file (ProtectedRevision object) contenttype is likely == u'text/x-markdown;charset=utf-8' arguments is not used Markdown processing takes place in five steps: 1. A bunch of "preprocessors" munge the input text. 2. BlockParser() parses the high-level structural elements of the pre-processed text into an ElementTree. 3. A bunch of "treeprocessors" are run against the ElementTree. One such treeprocessor runs InlinePatterns against the ElementTree, detecting inline markup. 4. Some post-processors are run against the ElementTree nodes containing text and the ElementTree is converted to an EmeraldTree. 5. The root of the EmeraldTree is returned. """ # read the data from wiki storage and convert to unicode text = decode_data(data, contenttype) # Normalize whitespace for consistent parsing. - copied from NormalizeWhitespace in markdown/preprocessors.py text = text.replace(md_util.STX, "").replace(md_util.ETX, "") text = text.replace("\r\n", "\n").replace("\r", "\n") + "\n\n" text = text.expandtabs(self.markdown.tab_length) text = re.sub(r'(?<=\n) +\n', '\n', text) # save line counts for start of each block, used later for edit autoscroll self.count_lines(text) # {{{ similar to parts of Markdown 3.0.0 core.py convert method # Split into lines and run the line preprocessors. lines = text.split("\n") for prep in self.markdown.preprocessors: lines = prep.run(lines) # Parse the high-level elements. root = self.markdown.parser.parseDocument(lines).getroot() # Run the tree-processors for treeprocessor in self.markdown.treeprocessors: newRoot = treeprocessor.run(root) if newRoot is not None: root = newRoot # }}} end Markdown 3.0.0 core.py convert method add_lineno = bool(flaskg and flaskg.add_lineno_attr) # run markdown post processors and convert from ElementTree to an EmeraldTree object converted = self.do_children(root, add_lineno=add_lineno) # convert html embedded in text strings to EmeraldTree nodes self.convert_embedded_markup(converted) # convert P-tags containing block elements to DIV-tags self.convert_invalid_p_nodes(converted) body = moin_page.body(children=converted) root = moin_page.page(children=[body]) return root