def parse(self, stream):
if stream.test('list_item'):
# parse list items
stream.next()
val = self.machine.dispatch_node(stream)
return nodes.ListItem([nodes.Text(val)])
def finish():
return nodes.List(list_type, children)
def is_empty_node(node):
return node.is_linebreak_node or \
(node.is_text_node and not node.text.strip())
def finish_if_list_end():
if stream.test('list_end'):
stream.next()
return finish()
stream.expect('list_begin')
t = stream.expect('list_type')
if not t.value:
list_type = 'unordered'
else:
list_type = {
'1': 'arabic',
'a': 'alphalower',
'A': 'alphalower',
'*': 'unordered'
}.get(t.value, None)
if list_type is None:
ret = u'[list]' + (u''.join(
filter_stream(stream, ('list_end', 'eof'), False)))
ret += stream.expect('list_end').value
return nodes.Text(ret)
children = filter(lambda n: not is_empty_node(n),
parse_child_nodes(stream, self, ('list_end', 'eof')))
# broken markup, no end tags...
if stream.eof:
return finish()
finish_if_list_end()
return finish()
def parse(self, stream):
stream.expect('escaped_code_begin')
buffer = []
while stream.current.type != 'escaped_code_end':
buffer.append(stream.current.value)
stream.next()
stream.expect('escaped_code_end')
return nodes.Code([nodes.Text(u''.join(buffer))])
def parse(self, stream):
if stream.test('stroke_end'):
node = nodes.Text(stream.current.value)
stream.next()
return node
stream.expect('stroke_begin')
children = parse_child_nodes(stream, self, 'strike_end')
stream.expect('stroke_end')
return nodes.Stroke(children)
def parse(self, stream):
stream.expect('quote_begin')
user = stream.expect('quote_user')
ret = []
if user.value is not None:
u = user.value
user = u[-1] == ':' and u or u'%s said:' % u
ret = [nodes.Strong([nodes.Text(user)]), nodes.Newline()]
children = parse_child_nodes(stream, self, 'quote_end')
stream.expect('quote_end')
return nodes.Container(ret + [nodes.Quote(children)])
def process(emanager, parent, ctx):
"""
Insert real paragraphs into the node and return it.
"""
for node in parent.children:
if node.is_container and not node.is_raw:
process(node, ctx)
if not parent.allows_paragraphs:
return parent
paragraphs = [[]]
for child in joined_text_iter(parent):
if child.is_text_node:
blockiter = iter(_paragraph_re.split(child.text))
for block in blockiter:
try:
is_paragraph = blockiter.next()
except StopIteration:
is_paragraph = False
if block:
paragraphs[-1].append(nodes.Text(block))
if is_paragraph:
paragraphs.append([])
elif child.is_block_tag:
paragraphs.extend((child, []))
else:
paragraphs[-1].append(child)
del parent.children[:]
for paragraph in paragraphs:
if not isinstance(paragraph, list):
parent.children.append(paragraph)
else:
for node in paragraph:
if not node.is_text_node or node.text:
parent.children.append(nodes.Paragraph(paragraph))
break
return parent
def parseTextBlock(self):
text = nodes.Text()
text.line = self.line()
spaces = self.expect('indent').val
if not self._spaces: self._spaces = spaces
indent = ' ' * (spaces - self._spaces)
while 'outdent' != self.peek().type:
t = self.peek().type
if 'newline' == t:
text.append('\n')
self.advance()
elif 'indent' == t:
text.append('\n')
for node in self.parseTextBlock().nodes:
text.append(node)
text.append('\n')
else:
text.append(indent + self.advance().val)
if spaces == self._spaces: self._spaces = None
self.expect('outdent')
return text
def parse(self, stream):
return nodes.Text(stream.expect('text').value)
def flush_text_buf():
if text_buf:
text = u''.join(text_buf)
if text:
yield nodes.Text(text)
del text_buf[:]
def parseText(self):
tok = self.expect('text')
node = nodes.Text(tok.val)
node.line = self.line()
return node