Add class component example and add runtime checks to component return value.

Author: ianjosephwilson

tdom/transformer.py

@@ -174,6 +174,16 @@ def interpolate_component(
     # @DESIGN: Determine return signature from callable info (cached inspection) ?
     callable_info = get_callable_info(component_callable)
     kwargs = _prep_component_kwargs(callable_info, resolved_attrs, system=system_dict)
+
+    # @DESIGN: We can try to wrap this type resolution up but it is
+    # hard to tell component authors what should be returned if we have this
+    # union, and this is actually the simplified one without iterable, bool or
+    # Node.
+
+    # Component() ->
+    # None | Template | tuple[None | Template, dict[str, object]] |
+    # Callable[[], None | Template | tuple[None | Template, dict[str, object]]]
+
     res = component_callable(**kwargs)
 
     # @DESIGN: callable or has_attr('__call__') for class components?
@@ -184,17 +194,34 @@ def interpolate_component(
 
     # @DESIGN: Determine return signature via runtime inspection?
     if isinstance(res, tuple):
-        result_template, comp_info = res
+        if len(res) != 2:
+            raise ValueError(
+                f"Tuple form of component return value must be len() 2, not: {len(res)}"
+            )
+        else:
+            result_template, comp_info = res
+
+        # @DESIGN: Use open-ended dict for opt-in second return argument?
         context_values = comp_info.get("context_values", ()) if comp_info else ()
+        for entry in context_values:
+            if not isinstance(entry, tuple):
+                raise ValueError(
+                    f"Entries for context_values must be 2-tuples but found type: {type(entry)}."
+                )
+            elif len(entry) != 2:
+                raise ValueError(
+                    f"Entries for context_values must be 2-tuples but found len(): {len(entry)}."
+                )
+            elif not isinstance(entry[0], ContextVar):
+                raise ValueError(
+                    f"Invalid context variable in component return value: {type(entry[0])}"
+                )
     else:
         result_template = res
         comp_info = None
         context_values = ()
 
-    # @DESIGN: Use open-ended dict for opt-in second return argument?
-    context_values = comp_info.get("context_values", ()) if comp_info else ()
-
-    if result_template:
+    if isinstance(result_template, Template):
         result_struct = render_api.transform_api.transform_template(result_template)
         if context_values:
             walker = render_api.walk_template_with_context(
@@ -203,6 +230,10 @@ def interpolate_component(
         else:
             walker = render_api.walk_template(bf, result_template, result_struct)
         return (container_tag, iter(walker))
+    elif result_template is None:
+        pass
+    else:
+        raise ValueError(f"Unknown component return value: {type(result_template)}")
 
 
 type InterpolateRawTextInfo = tuple[str, Template]

tdom/transformer_test.py

@@ -3,6 +3,9 @@
 from markupsafe import Markup, escape as markupsafe_escape
 import typing as t
 import pytest
+from dataclasses import dataclass
+from collections.abc import Callable
+from itertools import chain
 
 from .transformer import (
     render_service_factory,
@@ -340,3 +343,62 @@ def test_escape_structured_text():
         render_api.render_template(content_t)
         == f"<div>{LT}script{GT}console.log({DQ}123!{DQ});{LT}/script{GT}</div>"
     )
+
+
+@dataclass
+class Pager:
+    left_pages: tuple = ()
+    page: int = 0
+    right_pages: tuple = ()
+    prev_page: int | None = None
+    next_page: int | None = None
+
+
+@dataclass
+class PagerDisplay:
+    pager: Pager
+    paginate_url: Callable[[int], str]
+    root_classes: tuple[str, ...] = ("cb", "tc", "w-100")
+    part_classes: tuple[str, ...] = ("dib", "pa1")
+
+    def __call__(self) -> Template:
+        parts = [t"<div class={self.root_classes}>"]
+        if self.pager.prev_page:
+            parts.append(
+                t"<a class={self.part_classes} href={self.paginate_url(self.pager.prev_page)}>Prev</a>"
+            )
+        for left_page in self.pager.left_pages:
+            parts.append(
+                t'<a class={self.part_classes} href="{self.paginate_url(left_page)}">{left_page}</a>'
+            )
+        parts.append(t"<span class={self.part_classes}>{self.pager.page}</span>")
+        for right_page in self.pager.right_pages:
+            parts.append(
+                t'<a class={self.part_classes} href="{self.paginate_url(right_page)}">{right_page}</a>'
+            )
+        if self.pager.next_page:
+            parts.append(
+                t"<a class={self.part_classes} href={self.paginate_url(self.pager.next_page)}>Next</a>"
+            )
+        parts.append(t"</div>")
+        return Template(*chain.from_iterable(parts))
+
+
+def test_class_component():
+    def paginate_url(page):
+        return f"/pages?{page}"
+
+    def Footer(pager, paginate_url, footer_classes=("footer",)):
+        return t"<div class={footer_classes}><{PagerDisplay} pager={pager} paginate_url={paginate_url} /></div>"
+
+    pager = Pager(
+        left_pages=(1, 2), page=3, right_pages=(4, 5), next_page=6, prev_page=None
+    )
+    content_t = t"<{Footer} pager={pager} paginate_url={paginate_url} />"
+    render_api = render_service_factory()
+    res = render_api.render_template(content_t)
+    print(res)
+    assert (
+        res
+        == '<div class="footer"><div class="cb tc w-100"><a href="/pages?1" class="dib pa1">1</a><a href="/pages?2" class="dib pa1">2</a><span class="dib pa1">3</span><a href="/pages?4" class="dib pa1">4</a><a href="/pages?5" class="dib pa1">5</a><a href="/pages?6" class="dib pa1">Next</a></div></div>'
+    )