Transformer Proof-of-Concept

tdom/escaping.py

@@ -2,17 +2,26 @@
 
 from markupsafe import escape as markup_escape
 
+from .protocols import HasHTMLDunder
+
+
 escape_html_text = markup_escape  # unify api for test of project
 
 
 GT = ">"
 LT = "<"
 
 
-def escape_html_comment(text: str) -> str:
+def escape_html_comment(text: str, allow_markup: bool = False) -> str:
     """Escape text injected into an HTML comment."""
     if not text:
         return text
+    elif allow_markup and isinstance(text, HasHTMLDunder):
+        return text.__html__()
+    elif not allow_markup and type(text) is not str:
+        # text manipulation triggers regular html escapes on Markup
+        text = str(text)
+
     # - text must not start with the string ">"
     if text[0] == ">":
         text = GT + text[1:]
@@ -39,8 +48,10 @@ def escape_html_comment(text: str) -> str:
 STYLE_RES = ((re.compile("</(?P<tagname>style)>", re.I | re.A), LT + r"/\g<tagname>>"),)
 
 
-def escape_html_style(text: str) -> str:
+def escape_html_style(text: str, allow_markup: bool = False) -> str:
     """Escape text injected into an HTML style element."""
+    if allow_markup and isinstance(text, HasHTMLDunder):
+        return text.__html__()
     for matche_re, replace_text in STYLE_RES:
         text = re.sub(matche_re, replace_text, text)
     return text
@@ -62,7 +73,7 @@ def escape_html_style(text: str) -> str:
 )
 
 
-def escape_html_script(text: str) -> str:
+def escape_html_script(text: str, allow_markup: bool = False) -> str:
     """
     Escape text injected into an HTML script element.
 
@@ -75,6 +86,8 @@ def escape_html_script(text: str) -> str:
     - "<script" as "\x3cscript"
     - "</script" as "\x3c/script"`
     """
+    if allow_markup and isinstance(text, HasHTMLDunder):
+        return text.__html__()
     for match_re, replace_text in SCRIPT_RES:
         text = re.sub(match_re, replace_text, text)
     return text

tdom/escaping_test.py

@@ -1,4 +1,15 @@
-from .escaping import escape_html_comment, escape_html_script, escape_html_style
+from markupsafe import Markup
+
+from .escaping import (
+    escape_html_comment,
+    escape_html_script,
+    escape_html_style,
+    escape_html_text,
+)
+
+
+def test_escape_html_text() -> None:
+    assert escape_html_text("<div>") == "&lt;div&gt;"
 
 
 def test_escape_html_comment_empty() -> None:
@@ -27,6 +38,15 @@ def test_escape_html_comment_ends_with_lt_dash() -> None:
     assert escape_html_comment("This is a comment<!-") == "This is a comment&lt;!-"
 
 
+def test_escape_html_comment_markup() -> None:
+    input_text = "-->"
+    escaped_text = "--&gt;"
+    out = escape_html_comment(Markup(input_text), allow_markup=False)
+    assert out != input_text and out == escaped_text
+    out = escape_html_comment(Markup(input_text), allow_markup=True)
+    assert out == input_text and out != escaped_text
+
+
 def test_escape_html_style() -> None:
     input_text = "body { color: red; }</style> p { font-SIZE: 12px; }</STYLE>"
     expected_output = (
@@ -35,10 +55,28 @@ def test_escape_html_style() -> None:
     assert escape_html_style(input_text) == expected_output
 
 
+def test_escape_html_style_markup() -> None:
+    input_text = "</STYLE>"
+    escaped_text = "&lt;/STYLE>"
+    out = escape_html_style(Markup(input_text), allow_markup=False)
+    assert out != input_text and out == escaped_text
+    out = escape_html_style(Markup(input_text), allow_markup=True)
+    assert out == input_text and out != escaped_text
+
+
 def test_escape_html_script() -> None:
     input_text = "<!-- <script>var a = 1;</script> </SCRIPT>"
     expected_output = "\\x3c!-- \\x3cscript>var a = 1;\\x3c/script> \\x3c/SCRIPT>"
     assert escape_html_script(input_text) == expected_output
     # Smoketest that escaping is working and we are not just escaping back to the same value.
     for text in ("<script", "</script", "<!--"):
         assert escape_html_script(text) != text
+
+
+def test_escape_html_script_markup() -> None:
+    input_text = "<script>"
+    escaped_text = "\\x3cscript>"
+    out = escape_html_script(Markup(input_text), allow_markup=False)
+    assert out != input_text and out == escaped_text
+    out = escape_html_script(Markup(input_text), allow_markup=True)
+    assert out == input_text and out != escaped_text

tdom/processor.py

@@ -1,13 +1,13 @@
 import sys
 import typing as t
-from collections.abc import Iterable, Sequence
+from collections.abc import Iterable, Sequence, Callable
 from functools import lru_cache
 from string.templatelib import Interpolation, Template
 from dataclasses import dataclass
 
 from markupsafe import Markup
 
-from .callables import get_callable_info
+from .callables import get_callable_info, CallableInfo
 from .format import format_interpolation as base_format_interpolation
 from .format import format_template
 from .nodes import Comment, DocumentType, Element, Fragment, Node, Text
@@ -31,11 +31,7 @@
 from .placeholders import TemplateRef
 from .template_utils import template_from_parts
 from .utils import CachableTemplate, LastUpdatedOrderedDict
-
-
-@t.runtime_checkable
-class HasHTMLDunder(t.Protocol):
-    def __html__(self) -> str: ...  # pragma: no cover
+from .protocols import HasHTMLDunder
 
 
 # TODO: in Ian's original PR, this caching was tethered to the
@@ -437,6 +433,39 @@ def _kebab_to_snake(name: str) -> str:
     return name.replace("-", "_").lower()
 
 
+def _prep_component_kwargs(
+    callable_info: CallableInfo,
+    attrs: AttributesDict,
+    system_kwargs: dict[str, object],
+    kebab_to_snake: Callable[[str], str] = _kebab_to_snake,
+):
+    if callable_info.requires_positional:
+        raise TypeError(
+            "Component callables cannot have required positional arguments."
+        )
+
+    kwargs: AttributesDict = {}
+
+    # Add all supported attributes
+    for attr_name, attr_value in attrs.items():
+        snake_name = kebab_to_snake(attr_name)
+        if snake_name in callable_info.named_params or callable_info.kwargs:
+            kwargs[snake_name] = attr_value
+
+    for attr_name, attr_value in system_kwargs.items():
+        if attr_name in callable_info.named_params or callable_info.kwargs:
+            kwargs[attr_name] = attr_value
+
+    # Check to make sure we've fully satisfied the callable's requirements
+    missing = callable_info.required_named_params - kwargs.keys()
+    if missing:
+        raise TypeError(
+            f"Missing required parameters for component: {', '.join(missing)}"
+        )
+
+    return kwargs
+
+
 def _invoke_component(
     attrs: AttributesDict,
     children: list[Node],  # TODO: why not TNode, though?
@@ -477,29 +506,9 @@ def _invoke_component(
         )
     callable_info = get_callable_info(value)
 
-    if callable_info.requires_positional:
-        raise TypeError(
-            "Component callables cannot have required positional arguments."
-        )
-
-    kwargs: AttributesDict = {}
-
-    # Add all supported attributes
-    for attr_name, attr_value in attrs.items():
-        snake_name = _kebab_to_snake(attr_name)
-        if snake_name in callable_info.named_params or callable_info.kwargs:
-            kwargs[snake_name] = attr_value
-
-    # Add children if appropriate
-    if "children" in callable_info.named_params or callable_info.kwargs:
-        kwargs["children"] = tuple(children)
-
-    # Check to make sure we've fully satisfied the callable's requirements
-    missing = callable_info.required_named_params - kwargs.keys()
-    if missing:
-        raise TypeError(
-            f"Missing required parameters for component: {', '.join(missing)}"
-        )
+    kwargs = _prep_component_kwargs(
+        callable_info, attrs, system_kwargs={"children": tuple(children)}
+    )
 
     result = value(**kwargs)
     return _node_from_value(result)

tdom/protocols.py

@@ -0,0 +1,6 @@
+import typing as t
+
+
+@t.runtime_checkable
+class HasHTMLDunder(t.Protocol):
+    def __html__(self) -> str: ...  # pragma: no cover

tdom/template_utils.py

@@ -74,3 +74,14 @@ def __post_init__(self):
             raise ValueError(
                 "TemplateRef must have one more string than interpolation indexes."
             )
+
+    def __iter__(self):
+        index = 0
+        last_s_index = len(self.strings) - 1
+        while index <= last_s_index:
+            s = self.strings[index]
+            if s:
+                yield s
+            if index < last_s_index:
+                yield self.i_indexes[index]
+            index += 1