refactor tags a bit (#49)

Author: joshuadavidthomas

src/django_bird/_typing.py

@@ -10,3 +10,5 @@
     )
 
 override = typing_override
+
+TagBits = list[str]

src/django_bird/templatetags/django_bird.py

@@ -1,13 +1,12 @@
-# pyright: reportAny=false
 from __future__ import annotations
 
 from django import template
 
-from .tags import do_bird
-from .tags import do_slot
+from .tags import bird
+from .tags import slot
 
 register = template.Library()
 
 
-register.tag("bird", do_bird)
-register.tag("bird:slot", do_slot)
+register.tag(bird.TAG, bird.do_bird)
+register.tag(slot.TAG, slot.do_slot)

src/django_bird/templatetags/tags/bird.py

@@ -12,34 +12,48 @@
 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
 from django_bird.conf import app_settings
 
 from .slot import SlotNode
 
+TAG = "bird"
+END_TAG = "endbird"
+
 
 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)
 
-    if len(bits) < 2:
-        msg = f"{token.contents.split()[0]} tag requires at least one argument"
+
+def parse_bird_name(bits: TagBits) -> str:
+    if len(bits) == 1:
+        msg = f"{TAG} tag requires at least one argument"
         raise template.TemplateSyntaxError(msg)
 
     # {% bird name %}
     # {% bird 'name' %}
     # {% bird "name" %}
-    name = bits[1].strip("'\"")
-    attrs = bits[2:]
+    return bits[1].strip("'\"")
+
 
+def parse_attrs(bits: TagBits) -> TagBits:
+    return bits[2:]
+
+
+def parse_nodelist(attrs: TagBits, parser: Parser) -> NodeList | None:
     # self-closing tag
     # {% bird name / %}
     if len(attrs) > 0 and attrs[-1] == "/":
         nodelist = None
     else:
-        nodelist = parser.parse(("endbird",))
+        nodelist = parser.parse((END_TAG,))
         parser.delete_first_token()
-
-    return BirdNode(name, attrs, nodelist)
+    return nodelist
 
 
 class BirdNode(template.Node):

src/django_bird/templatetags/tags/slot.py

@@ -11,31 +11,39 @@
 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"
+END_TAG = "endbird:slot"
+
 
 def do_slot(parser: Parser, token: Token) -> SlotNode:
     bits = token.split_contents()
     name = parse_slot_name(bits)
-    nodelist = parser.parse(("endbird:slot",))
-    parser.delete_first_token()
+    nodelist = parse_nodelist(parser)
     return SlotNode(name, nodelist)
 
 
-def parse_slot_name(tag_args: list[str]) -> str:
-    if len(tag_args) == 1:
+def parse_slot_name(bits: TagBits) -> str:
+    if len(bits) == 1:
         return "default"
-    elif len(tag_args) == 2:
-        name = tag_args[1]
+    elif len(bits) == 2:
+        name = bits[1]
         if name.startswith("name="):
             name = name.split("=")[1]
         else:
             name = name
         return name.strip("'\"")
     else:
-        raise template.TemplateSyntaxError(
-            "slot tag requires either no arguments, one argument, or 'name=\"slot_name\"'"
-        )
+        msg = f"{TAG} tag requires either no arguments, one argument, or 'name=\"slot_name\"'"
+        raise template.TemplateSyntaxError(msg)
+
+
+def parse_nodelist(parser: Parser) -> NodeList:
+    nodelist = parser.parse((END_TAG,))
+    parser.delete_first_token()
+    return nodelist
 
 
 class SlotNode(template.Node):

tests/templatetags/test_bird.py

@@ -12,32 +12,34 @@
 from django.template.exceptions import TemplateSyntaxError
 from django.test import override_settings
 
+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
 from django_bird.templatetags.tags.bird import do_bird
 
 
 class TestTemplateTag:
     @pytest.mark.parametrize(
-        "name_arg,expected",
+        "name,expected",
         [
             ("button", "button"),
             ("'button'", "button"),
             ('"button"', "button"),
             ("button.label", "button.label"),
         ],
     )
-    def test_node_name(self, name_arg, expected):
-        token = Token(TokenType.BLOCK, f"bird {name_arg}")
+    def test_node_name(self, name, expected):
+        token = Token(TokenType.BLOCK, f"{TAG} {name}")
         parser = Parser(
-            [Token(TokenType.BLOCK, "endbird")],
+            [Token(TokenType.BLOCK, END_TAG)],
         )
         node = do_bird(parser, token)
         assert node.name == expected
 
     def test_missing_argument(self):
-        token = Token(TokenType.BLOCK, "bird")
+        token = Token(TokenType.BLOCK, TAG)
         parser = Parser(
-            [Token(TokenType.BLOCK, "endbird")],
+            [Token(TokenType.BLOCK, END_TAG)],
         )
         with pytest.raises(TemplateSyntaxError):
             do_bird(parser, token)
@@ -51,9 +53,9 @@ def test_missing_argument(self):
         ],
     )
     def test_node_attrs(self, attrs, expected_attrs):
-        token = Token(TokenType.BLOCK, f"bird button {attrs}")
+        token = Token(TokenType.BLOCK, f"{TAG} button {attrs}")
         parser = Parser(
-            [Token(TokenType.BLOCK, "endbird")],
+            [Token(TokenType.BLOCK, END_TAG)],
         )
         node = do_bird(parser, token)
         assert node.attrs == expected_attrs

tests/templatetags/test_slot.py

@@ -9,7 +9,7 @@
 
 
 @pytest.mark.parametrize(
-    "tag_args,expected",
+    "bits,expected",
     [
         (["slot"], "default"),
         (["slot", "foo"], "foo"),
@@ -19,8 +19,8 @@
         (["slot", "name='foo'"], "foo"),
     ],
 )
-def test_parse_slot_name(tag_args, expected):
-    assert parse_slot_name(tag_args) == expected
+def test_parse_slot_name(bits, expected):
+    assert parse_slot_name(bits) == expected
 
 
 def test_parse_slot_name_no_args():