Restore support for text expressions (#148)

* Restore support for text expressions
* Use AST-native text interpolation codegen
* Normalize multiline text indentation

Author: berendkleinhaneveld

collagraph/sfc/compiler.py

@@ -2,6 +2,7 @@
 
 import ast
 import logging
+import re
 import sys
 import textwrap
 from collections import defaultdict
@@ -368,6 +369,118 @@ def ast_create_list_fragment(name: str, parent: str | None) -> ast.Assign:
     )
 
 
+def parse_text_interpolations(text: str) -> list[tuple[bool, str]]:
+    """
+    Parse text with {{expression}} interpolations.
+
+    Returns a list of tuples where:
+    - (False, str) represents static text
+    - (True, str) represents an expression to be evaluated
+
+    Examples:
+        "Hello {{name}}" -> [(False, "Hello "), (True, "name")]
+        "Static text" -> [(False, "Static text")]
+        "{{a}} and {{b}}" -> [(True, "a"), (False, " and "), (True, "b")]
+    """
+    result = []
+    i = 0
+    n = len(text)
+
+    while i < n:
+        # Look for start of interpolation
+        start = text.find("{{", i)
+        if start == -1:
+            # No more interpolations, add remaining text
+            if i < n:
+                result.append((False, text[i:]))
+            break
+
+        # Check for escape sequence \{{
+        if start > 0 and text[start - 1] == "\\":
+            # Escaped - include text up to and including the {{ as static
+            # but remove the backslash
+            if i < start - 1:
+                result.append((False, text[i : start - 1]))
+            result.append((False, "{{"))
+            i = start + 2
+            continue
+
+        # Add static text before the interpolation
+        if start > i:
+            result.append((False, text[i:start]))
+
+        # Find the end of the interpolation
+        end = text.find("}}", start + 2)
+        if end == -1:
+            # Unclosed interpolation - treat rest as static
+            result.append((False, text[start:]))
+            break
+
+        # Extract the expression
+        expr = text[start + 2 : end].strip()
+        if expr:
+            result.append((True, expr))
+
+        i = end + 2
+
+    return result
+
+
+def normalize_multiline_text(text: str) -> str:
+    if "\n" not in text and "\r" not in text:
+        return text
+    return re.sub(r"(\r?\n)[ \t]+", r"\1", text)
+
+
+def ast_set_text_bind(
+    el: str,
+    parts: list[tuple[bool, str]],
+    names: set[str],
+    list_names: list[dict[str, set[str]]],
+) -> ast.Expr:
+    joined_values: list[ast.Constant | ast.FormattedValue] = []
+    for is_expr, part in parts:
+        if is_expr:
+            expression_ast = ast.parse(part, mode="eval")
+            joined_values.append(
+                ast.FormattedValue(
+                    value=expression_ast.body,
+                    conversion=-1,
+                )
+            )
+        elif part:
+            joined_values.append(ast.Constant(value=part))
+
+    source = ast.Expression(
+        body=ast.Call(
+            func=ast.Attribute(
+                value=ast.Name(id=el, ctx=ast.Load()),
+                attr="set_bind",
+                ctx=ast.Load(),
+            ),
+            args=[
+                ast.Constant(value="content"),
+                ast.Lambda(
+                    args=ast.arguments(
+                        posonlyargs=[],
+                        args=[],
+                        kwonlyargs=[],
+                        kw_defaults=[],
+                        defaults=[],
+                    ),
+                    body=ast.JoinedStr(values=joined_values),
+                ),
+            ],
+            keywords=[],
+        )
+    )
+    return ast_named_lambda(
+        source,
+        {"renderer", "new", el, "watch"} | names,
+        list_names,
+    )
+
+
 def safe_tag(tag):
     return tag.replace("-", "_").replace(".", "_")
 
@@ -550,9 +663,57 @@ def create_children(
                 # Ignore comments
                 continue
             if isinstance(child, TextElement):
-                # children_args.extend(args_for_text_element(child, names=names))
-                # continue
-                raise NotImplementedError()
+                # Create a text element fragment
+                text_el = f"text{counter['text']}"
+                counter["text"] += 1
+
+                # Create the TEXT_ELEMENT fragment
+                result.append(
+                    ast.Assign(
+                        targets=[ast.Name(id=text_el, ctx=ast.Store())],
+                        value=ast.Call(
+                            func=ast.Name(id="Fragment", ctx=ast.Load()),
+                            args=[ast.Name(id="renderer", ctx=ast.Load())],
+                            keywords=[
+                                ast.keyword(
+                                    arg="tag", value=ast.Constant(value="TEXT_ELEMENT")
+                                ),
+                                ast.keyword(
+                                    arg="parent",
+                                    value=ast.Name(id=target, ctx=ast.Load())
+                                    if target
+                                    else ast.Constant(value=None),
+                                ),
+                            ],
+                        ),
+                    )
+                )
+
+                # Parse the text content for interpolations
+                text_content = normalize_multiline_text(child.content)
+                has_interpolation = "{{" in text_content and "}}" in text_content
+
+                if has_interpolation:
+                    parts = parse_text_interpolations(text_content)
+                    if any(is_expr for is_expr, _ in parts):
+                        result.append(
+                            ast_set_text_bind(
+                                text_el,
+                                parts,
+                                names,
+                                list_names,
+                            )
+                        )
+                    else:
+                        # Only escaped/unclosed interpolation-like text was found.
+                        result.append(
+                            ast_set_attribute(text_el, "content", text_content)
+                        )
+                else:
+                    # Static text - set attribute directly
+                    result.append(ast_set_attribute(text_el, "content", text_content))
+
+                continue
 
             # Create element name
             tag = safe_tag(child.tag)

tests/data/text/expressions.cgx

@@ -3,6 +3,14 @@
     <p>Static content</p>
     <p>Dynamic {{content}}</p>
     <p>Even {{more}} dyna{}mic\{} {{content}}</p>
+    <p>Quote "{{content}}" and slash \\ {{more}}</p>
+    <p>Line "{{content}}"
+      next {{more}}</p>
+    <p>First line
+      second line</p>
+    <p>Complex "{{content}}"
+      middle \{{literal}} {{more}}
+        tail {{content}}/{{more}}</p>
     <p>Split<!--by a comment--> and split by <span>an</span> element</p>
   </div>
 </template>

tests/test_text_expressions.py

@@ -1,11 +1,9 @@
-import pytest
 from observ import reactive
 
 from collagraph import Collagraph, DictRenderer, EventLoopType
 from collagraph.renderers.dict_renderer import format_dict
 
 
-@pytest.mark.xfail
 def test_text_elements():
     from tests.data.text.expressions import Example
 
@@ -19,35 +17,81 @@ def test_text_elements():
 
     assert result["type"] == "div"
 
-    static_p, dynamic_p, multiple_p, split_p = result["children"]
+    (
+        static_p,
+        dynamic_p,
+        multiple_p,
+        quoted_p,
+        multiline_p,
+        static_multiline_p,
+        complex_multiline_p,
+        split_p,
+    ) = result["children"]
 
     assert static_p["type"] == "p"
     assert dynamic_p["type"] == "p"
     assert multiple_p["type"] == "p"
+    assert quoted_p["type"] == "p"
+    assert multiline_p["type"] == "p"
+    assert static_multiline_p["type"] == "p"
+    assert complex_multiline_p["type"] == "p"
     assert split_p["type"] == "p"
 
     assert (
-        "children" in static_p and "children" in dynamic_p and "children" in multiple_p
+        "children" in static_p
+        and "children" in dynamic_p
+        and "children" in multiple_p
+        and "children" in quoted_p
+        and "children" in multiline_p
+        and "children" in static_multiline_p
+        and "children" in complex_multiline_p
     ), format_dict(container)
 
     assert (
         len(static_p["children"])
         == len(dynamic_p["children"])
         == len(multiple_p["children"])
+        == len(quoted_p["children"])
+        == len(multiline_p["children"])
+        == len(static_multiline_p["children"])
+        == len(complex_multiline_p["children"])
         == 1
     ), format_dict(container)
 
-    static, dynamic, multiple = (
+    (
+        static,
+        dynamic,
+        multiple,
+        quoted,
+        multiline,
+        static_multiline,
+        complex_multiline,
+    ) = (
         static_p["children"][0],
         dynamic_p["children"][0],
         multiple_p["children"][0],
+        quoted_p["children"][0],
+        multiline_p["children"][0],
+        static_multiline_p["children"][0],
+        complex_multiline_p["children"][0],
     )
     assert static["type"] == "TEXT_ELEMENT"
     assert dynamic["type"] == "TEXT_ELEMENT"
     assert multiple["type"] == "TEXT_ELEMENT"
+    assert quoted["type"] == "TEXT_ELEMENT"
+    assert multiline["type"] == "TEXT_ELEMENT"
+    assert static_multiline["type"] == "TEXT_ELEMENT"
+    assert complex_multiline["type"] == "TEXT_ELEMENT"
     assert static["attrs"]["content"] == "Static content"
     assert dynamic["attrs"]["content"] == "Dynamic foo"
     assert multiple["attrs"]["content"] == r"Even bar dyna{}mic\{} foo"
+    assert quoted["attrs"]["content"] == 'Quote "foo" and slash \\\\ bar'
+    assert multiline["attrs"]["content"] == 'Line "foo"\nnext bar'
+    assert static_multiline["attrs"]["content"] == "First line\nsecond line"
+    assert (
+        complex_multiline["attrs"]["content"]
+        == 'Complex "foo"\nmiddle {{literal}} bar\ntail foo/bar'
+    )
 
     assert len(split_p["children"]) == 4
     assert split_p["children"][0]["type"] == "TEXT_ELEMENT"