Write a test for passing a component as an attribute.

Author: davepeck

.gitignore

@@ -8,3 +8,6 @@ wheels/
 
 # Virtual environments
 .venv
+
+# Coverage
+.coverage

html_tstring/parser.py

@@ -95,6 +95,7 @@ def close(self) -> None:
 
     def get_node(self) -> Node:
         """Get the Node tree parsed from the input HTML."""
+        # CONSIDER: Should we invert things and offer streaming parsing?
         assert not self.stack, "Did you forget to call close()?"
         if len(self.root.children) > 1:
             # The parse structure results in multiple root elements, so we

html_tstring/processor.py

@@ -77,6 +77,8 @@ def _instrument(
     """
     count = len(strings)
 
+    print("Instrumenting:", strings, callable_ids)  # DEBUG
+
     callable_placeholders: dict[int, str] = {}
 
     for i, s in enumerate(strings):
@@ -105,7 +107,9 @@ def _instrument_and_parse_internal(
     The result is cached to avoid re-parsing the same template multiple times.
     """
     instrumented = _instrument(strings, callable_ids)
-    return parse_html(instrumented)
+    i_list = list(instrumented)
+    print("Instrumented:", "".join(i_list))  # DEBUG
+    return parse_html(i_list)
 
 
 def _callable_id(value: object) -> int | None:
@@ -185,7 +189,9 @@ def _substitute_style_attr(value: object) -> t.Iterable[tuple[str, str | None]]:
         yield ("style", str(value))
 
 
-def _substitute_spread_attrs(value: object) -> t.Iterable[tuple[str, str | None]]:
+def _substitute_spread_attrs(
+    value: object,
+) -> t.Iterable[tuple[str, str | t.Callable | None]]:
     """
     Substitute a spread attribute based on the interpolated value.
 
@@ -212,7 +218,7 @@ def _substitute_spread_attrs(value: object) -> t.Iterable[tuple[str, str | None]
 def _substitute_attr(
     key: str,
     value: object,
-) -> t.Iterable[tuple[str, str | None]]:
+) -> t.Iterable[tuple[str, str | t.Callable | None]]:
     """
     Substitute a single attribute based on its key and the interpolated value.
 
@@ -234,15 +240,17 @@ def _substitute_attr(
             yield (key, None)
         case False | None:
             pass
+        case _ if callable(value):
+            yield (key, value)
         case _:
             yield (key, str(value))
 
 
 def _substitute_attrs(
     attrs: dict[str, str | None], interpolations: tuple[Interpolation, ...]
-) -> dict[str, str | None]:
+) -> dict[str, str | t.Callable | None]:
     """Substitute placeholders in attributes based on the corresponding interpolations."""
-    new_attrs: dict[str, str | None] = {}
+    new_attrs: dict[str, str | ComponentCallable | None] = {}
     for key, value in attrs.items():
         if value and value.startswith(_PLACEHOLDER_PREFIX):
             index = _placholder_index(value)
@@ -297,27 +305,35 @@ def _node_from_value(value: object) -> Node:
             children = [_node_from_value(v) for v in value]
             return Fragment(children=children)
         case HasHTMLDunder():
+            # CONSIDER: could we return a lazy Text?
             return Text(Markup(value.__html__()))
         case _:
+            # CONSIDER: could we return a lazy Text?
             return Text(str(value))
 
 
+type ComponentReturn = Node | Template | str | HasHTMLDunder
+type ComponentCallable = t.Callable[..., ComponentReturn | t.Iterable[ComponentReturn]]
+
+
 def _invoke_component(
     tag: str,
-    new_attrs: dict[str, str | None],
+    new_attrs: dict[str, str | t.Callable | None],
     new_children: list[Node],
     interpolations: tuple[Interpolation, ...],
 ) -> Node:
     """Substitute a component invocation based on the corresponding interpolations."""
     index = _placholder_index(tag)
     interpolation = interpolations[index]
     value = format_interpolation(interpolation)
+    # TODO: consider use of signature() or other approaches to validation.
     if not callable(value):
         raise TypeError(
             f"Expected a callable for component invocation, got {type(value).__name__}"
         )
     # Call the component and return the resulting node
     result = value(*new_children, **new_attrs)
+    print("RESULTIS:", result)  # DEBUG
     match result:
         case Node():
             return result
@@ -348,7 +364,10 @@ def _substitute_node(p_node: Node, interpolations: tuple[Interpolation, ...]) ->
             if tag.startswith(_PLACEHOLDER_PREFIX):
                 return _invoke_component(tag, new_attrs, new_children, interpolations)
             else:
-                return Element(tag=tag, attrs=new_attrs, children=new_children)
+                final_attrs = {
+                    k: str(v) if v is not None else None for k, v in new_attrs.items()
+                }
+                return Element(tag=tag, attrs=final_attrs, children=new_children)
         case Fragment(children=children):
             new_children = _substitute_and_flatten_children(children, interpolations)
             return Fragment(children=new_children)
@@ -367,4 +386,3 @@ def html(template: Template) -> Node:
     # where interpolations go.
     p_node = _instrument_and_parse(template)
     return _substitute_node(p_node, template.interpolations)
-    return _substitute_node(p_node, template.interpolations)

html_tstring/processor_test.py

@@ -5,7 +5,7 @@
 from markupsafe import Markup
 
 from .nodes import Element, Fragment, Node, Text
-from .processor import html
+from .processor import ComponentCallable, html
 
 # --------------------------------------------------------------------------
 # Basic HTML parsing tests
@@ -476,7 +476,7 @@ def test_interpolated_style_attribute():
 
 
 def TemplateComponent(
-    *children: Node, first: int, second: int, third: str, **attrs: t.Any
+    *children: Node, first: str, second: int, third: str, **attrs: t.Any
 ) -> Template:
     new_attrs = {
         "id": third,
@@ -532,3 +532,29 @@ def test_fragment_from_component():
         ],
     )
     assert str(node) == "<table><tr><td>Column 1</td><td>Column 2</td></tr></table>"
+
+
+def test_component_passed_as_attr_value():
+    def WrapperComponent(
+        *children: Node, another: ComponentCallable, **attrs: t.Any
+    ) -> Template:
+        print("WrapperComponent called with:", type(another), another)
+        return t"<{another} {attrs}>{children}</{another}>"
+
+    node = html(
+        t'<{WrapperComponent} another={TemplateComponent} class="wrapped" first=1 second={99} third="comp1"><p>Inside wrapper</p></{WrapperComponent}>'
+    )
+    assert node == Element(
+        "div",
+        attrs={
+            "id": "comp1",
+            "data-first": "1",
+            "data-second": "99",
+            "class": "wrapped",
+        },
+        children=[Text("Component: "), Element("p", children=[Text("Inside wrapper")])],
+    )
+    assert (
+        str(node)
+        == '<div id="comp1" data-first="1" data-second="99" class="wrapped">Component: <p>Inside wrapper</p></div>'
+    )

pyproject.toml

@@ -34,6 +34,7 @@ CI = "https://github.com/t-strings/html-tstring/actions"
 dev = [
   "pyright>=1.1.404",
   "pytest>=8.4.1",
+  "pytest-cov>=6.3.0",
   "pytest-watcher>=0.4.3",
   "ruff>=0.12.11",
 ]