jlec 15/06/22 08:24:26 Added: mistune-0.6-inline-html.patch Log: Backport patches for API break in last version (Portage version: 2.2.20/cvs/Linux x86_64, signed Manifest commit with key E9402A79B03529A2!)
Revision Changes Path 1.1 dev-python/mistune/files/mistune-0.6-inline-html.patch file : http://sources.gentoo.org/viewvc.cgi/gentoo-x86/dev-python/mistune/files/mistune-0.6-inline-html.patch?rev=1.1&view=markup plain: http://sources.gentoo.org/viewvc.cgi/gentoo-x86/dev-python/mistune/files/mistune-0.6-inline-html.patch?rev=1.1&content-type=text/plain Index: mistune-0.6-inline-html.patch =================================================================== 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)
