refactor and clean up slot templatetag (#161)

Author: joshuadavidthomas

src/django_bird/templatetags/tags/slot.py

@@ -2,16 +2,15 @@
 from __future__ import annotations
 
 from typing import cast
+from typing import final
 
 from django import template
 from django.template.base import NodeList
 from django.template.base import Parser
 from django.template.base import Token
 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
 from django_bird._typing import override
 
 TAG = "bird:slot"
@@ -21,52 +20,42 @@
 
 
 def do_slot(parser: Parser, token: Token) -> SlotNode:
-    bits = token.split_contents()
-    name = parse_slot_name(bits)
-    nodelist = parse_nodelist(parser)
-    return SlotNode(name, nodelist)
-
-
-def parse_slot_name(bits: TagBits) -> str:
-    if len(bits) == 1:
-        return DEFAULT_SLOT
-    elif len(bits) == 2:
-        name = bits[1]
-        if name.startswith("name="):
-            name = name.split("=")[1]
-        else:
-            name = name
-        return name.strip("'\"")
-    else:
-        msg = f"{TAG} tag requires either no arguments, one argument, or 'name=\"slot_name\"'"
+    _tag, *bits = token.split_contents()
+    if len(bits) > 1:
+        msg = f"{TAG} tag requires either one or no arguments"
         raise template.TemplateSyntaxError(msg)
 
+    if len(bits) == 0:
+        name = DEFAULT_SLOT
+    else:
+        name = bits[0]
+        if name.startswith("name="):
+            _, name = name.split("=")
+        name = name.strip("'\"")
 
-def parse_nodelist(parser: Parser) -> NodeList:
     nodelist = parser.parse((END_TAG,))
     parser.delete_first_token()
-    return nodelist
+
+    return SlotNode(name, nodelist)
 
 
+@final
 class SlotNode(template.Node):
     def __init__(self, name: str, nodelist: NodeList):
         self.name = name
         self.nodelist = nodelist
 
     @override
     def render(self, context: Context) -> SafeString:
-        default_content: str = self.nodelist.render(context)
         slots = context.get("slots")
 
         if not slots or not isinstance(slots, dict):
-            return mark_safe(default_content)
+            return self.nodelist.render(context)
 
         slots_dict = cast(dict[str, str], slots)
         slot_content = slots_dict.get(self.name)
 
         if slot_content is None or slot_content == "":
-            return mark_safe(default_content)
+            return self.nodelist.render(context)
 
-        t = template.Template(slot_content)
-        content = t.render(context)
-        return mark_safe(content)
+        return template.Template(slot_content).render(context)

tests/templatetags/test_slot.py

@@ -3,32 +3,39 @@
 import pytest
 from django.template import Context
 from django.template import Template
+from django.template.base import Parser
+from django.template.base import Token
+from django.template.base import TokenType
 from django.template.exceptions import TemplateSyntaxError
 
-from django_bird.templatetags.tags.slot import parse_slot_name
+from django_bird.templatetags.tags.slot import DEFAULT_SLOT
+from django_bird.templatetags.tags.slot import END_TAG
+from django_bird.templatetags.tags.slot import TAG
+from django_bird.templatetags.tags.slot import SlotNode
+from django_bird.templatetags.tags.slot import do_slot
 from tests.utils import TestComponent
 from tests.utils import TestComponentCase
 from tests.utils import normalize_whitespace
 
 
 @pytest.mark.parametrize(
-    "bits,expected",
+    "contents,expected",
     [
-        (["slot"], "default"),
-        (["slot", "foo"], "foo"),
-        (["slot", "'foo'"], "foo"),
-        (["slot", '"foo"'], "foo"),
-        (["slot", 'name="foo"'], "foo"),
-        (["slot", "name='foo'"], "foo"),
+        ("", SlotNode(name=DEFAULT_SLOT, nodelist=None)),
+        ("foo", SlotNode(name="foo", nodelist=None)),
+        ("'foo'", SlotNode(name="foo", nodelist=None)),
+        ('"foo"', SlotNode(name="foo", nodelist=None)),
+        ('name="foo"', SlotNode(name="foo", nodelist=None)),
+        ("name='foo'", SlotNode(name="foo", nodelist=None)),
     ],
 )
-def test_parse_slot_name(bits, expected):
-    assert parse_slot_name(bits) == expected
+def test_parse_slot_name(contents, expected):
+    start_token = Token(TokenType.BLOCK, f"{TAG} {contents}")
+    end_token = Token(TokenType.BLOCK, END_TAG)
 
+    node = do_slot(Parser([end_token]), start_token)
 
-def test_parse_slot_name_no_args():
-    with pytest.raises(TemplateSyntaxError):
-        assert parse_slot_name([])
+    assert node.name == expected.name
 
 
 class TestTemplateTag: