def visit_qandaentry_number(self, element, depth):
"""
Convert::
<question>Q</question><answer>A</answer>
to::
<list-item>
<list-item-body><p>Q</p><p>A</p></list-item-body>
</list-item>
"""
items = []
for child in element:
if isinstance(child, ET.Element):
if child.tag.name == 'question' or child.tag.name == 'answer':
r = self.visit(child, depth)
if r is None:
r = ()
elif not isinstance(r, (list, tuple)):
r = (r, )
items.extend(r)
else:
items.append(child)
item_body = ET.Element(moin_page('list-item-body'),
attrib={},
children=items)
return ET.Element(moin_page('list-item'),
attrib={},
children=[item_body])
def visit_simple_list(self, moin_page_tag, attrib, element, depth):
"""
There is different list element in DocBook with different
semantic meaning, but with an unique result in the DOM Tree.
Here we handle the conversion of such of list.
"""
list_item_tags = {'listitem', 'step', 'stepalternatives', 'member'}
items = []
for child in element:
if isinstance(child, ET.Element):
if child.tag.name in list_item_tags:
children = self.visit(child, depth)
list_item_body = ET.Element(moin_page('list-item-body'),
attrib={},
children=children)
tag = ET.Element(moin_page('list-item'),
attrib={},
children=[list_item_body])
tag = (tag, )
items.extend(tag)
else:
r = self.visit(child, depth)
if r is None:
r = ()
elif not isinstance(r, (list, tuple)):
r = (r, )
items.extend(r)
else:
items.append(child)
return ET.Element(moin_page.list, attrib=attrib, children=items)
def visit_moinpage_list(self, element):
"""
Function called to handle the conversion of list.
It will called a specific function to handle (un)ordered list,
with the appropriate DocBook tag.
Or a specific function to handle definition list.
"""
item_label_generate = element.get(moin_page('item-label-generate'))
if 'ordered' == item_label_generate:
attrib = {}
# Get the list-style-type to define correctly numeration
list_style_type = element.get(moin_page('list-style-type'))
if 'upper-alpha' == list_style_type:
attrib[docbook('numeration')] = 'upperalpha'
elif 'upper-roman' == list_style_type:
attrib[docbook('numeration')] = 'upperroman'
elif 'lower-alpha' == list_style_type:
attrib[docbook('numeration')] = 'loweralpha'
elif 'lower-roman' == list_style_type:
attrib[docbook('numeration')] = 'lowerroman'
else:
attrib[docbook('numeration')] = 'arabic'
return self.handle_simple_list(docbook.orderedlist,
element,
attrib=attrib)
elif 'unordered' == item_label_generate:
return self.handle_simple_list(docbook.itemizedlist,
element,
attrib={})
else:
return self.new_copy(docbook.variablelist, element, attrib={})
def visit_list(self, element):
"""
Convert a list of item (whatever the type : ordered or unordered)
So we have html code like::
<ul>
<li>Item 1</li>
<li>Item 2</li>
</ul>
Which will be converted to::
<list>
<list-item>
<list-item-body>Item 1</list-item-body>
</list-item>
<list-item>
<list-item-body>Item 2</list-item-body>
</list-item>
</list>
"""
# We will define the appropriate attribute
# according to the type of the list
attrib = {}
if element.tag == "ul" or element.tag == "dir":
attrib[moin_page('item-label-generate')] = 'unordered'
elif element.tag == "ol":
attrib[moin_page('item-label-generate')] = 'ordered'
return ET.Element(moin_page.list, attrib=attrib, children=self.do_children(element))
def error(self, message):
"""
Return a DOM Tree containing an error message.
"""
error = self.new(moin_page('error'), attrib={}, children=[message])
part = self.new(moin_page('part'), attrib={}, children=[error])
body = self.new(moin_page('body'), attrib={}, children=[part])
return self.new(moin_page('page'), attrib={}, children=[body])
def add_attr_to_style(attrib, attr):
attr = attr.strip().encode('ascii', errors='backslashreplace').decode('unicode-escape')
if not attr.endswith(';'):
attr += ';'
if attrib.get(moin_page('style'), ""):
attrib[moin_page('style')] = attrib.get(moin_page('style'), "") + " " + attr
else:
attrib[moin_page('style')] = attr
def block_table_repl(self, iter_content, stack, table, table_args=''):
stack.clear()
# TODO: table attributes
elem = moin_page.table()
stack.push(elem)
if table_args:
table_args = _TableArguments()(table_args)
for key, value in table_args.keyword.iteritems():
attrib = elem.attrib
if key in ('class', 'style', 'number-columns-spanned',
'number-rows-spanned'):
attrib[moin_page(key)] = value
element = moin_page.table_body()
stack.push(element)
lines = _Iter(self.block_table_lines(iter_content),
startno=iter_content.lineno)
element = moin_page.table_row()
stack.push(element)
preprocessor_status = []
for line in lines:
m = self.tablerow_re.match(line)
if not m:
return
if m.group('newrow'):
stack.pop_name('table-row')
element = moin_page.table_row()
stack.push(element)
cells = m.group('cells')
if cells:
cells = cells.split('||')
for cell in cells:
if stack.top_check('table-cell'):
stack.pop()
cell = re.split(r'\s*\|\s*', cell)
element = moin_page.table_cell()
if len(cell) > 1:
cell_args = _TableArguments()(cell[0])
for key, value in cell_args.keyword.iteritems():
attrib = element.attrib
if key in ('class', 'style',
'number-columns-spanned',
'number-rows-spanned'):
attrib[moin_page(key)] = value
cell = cell[1]
else:
cell = cell[0]
stack.push(element)
self.preprocessor.push()
self.parse_inline(cell, stack, self.inline_re)
preprocessor_status = self.preprocessor.pop()
elif m.group('text'):
self.preprocessor.push(preprocessor_status)
self.parse_inline('\n{0}'.format(m.group('text')), stack,
self.inline_re)
preprocessor_status = self.preprocessor.pop()
stack.pop_name('table')
def rowspan_colspan(self, element):
attrib = {}
rowspan = element.get(html.rowspan)
colspan = element.get(html.colspan)
if rowspan:
attrib[moin_page('number-rows-spanned')] = rowspan
if colspan:
attrib[moin_page('number-columns-spanned')] = colspan
return attrib
def add_attr_to_style(attrib, attr):
attr = attr.strip().decode('unicode-escape')
if not attr.endswith(';'):
attr += ';'
if attrib.get(moin_page('style'), ""):
attrib[moin_page('style')] = attrib.get(
moin_page('style'), "") + " " + attr
else:
attrib[moin_page('style')] = attr
def visit_xhtml_td(self, element, attr={}):
attrib = attr
rowspan = element.get(html.rowspan)
colspan = element.get(html.colspan)
if rowspan:
attrib[moin_page('number-rows-spanned')] = rowspan
if colspan:
attrib[moin_page('number-columns-spanned')] = colspan
return self.new_copy(moin_page.table_cell, element, attrib=attrib)
def visit_moinpage_table_cell(self, element):
attrib = {}
rowspan = element.get(moin_page('number-rows-spanned'))
colspan = element.get(moin_page('number-columns-spanned'))
print("rowspan : {0}".format(rowspan))
if rowspan:
attrib[docbook.rowspan] = rowspan
if colspan:
attrib[docbook.colspan] = colspan
return self.new_copy(docbook.td, element, attrib=attrib)
def visit_docbook_footnote(self, element, depth):
"""
<footnote> --> <note note-class="footnote"><note-body>
"""
attrib = {}
key = moin_page('note-class')
attrib[key] = "footnote"
children = self.new(moin_page('note-body'),
attrib={},
children=self.do_children(element, depth))
if len(children) > 1:
# must delete lineno because footnote will be placed near end of page and out of sequence
del children._children[1].attrib[html.data_lineno]
return self.new(moin_page.note, attrib=attrib, children=[children])
def build_dom_calendar_table(rows, head=None, caption=None, cls=None):
"""
Build a DOM table with data from <rows>.
"""
table = moin_page.table()
if cls is not None:
table.attrib[moin_page('class')] = cls
if caption is not None:
table_caption = moin_page.caption()
table_caption.append(caption)
table.append(table_caption)
if head is not None:
table_head = moin_page.table_header()
table_row = moin_page.table_row()
for _idx, cell_tuple in enumerate(head):
(cell, cell_class) = cell_tuple
table_cell = moin_page.table_cell(children=[cell])
table_cell.attrib[moin_page('class')] = cell_class
table_row.append(table_cell)
table_head.append(table_row)
table.append(table_head)
table_body = moin_page.table_body()
for row in rows:
table_row = moin_page.table_row()
for cell_tuple in row:
# - cell content
# - href for <a> tag
# - CSS class for <td> tag
(cell, cell_addr, cell_class) = cell_tuple
# empty cell
if not cell_addr:
table_cell = moin_page.table_cell(children=[cell])
table_cell.attrib[moin_page('class')] = cell_class
# cell with link to calendar
else:
table_a = moin_page.a(attrib={xlink.href: Iri(cell_addr)},
children=[cell])
table_cell = moin_page.table_cell(children=[table_a])
table_cell.attrib[moin_page('class')] = cell_class
table_row.append(table_cell)
table_body.append(table_row)
table.append(table_body)
return table
def visit_qandaentry_qanda(self, element, depth):
"""
Convert::
<question>Q body</question><answer>A Body</answer>
to::
<list-item>
<list-item-label>Q:</list-item-label>
<list-item-body>Q Body</list-item-body>
</list-item>
<list-item>
<list-item-label>A:</list-item-label>
<list-item-body>A Body</list-item-body>
</list-item>
"""
items = []
for child in element:
if isinstance(child, ET.Element):
r = ()
item_label = None
if child.tag.name == 'question':
item_label = ET.Element(moin_page('list-item-label'),
attrib={},
children="Q:")
elif child.tag.name == 'answer':
item_label = ET.Element(moin_page('list-item-label'),
attrib={},
children="A:")
else:
r = self.visit(child, depth)
if r is None:
r = ()
elif not isinstance(r, (list, tuple)):
r = (r, )
items.extend(r)
if item_label is not None:
item_body = ET.Element(moin_page('list-item-body'),
attrib={},
children=self.visit(child, depth))
r = (item_label, item_body)
list_item = ET.Element(moin_page('list-item'),
attrib={},
children=r)
items.append(list_item)
else:
items.append(child)
return items
def block_separator_repl(self, _iter_content, stack, separator, hr_class='moin-hr{0}'):
stack.clear()
hr_height = min((len(separator) - 3), 6)
hr_height = max(hr_height, 1)
attrib = {moin_page('class'): hr_class.format(hr_height)}
elem = moin_page.separator(attrib=attrib)
stack.top_append(elem)
def visit_docbook_informalfigure(self, element, depth):
"""
<informalfigure> --> <div html:class="figure">
"""
attrib = {}
attrib[html.class_] = 'db-figure'
return self.new_copy(moin_page('div'), element, depth, attrib=attrib)
def visit_docbook_sect(self, element, depth):
"""
This is the function to convert a numbered section.
Numbered section uses tag like <sectN> where N is the number
of the section between 1 and 5.
The sections are supposed to be correctly nested.
We only convert a section to an heading if one of the children
is a title element.
TODO: See if we can unify with recursive section below.
TODO: Add div element, with specific id
"""
self.is_section = True
title = ''
for child in element:
if isinstance(child, ET.Element):
uri = child.tag.uri
name = self.docbook_namespace.get(uri, None)
if name == 'docbook' and child.tag.name == 'title':
title = child
# Remove the title element to avoid double conversion
element.remove(child)
heading_level = element.tag.name[4]
key = moin_page('outline-level')
attrib = {}
attrib[key] = heading_level
return self.new(moin_page.h, attrib=attrib, children=title)
def visit_docbook_inlinequation(self, element, depth):
"""
<inlinequation> --> <span element="equation">
"""
attrib = {}
attrib[moin_page('element')] = 'equation'
return self.new_copy(moin_page.span, element, depth, attrib=attrib)
def visit_docbook_blockquote(self, element, depth):
"""
<blockquote>
<attribution>Author</attribution>
Text
</blockquote>
--> <blockquote source="Author">Text</blockquote>
<blockquote>Text</blockquote>
--> <blockquote source="Unknow">Text</blockquote>
"""
# TODO: Translate
source = "Unknow"
children = []
for child in element:
if isinstance(child, ET.Element):
if child.tag.name == "attribution":
source = self.do_children(child, depth + 1)
else:
children.extend(self.do_children(child, depth + 1))
else:
children.append(child)
attrib = {}
attrib[moin_page('source')] = source[0]
return self.new(moin_page.blockquote, attrib=attrib, children=children)
def visit_docbook_informalequation(self, element, depth):
"""
<informalequation> --> <div html:class="equation">
"""
attrib = {}
attrib[html.class_] = 'db-equation'
return self.new_copy(moin_page('div'), element, depth, attrib=attrib)
def inline_comment_repl(self, stack, comment, comment_begin=None, comment_end=None):
if comment_begin:
attrib = {moin_page('class'): 'comment'}
elem = moin_page.span(attrib=attrib)
stack.push(elem)
else:
stack.pop()
def visit_docbook_trademark(self, element, depth):
"""
Depending of the trademark class, a specific entities is added to the string.
Docbook supports 4 types of trademark: copyright, registered, trade (mark), and service (mark).
<trademark> --> <span class="db-trademark">
"""
trademark_entities = {
'copyright': '\xa9 ', # '© ',
'registered': '\xae', # u'®',
'trade': '\u2122', # no entity name defined for superscript TM
}
trademark_class = element.get('class')
children = self.do_children(element, depth)
if trademark_class in trademark_entities:
if trademark_class == 'copyright':
children.insert(0, trademark_entities[trademark_class])
else:
children.append(trademark_entities[trademark_class])
elif trademark_class == 'service':
# no entity name nor entity number defined for superscript SM
sup_attrib = {moin_page('baseline-shift'): 'super'}
service_mark = self.new(moin_page.span,
attrib=sup_attrib,
children=['SM'])
children.append(service_mark)
attrib = {html.class_: 'db-trademark'}
return self.new(moin_page.span, attrib=attrib, children=children)
def visit_xhtml_sup(self, element):
"""
<sup>Text</sup> --> <span base-line-shift="super">Text</span>
"""
key = moin_page('baseline-shift')
attrib = {}
attrib[key] = 'super'
return self.new_copy(moin_page.span, element, attrib)
def visit_xhtml_small(self, element):
"""
<small>Text</small> --> <span font-size=85%>Text</span>
"""
key = moin_page('font-size')
attrib = {}
attrib[key] = '85%'
return self.new_copy(moin_page.span, element, attrib)
def visit_xhtml_big(self, element):
"""
<big>Text</big> --> <span font-size=120%>Text</span>
"""
key = moin_page('font-size')
attrib = {}
attrib[key] = '120%'
return self.new_copy(moin_page.span, element, attrib)
def convert_attributes(self, element):
result = {}
for key, value in element.attrib.items():
if key in self.standard_attributes:
result[moin_page(key)] = value
if key == 'id':
result[xml('id')] = value
return result
def visit_docbook_itemizedlist(self, element, depth):
"""
<itemizedlist> --> <list item-label-generate="unordered">
"""
attrib = {}
key = moin_page('item-label-generate')
attrib[key] = 'unordered'
return self.visit_simple_list(moin_page.list, attrib, element, depth)
def visit_docbook_superscript(self, element, depth):
"""
<superscript> --> <span baseline-shift="super">
"""
attrib = {}
key = moin_page('baseline-shift')
attrib[key] = 'super'
return self.new_copy(moin_page.span, element, depth, attrib=attrib)
def visit_docbook_simplelist(self, element, depth):
"""
<simplelist> --> <list item-label-generate="unordered">
"""
# TODO: Add support of the type attribute
attrib = {}
key = moin_page('item-label-generate')
attrib[key] = 'unordered'
return self.visit_simple_list(moin_page.list, attrib, element, depth)
def visit_docbook_procedure(self, element, depth):
"""
<procedure> --> <list item-label-generate="ordered">
"""
# TODO: See to add Procedure text (if needed)
attrib = {}
key = moin_page('item-label-generate')
attrib[key] = 'ordered'
return self.visit_simple_list(moin_page.list, attrib, element, depth)
