Clarify attribute interpolation pipeline (#75)

* Add test for component spread attribute type coercion.

* Do not coerce general spread attributes until processing for html.

* Do not coerce True data attributes until processing back to html.

* Relax type restriction _within_ the pipeline.

* Check that static special attributes are passed through.

* Only process special attributes from interpolations and only process them once during the attrs pipeline.

* Add bare attribute test.

* Import bare attributes into the pipeline with a value of True.

Author: ianjosephwilson

tdom/processor.py

@@ -235,12 +235,12 @@ def _process_aria_attr(value: object) -> t.Iterable[tuple[str, str | None]]:
             yield f"aria-{sub_k}", str(sub_v)
 
 
-def _process_data_attr(value: object) -> t.Iterable[tuple[str, str | None]]:
+def _process_data_attr(value: object) -> t.Iterable[tuple[str, object | None]]:
     """Produce data-* attributes based on the interpolated value for "data"."""
     d = _force_dict(value, kind="data")
     for sub_k, sub_v in d.items():
         if sub_v is True:
-            yield f"data-{sub_k}", None
+            yield f"data-{sub_k}", True
         elif sub_v not in (False, None):
             yield f"data-{sub_k}", str(sub_v)
 
@@ -305,13 +305,18 @@ def _process_attr(
     if custom_processor := CUSTOM_ATTR_PROCESSORS.get(key):
         yield from custom_processor(value)
         return
+    yield (key, value)
 
-    # General handling for all other attributes:
+
+def _process_static_attr(
+    key: str, value: str | None
+) -> t.Iterable[tuple[str, object | None]]:
+    """
+    Bring static attributes, parsed from html but without interpolations, into the pipeline.
+    """
     match value:
-        case True:
-            yield (key, None)
-        case False | None:
-            pass
+        case None:
+            yield (key, True)
         case _:
             yield (key, value)
 
@@ -330,7 +335,8 @@ def _substitute_interpolated_attrs(
         if value is not None:
             has_placeholders, new_value = _replace_placeholders(value, interpolations)
             if has_placeholders:
-                new_attrs[key] = new_value
+                for sub_k, sub_v in _process_attr(key, new_value):
+                    new_attrs[sub_k] = sub_v
                 continue
 
         if (index := _find_placeholder(key)) is not None:
@@ -341,7 +347,8 @@ def _substitute_interpolated_attrs(
                 new_attrs[sub_k] = sub_v
         else:
             # Static attribute
-            new_attrs[key] = value
+            for sub_k, sub_v in _process_static_attr(key, value):
+                new_attrs[sub_k] = sub_v
     return new_attrs
 
 
@@ -354,9 +361,13 @@ def _process_html_attrs(attrs: dict[str, object]) -> dict[str, str | None]:
     """
     processed_attrs: dict[str, str | None] = {}
     for key, value in attrs.items():
-        for sub_k, sub_v in _process_attr(key, value):
-            # Convert to string, preserving None
-            processed_attrs[sub_k] = str(sub_v) if sub_v is not None else None
+        match value:
+            case True:
+                processed_attrs[key] = None
+            case False | None:
+                pass
+            case _:
+                processed_attrs[key] = str(value)
     return processed_attrs
 
 

tdom/processor_test.py

@@ -53,6 +53,13 @@ def test_parse_chain_of_void_elements():
     assert str(node) == '<br /><hr /><img src="image.png" /><br /><hr />'
 
 
+def test_static_boolean_attr_retained():
+    # Make sure a boolean attribute (bare attribute) is not omitted.
+    node = html(t"<input disabled>")
+    assert node == Element("input", {"disabled": None})
+    assert str(node) == "<input disabled />"
+
+
 def test_parse_element_with_text():
     node = html(t"<p>Hello, world!</p>")
     assert node == Element(
@@ -693,6 +700,14 @@ def test_style_attribute_non_str_non_dict():
         _ = html(t"<p style={styles}>Warning!</p>")
 
 
+def test_special_attrs_as_static():
+    node = html(t'<p aria="aria?" data="data?" class="class?" style="style?"></p>')
+    assert node == Element(
+        "p",
+        attrs={"aria": "aria?", "data": "data?", "class": "class?", "style": "style?"},
+    )
+
+
 # --------------------------------------------------------------------------
 # Function component interpolation tests
 # --------------------------------------------------------------------------
@@ -1068,6 +1083,7 @@ def AttributeTypeComponent(
     data_none: None,
     data_float: float,
     data_dt: datetime.datetime,
+    **kws: dict[str, object | None],
 ) -> Template:
     """Component to test that we don't incorrectly convert attribute types."""
     assert isinstance(data_int, int)
@@ -1076,6 +1092,24 @@ def AttributeTypeComponent(
     assert data_none is None
     assert isinstance(data_float, float)
     assert isinstance(data_dt, datetime.datetime)
+    for kw, v_type in [
+        ("spread_true", True),
+        ("spread_false", False),
+        ("spread_int", int),
+        ("spread_none", None),
+        ("spread_float", float),
+        ("spread_dt", datetime.datetime),
+        ("spread_dict", dict),
+        ("spread_list", list),
+    ]:
+        if v_type in (True, False, None):
+            assert kw in kws and kws[kw] is v_type, (
+                f"{kw} should be {v_type} but got {kws=}"
+            )
+        else:
+            assert kw in kws and isinstance(kws[kw], v_type), (
+                f"{kw} should instance of {v_type} but got {kws=}"
+            )
     return t"Looks good!"
 
 
@@ -1086,10 +1120,20 @@ def test_attribute_type_component():
     a_none: None = None
     a_float: float = 3.14
     a_dt: datetime.datetime = datetime.datetime(2024, 1, 1, 12, 0, 0)
+    spread_attrs: dict[str, object | None] = {
+        "spread_true": True,
+        "spread_false": False,
+        "spread_none": None,
+        "spread_int": 0,
+        "spread_float": 0.0,
+        "spread_dt": datetime.datetime(2024, 1, 1, 12, 0, 1),
+        "spread_dict": dict(),
+        "spread_list": ["eggs", "milk"],
+    }
     node = html(
         t"<{AttributeTypeComponent} data-int={an_int} data-true={a_true} "
         t"data-false={a_false} data-none={a_none} data-float={a_float} "
-        t"data-dt={a_dt} />"
+        t"data-dt={a_dt} {spread_attrs}/>"
     )
     assert node == Text("Looks good!")
     assert str(node) == "Looks good!"