diff options
Diffstat (limited to 'dev-python/mistune/files/mistune-0.6-inline-html.patch')
| -rw-r--r-- | dev-python/mistune/files/mistune-0.6-inline-html.patch | 536 |
1 files changed, 536 insertions, 0 deletions
diff --git a/dev-python/mistune/files/mistune-0.6-inline-html.patch b/dev-python/mistune/files/mistune-0.6-inline-html.patch new file mode 100644 index 00000000000..f10aee5b6d0 --- /dev/null +++ b/dev-python/mistune/files/mistune-0.6-inline-html.patch @@ -0,0 +1,536 @@ +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) |