perf: improve performance

Author: lepture

src/mistune/block_parser.py

@@ -20,6 +20,8 @@
 )
 from .list_parser import parse_list, LIST_PATTERN
 
+DEFAULT_MAX_NESTED_LEVEL = 20
+
 _INDENT_CODE_TRIM = re.compile(r"^ {1,4}", flags=re.M)
 _ATX_HEADING_TRIM = re.compile(r"(\s+|^)#+\s*$")
 _BLOCK_QUOTE_TRIM = re.compile(r"^ ?", flags=re.M)
@@ -92,7 +94,7 @@ def __init__(
         self,
         block_quote_rules: Optional[List[str]] = None,
         list_rules: Optional[List[str]] = None,
-        max_nested_level: int = 100,
+        max_nested_level: int = DEFAULT_MAX_NESTED_LEVEL,
     ):
         super(BlockParser, self).__init__()
 

src/mistune/core.py

@@ -17,7 +17,6 @@
     Type,
     TypeVar,
     Union,
-    cast,
 )
 
 if sys.version_info >= (3, 11):
@@ -201,6 +200,7 @@ def register(
         :param before: insert this rule before a built-in rule
         """
         self._methods[name] = lambda m, state: func(self, m, state)
+        self.__sc.clear()
         if pattern:
             self.specification[name] = pattern
         if name not in self.rules:
@@ -246,7 +246,7 @@ def render_wiki(renderer, key, title):
 
     def _get_method(self, name: str) -> Callable[..., str]:
         try:
-            return cast(Callable[..., str], object.__getattribute__(self, name))
+            return object.__getattribute__(self, name)
         except AttributeError:
             method = self.__methods.get(name)
             if not method:

src/mistune/inline_parser.py

@@ -86,6 +86,8 @@ def __init__(self, hard_wrap: bool = False) -> None:
 
         self.hard_wrap = hard_wrap
         self._fast_trigger_chars: Optional[Set[str]] = None
+        self._fast_trigger_re: Optional[re.Pattern[str]] = None
+        self._fast_trigger_re_chars: Optional[Tuple[str, ...]] = None
         # lazy add linebreak
         if hard_wrap:
             self.specification["linebreak"] = self.HARD_LINEBREAK
@@ -103,6 +105,8 @@ def register(
     ) -> None:
         super().register(name, pattern, func, before=before)
         self._fast_trigger_chars = None
+        self._fast_trigger_re = None
+        self._fast_trigger_re_chars = None
 
     def parse_escape(self, m: Match[str], state: InlineState) -> int:
         text = m.group(0)
@@ -372,24 +376,23 @@ def _find_fast_text_end(self, src: str, pos: int) -> Optional[int]:
         if chars is None:
             return None
 
-        end_pos: Optional[int] = None
-        for c in chars:
-            if c == "\n":
-                continue
-            p = src.find(c, pos)
-            if p != -1 and (end_pos is None or p < end_pos):
-                end_pos = p
-
-        if "\n" in chars:
-            p = src.find("\n", pos)
-            if p != -1:
-                p = self._find_linebreak_start(src, pos, p)
-                if end_pos is None or p < end_pos:
-                    end_pos = p
-
-        if end_pos is None:
+        trigger_re = self._get_fast_trigger_re(chars)
+        m = trigger_re.search(src, pos)
+        if m is None:
             return len(src)
-        return end_pos
+
+        if m.group(0) == "\n":
+            return self._find_linebreak_start(src, pos, m.start())
+        return m.start()
+
+    def _get_fast_trigger_re(self, chars: Set[str]) -> re.Pattern[str]:
+        key = tuple(sorted(chars))
+        if self._fast_trigger_re is None or self._fast_trigger_re_chars != key:
+            pattern = "[" + re.escape("".join(key)) + "]"
+            self._fast_trigger_re = re.compile(pattern)
+            self._fast_trigger_re_chars = key
+        assert self._fast_trigger_re is not None
+        return self._fast_trigger_re
 
     def _find_linebreak_start(self, src: str, min_pos: int, newline_pos: int) -> int:
         pos = newline_pos

tests/test_misc.py

@@ -154,6 +154,41 @@ def test_use_plugin(self):
         md = mistune.Markdown(mistune.HTMLRenderer())
         md.use(url)
 
+    def test_inline_plugin_refreshes_fast_trigger_cache(self):
+        def parse_at(inline, m, state):
+            state.append_token({"type": "at", "raw": m.group(0)})
+            return m.end()
+
+        def render_at(renderer, text):
+            return "<at>" + text + "</at>"
+
+        def plugin(md):
+            md.inline.register("at", r"@+", parse_at)
+            md.renderer.register("at", render_at)
+
+        md = mistune.create_markdown(escape=False)
+        md("plain text")
+        md.use(plugin)
+
+        self.assertEqual(md("@@").strip(), "<p><at>@@</at></p>")
+
+    def test_inline_plugin_with_untracked_trigger_uses_regex_scanner(self):
+        def parse_x(inline, m, state):
+            state.append_token({"type": "xword", "raw": m.group(0)})
+            return m.end()
+
+        def render_x(renderer, text):
+            return "<x>" + text + "</x>"
+
+        def plugin(md):
+            md.inline.register("xword", r"(?=x)x+", parse_x)
+            md.renderer.register("xword", render_x)
+
+        md = mistune.create_markdown(escape=False)
+        md.use(plugin)
+
+        self.assertEqual(md("xx").strip(), "<p><x>xx</x></p>")
+
     def test_markdown_func(self):
         result = mistune.markdown("**b**")
         expected = "<p><strong>b</strong></p>\n"
@@ -248,11 +283,18 @@ def test_html_tag_text_following_list(self):
         expected = "<p>foo</p>\n<ul>\n<li>bar</li>\n</ul>\n<p>table</p>"
         self.assertEqual(result.strip(), expected)
 
+    def test_max_nested_level_setting(self):
+        self.assertEqual(mistune.BlockParser().max_nested_level, 20)
+        self.assertEqual(mistune.create_markdown().block.max_nested_level, 20)
+        md = mistune.Markdown(block=mistune.BlockParser(max_nested_level=7))
+        self.assertEqual(md.block.max_nested_level, 7)
+
     def test_deeply_nested_block_quote_and_list(self):
         # Block quotes and lists each capped their own nesting at the limit but
         # not each other's, so alternating them recursed without bound. This
         # must terminate instead of raising RecursionError.
-        text = "".join(">" * i + " " + "- " * i + "item\n" for i in range(1, 300))
+        max_level = mistune.create_markdown().block.max_nested_level
+        text = "".join(">" * i + " " + "- " * i + "item\n" for i in range(1, max_level + 80))
         md = mistune.create_markdown()
         md(text)
         ast = mistune.create_markdown(renderer="ast")

tests/test_renderers.py

@@ -1,6 +1,6 @@
 from unittest import TestCase
 
-from mistune import create_markdown
+from mistune import BlockState, HTMLRenderer, create_markdown
 from mistune.renderers.rst import RSTRenderer
 from mistune.renderers.markdown import MarkdownRenderer
 from tests import BaseTestCase
@@ -65,3 +65,19 @@ def test_prose_not_over_escaped(self):
             "ratio a/b is fine\n",
         ):
             self.assert_round_trip(text)
+
+
+class TestRendererMethodRegistration(TestCase):
+    def test_registered_renderer_method(self):
+        renderer = HTMLRenderer(escape=False)
+
+        def render_wiki(renderer, key, title):
+            return f'<a href="/wiki/{key}">{title}</a>'
+
+        renderer.register("wiki", render_wiki)
+        token = {"type": "wiki", "raw": "python", "attrs": {"title": "Python"}}
+
+        self.assertEqual(
+            renderer.render_token(token, BlockState()),
+            '<a href="/wiki/python">Python</a>',
+        )