Token precendence about mistletoe HOT 3 CLOSED

I think I'm doing that only for HTMLSpan and not for HTMLBlock, in accordance with CommonMark. Part of the reason, and CommonMark is aware of this, is the performance cost when recursively rendering within HTML elements. The interesting thing is that CommonMark has some pretty particular definitions for HTMLBlock. Using these definitions, I think not rendering inner elements for HTMLBlock would be following the rule of least surprises. You can take a look at Section 4.6 in the spec in case you're interested.

Sorry for the late response! I'm closing the issue, but feel free to comment further.

from mistletoe.

I played with it a little, and perhaps this is what's going on. Using this code:

class Aside(SpanToken):
    pattern = re.compile(r"<aside>(.+?)</aside>")

class CustomRenderer(HTMLRenderer):
    def __init__(self):
        super().__init__(Aside)

    def render_aside(self, token):
        return '<aside>{}</aside>'.format(self.render_inner(token))

I can render:

bar <aside>*foo*</aside>

to:

<p>bar <aside><em>foo</em></aside></p>

But this markdown snippet will not render the inner emphasis:

<aside>*foo*</aside>

Because the entire block is first captured by the HTMLBlock token. To get around this, you need to define both a block-level aside tag and a span-level one, and pass both of them into the super constructor. Something like:

from mistletoe.span_token import tokenize_inner

class AsideBlock(BlockToken):
    def __init__(self, lines):
        # edit: strings are immutable! typo in the previous version of this reply
        lines[0] = lines[0].replace('<aside>', '')
        lines[-1] = lines[-1].replace('</aside>', '')
        super().__init__(''.join(lines), tokenize_inner)

    @classmethod
    def start(cls, line):
        return line.lstrip().startswith('<aside>')

    @classmethod
    def read(cls, lines):
        line_buffer = []
        for line in lines:
            line_buffer.append(line)
            if line.rstrip().endswith('</aside>') or line == '\n':
                break
        return line_buffer

By the way, rendering the inner elements of HTMLSpan should also be the standard behavior, and I'll probably add it soon. Let me know if there're any further questions!

from mistletoe.

Cool, this works. (Note: I did have to modify the AsideBlock init function a bit since strings are immutable so lines[0].replace returns a string but doesn't modify the given one). Thanks!

In terms of making it the default behavior to render inner elements, do you think you'd do that for both HTMLSpan and HTMLBlock or just one of them? I went back and forth on whether I wanted to do this for all elements or not - I think it probably makes sense, though I don't think it's strictly commonmark compliant.

from mistletoe.