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
