Track placeholder callables into parser and onto component elements for end tag check.

Author: ianjosephwilson

tdom/nodes.py

@@ -77,11 +77,17 @@ def __str__(self) -> str:
         return f"<!DOCTYPE {self.text}>"
 
 
+@dataclass
+class ComponentInfo:
+    endtag: str | None
+
+
 @dataclass(slots=True)
 class Element(Node):
     tag: str
     attrs: dict[str, str | None] = field(default_factory=dict)
     children: list[Node] = field(default_factory=list)
+    component_info: ComponentInfo | None = None
 
     def __post_init__(self):
         """Ensure all preconditions are met."""

tdom/parser.py

@@ -15,6 +15,7 @@
     Fragment,
     Node,
     Text,
+    ComponentInfo,
 )
 
 _FRAGMENT_TAG = f"t🐍f-{''.join(random.choices(string.ascii_lowercase, k=4))}-"
@@ -23,11 +24,16 @@
 class NodeParser(HTMLParser):
     root: Fragment
     stack: list[Element]
+    placeholder_callables: dict[str, int]
 
-    def __init__(self):
+    def __init__(self, placeholder_callables: dict[str, int] | None = None):
         super().__init__()
         self.root = Fragment(children=[])
         self.stack = []
+        if placeholder_callables is None:
+            self.placeholder_callables = {}
+        else:
+            self.placeholder_callables = placeholder_callables
 
     def handle_starttag(
         self, tag: str, attrs: t.Sequence[tuple[str, str | None]]
@@ -42,16 +48,24 @@ def handle_startendtag(
         self, tag: str, attrs: t.Sequence[tuple[str, str | None]]
     ) -> None:
         node = Element(tag, attrs=LastUpdatedOrderedDict(attrs), children=[])
+        if node.tag in self.placeholder_callables:
+            node.component_info = ComponentInfo(endtag=None)
         self.append_element_child(node)
 
     def handle_endtag(self, tag: str) -> None:
         if not self.stack:
             raise ValueError(f"Unexpected closing tag </{tag}> with no open element.")
 
         element = self.stack.pop()
-        if element.tag != tag:
+        if element.tag != tag and (
+            element.tag not in self.placeholder_callables
+            or self.placeholder_callables[element.tag]
+            != self.placeholder_callables[tag]
+        ):
             raise ValueError(f"Mismatched closing tag </{tag}> for <{element.tag}>.")
 
+        if element.tag in self.placeholder_callables:
+            element.component_info = ComponentInfo(endtag=tag)
         self.append_element_child(element)
 
     def handle_data(self, data: str) -> None:
@@ -130,7 +144,9 @@ def feed(self, data: str) -> None:
         super().feed(data)
 
 
-def parse_html(input: str | t.Iterable[str]) -> Node:
+def parse_html(
+    input: str | t.Iterable[str], placeholder_callables: dict[str, int] | None = None
+) -> Node:
     """
     Parse a string, or sequence of HTML string chunks, into a Node tree.
 
@@ -139,7 +155,7 @@ def parse_html(input: str | t.Iterable[str]) -> Node:
     This is particularly useful if you want to keep specific text chunks
     separate in the resulting Node tree.
     """
-    parser = NodeParser()
+    parser = NodeParser(placeholder_callables=placeholder_callables)
     iterable = [input] if isinstance(input, str) else input
     for chunk in iterable:
         parser.feed(chunk)

tdom/processor.py

@@ -138,7 +138,7 @@ def _replace_placeholders(
 
 def _instrument(
     strings: tuple[str, ...], callable_infos: tuple[CallableInfo | None, ...]
-) -> t.Iterable[str]:
+) -> tuple[list[str], dict[str, int]]:
     """
     Join the strings with placeholders in between where interpolations go.
 
@@ -150,24 +150,24 @@ def _instrument(
     """
     count = len(strings)
 
-    callable_placeholders: dict[int, str] = {}
+    placeholder_callables: dict[str, int] = {}
 
+    parts = []
     for i, s in enumerate(strings):
-        yield s
+        parts.append(s)
         # There are always count-1 placeholders between count strings.
         if i < count - 1:
             placeholder = _placeholder(i)
 
             # Special case for component callables: if the interpolation
             # is a callable, we need to make sure that any matching closing
-            # tag uses the same placeholder.
+            # tag's placeholder is the same callable
             callable_info = callable_infos[i]
             if callable_info:
-                placeholder = callable_placeholders.setdefault(
-                    callable_info.id, placeholder
-                )
+                placeholder_callables[placeholder] = callable_info.id
 
-            yield placeholder
+            parts.append(placeholder)
+    return parts, placeholder_callables
 
 
 @lru_cache(maxsize=0 if "pytest" in sys.modules else 512)
@@ -190,8 +190,8 @@ def _instrument_and_parse(cached_template: CachedTemplate) -> Node:
     callable_infos = tuple(
         _callable_info(interpolation.value) for interpolation in template.interpolations
     )
-    instrumented = _instrument(template.strings, callable_infos)
-    return parse_html(instrumented)
+    instrumented, placeholder_callables = _instrument(template.strings, callable_infos)
+    return parse_html(instrumented, placeholder_callables=placeholder_callables)
 
 
 def _callable_info(value: object) -> CallableInfo | None:
@@ -522,9 +522,26 @@ def _substitute_node(p_node: Node, interpolations: tuple[Interpolation, ...]) ->
             interpolation = interpolations[index]
             value = format_interpolation(interpolation)
             return _node_from_value(value)
-        case Element(tag=tag, attrs=attrs, children=children):
+        case Element(
+            tag=tag, attrs=attrs, children=children, component_info=component_info
+        ):
             new_children = _substitute_and_flatten_children(children, interpolations)
             if (index := _find_placeholder(tag)) is not None:
+                if component_info is None:
+                    raise TypeError(
+                        "Only callables can be used for interpolations located in tags."
+                    )
+                elif component_info.endtag is not None:
+                    end_index = _find_placeholder(component_info.endtag)
+                    if end_index is None:
+                        # Avoid typecheck errors.
+                        raise ValueError(
+                            "The endtag of a component must be an interpolation."
+                        )
+                    elif interpolations[index].value != interpolations[end_index].value:
+                        raise ValueError(
+                            "The endtag interpolation's value should match the starttag interpolation's value."
+                        )
                 component_attrs = _substitute_interpolated_attrs(attrs, interpolations)
                 return _invoke_component(
                     component_attrs, new_children, interpolations[index]