Refactor: split __applyPattern into 2 overloads

Author: oprypin

markdown/treeprocessors.py

@@ -26,6 +26,7 @@
 
 from __future__ import annotations
 
+import functools
 import re
 import xml.etree.ElementTree as etree
 from typing import TYPE_CHECKING, Any
@@ -250,13 +251,14 @@ def linkText(text: str | None) -> None:
 
         return result
 
+    @functools.singledispatchmethod
     def __applyPattern(
         self,
-        pattern: inlinepatterns.Pattern,
         data: str,
         patternIndex: int,
         startIndex: int = 0
-    ) -> tuple[str, bool, int]:
         """
         Check if the line fits the pattern, create the necessary
         elements, add it to `stashed_nodes`.
@@ -271,64 +273,85 @@ def __applyPattern(
             String with placeholders instead of `ElementTree` elements.
 
         """
-        new_style = isinstance(pattern, inlinepatterns.InlineProcessor)
-
         for exclude in pattern.ANCESTOR_EXCLUDES:
             if exclude.lower() in self.ancestors:
                 return data, False, 0
 
-        if new_style:
-            match = None
-            # Since `handleMatch` may reject our first match,
-            # we iterate over the buffer looking for matches
-            # until we can't find any more.
-            for match in pattern.getCompiledRegExp().finditer(data, startIndex):
-                node, start, end = pattern.handleMatch(match, data)
-                if start is None or end is None:
-                    startIndex += match.end(0)
-                    match = None
-                    continue
-                break
-        else:  # pragma: no cover
-            match = pattern.getCompiledRegExp().match(data[startIndex:])
-            leftData = data[:startIndex]
 
         if not match:
             return data, False, 0
 
-        if not new_style:  # pragma: no cover
-            node = pattern.handleMatch(match)
-            start = match.start(0)
-            end = match.end(0)
+
+        if not isinstance(node, str):
+            self.__handleInlineForChildNodes(node, patternIndex)
+
+        placeholder = self.__stashNode(node, pattern.type())
+
+        return "{}{}{}{}".format(leftData,
+                                 match.group(1),
+                                 placeholder, match.groups()[-1]), True, 0
+
+    @__applyPattern.register
+    def _(
+        self,
+        pattern: inlinepatterns.InlineProcessor,
+        data: str,
+        patternIndex: int,
+        startIndex: int = 0
+    ) -> tuple[str, bool, int]:
+        # This overload handles new-style patterns.
+        for exclude in pattern.ANCESTOR_EXCLUDES:
+            if exclude.lower() in self.ancestors:
+                return data, False, 0
+
+        match = None
+        # Since `handleMatch` may reject our first match,
+        # we iterate over the buffer looking for matches
+        # until we can't find any more.
+        for match in pattern.getCompiledRegExp().finditer(data, startIndex):
+            node, start, end = pattern.handleMatch(match, data)
+            if start is None or end is None:
+                startIndex += match.end(0)
+                match = None
+                continue
+            break
+
+        if not match:
+            return data, False, 0
 
         if node is None:
             return data, True, end
 
         if not isinstance(node, str):
-            if not isinstance(node.text, util.AtomicString):
-                # We need to process current node too
-                for child in [node] + list(node):
-                    if not isString(node):
-                        if child.text:
-                            self.ancestors.append(child.tag.lower())
-                            child.text = self.__handleInline(
-                                child.text, patternIndex + 1
-                            )
-                            self.ancestors.pop()
-                        if child.tail:
-                            child.tail = self.__handleInline(
-                                child.tail, patternIndex
-                            )
 
         placeholder = self.__stashNode(node, pattern.type())
 
-        if new_style:
-            return "{}{}{}".format(data[:start],
-                                   placeholder, data[end:]), True, 0
-        else:  # pragma: no cover
-            return "{}{}{}{}".format(leftData,
-                                     match.group(1),
-                                     placeholder, match.groups()[-1]), True, 0
+                if not isString(node):
+                    if child.text:
+                        self.ancestors.append(child.tag.lower())
+                        child.text = self.__handleInline(
+                            child.text, patternIndex + 1
+                        )
+                        self.ancestors.pop()
+                    if child.tail:
+                        child.tail = self.__handleInline(
+                            child.tail, patternIndex
+                        )
 
     def __build_ancestors(self, parent: etree.Element | None, parents: list[str]) -> None:
         """Build the ancestor list."""