class ListDirective(Directive):
rules = [
rule(make_bbcode_tag('list', True),
bygroups('list_type'),
enter='list'),
rule(r'\[\*\]\s*(.*)(?m)',
bygroups('value'),
enter='list_item',
leave='list_item',
one=True),
rule(make_bbcode_end('list', False), leave='list')
]
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()
class SuperscriptDirective(Directive):
rules = [rule(r'\^\^\(', enter='sup'), rule(r'\)\^\^', leave='sup')]
def parse(self, stream):
stream.expect('sup_begin')
children = parse_child_nodes(stream, self, 'sup_end')
stream.expect('sup_end')
return nodes.Sup(children)
class SmallDirective(Directive):
rules = [rule(r'-~', enter='small'), rule(r'~-', leave='small')]
def parse(self, stream):
stream.expect('small_begin')
children = parse_child_nodes(stream, self, 'small_end')
stream.expect('small_end')
return nodes.Small(children)
class CodeDirective(Directive):
rules = [rule(r'\{\{\{', enter='code'), rule(r'\}\}\}', leave='code')]
def parse(self, stream):
stream.expect('code_begin')
data = escape(u''.join(filter_stream(stream, 'code_end')))
stream.expect('code_end')
return nodes.Preformatted([nodes.HTML(data)])
class BigDirective(Directive):
rules = [rule(r'\+~', enter='big'), rule(r'~\+', leave='big')]
def parse(self, stream):
stream.expect('big_begin')
children = parse_child_nodes(stream, self, 'big_end')
stream.expect('big_end')
return nodes.Big(children)
class StrokeDirective(Directive):
rules = [rule(r'~~\(', enter='stroke'), rule(r'\)~~', leave='stroke')]
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)
class ColorDirective(Directive):
rules = [
rule(make_bbcode_tag('color', True), bygroups('color'), enter='color'),
rule(make_bbcode_end('color'), leave='color')
]
def parse(self, stream):
stream.expect('color_begin')
color = stream.expect('color').value
children = parse_child_nodes(stream, self, 'color_end')
stream.expect('color_end')
return nodes.Color(color, children)
class UrlDirective(Directive):
rules = [
rule(make_bbcode_tag('url', True), bygroups('url_source'),
enter='url'),
rule(make_bbcode_end('url'), leave='url'),
]
def parse(self, stream):
stream.expect('url_begin')
href = stream.expect('url_source').value
children = parse_child_nodes(stream, self, 'url_end')
title = children and u''.join(n.text for n in children)
if href is None:
href = title
stream.expect('url_end')
return nodes.Link(href, children, title)
class SubscriptDirective(Directive):
rule = rule(r',,', enter='sub', leave='sub')
def parse(self, stream):
stream.expect('sub_begin')
children = parse_child_nodes(stream, self, 'sub_end')
stream.expect('sub_end')
return nodes.Sub(children)
class EmphasizedDirective(Directive):
rule = rule(r"''", enter='emphasized', leave='emphasized')
def parse(self, stream):
stream.expect('emphasized_begin')
children = parse_child_nodes(stream, self, 'emphasized_end')
stream.expect('emphasized_end')
return nodes.Emphasized(children)
class UnderlineDirective(Directive):
rule = rule(r'__', enter='underline', leave='underline')
def parse(self, stream):
stream.expect('underline_begin')
children = parse_child_nodes(stream, self, 'underline_end')
stream.expect('underline_end')
return nodes.Underline(children)
class StrongDirective(Directive):
rule = rule(r'\*\*', enter='strong', leave='strong')
def parse(self, stream):
stream.expect('strong_begin')
children = parse_child_nodes(stream, self, 'strong_end')
stream.expect('strong_end')
return nodes.Strong(children)
class LinkDirective(Directive):
rule = rule(r'\[([^\s]+?\S)(\s(?:.+?))?\]',
bygroups('link_href', 'link_title'),
enter='link',
one=True)
def parse(self, stream):
stream.expect('link')
return nodes.Link(stream.expect('link_href').value,
title=stream.expect('link_title').value)
class EscapedCodeDirective(Directive):
rule = rule(r'\`\`', enter='escaped_code', leave='escaped_code')
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))])
class QuoteDirective(Directive):
rules = [
rule(make_bbcode_tag('quote', True),
bygroups('quote_user'),
enter='quote'),
rule(make_bbcode_end('quote'), leave='quote')
]
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)])
class HeadlineDirective(Directive):
rule = rule(r'(={1,6})(.*?)(\1)',
bygroups('headline_level', 'headline_text'),
enter='headline',
one=True)
def parse(self, stream):
stream.expect('headline')
token = stream.expect('headline_level')
return nodes.Headline(
len(token.value.strip()),
self.machine.parse(
self.machine.tokenize(stream.expect('headline_text').value),
True))
class RulerDirective(Directive):
rule = rule(r'^----+\s*(\n|$)(?m)', enter='ruler', one=True)
def parse(self, stream):
stream.expect('ruler')
return nodes.Ruler()
class BigDirective(SimpleMarkupDirective):
__directive_node__ = nodes.Big
rule = rule(r'\+~\(|\)~\+', enter='big', leave='big')
class SubscriptDirective(SimpleMarkupDirective):
__directive_node__ = nodes.Sub
rule = rule(r',,\(|\),,', enter='sub', leave='sub')
class StrongDirective(SimpleMarkupDirective):
__directive_node__ = nodes.Strong
rule = rule(r'\*\*', enter='strong', leave='strong')
class HTMLLinkDirective(Directive):
rule = rule(_url_pattern + r'[^\s\'"]+\S', enter='html_link', one=True)
def parse(self, stream):
return nodes.Link(stream.expect('html_link').value)
class EmphasizedDirective(SimpleMarkupDirective):
__directive_node__ = nodes.Emphasized
rule = rule(r"''", enter='emphasized', leave='emphasized')
def rules(self):
return [
rule(make_bbcode_tag(self.name), enter=self.name),
rule(make_bbcode_end(self.name), leave=self.name)]
class UnderlineDirective(SimpleMarkupDirective):
__directive_node__ = nodes.Underline
rule = rule(r'__', enter='underline', leave='underline')
class NewlineDirective(Directive):
rule = rule(r'\n', enter='nl', one=True)
def parse(self, stream):
stream.expect('nl')
return nodes.Newline()
class SuperscriptDirective(SimpleMarkupDirective):
__directive_node__ = nodes.Sup
rule = rule(r'\^\^\(|\)\^\^', enter='sup', leave='sup')
def rules(self):
return [
rule(make_bbcode_tag(self.name), enter=self.name),
rule(make_bbcode_end(self.name), leave=self.name)
]
class SmallDirective(SimpleMarkupDirective):
__directive_node__ = nodes.Small
rule = rule(r'-~\(|\)~-', enter='small', leave='small')
class EmailDirective(Directive):
rule = rule(r'[-\w._+]+\@[\w.-]+', enter='email', one=True)
def parse(self, stream):
return nodes.Link('mailto:%s' % stream.expect('email').value)
