Secure your code as it's written. Use Snyk Code to scan source code in minutes - no build needed - and fix issues immediately.
def setUp(self):
config = configparser.ConfigParser()
config.read("content/config/unit_test.ini")
self.parser = simdem.Parser(mistune.BlockLexer())
def test_trigger_more_cases():
markdown = mistune.Markdown(
inline=mistune.InlineLexer,
block=mistune.BlockLexer,
skip_html=True
)
ret = markdown.render('foo[^foo]\n\n[^foo]: foo\n\n[^foo]: bar\n')
assert 'bar' not in ret
import re
import copy
import mistune
root = os.path.dirname(__file__)
class MathBlockGrammar(mistune.BlockGrammar):
block_math = re.compile(r'^\$\$(.*?)\$\$', re.DOTALL)
latex_environment = re.compile(
r"^\\begin\{([a-z]*\*?)\}(.*?)\\end\{\1\}",
re.DOTALL
)
class MathBlockLexer(mistune.BlockLexer):
default_rules = ['block_math', 'latex_environment'] + \
mistune.BlockLexer.default_rules
def __init__(self, rules=None, **kwargs):
if rules is None:
rules = MathBlockGrammar()
super(MathBlockLexer, self).__init__(rules, **kwargs)
def parse_block_math(self, m):
"""Parse a $$math$$ block"""
self.tokens.append({
'type': 'block_math',
'text': m.group(1)
})
def parse_latex_environment(self, m):
import re
from mistune import BlockLexer
class PanelBlockLexer(BlockLexer):
def __init__(self, *args, **kwargs):
super(PanelBlockLexer, self).__init__(*args, **kwargs)
self.has_lead = False
self.enable_panel()
self.enable_paywall()
def enable_panel(self):
self.rules.panel_block = re.compile(r'\[ (.+)\n'
r'\n'
r'((?:.*?\n)*?)'
r'\n'
r'\]'
)
self.default_rules.insert(3, 'panel_block')
return f"{text}\n{'='*len(text)}\n"
def paragraph(self, text):
return text + "\n\n"
def block_code(self, code, language=None):
code = "\n".join([" " + line for line in code.splitlines()])
return super().block_code(code)
def header(self, text, level, raw=None):
if level == 2:
header_text = self._to_title(text)
return super().header(header_text, 2)
class RedisDocLexer(mistune.BlockLexer):
def enable_at_title(self):
self.rules.at_title = re.compile(r"^@(\w+) *(?:\n+|$)") # @example
self.default_rules.insert(0, "at_title")
def parse_at_title(self, m):
text = m.group(1)
self.tokens.append({"type": "heading", "level": 2, "text": text})
renderer = TerminalRender()
block_lexer = RedisDocLexer()
block_lexer.enable_at_title()
markdown_render = mistune.Markdown(renderer, block=block_lexer)
def render(text):
class MathMarkdown(mistune.Markdown):
def output_block_math(self):
return self.renderer.block_math(self.token["text"])
class MathInlineLexer(mistune.InlineLexer):
def __init__(self, *args, **kwargs):
super(MathInlineLexer, self).__init__(*args, **kwargs)
self.rules.inline_math = re.compile(r"\\\((.*?)\\\)", re.DOTALL)
self.default_rules.insert(0, "inline_math")
def output_inline_math(self, m):
return self.renderer.inline_math(m.group(1))
class MathBlockLexer(mistune.BlockLexer):
def __init__(self, *args, **kwargs):
super(MathBlockLexer, self).__init__(*args, **kwargs)
self.rules.block_math = re.compile(r"^\$\$(.*?)\$\$", re.DOTALL)
self.default_rules.insert(0, "block_math")
def parse_block_math(self, m):
self.tokens.append({"type": "block_math", "text": m.group(1)})
class MathRenderer(mistune.Renderer):
def __init__(self, **kwargs):
super(MathRenderer, self).__init__(**kwargs)
def block_math(self, text):
return "<p>$$%s$$</p>\n" % text
class FluffyMarkdownRenderer(
CodeRendererMixin,
mistune.Renderer,
):
pass
class FluffyMarkdownInlineLexer(
mistune.InlineLexer,
HtmlCommentsInlineLexerMixin,
):
pass
class FluffyMarkdownBlockLexer(
mistune.BlockLexer,
HtmlCommentsBlockLexerMixin,
):
pass
_renderer = FluffyMarkdownRenderer(
escape=True,
hard_wrap=False,
)
_inline = FluffyMarkdownInlineLexer(_renderer)
_inline.enable_html_comments()
_block = FluffyMarkdownBlockLexer(mistune.BlockGrammar())
_block.enable_html_comments()