def inline_link_repl(self, stack, link, link_url=None, link_item=None, link_text=None,
link_interwiki_site=None, link_interwiki_item=None):
"""Handle all kinds of links."""
if link_interwiki_site:
if is_known_wiki(link_interwiki_site):
link = Iri(scheme='wiki',
authority=link_interwiki_site,
path='/' + link_interwiki_item)
element = moin_page.a(attrib={xlink.href: link})
stack.push(element)
if link_text:
self.parse_inline(link_text, stack, self.inlinedesc_re)
else:
stack.top_append(link_interwiki_item)
stack.pop()
return
else:
# assume local language uses ":" inside of words, set link_item and continue
link_item = '{0}:{1}'.format(link_interwiki_site, link_interwiki_item)
if link_item is not None:
att = 'attachment:' # moin 1.9 needed this for an attached file
if link_item.startswith(att):
link_item = '/' + link_item[len(att):] # now we have a subitem
target = unicode(Iri(scheme='wiki.local', path=link_item))
text = link_item
else:
target = link_url
text = link_url
element = moin_page.a(attrib={xlink.href: target})
stack.push(element)
if link_text:
self.parse_inline(link_text, stack, self.inlinedesc_re)
else:
stack.top_append(text)
stack.pop()
def inline_link_repl(self, stack, link, link_url=None, link_item=None,
link_text=None, link_args=None,
link_interwiki_site=None, link_interwiki_item=None):
"""Handle all kinds of links."""
if link_interwiki_site:
if is_known_wiki(link_interwiki_site):
link = Iri(scheme='wiki',
authority=link_interwiki_site,
path='/' + link_interwiki_item)
element = moin_page.a(attrib={xlink.href: link})
stack.push(element)
if link_text:
self.parse_inline(link_text, stack, self.inlinedesc_re)
else:
stack.top_append(link_interwiki_item)
stack.pop()
return
else:
# assume local language uses ":" inside of words, set link_item and continue
link_item = '{0}:{1}'.format(link_interwiki_site, link_interwiki_item)
if link_args:
link_args = parse_arguments(link_args) # XXX needs different parsing
query = url_encode(link_args.keyword, charset=CHARSET, encode_keys=True)
else:
query = None
if link_item is not None:
att = 'attachment:' # moin 1.9 needed this for an attached file
if link_item.startswith(att):
link_item = '/' + link_item[len(att):] # now we have a subitem
if '#' in link_item:
path, fragment = link_item.rsplit('#', 1)
if link_item.startswith('#') and '/+convert/' in request.url:
# avoid traceback in link.py when converting moinwiki item to ReST | HTML | Docbook
path = request.url.split('+convert/')[-1]
else:
path, fragment = link_item, None
target = Iri(scheme='wiki.local', path=path, query=query, fragment=fragment)
text = link_item
else:
target = Iri(link_url)
text = link_url
element = moin_page.a(attrib={xlink.href: target})
stack.push(element)
if link_text:
self.parse_inline(link_text, stack, self.inlinedesc_re)
else:
stack.top_append(text)
stack.pop()
def visit_reference(self, node):
refuri = node.get('refuri', u'')
if refuri.startswith(u'<<') and refuri.endswith(u'>>'): # moin macro
macro_name = refuri[2:-2].split(u'(')[0]
if macro_name == u"TableOfContents":
arguments = refuri[2:-2].split(u'(')[1][:-1].split(u',')
node = moin_page.table_of_content()
self.open_moin_page_node(node)
if arguments and arguments[0]:
node.set(moin_page.outline_level, arguments[0])
return
arguments = refuri[2:-2].split(u'(')[1][:-1].split(u',')
self.open_moin_page_node(
moin_page.part(
attrib={moin_page.content_type: "x-moin/macro;name={0}".format(macro_name)}))
if arguments:
self.open_moin_page_node(moin_page.arguments())
for i in arguments:
self.open_moin_page_node(moin_page.argument(children=[i]))
self.close_moin_page_node()
self.close_moin_page_node()
self.open_moin_page_node(refuri)
self.close_moin_page_node()
return
if not allowed_uri_scheme(refuri):
return
self.open_moin_page_node(moin_page.a(attrib={xlink.href: refuri}))
def process_name(self, member_name):
name = unicode(member_name, 'utf-8')
attrib = {
xlink.href: Iri(scheme='wiki', authority='', path='/' + self.item_name,
query=u'do=get&member={0}'.format(name)),
}
return moin_page.a(attrib=attrib, children=[name, ])
def macro(self, content, arguments, page_url, alternative):
# TODO new arg parsing is not compatible, splits at blanks
try:
email = arguments[0]
except IndexError:
raise ValueError("You need to give an (obfuscated) email address")
try:
text = arguments[1]
except IndexError:
text = u''
from MoinMoin.mail.sendmail import decodeSpamSafeEmail
if flaskg.user.valid:
# decode address and generate mailto: link
email = decodeSpamSafeEmail(email)
result = moin_page.a(attrib={xlink.href: u'mailto:{0}'.format(email)}, children=[text or email])
else:
# unknown user, maybe even a spambot, so just return text as given in macro args
if text:
text += " "
result = moin_page.code(children=[text, "<{0}>".format(email)])
return result
def macro(self, content, arguments, page_url, alternative):
"""
Invocation: <<MailTo(user AT example DOT org, write me)>>
where 2nd parameter is optional.
"""
if arguments:
arguments = arguments[0].split(',')
try:
assert len(arguments) > 0 and len(arguments) < 3
email = arguments[0]
assert len(email) >= 5
except (AttributeError, AssertionError):
raise ValueError(
_("MailTo: invalid format, try: <<MailTo(user AT example DOT org, write me)>>"
))
try:
text = arguments[1]
except IndexError:
text = u''
if flaskg.user.valid:
# decode address and generate mailto: link
email = decodeSpamSafeEmail(email)
result = moin_page.a(
attrib={xlink.href: u'mailto:{0}'.format(email)},
children=[text or email])
else:
# unknown user, maybe even a spambot, so just return text as given in macro args
if text:
text += " "
result = moin_page.code(children=[text, "<{0}>".format(email)])
return result
def visit_reference(self, node):
refuri = node.get('refuri', u'')
if refuri.startswith(u'<<') and refuri.endswith(u'>>'): # moin macro
macro_name = refuri[2:-2].split(u'(')[0]
if macro_name == u"TableOfContents":
arguments = refuri[2:-2].split(u'(')[1][:-1].split(u',')
node = moin_page.table_of_content()
self.open_moin_page_node(node)
if arguments and arguments[0]:
node.set(moin_page.outline_level, arguments[0])
return
arguments = refuri[2:-2].split(u'(')[1][:-1].split(u',')
self.open_moin_page_node(
moin_page.part(
attrib={
moin_page.content_type:\
"x-moin/macro;name=%s" % macro_name, }))
if arguments:
self.open_moin_page_node(moin_page.arguments())
for i in arguments:
self.open_moin_page_node(moin_page.argument(children=[i]))
self.close_moin_page_node()
self.close_moin_page_node()
self.open_moin_page_node(refuri)
self.close_moin_page_node()
return
self.open_moin_page_node(moin_page.a(attrib={xlink.href: refuri}))
def inline_link_repl(self,
stack,
link,
link_url=None,
link_item=None,
link_text=None,
link_interwiki_site=None,
link_interwiki_item=None):
"""Handle all kinds of links."""
if link_interwiki_site:
if is_known_wiki(link_interwiki_site):
link = Iri(scheme='wiki',
authority=link_interwiki_site,
path='/' + link_interwiki_item)
element = moin_page.a(attrib={xlink.href: link})
stack.push(element)
if link_text:
self.parse_inline(link_text, stack, self.inlinedesc_re)
else:
stack.top_append(link_interwiki_item)
stack.pop()
return
else:
# assume local language uses ":" inside of words, set link_item and continue
link_item = '{0}:{1}'.format(link_interwiki_site,
link_interwiki_item)
if link_item is not None:
att = 'attachment:' # moin 1.9 needed this for an attached file
if link_item.startswith(att):
link_item = '/' + link_item[len(att):] # now we have a subitem
# we have Anchor macro, so we support anchor links despite lack of docs in Creole spec
if '#' in link_item:
path, fragment = link_item.rsplit('#', 1)
else:
path, fragment = link_item, None
target = Iri(scheme='wiki.local', path=path, fragment=fragment)
text = link_item
else:
target = Iri(link_url)
text = link_url
element = moin_page.a(attrib={xlink.href: target})
stack.push(element)
if link_text:
self.parse_inline(link_text, stack, self.inlinedesc_re)
else:
stack.top_append(text)
stack.pop()
def __call__(self, rev, contenttype=None, arguments=None):
item_name = rev.item.fqname.value
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 inline_link_repl(self, stack, link, link_url=None, link_item=None,
link_text=None, link_args=None,
link_interwiki_site=None, link_interwiki_item=None):
"""Handle all kinds of links."""
if link_interwiki_site:
if is_known_wiki(link_interwiki_site):
link = Iri(scheme='wiki',
authority=link_interwiki_site,
path='/' + link_interwiki_item)
element = moin_page.a(attrib={xlink.href: link})
stack.push(element)
if link_text:
self.parse_inline(link_text, stack, self.inlinedesc_re)
else:
stack.top_append(link_interwiki_item)
stack.pop()
return
else:
# assume local language uses ":" inside of words, set link_item and continue
link_item = '{0}:{1}'.format(link_interwiki_site, link_interwiki_item)
if link_args:
link_args = parse_arguments(link_args) # XXX needs different parsing
query = url_encode(link_args.keyword, charset=CHARSET, encode_keys=True)
else:
query = None
if link_item is not None:
att = 'attachment:' # moin 1.9 needed this for an attached file
if link_item.startswith(att):
link_item = '/' + link_item[len(att):] # now we have a subitem
if '#' in link_item:
path, fragment = link_item.rsplit('#', 1)
else:
path, fragment = link_item, None
target = Iri(scheme='wiki.local', path=path, query=query, fragment=fragment)
text = link_item
else:
target = Iri(link_url)
text = link_url
element = moin_page.a(attrib={xlink.href: target})
stack.push(element)
if link_text:
self.parse_inline(link_text, stack, self.inlinedesc_re)
else:
stack.top_append(text)
stack.pop()
def __call__(self, rev, contenttype=None, arguments=None):
item_name = rev.item.name
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=[u"Download {0}.".format(item_name)])
body = moin_page.body(children=(a, ))
return moin_page.page(children=(body, ))
def macro(self):
iwlist = app.cfg.interwiki_map.items()
iwlist.sort()
iw_list = moin_page.list()
for tag, url in iwlist:
href = join_wiki(url, 'RecentChanges')
link = moin_page.a(attrib={xlink.href: href}, children=[tag])
label = moin_page.code(children=[link])
iw_item_label = moin_page.list_item_label(children=[label])
if '$PAGE' not in url:
link = moin_page.a(attrib={xlink.href: url}, children=[url])
else:
link = url
body = moin_page.code(children=[link])
iw_item_body = moin_page.list_item_body(children=[body])
iw_item = moin_page.list_item(children=[iw_item_label, iw_item_body])
iw_list.append(iw_item)
return iw_list
def create_pagelink_list(self, pagenames, ordered=False):
""" creates an ET with a list of pagelinks from a list of pagenames """
page_list = moin_page.list(attrib={moin_page.item_label_generate: ordered and 'ordered' or 'unordered'})
for pagename in pagenames:
# This link can never reach pagelinks
url = unicode(iri.Iri(scheme=u'wiki', authority=u'', path=u'/' + pagename))
pagelink = moin_page.a(attrib={xlink.href: url}, children=[pagename])
item_body = moin_page.list_item_body(children=[pagelink])
item = moin_page.list_item(children=[item_body])
page_list.append(item)
return page_list
def create_pagelink_list(self, pagenames, ordered=False):
""" creates an ET with a list of pagelinks from a list of pagenames """
page_list = moin_page.list(attrib={moin_page.item_label_generate: ordered and 'ordered' or 'unordered'})
for pagename in pagenames:
# This link can never reach pagelinks
url = unicode(iri.Iri(scheme=u'wiki', authority=u'', path=u'/' + pagename))
pagelink = moin_page.a(attrib={xlink.href: url}, children=[pagename])
item_body = moin_page.list_item_body(children=[pagelink])
item = moin_page.list_item(children=[item_body])
page_list.append(item)
return page_list
def process_name(self, member_name):
attrib = {
xlink.href:
Iri(scheme='wiki',
authority='',
path='/' + self.item_name,
query='do=get&member=%s' % member_name),
}
return moin_page.a(attrib=attrib, children=[
member_name,
])
def inline_url_repl(self, stack, url, url_target, escaped_url=None):
"""Handle raw urls in text."""
if not escaped_url:
# this url is NOT escaped
attrib = {xlink.href: url_target}
element = moin_page.a(attrib=attrib, children=(url_target,))
stack.top_append(element)
else:
# this url is escaped, we render it as text
stack.top_append(url_target)
def inline_url_repl(self, stack, url, url_target, escaped_url=None):
"""Handle raw urls in text."""
if not escaped_url:
# this url is NOT escaped
attrib = {xlink.href: url_target}
element = moin_page.a(attrib=attrib, children=(url_target, ))
stack.top_append(element)
else:
# this url is escaped, we render it as text
stack.top_append(url_target)
def process_name(self, member_name):
name = unicode(member_name, 'utf-8')
attrib = {
xlink.href:
Iri(scheme='wiki',
authority='',
path='/' + self.item_name,
query=u'do=get&member={0}'.format(name)),
}
return moin_page.a(attrib=attrib, children=[
name,
])
def __call__(self, rev, contenttype=None, arguments=None):
item_name = rev.item.name
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=[u"Download {0}.".format(item_name)])
body = moin_page.body(children=(a, ))
return moin_page.page(children=(body, ))
def visit_reference(self, node):
refuri = node.get('refuri', u'')
if refuri.startswith(u'<<') and refuri.endswith(u'>>'): # moin macro
macro_name = refuri[2:-2].split(u'(')[0]
if macro_name == u"TableOfContents":
arguments = refuri[2:-2].split(u'(')[1][:-1].split(u',')
node = moin_page.table_of_content()
self.open_moin_page_node(node)
if arguments and arguments[0]:
node.set(moin_page.outline_level, arguments[0])
return
if macro_name == u"Include":
# include macros are expanded by include.py similar to transclusions
# rst include handles only wiki pages and does not support additional arguments like moinwiki
arguments = refuri[2:-2].split(u'(')[1][:-1].split(u',')
link = Iri(scheme=u'wiki.local', path=arguments)
node = xinclude.include(
attrib={
xinclude.href: link,
moin_page.alt: refuri,
moin_page.content_type: 'x-moin/macro;name=' +
macro_name,
})
self.open_moin_page_node(node)
return
try:
arguments = refuri[2:-2].split(u'(')[1][:-1]
except IndexError:
arguments = u'' # <<DateTime>>
self.open_moin_page_node(
moin_page.inline_part(
attrib={
moin_page.content_type:
"x-moin/macro;name={0}".format(macro_name)
}))
if arguments:
self.open_moin_page_node(moin_page.arguments())
self.open_moin_page_node(arguments)
self.close_moin_page_node()
self.close_moin_page_node()
return
if not allowed_uri_scheme(refuri):
self.visit_error(node)
return
if refuri == u'':
# build a link to a heading or an explicitly defined anchor
refuri = Iri(scheme='wiki.local',
fragment=node.attributes['name'].replace(' ', '_'))
self.open_moin_page_node(moin_page.a(attrib={xlink.href: refuri}))
def __call__(self, content):
item_name = content # we just give the name of the item in the content
attrib = {
xlink.href:
Iri(scheme='wiki',
authority='',
path='/' + item_name,
query='do=modify'),
}
return moin_page.a(attrib=attrib,
children=[
_("%(item_name)s does not exist. Create it?",
item_name=item_name)
])
def inline_link_repl(self, stack, link, link_url=None, link_page=None, link_text=None):
"""Handle all kinds of links."""
if link_page is not None:
att = "attachment:" # moin 1.9 needed this for an attached file
if link_page.startswith(att):
link_page = "/" + link_page[len(att) :] # now we have a subitem
target = unicode(Iri(scheme="wiki.local", path=link_page))
text = link_page
else:
target = link_url
text = link_url
element = moin_page.a(attrib={xlink.href: target})
stack.push(element)
self.parse_inline(link_text or text, stack, self.link_desc_re)
stack.pop()
def inline_freelink_repl(self,
stack,
freelink,
freelink_bang=None,
freelink_interwiki_page=None,
freelink_interwiki_ref=None,
freelink_page=None,
freelink_email=None):
if freelink_bang:
stack.top_append(freelink)
return
attrib = {}
if freelink_page:
page = freelink_page.encode('utf-8')
if '#' in page:
path, fragment = page.rsplit('#', 1)
else:
path, fragment = page, None
link = Iri(scheme='wiki.local', path=path, fragment=fragment)
text = freelink_page
elif freelink_email:
link = 'mailto:' + freelink_email
text = freelink_email
else:
wikitag_bad = resolve_interwiki(freelink_interwiki_ref,
freelink_interwiki_page)[3]
if wikitag_bad:
stack.top_append(freelink)
return
link = Iri(scheme='wiki',
authority=freelink_interwiki_ref,
path='/' + freelink_interwiki_page)
text = freelink_interwiki_page
attrib[xlink.href] = link
element = moin_page.a(attrib, children=[text])
stack.top_append(element)
def macro(self, content, arguments, page_url, alternative):
request = self.request
if arguments:
item_count = int(arguments[0])
else:
item_count = 1
rootitem = Item(request, u'')
all_item_names = [i.name for i in rootitem.list_items()]
# Now select random item from the full list, and if it exists and
# we can read it, save.
random_item_names = []
found = 0
while found < item_count and all_item_names:
# Take one random item from the list
item_name = random.choice(all_item_names)
all_item_names.remove(item_name)
# Filter out items the user may not read.
try:
item = Item.create(item_name)
random_item_names.append(item_name)
found += 1
except AccessDeniedError:
pass
if not random_item_names:
return
random_item_names.sort()
result = moin_page.span()
for name in random_item_names:
link = unicode(Iri(scheme=u'wiki', authority=u'', path=u'/' + name))
result.append(moin_page.a(attrib={xlink.href: link}, children=[name]))
result.append(", ")
del result[-1] # kill last comma
return result
def inline_link_repl(self,
stack,
link,
link_url=None,
link_page=None,
link_text=None):
"""Handle all kinds of links."""
if link_page is not None:
att = 'attachment:' # moin 1.9 needed this for an attached file
if link_page.startswith(att):
link_page = '/' + link_page[len(att):] # now we have a subitem
target = unicode(Iri(scheme='wiki.local', path=link_page))
text = link_page
else:
target = link_url
text = link_url
element = moin_page.a(attrib={xlink.href: target})
stack.push(element)
self.parse_inline(link_text or text, stack, self.link_desc_re)
stack.pop()
def inline_link_repl(self,
stack,
link,
link_url=None,
link_item=None,
link_text=None,
link_args=None):
"""Handle all kinds of links."""
if link_args:
link_args = parse_arguments(
link_args) # XXX needs different parsing
query = url_encode(link_args.keyword,
charset=config.charset,
encode_keys=True)
else:
query = None
if link_item is not None:
att = 'attachment:' # moin 1.9 needed this for an attached file
if link_item.startswith(att):
link_item = '/' + link_item[len(att):] # now we have a subitem
if '#' in link_item:
path, fragment = link_item.rsplit('#', 1)
else:
path, fragment = link_item, None
target = Iri(scheme='wiki.local',
path=path,
query=query,
fragment=fragment)
text = link_item
else:
target = Iri(link_url)
text = link_url
element = moin_page.a(attrib={xlink.href: target})
stack.push(element)
if link_text:
self.parse_inline(link_text, stack, self.inlinedesc_re)
else:
stack.top_append(text)
stack.pop()
def macro(self, content, arguments, page_url, alternative):
if arguments:
item_count = int(arguments[0])
else:
item_count = 1
all_item_names = [i.name for i in flaskg.storage.iteritems()]
# Now select random item from the full list, and if it exists and
# we can read it, save.
random_item_names = []
found = 0
while found < item_count and all_item_names:
# Take one random item from the list
item_name = random.choice(all_item_names)
all_item_names.remove(item_name)
# Filter out items the user may not read.
try:
item = Item.create(item_name)
random_item_names.append(item_name)
found += 1
except AccessDenied:
pass
if not random_item_names:
return
random_item_names.sort()
result = moin_page.span()
for name in random_item_names:
link = unicode(Iri(scheme=u'wiki', authority=u'', path=u'/' + name))
result.append(moin_page.a(attrib={xlink.href: link}, children=[name]))
result.append(", ")
del result[-1] # kill last comma
return result
def inline_freelink_repl(self, stack, freelink, freelink_bang=None,
freelink_interwiki_page=None, freelink_interwiki_ref=None,
freelink_page=None, freelink_email=None):
if freelink_bang:
stack.top_append(freelink)
return
attrib = {}
if freelink_page:
page = freelink_page.encode('utf-8')
if '#' in page:
path, fragment = page.rsplit('#', 1)
else:
path, fragment = page, None
link = Iri(scheme='wiki.local', path=path, fragment=fragment)
text = freelink_page
elif freelink_email:
link = 'mailto:' + freelink_email
text = freelink_email
else:
if not is_known_wiki(freelink_interwiki_ref):
stack.top_append(freelink)
return
link = Iri(scheme='wiki',
authority=freelink_interwiki_ref,
path='/' + freelink_interwiki_page)
text = freelink_interwiki_page
attrib[xlink.href] = link
element = moin_page.a(attrib, children=[text])
stack.top_append(element)
def inline_link_repl(self,
stack,
link,
link_url=None,
link_item=None,
link_args=None,
external_link_url=None,
alt_text=''):
"""Handle all kinds of links."""
link_text = ''
if link_args and len(link_args.split('|')) > 2:
link_args = parse_arguments(' '.join(link_args.split(
'|')[:-1])) # TODO needs parsing for mediawiki_args
query = url_encode(link_args.keyword,
charset=config.charset,
encode_keys=True)
else:
if link_args:
link_text = link_args.split('|')[-1]
link_args = parse_arguments(' '.join(
link_args.split('|')[:-1]))
query = None
if link_item is not None:
if '#' in link_item:
path, fragment = link_item.rsplit('#', 1)
else:
path, fragment = link_item, None
target = Iri(scheme='wiki.local',
path=path,
query=query,
fragment=fragment)
text = link_item
else:
if link_url and len(link_url.split(':')) > 0 and link_url.split(
':')[0] == 'File':
object_item = ':'.join(link_url.split(':')[1:])
args = link_args.keyword
if object_item is not None:
if 'do' not in args:
# by default, we want the item's get url for transclusion of raw data:
args['do'] = 'get'
query = url_encode(args,
charset=config.charset,
encode_keys=True)
target = Iri(scheme='wiki.local',
path=object_item,
query=query,
fragment=None)
text = object_item
else:
target = Iri(object_url)
text = object_url
attrib = {xlink.href: target}
if link_text is not None:
attrib[moin_page.alt] = link_text
element = moin_page.object(attrib)
stack.push(element)
if link_text:
self.preprocessor.push()
self.parse_inline(link_text, stack, self.inlinedesc_re)
self.preprocessor.pop()
else:
stack.top_append(text)
stack.pop()
return
target = Iri(link_url)
text = link_url
if external_link_url:
target = Iri(external_link_url)
text = alt_text
element = moin_page.a(attrib={xlink.href: target})
stack.push(element)
if link_text:
self.preprocessor.push()
self.parse_inline(link_text, stack, self.inlinedesc_re)
self.preprocessor.pop()
else:
stack.top_append(text)
stack.pop()
def inline_url_repl(self, stack, url, url_target):
url = Iri(url_target)
attrib = {xlink.href: url}
element = moin_page.a(attrib=attrib, children=[url_target])
stack.top_append(element)
def inline_url_repl(self, stack, url, url_target):
url = Iri(url_target)
attrib = {xlink.href: url}
element = moin_page.a(attrib=attrib, children=[url_target])
stack.top_append(element)
def __call__(self, content):
item_name = content # we just give the name of the item in the content
attrib = {
xlink.href: Iri(scheme='wiki', authority='', path='/'+item_name, query='do=get'),
}
return moin_page.a(attrib=attrib, children=["Download %s." % item_name])
def inline_link_repl(self, stack, link, link_url=None, link_item=None,
link_args=u'', external_link_url=None, alt_text=u''):
"""Handle all kinds of links."""
link_text = ''
link_args_list = []
# Remove the first pipe/space, example of link_args : |arg1|arg2 or " arg1 arg2"
parsed_args = self.parse_args(link_args[1:])
query = None
if parsed_args.keyword:
query = url_encode(parsed_args.keyword, charset=CHARSET, encode_keys=True)
# Take the last of positional parameters as link_text(caption)
if parsed_args.positional:
link_text = parsed_args.positional.pop()
if link_item is not None:
if '#' in link_item:
path, fragment = link_item.rsplit('#', 1)
else:
path, fragment = link_item, None
target = Iri(scheme='wiki.local', path=path, query=query, fragment=fragment)
text = link_item
else:
if link_url and len(link_url.split(':')) > 0 and link_url.split(':')[0] == 'File':
object_item = ':'.join(link_url.split(':')[1:])
args = parsed_args.keyword
if object_item is not None:
if 'do' not in args:
# by default, we want the item's get url for transclusion of raw data:
args['do'] = 'get'
query = url_encode(args, charset=CHARSET, encode_keys=True)
target = Iri(scheme='wiki.local', path=object_item, query=query, fragment=None)
text = object_item
else:
target = Iri(scheme='wiki.local', path=object_url)
text = object_url
if not link_text:
link_text = text
attrib = {xlink.href: target}
attrib[moin_page.alt] = link_text
element = moin_page.object(attrib)
stack.push(element)
if link_text:
self.preprocessor.push()
self.parse_inline(link_text, stack, self.inlinedesc_re)
self.preprocessor.pop()
else:
stack.top_append(text)
stack.pop()
return
target = Iri(scheme='wiki.local', path=link_url)
text = link_url
if external_link_url:
target = Iri(external_link_url)
text = alt_text
element = moin_page.a(attrib={xlink.href: target})
stack.push(element)
if link_text:
self.preprocessor.push()
self.parse_inline(link_text, stack, self.inlinedesc_re)
self.preprocessor.pop()
else:
stack.top_append(text)
stack.pop()