def test_escaping(): """Check if escaping works properly.""" tree = parse("\\__bar\\__") assert tree == nodes.Document([nodes.Text("__bar__")]) tree = parse("'bar'") assert tree == nodes.Document([nodes.Text("'bar'")])
def test_autoclosing(): """Check if the automatic closing works.""" tree = parse("''foo __bar") assert tree == nodes.Document([ nodes.Emphasized( [nodes.Text('foo '), nodes.Underline([nodes.Text('bar')])]) ])
def test_default_itransformer(): """Test that the default ITransformer implementation returns the tree unchanged""" transformer = ITransformer() tree = nodes.Document( [nodes.Text('\nYea'), nodes.Strong([nodes.Text('foo')])]) transformed = transformer.transform(tree) eq_(render(transformed, None, 'html'), '\nYea<strong>foo</strong>')
def test_simple_lists(): """Check if simple lists work.""" tree = parse(' * foo\n * ^^(bar)^^\n * ,,(baz),,') assert tree == nodes.Document([ nodes.List('unordered', [ nodes.ListItem([nodes.Text('foo')]), nodes.ListItem([nodes.Sup([nodes.Text('bar')])]), nodes.ListItem([nodes.Sub([nodes.Text('baz')])]) ]) ])
def test_table_cell_classes(): """Test the table cell classes.""" tree = parse('||<cellclass=foo>1||<bar>2||') assert tree == nodes.Document([ nodes.Table([ nodes.TableRow([ nodes.TableCell([nodes.Text('1')], class_='foo'), nodes.TableCell([nodes.Text('2')], class_='bar') ]) ]) ])
def test_table_row_classes(): """Test the table row class assignments.""" tree = parse('||<foo>1||2||3') assert tree == nodes.Document([ nodes.Table([ nodes.TableRow([ nodes.TableCell([nodes.Text('1')]), nodes.TableCell([nodes.Text('2')]), nodes.TableCell([nodes.Text('3')]) ], class_='foo') ]) ])
def parse(markup, catch_stack_errors=True, transformers=None): """Parse markup into a node.""" try: return Parser(markup, transformers).parse() except StackExhaused: if not catch_stack_errors: raise return nodes.Paragraph([ nodes.Strong([nodes.Text(_(u'Internal parser error: '))]), nodes.Text( _(u'The parser could not process the text because ' u'it exceeded the maximum allowed depth for nested ' u'elements')) ])
def test_span_table(): """Test tables with col/rowspans.""" tree = parse('||<-2>1||<|2>2||\n||3||4||') assert tree == nodes.Document([ nodes.Table([ nodes.TableRow([ nodes.TableCell([nodes.Text('1')], colspan=2), nodes.TableCell([nodes.Text('2')], rowspan=2) ]), nodes.TableRow([ nodes.TableCell([nodes.Text('3')]), nodes.TableCell([nodes.Text('4')]) ]) ]) ])
def test_external_links(): """Test all kind of external links.""" tree = parse('[http://example.org :blub:][?action=edit]') assert tree == nodes.Document([ nodes.Link('http://example.org', [nodes.Text(':blub:')]), nodes.Link('?action=edit') ])
def test_table_alignment(): """Check if table alignment parameters work.""" tree = parse('||<:~>1||<(v>2||<)^>3||') assert tree == nodes.Document([ nodes.Table([ nodes.TableRow([ nodes.TableCell([nodes.Text('1')], align='center', valign='middle'), nodes.TableCell([nodes.Text('2')], align='left', valign='bottom'), nodes.TableCell([nodes.Text('3')], align='right', valign='top') ]) ]) ])
def test_nested_lists(): """Check if nested lists work.""" tree = parse(' * foo\n 1. bar\n a. baz\n * blub') assert tree == nodes.Document([ nodes.List('unordered', [ nodes.ListItem([ nodes.Text('foo'), nodes.List('arabic', [ nodes.ListItem([ nodes.Text('bar'), nodes.List('alphalower', [nodes.ListItem([nodes.Text('baz')])]) ]) ]) ]), nodes.ListItem([nodes.Text('blub')]) ]) ])
def test_automatic_paragraphs_transformer(): transformer = AutomaticParagraphs() tree = nodes.Document([ nodes.Text('\nYea'), nodes.Strong([nodes.Text('foo')]), nodes.Text('\n\nfaz') ]) transformed = transformer.transform(tree) eq_(render(transformed, None, 'html'), '<p>\nYea<strong>foo</strong></p><p>faz</p>') # test paragraph with block tags tree = nodes.Document( [nodes.Text('\nYea'), nodes.Ruler(), nodes.Text('\n\nfaz')]) transformed = transformer.transform(tree) eq_(render(transformed, None, 'html'), '<p>\nYea</p><hr><p>faz</p>')
def test_headline_processor_transformer(): transformer = HeadlineProcessor() tree = nodes.Document([ nodes.Headline(1, [nodes.Text('foo')], 'foo'), nodes.Paragraph([nodes.Text('some text')]), nodes.Headline(2, [nodes.Text('faz')], ''), nodes.Paragraph([nodes.Text('other text')]), nodes.Headline(1, [nodes.Text('foo')], 'foo') ]) expected = nodes.Document([ nodes.Headline(1, [nodes.Text('foo')], 'foo'), nodes.Paragraph([nodes.Text('some text')]), nodes.Headline(2, [nodes.Text('faz')], 'empty-headline'), nodes.Paragraph([nodes.Text('other text')]), nodes.Headline(1, [nodes.Text('foo')], 'foo-2') ]) transformed = transformer.transform(tree) eq_(transformed, expected)
def parse_code(self, stream): """ Parse inline code, don't confuse that with `parse_pre_block`. Returns a `Code` node. """ stream.expect('code_begin') buffer = [] while stream.current.type == 'text': buffer.append(stream.current.value) stream.next() stream.expect('code_end') return nodes.Code([nodes.Text(u''.join(buffer))])
def parse_escaped_code(self, stream): """ This parses escaped code formattings. Escaped code formattings work like normal code formattings but their delimiter backticks are doubled so that one can use single backticks inside. Returns a `Code` node. """ 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 test_inline_formattings(): """Simple test for some inline formattings.""" tree = parse("''baz'' but '''foo''' and __bar__.") assert tree == nodes.Document([ nodes.Emphasized([nodes.Text('baz')]), nodes.Text(' but '), nodes.Strong([nodes.Text('foo')]), nodes.Text(' and '), nodes.Underline([nodes.Text('bar')]), nodes.Text('.') ])
def transform(self, parent): """ Insert real paragraphs into the node and return it. """ for node in parent.children: if node.is_container and not node.is_raw: self.transform(node) if not parent.allows_paragraphs: return parent paragraphs = [[]] for child in self.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 test_simple_table(): """Test the simple table markup.""" tree = parse('||1||2||3||\n||4||5||6||') assert tree == nodes.Document([ nodes.Table([ nodes.TableRow([ nodes.TableCell([nodes.Text('1')]), nodes.TableCell([nodes.Text('2')]), nodes.TableCell([nodes.Text('3')]) ]), nodes.TableRow([ nodes.TableCell([nodes.Text('4')]), nodes.TableCell([nodes.Text('5')]), nodes.TableCell([nodes.Text('6')]) ]) ]) ])
def parse_pre_block(self, stream): """ Parse a pre block or parser block. If a shebang is present the parser with that name is instanciated and expanded, if it's a dynamic parser a `Parser` node will be returned. If no shebang is present or a parser with that name does not exist the data is handled as preformatted block data and a `Preformatted` node is returned. """ stream.expect('pre_begin') if stream.current.type == 'parser_begin': name = stream.current.value stream.next() args, kwargs = self.parse_arguments(stream, 'parser_end') if stream.current.type != 'pre_end': stream.next() else: name = None children = [] text_node = None while stream.current.type != 'pre_end': node = self.parse_node(stream) if node.is_text_node: if text_node is None and node.text[:1] == '\n': node.text = node.text[1:] text_node = node children.append(node) if text_node is not None and text_node.text[-1:] == '\n': text_node.text = text_node.text[:-1] stream.expect('pre_end') if name is None: return nodes.Preformatted(children) data = u''.join(x.text for x in children) return nodes.Preformatted([nodes.Text(data)])
def flush_text_buf(): if text_buf: text = u''.join(text_buf) if text: yield nodes.Text(text) del text_buf[:]
def test_pre(): """Test normal pre blocks.""" tree = parse('{{{\nfoo\n}}}') assert tree == nodes.Document([nodes.Preformatted([nodes.Text('foo')])])
def test_breakers(): """Test the ruler.""" tree = parse('foo\n-----------------') assert tree == nodes.Document([nodes.Text('foo\n'), nodes.Ruler()])
def parse_text(self, stream): """Expects a ``'text'`` token and returns a `nodes.Text`.""" return nodes.Text(stream.expect('text').value)
def parse_raw(self, stream): """Parse a raw marked section.""" return nodes.Raw([nodes.Text(stream.expect('raw').value)])