| diff --git a/CHANGES.rst b/CHANGES.rst |
| index eb204dd..3eb99a7 100644 |
| --- a/CHANGES.rst |
| +++ b/CHANGES.rst |
| @@ -3,6 +3,14 @@ Changelog |
| |
| Here is the full history of mistune. |
| |
| +Version 0.7 |
| +~~~~~~~~~~~ |
| + |
| +Release date not decided. |
| + |
| +* Fix the breaking change in version 0.6 with options: **parse_inline_html** and **parse_block_html** |
| + |
| + |
| Version 0.6 |
| ~~~~~~~~~~~ |
| |
| diff --git a/README.rst b/README.rst |
| index 894833b..f6cb5f9 100644 |
| --- a/README.rst |
| +++ b/README.rst |
| @@ -38,12 +38,6 @@ Installing mistune with pip:: |
| |
| $ pip install mistune |
| |
| -If pip is not available, try easy_install:: |
| - |
| - $ easy_install mistune |
| - |
| -Cython Feature |
| -~~~~~~~~~~~~~~ |
| |
| Mistune can be faster, if you compile with cython:: |
| |
| @@ -59,10 +53,49 @@ A simple API that render a markdown formatted text: |
| |
| import mistune |
| |
| - mistune.markdown('I am using **markdown**') |
| - # output: <p>I am using <strong>markdown</strong></p> |
| + mistune.markdown('I am using **mistune markdown parser**') |
| + # output: <p>I am using <strong>mistune markdown parser</strong></p> |
| + |
| +If you care about performance, it is better to re-use the Markdown instance: |
| + |
| +.. code:: python |
| + |
| + import mistune |
| + |
| + markdown = mistune.Markdown() |
| + markdown('I am using **mistune markdown parser**') |
| + |
| +Mistune has enabled all features by default. You don't have to configure |
| +anything. But there are options for you to change the parser behaviors. |
| + |
| + |
| +Options |
| +------- |
| + |
| +Here is a list of all options that will affect the rendering results, |
| +configure them with ``mistune.Renderer``: |
| + |
| +.. code:: python |
| + |
| + renderer = mistune.Renderer(escape=True, hard_wrap=True) |
| + # use this renderer instance |
| + markdown = mistune.Markdown(renderer=renderer) |
| + markdown(text) |
| + |
| +* **escape**: if set to *True*, all raw html tags will be escaped. |
| +* **hard_wrap**: if set to *True*, it will has GFM line breaks feature. |
| +* **use_xhtml**: if set to *True*, all tags will be in xhtml, for example: ``<hr />``. |
| +* **parse_html**: parse text in block and inline level html. |
| +* **parse_block_html**: parse text only in block level html. |
| +* **parse_inline_html**: parse text only in inline level html. |
| + |
| +When using the default renderer, you can use one of the following shortcuts:: |
| + |
| + mistune.markdown(text, escape=True, hard_wrap=True) |
| + |
| + markdown = mistune.Markdown(escape=True, hard_wrap=True) |
| + markdown(text) |
| |
| -Mistune has all features by default. You don't have to configure anything. |
| |
| Renderer |
| -------- |
| @@ -79,7 +112,7 @@ Here is an example of code highlighting: |
| from pygments.lexers import get_lexer_by_name |
| from pygments.formatters import HtmlFormatter |
| |
| - class MyRenderer(mistune.Renderer): |
| + class HighlightRenderer(mistune.Renderer): |
| def block_code(self, code, lang): |
| if not lang: |
| return '\n<pre><code>%s</code></pre>\n' % \ |
| @@ -88,9 +121,9 @@ Here is an example of code highlighting: |
| formatter = HtmlFormatter() |
| return highlight(code, lexer, formatter) |
| |
| - renderer = MyRenderer() |
| - md = mistune.Markdown(renderer=renderer) |
| - print(md.render('Some Markdown text.')) |
| + renderer = HighlightRenderer() |
| + markdown = mistune.Markdown(renderer=renderer) |
| + print(markdown('Some code text.')) |
| |
| |
| Block Level |
| @@ -127,34 +160,18 @@ Here is a list of span level renderer API:: |
| linebreak() |
| newline() |
| link(link, title, content) |
| - tag(html) |
| strikethrough(text) |
| text(text) |
| + inline_html(text) |
| |
| +Footnotes |
| +~~~~~~~~~ |
| |
| -Options |
| -------- |
| - |
| -Here is a list of all options that will affect the rendering results: |
| - |
| -.. code:: python |
| - |
| - renderer = mistune.Renderer(escape=True) |
| - md = mistune.Markdown(renderer=renderer) |
| - md.render(text) |
| - |
| -* **escape**: if set to *True*, all raw html tags will be escaped. |
| -* **hard_wrap**: if set to *True*, it will has GFM line breaks feature. |
| -* **use_xhtml**: if set to *True*, all tags will be in xhtml, for example: ``<hr />``. |
| -* **parse_html**: parse text in block level html. |
| - |
| -When using the default renderer, you can use one of the following shorthands:: |
| - |
| - mistune.markdown(text, escape=True) |
| - |
| - md = mistune.Markdown(escape=True) |
| - md.render(text) |
| +Here is a list of renderers related to footnotes:: |
| |
| + footnote_ref(key, index) |
| + footnote_item(key, text) |
| + footnotes(text) |
| |
| Lexers |
| ------ |
| @@ -172,33 +189,23 @@ It is an inline grammar, which requires custom ``InlineGrammar`` and |
| import copy |
| from mistune import Renderer, InlineGrammar, InlineLexer |
| |
| - class MyRenderer(Renderer): |
| + class WikiLinkRenderer(Renderer): |
| def wiki_link(self, alt, link): |
| return '<a href="%s">%s</a>' % (link, alt) |
| |
| + class WikiLinkInlineLexer(InlineLexer): |
| + def enable_wiki_link(self): |
| + # add wiki_link rules |
| + self.rules.wiki_link = re.compile( |
| + r'\[\[' # [[ |
| + r'([\s\S]+?\|[\s\S]+?)' # Page 2|Page 2 |
| + r'\]\](?!\])' # ]] |
| + ) |
| |
| - class MyInlineGrammar(InlineGrammar): |
| - # it would take a while for creating the right regex |
| - wiki_link = re.compile( |
| - r'\[\[' # [[ |
| - r'([\s\S]+?\|[\s\S]+?)' # Page 2|Page 2 |
| - r'\]\](?!\])' # ]] |
| - ) |
| - |
| - |
| - class MyInlineLexer(InlineLexer): |
| - default_rules = copy.copy(InlineLexer.default_rules) |
| - |
| - # Add wiki_link parser to default rules |
| - # you can insert it any place you like |
| - default_rules.insert(3, 'wiki_link') |
| - |
| - def __init__(self, renderer, rules=None, **kwargs): |
| - if rules is None: |
| - # use the inline grammar |
| - rules = MyInlineGrammar() |
| - |
| - super(MyInlineLexer, self).__init__(renderer, rules, **kwargs) |
| + # Add wiki_link parser to default rules |
| + # you can insert it some place you like |
| + # but place matters, maybe 3 is not good |
| + self.default_rules.insert(3, 'wiki_link') |
| |
| def output_wiki_link(self, m): |
| text = m.group(1) |
| @@ -211,8 +218,10 @@ You should pass the inline lexer to ``Markdown`` parser: |
| |
| .. code:: python |
| |
| - renderer = MyRenderer() |
| - inline = MyInlineLexer(renderer) |
| + renderer = WikiLinkRenderer() |
| + inline = WikiLinkInlineLexer(renderer) |
| + # enable the feature |
| + inline.enable_wiki_link() |
| markdown = Markdown(renderer, inline=inline) |
| markdown('[[Link Text|Wiki Link]]') |
| |
| @@ -220,12 +229,21 @@ It is the same with block level lexer. It would take a while to understand |
| the whole mechanism. But you won't do the trick a lot. |
| |
| |
| -Contribution |
| ------------- |
| +Contribution & Extensions |
| +------------------------- |
| |
| Mistune itself doesn't accept any extension. It will always be a simple one |
| file script. |
| |
| If you want to add features, you can head over to `mistune-contrib`_. |
| |
| +Here are some extensions already in `mistune-contrib`_: |
| + |
| +* Math/MathJax features |
| +* Highlight Code Renderer |
| +* TOC table of content features |
| +* MultiMarkdown Metadata parser |
| + |
| +Get inspired with the contrib repository. |
| + |
| .. _`mistune-contrib`: https://github.com/lepture/mistune-contrib |
| diff --git a/mistune.py b/mistune.py |
| index 316f86d..86d215e 100644 |
| --- a/mistune.py |
| +++ b/mistune.py |
| @@ -476,6 +476,11 @@ class InlineLexer(object): |
| 'double_emphasis', 'emphasis', 'code', |
| 'linebreak', 'strikethrough', 'text', |
| ] |
| + inline_html_rules = [ |
| + 'escape', 'autolink', 'url', 'link', 'reflink', |
| + 'nolink', 'double_emphasis', 'emphasis', 'code', |
| + 'linebreak', 'strikethrough', 'text', |
| + ] |
| |
| def __init__(self, renderer, rules=None, **kwargs): |
| self.renderer = renderer |
| @@ -491,6 +496,10 @@ class InlineLexer(object): |
| self._in_link = False |
| self._in_footnote = False |
| |
| + kwargs.update(self.renderer.options) |
| + _to_parse = kwargs.get('parse_html') or kwargs.get('parse_inline_html') |
| + self._parse_inline_html = _to_parse |
| + |
| def __call__(self, text): |
| return self.output(text) |
| |
| @@ -553,7 +562,15 @@ class InlineLexer(object): |
| return self.renderer.autolink(link, False) |
| |
| def output_inline_html(self, m): |
| - return self.renderer.inline_html(m.group(0)) |
| + text = m.group(0) |
| + if self._parse_inline_html: |
| + if m.group(1) == 'a': |
| + self._in_link = True |
| + text = self.output(text, rules=self.inline_html_rules) |
| + self._in_link = False |
| + else: |
| + text = self.output(text, rules=self.inline_html_rules) |
| + return self.renderer.inline_html(text) |
| |
| def output_footnote(self, m): |
| key = _keyify(m.group(1)) |
| @@ -909,6 +926,10 @@ class Markdown(object): |
| self.footnotes = [] |
| self.tokens = [] |
| |
| + # detect if it should parse text in block html |
| + _to_parse = kwargs.get('parse_html') or kwargs.get('parse_block_html') |
| + self._parse_block_html = _to_parse |
| + |
| def __call__(self, text): |
| return self.parse(text) |
| |
| @@ -1072,7 +1093,7 @@ class Markdown(object): |
| |
| def output_block_html(self): |
| text = self.token['text'] |
| - if self.options.get('parse_html') and not self.token.get('pre'): |
| + if self._parse_block_html and not self.token.get('pre'): |
| text = self.inline(text) |
| return self.renderer.block_html(text) |
| |
| diff --git a/tests/test_cases.py b/tests/test_cases.py |
| index 933fa4c..3853a67 100644 |
| --- a/tests/test_cases.py |
| +++ b/tests/test_cases.py |
| @@ -99,12 +99,36 @@ def test_use_xhtml(): |
| assert '<img src="bar" alt="foo" title="title" />' in ret |
| |
| |
| -def test_block_html(): |
| +def test_parse_html(): |
| ret = mistune.markdown('<div>**foo**</div>') |
| assert '<strong>' not in ret |
| ret = mistune.markdown('<div>**foo**</div>', parse_html=True) |
| assert '<strong>' in ret |
| |
| + ret = mistune.markdown('<span>**foo**</span>') |
| + assert '<strong>' not in ret |
| + ret = mistune.markdown('<span>**foo**</span>', parse_html=True) |
| + assert '<strong>' in ret |
| + |
| + ret = mistune.markdown('<span>http://example.com</span>', parse_html=True) |
| + assert 'href' in ret |
| + ret = mistune.markdown('<a>http://example.com</a>', parse_html=True) |
| + assert 'href' not in ret |
| + |
| + |
| +def test_parse_inline_html(): |
| + ret = mistune.markdown('<div>**foo**</div>', parse_inline_html=True) |
| + assert '<strong>' not in ret |
| + ret = mistune.markdown('<span>**foo**</span>', parse_inline_html=True) |
| + assert '<strong>' in ret |
| + |
| + |
| +def test_parse_block_html(): |
| + ret = mistune.markdown('<div>**foo**</div>', parse_block_html=True) |
| + assert '<strong>' in ret |
| + ret = mistune.markdown('<span>**foo**</span>', parse_block_html=True) |
| + assert '<strong>' not in ret |
| + |
| |
| def test_trigger_more_cases(): |
| markdown = mistune.Markdown( |
| @@ -114,79 +138,3 @@ def test_trigger_more_cases(): |
| ) |
| ret = markdown.render('foo[^foo]\n\n[^foo]: foo\n\n[^foo]: bar\n') |
| assert 'bar' not in ret |
| - |
| - |
| -def test_custom_lexer(): |
| - import copy |
| - |
| - class MyInlineGrammar(mistune.InlineGrammar): |
| - # it would take a while for creating the right regex |
| - wiki_link = re.compile( |
| - r'\[\[' # [[ |
| - r'([\s\S]+?\|[\s\S]+?)' # Page 2|Page 2 |
| - r'\]\](?!\])' # ]] |
| - ) |
| - |
| - class MyInlineLexer(mistune.InlineLexer): |
| - default_rules = copy.copy(mistune.InlineLexer.default_rules) |
| - default_rules.insert(3, 'wiki_link') |
| - |
| - def __init__(self, renderer, rules=None, **kwargs): |
| - if rules is None: |
| - rules = MyInlineGrammar() |
| - |
| - super(MyInlineLexer, self).__init__(renderer, rules, **kwargs) |
| - |
| - def output_wiki_link(self, m): |
| - text = m.group(1) |
| - alt, link = text.split('|') |
| - return '<a href="%s">%s</a>' % (link, alt) |
| - |
| - markdown = mistune.Markdown(inline=MyInlineLexer) |
| - ret = markdown('[[Link Text|Wiki Link]]') |
| - assert '<a href' in ret |
| - |
| - |
| -def test_token_tree(): |
| - """Tests a Renderer that returns a list from the placeholder method.""" |
| - |
| - class CustomRenderer(mistune.Renderer): |
| - def placeholder(self): |
| - return [] |
| - |
| - def __getattribute__(self, name): |
| - """Saves the arguments to each Markdown handling method.""" |
| - found = CustomRenderer.__dict__.get(name) |
| - if found: |
| - return object.__getattribute__(self, name) |
| - |
| - def fake_method(*args, **kwargs): |
| - return [(name, args, kwargs)] |
| - return fake_method |
| - |
| - with open(os.path.join(root, 'fixtures', 'data', 'tree.md')) as f: |
| - content = f.read() |
| - |
| - expected = [ |
| - ('header', ([('text', ('Title here',), {})], 2, 'Title here'), {}), |
| - ('paragraph', ([('text', ('Some text.',), {})],), {}), |
| - ('paragraph', |
| - ([('text', ('In two paragraphs. And then a list.',), {})],), |
| - {}), |
| - ('list', |
| - ([('list_item', ([('text', ('foo',), {})],), {}), |
| - ('list_item', |
| - ([('text', ('bar',), {}), |
| - ('list', |
| - ([('list_item', ([('text', ('meep',), {})],), {}), |
| - ('list_item', ([('text', ('stuff',), {})],), {})], |
| - True), |
| - {})],), |
| - {})], |
| - False), |
| - {}) |
| - ] |
| - |
| - processor = mistune.Markdown(renderer=CustomRenderer()) |
| - found = processor.render(content) |
| - assert expected == found, "Expected:\n%r\n\nFound:\n%r" % (expected, found) |
| diff --git a/tests/test_subclassing.py b/tests/test_subclassing.py |
| index 2cebfc0..f0df225 100644 |
| --- a/tests/test_subclassing.py |
| +++ b/tests/test_subclassing.py |
| @@ -2,6 +2,7 @@ |
| |
| import os |
| import re |
| +import copy |
| import mistune |
| |
| root = os.path.dirname(__file__) |
| @@ -73,7 +74,7 @@ class MarkdownWithMath(mistune.Markdown): |
| ) |
| |
| |
| -class CustomRenderer(mistune.Renderer): |
| +class MathRenderer(mistune.Renderer): |
| def block_math(self, text): |
| return '$$%s$$' % text |
| |
| @@ -92,7 +93,7 @@ def assert_data(filename): |
| else: |
| text = filename |
| |
| - rv = MarkdownWithMath(renderer=CustomRenderer()).render(text) |
| + rv = MarkdownWithMath(renderer=MathRenderer()).render(text) |
| assert text in rv |
| |
| |
| @@ -109,3 +110,82 @@ def test_markdown2html_math(): |
| def test_math_paragraph(): |
| # https://github.com/ipython/ipython/issues/6724 |
| assert_data('math-paragraph.md') |
| + |
| + |
| +class WikiInlineGrammar(mistune.InlineGrammar): |
| + # it would take a while for creating the right regex |
| + wiki_link = re.compile( |
| + r'\[\[' # [[ |
| + r'([\s\S]+?\|[\s\S]+?)' # Page 2|Page 2 |
| + r'\]\](?!\])' # ]] |
| + ) |
| + |
| + |
| +class WikiInlineLexer(mistune.InlineLexer): |
| + default_rules = copy.copy(mistune.InlineLexer.default_rules) |
| + default_rules.insert(3, 'wiki_link') |
| + |
| + def __init__(self, renderer, rules=None, **kwargs): |
| + if rules is None: |
| + rules = WikiInlineGrammar() |
| + |
| + super(WikiInlineLexer, self).__init__(renderer, rules, **kwargs) |
| + |
| + def output_wiki_link(self, m): |
| + text = m.group(1) |
| + alt, link = text.split('|') |
| + return '<a href="%s">%s</a>' % (link, alt) |
| + |
| + |
| +def test_custom_lexer(): |
| + markdown = mistune.Markdown(inline=WikiInlineLexer) |
| + ret = markdown('[[Link Text|Wiki Link]]') |
| + assert '<a href' in ret |
| + |
| + |
| +class TokenTreeRenderer(mistune.Renderer): |
| + # options is required |
| + options = {} |
| + |
| + def placeholder(self): |
| + return [] |
| + |
| + def __getattribute__(self, name): |
| + """Saves the arguments to each Markdown handling method.""" |
| + found = TokenTreeRenderer.__dict__.get(name) |
| + if found is not None: |
| + return object.__getattribute__(self, name) |
| + |
| + def fake_method(*args, **kwargs): |
| + return [(name, args, kwargs)] |
| + return fake_method |
| + |
| + |
| +def test_token_tree(): |
| + """Tests a Renderer that returns a list from the placeholder method.""" |
| + with open(os.path.join(root, 'fixtures', 'data', 'tree.md')) as f: |
| + content = f.read() |
| + |
| + expected = [ |
| + ('header', ([('text', ('Title here',), {})], 2, 'Title here'), {}), |
| + ('paragraph', ([('text', ('Some text.',), {})],), {}), |
| + ('paragraph', |
| + ([('text', ('In two paragraphs. And then a list.',), {})],), |
| + {}), |
| + ('list', |
| + ([('list_item', ([('text', ('foo',), {})],), {}), |
| + ('list_item', |
| + ([('text', ('bar',), {}), |
| + ('list', |
| + ([('list_item', ([('text', ('meep',), {})],), {}), |
| + ('list_item', ([('text', ('stuff',), {})],), {})], |
| + True), |
| + {})],), |
| + {})], |
| + False), |
| + {}) |
| + ] |
| + |
| + processor = mistune.Markdown(renderer=TokenTreeRenderer()) |
| + found = processor.render(content) |
| + assert expected == found, "Expected:\n%r\n\nFound:\n%r" % (expected, found) |
