rename internal BirdNode attrs to params (#53)

* rename internal `BirdNode` attrs to params

in preparation of adding props

* fix mypy

Author: joshuadavidthomas

src/django_bird/components/attrs.py

@@ -0,0 +1,54 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from django import template
+from django.template.context import Context
+from django.utils.safestring import SafeString
+from django.utils.safestring import mark_safe
+
+from django_bird._typing import TagBits
+
+
+@dataclass
+class Param:
+    name: str
+    value: str | bool | None
+
+    def render(self, context: Context) -> str:
+        if self.value is None:
+            return ""
+        if isinstance(self.value, bool) and self.value:
+            return self.name
+        try:
+            value = template.Variable(str(self.value)).resolve(context)
+        except template.VariableDoesNotExist:
+            value = self.value
+        return f'{self.name}="{value}"'
+
+    @classmethod
+    def from_bit(cls, bit: str):
+        value: str | bool
+        if "=" in bit:
+            name, value = bit.split("=", 1)
+            value = value.strip("'\"")
+        else:
+            name, value = bit, True
+        return cls(name, value)
+
+
+@dataclass
+class Params:
+    attrs: list[Param]
+
+    def render_attrs(self, context: Context) -> SafeString:
+        rendered = " ".join(attr.render(context) for attr in self.attrs)
+        return mark_safe(rendered)
+
+    @classmethod
+    def from_bits(cls, bits: TagBits):
+        params: list[Param] = []
+        for bit in bits:
+            param = Param.from_bit(bit)
+            params.append(param)
+        return cls(attrs=params)

src/django_bird/components/params.py

@@ -13,7 +13,7 @@
 
 from django_bird._typing import TagBits
 from django_bird._typing import override
-from django_bird.components.attrs import Attrs
+from django_bird.components.params import Params
 from django_bird.components.slots import DEFAULT_SLOT
 from django_bird.components.slots import Slots
 from django_bird.components.templates import get_template_names
@@ -25,9 +25,9 @@
 def do_bird(parser: Parser, token: Token) -> BirdNode:
     bits = token.split_contents()
     name = parse_bird_name(bits)
-    attrs = parse_attrs(bits)
-    nodelist = parse_nodelist(attrs, parser)
-    return BirdNode(name, attrs, nodelist)
+    params = Params.from_bits(bits[2:])
+    nodelist = parse_nodelist(bits, parser)
+    return BirdNode(name, params, nodelist)
 
 
 def parse_bird_name(bits: TagBits) -> str:
@@ -41,14 +41,10 @@ def parse_bird_name(bits: TagBits) -> str:
     return bits[1].strip("'\"")
 
 
-def parse_attrs(bits: TagBits) -> TagBits:
-    return bits[2:]
-
-
-def parse_nodelist(attrs: TagBits, parser: Parser) -> NodeList | None:
+def parse_nodelist(bits: TagBits, parser: Parser) -> NodeList | None:
     # self-closing tag
     # {% bird name / %}
-    if len(attrs) > 0 and attrs[-1] == "/":
+    if len(bits) > 0 and bits[-1] == "/":
         nodelist = None
     else:
         nodelist = parser.parse((END_TAG,))
@@ -57,9 +53,9 @@ def parse_nodelist(attrs: TagBits, parser: Parser) -> NodeList | None:
 
 
 class BirdNode(template.Node):
-    def __init__(self, name: str, attrs: list[str], nodelist: NodeList | None) -> None:
+    def __init__(self, name: str, params: Params, nodelist: NodeList | None) -> None:
         self.name = name
-        self.attrs = attrs
+        self.params = params
         self.nodelist = nodelist
 
     @override
@@ -78,11 +74,11 @@ def get_component_name(self, context: Context) -> str:
         return name
 
     def get_component_context_data(self, context: Context) -> dict[str, Any]:
-        attrs = Attrs.parse(self.attrs, context)
+        attrs = self.params.render_attrs(context)
         slots = Slots.collect(self.nodelist, context).render()
         default_slot = slots.get(DEFAULT_SLOT) or context.get("slot")
         return {
-            "attrs": attrs.flatten(),
+            "attrs": attrs,
             "slot": default_slot,
             "slots": slots,
         }

src/django_bird/templatetags/tags/bird.py

@@ -0,0 +1,69 @@
+from __future__ import annotations
+
+import pytest
+
+from django_bird.components.params import Param
+from django_bird.components.params import Params
+
+
+class TestParam:
+    @pytest.mark.parametrize(
+        "param,context,expected",
+        [
+            (Param(name="class", value="btn"), {}, 'class="btn"'),
+            (Param(name="class", value="btn"), {"btn": "blue"}, 'class="blue"'),
+            (Param(name="disabled", value=True), {}, "disabled"),
+            (Param(name="disabled", value=None), {}, ""),
+        ],
+    )
+    def test_render(self, param, context, expected):
+        assert param.render(context) == expected
+
+    @pytest.mark.parametrize(
+        "bit,expected",
+        [
+            ("class='btn'", Param(name="class", value="btn")),
+            ('class="btn"', Param(name="class", value="btn")),
+            ("disabled", Param(name="disabled", value=True)),
+        ],
+    )
+    def test_from_bit(self, bit, expected):
+        assert Param.from_bit(bit) == expected
+
+
+class TestParams:
+    @pytest.mark.parametrize(
+        "params,context,expected",
+        [
+            (Params(attrs=[Param(name="class", value="btn")]), {}, 'class="btn"'),
+            (
+                Params(attrs=[Param(name="class", value="btn")]),
+                {"btn": "blue"},
+                'class="blue"',
+            ),
+            (Params(attrs=[Param(name="disabled", value=True)]), {}, "disabled"),
+            (
+                Params(
+                    attrs=[
+                        Param(name="class", value="btn"),
+                        Param(name="disabled", value=True),
+                    ]
+                ),
+                {},
+                'class="btn" disabled',
+            ),
+        ],
+    )
+    def test_render_attrs(self, params, context, expected):
+        assert params.render_attrs(context) == expected
+
+    @pytest.mark.parametrize(
+        "bits,expected",
+        [
+            (["class='btn'"], Params(attrs=[Param(name="class", value="btn")])),
+            (['class="btn"'], Params(attrs=[Param(name="class", value="btn")])),
+            (["disabled"], Params(attrs=[Param(name="disabled", value=True)])),
+        ],
+    )
+    def test_from_bits(self, bits, expected):
+        assert Params.from_bits(bits) == expected

tests/components/test_params.py

@@ -11,6 +11,8 @@
 from django.template.base import TokenType
 from django.template.exceptions import TemplateSyntaxError
 
+from django_bird.components.params import Param
+from django_bird.components.params import Params
 from django_bird.templatetags.tags.bird import END_TAG
 from django_bird.templatetags.tags.bird import TAG
 from django_bird.templatetags.tags.bird import BirdNode
@@ -44,20 +46,28 @@ def test_missing_argument(self):
             do_bird(parser, token)
 
     @pytest.mark.parametrize(
-        "attrs,expected_attrs",
+        "params,expected_params",
         [
-            ("class='btn'", ["class='btn'"]),
-            ("class='btn' id='my-btn'", ["class='btn'", "id='my-btn'"]),
-            ("disabled", ["disabled"]),
+            ("class='btn'", Params(attrs=[Param(name="class", value="btn")])),
+            (
+                "class='btn' id='my-btn'",
+                Params(
+                    attrs=[
+                        Param(name="class", value="btn"),
+                        Param(name="id", value="my-btn"),
+                    ]
+                ),
+            ),
+            ("disabled", Params(attrs=[Param(name="disabled", value=True)])),
         ],
     )
-    def test_node_attrs(self, attrs, expected_attrs):
-        token = Token(TokenType.BLOCK, f"{TAG} button {attrs}")
+    def test_node_params(self, params, expected_params):
+        token = Token(TokenType.BLOCK, f"{TAG} button {params}")
         parser = Parser(
             [Token(TokenType.BLOCK, END_TAG)],
         )
         node = do_bird(parser, token)
-        assert node.attrs == expected_attrs
+        assert node.params == expected_params
 
     @pytest.mark.parametrize(
         "component,template,context,expected",
@@ -274,7 +284,7 @@ class TestNode:
     )
     def test_get_component_name(self, name, context, expected, create_bird_template):
         create_bird_template(name=name, content="<button>Click me</button>")
-        node = BirdNode(name=name, attrs=[], nodelist=None)
+        node = BirdNode(name=name, params=Params([]), nodelist=None)
 
         component_name = node.get_component_name(context=Context(context))