def macro(self): return ET.XML(""" <form xmlns="%s" method="get" action="%s/%s"> <input type="hidden" name="do" value="goto" /> <p> <input type="text" name="target" size="30" /> <input type="submit" value="%s" /> </p> </form> """ % (html, self.request.getScriptname(), self.page_name, _("Go To Item"))) #HHH ?
def visit_moinpage_note(self, elem): # TODO: Check note-class top = self._special_stack[-1] if len(elem) == 0: # explicit footnote placement: show prior footnotes, empty stack, reset counter if len(top._footnotes) == 0: return footnotes_div = self.create_footnotes(top) top.remove_footnotes() self._id.zero_id('note') # bump note-placement counter to insure unique footnote ids self._id.gen_id('note-placement') return footnotes_div body = None for child in elem: if child.tag.uri == moin_page: if child.tag.name == 'note-body': body = self.do_children(child) id = self._id.gen_id('note') prefixed_id = '%s-%s' % (self._id.get_id('note-placement'), id) elem_ref = ET.XML(""" <html:sup xmlns:html="{0}" html:id="note-{1}-ref" html:class="moin-footnote"> <html:a html:href="#note-{2}">{3}</html:a> </html:sup> """.format(html, prefixed_id, prefixed_id, id)) elem_note = ET.XML(""" <html:p xmlns:html="{0}" html:id="note-{1}"> <html:sup><html:a html:href="#note-{2}-ref">{3}</html:a></html:sup> </html:p> """.format(html, prefixed_id, prefixed_id, id)) elem_note.extend(body) top.add_footnote(elem_note) return elem_ref
def visit_moinpage_note(self, elem): # TODO: Check note-class body = None for child in elem: if child.tag.uri == moin_page: if child.tag.name == 'note-body': body = self.do_children(child) id = self._id.gen_id('note') elem_ref = ET.XML(""" <html:sup xmlns:html="%s" html:id="note-%d-ref" html:class="moin-footnote"><html:a html:href="#note-%d">%d</html:a></html:sup> """ % (html, id, id, id)) elem_note = ET.XML(""" <html:p xmlns:html="%s" html:id="note-%d"><html:sup><html:a html:href="#note-%d-ref">%d</html:a></html:sup></html:p> """ % (html, id, id, id)) elem_note.extend(body) self._special_stack[-1].add_footnote(elem_note) return elem_ref
def test_converter_refs(tree_xml, links_expected, transclusions_expected, external_expected): converter = ConverterItemRefs() tree = ET.XML(tree_xml) converter(tree) links_result = converter.get_links() transclusions_result = converter.get_transclusions() external_result = converter.get_external_links() # sorting instead of sets # so that we avoid deduplicating duplicated items in the result assert sorted(links_result) == sorted(links_expected) assert sorted(transclusions_result) == sorted(transclusions_expected) assert sorted(external_result) == sorted(external_expected)
def __call__(self, content, aruments=None): """ Function called by the converter to process the conversion. """ # Initalize our attributes self.section_depth = 0 self.heading_level = 0 self.is_section = False # We store the standard attributes of an element. # Once we have been able to put it into an output element, # we clear this attribute. self.standard_attribute = {} # We will create an element tree from the DocBook content # The content is given to the converter as a list of string, # line per line. # So we will concatenate all in one string. docbook_str = u'\n'.join(content) logging.debug(docbook_str) try: # XXX: The XML parser need bytestring. tree = ET.XML(docbook_str.encode('utf-8')) except ET.ParseError as detail: return self.error(str(detail)) try: if tree.tag.name in self.block_tags: return self.start_dom_tree(tree, 0) else: # XXX: Internationalization return self.error("The root element of the docbook document is not supported by the converter") # XXX: Error handling could probably be better. except NameSpaceError as detail: return self.error(str(detail)) return result
def handle_input(self, input): i = self.input_re.sub(r'\1 ' + self.input_namespaces, input) return ET.XML(i.encode("utf-8"))
def test_unknown(self): page = ET.XML("<page:unknown {0}/>".format(self.input_namespaces)) pytest.raises(ElementException, self.conv.__call__, page)
def run_test(tree_xml, output): tree = ET.XML(tree_xml) converter = ConverterPage() tree = converter(tree) assert serialize(tree, method="html") == output
def recurse(self, elem, page_href): # Check if we reached a new page page_href_new = elem.get(self.tag_page_href) if page_href_new: page_href_new = Iri(page_href_new) if page_href_new != page_href: page_href = page_href_new self.stack.append(page_href) else: self.stack.append(None) else: self.stack.append(None) try: if elem.tag == self.tag_xi_include: href = elem.get(self.tag_xi_href) xpointer = elem.get(self.tag_xi_xpointer) xp_include_pages = None xp_include_sort = None xp_include_items = None xp_include_skipitems = None xp_include_heading = None xp_include_level = None if xpointer: xp = XPointer(xpointer) xp_include = None xp_namespaces = {} for entry in xp: uri = None name = entry.name.split(':', 1) if len(name) > 1: prefix, name = name uri = xp_namespaces.get(prefix, False) else: name = name[0] if uri is None and name == 'xmlns': d_prefix, d_uri = entry.data.split('=', 1) xp_namespaces[d_prefix] = d_uri elif uri == moin_page.namespace and name == 'include': xp_include = XPointer(entry.data) if xp_include: for entry in xp_include: name, data = entry.name, entry.data if name == 'pages': xp_include_pages = data elif name == 'sort': xp_include_sort = data elif name == 'items': xp_include_items = int(data) elif name == 'skipitems': xp_include_skipitems = int(data) elif name == 'heading': xp_include_heading = data elif name == 'level': xp_include_level = data if href: # We have a single page to include href = Iri(href) link = Iri(scheme='wiki', authority='') if href.scheme == 'wiki': if href.authority: raise ValueError( "can't handle xinclude for non-local authority" ) else: path = href.path[1:] elif href.scheme == 'wiki.local': page = page_href path = href.path if path[0] == '': # /subitem tmp = page.path[1:] tmp.extend(path[1:]) path = tmp elif path[0] == '..': # ../sisteritem path = page.path[1:] + path[1:] else: raise ValueError( "can't handle xinclude for schemes other than wiki or wiki.local" ) link.path = path page = Item.create(unicode(path)) pages = ((page, link), ) elif xp_include_pages: # We have a regex of pages to include from MoinMoin.search.term import NameFn inc_match = re.compile(xp_include_pages) root_item = Item(name=u'') pagelist = [ item.name for item in root_item.list_items(NameFn(inc_match)) ] pagelist.sort() if xp_include_sort == 'descending': pagelist.reverse() if xp_include_skipitems is not None: pagelist = pagelist[xp_include_skipitems:] if xp_include_items is not None: pagelist = pagelist[xp_include_items + 1:] pages = ((Item.create(p), Iri(scheme='wiki', authority='', path='/' + p)) for p in pagelist) included_elements = [] for page, page_href in pages: if page_href in self.stack: w = ( '<p xmlns="%s"><strong class="error">Recursive include of "%s" forbidden</strong></p>' % (html.namespace, page.name)) div.append(ET.XML(w)) continue # TODO: Is this correct? if not flaskg.user.may.read(page.name): continue if xp_include_heading is not None: attrib = {self.tag_href: page_href} children = (xp_include_heading or page.name, ) elem_a = ET.Element(self.tag_a, attrib, children=children) attrib = { self.tag_outline_level: xp_include_level or '1' } elem_h = ET.Element(self.tag_h, attrib, children=(elem_a, )) div.append(elem_h) page_doc = page.internal_representation() # page_doc.tag = self.tag_div # XXX why did we have this? self.recurse(page_doc, page_href) # Wrap the page with the overlay, but only if it's a "page", or "a". # The href needs to be an absolute URI, without the prefix "wiki://" if page_doc.tag.endswith("page") or page_doc.tag.endswith( "a"): page_doc = wrap_object_with_overlay( page_doc, href=unicode(page_href.path)) included_elements.append(page_doc) if len(included_elements) > 1: # use a div as container result = ET.Element(self.tag_div) result.extend(included_elements) elif included_elements: result = included_elements[0] else: result = None return result for i in xrange(len(elem)): child = elem[i] if isinstance(child, ET.Node): ret = self.recurse(child, page_href) if ret: elem[i] = ret finally: self.stack.pop()