Template-Strings (t-Strings)

from string.templatelib import Interpolation, Template, convert


def render(template: Template) -> str:
    """Render a template exactly like the matching f-string."""
    out: list[str] = []
    for part in template:
        if isinstance(part, Interpolation):
            # Apply part.conversion (with convert) and part.format_spec (with format).
            out.append(str(part.value))
        else:
            out.append(part)
    return "".join(out)

from main import render


def test_plain():
    """Ein einfacher Wert wird unverändert eingesetzt"""
    name = "Ada"
    got = render(t"Hi {name}!")
    assert got == "Hi Ada!", f"render lieferte {got!r}, erwartet 'Hi Ada!'"


def test_format_spec():
    """Die Formatangabe wird angewendet, wie im f-String"""
    price = 3.14159
    got = render(t"{price:.2f} EUR")
    assert got == "3.14 EUR", f"render lieferte {got!r}: part.format_spec mit format() anwenden"


def test_conversion():
    """!r wird angewendet, wie im f-String"""
    word = "hi"
    got = render(t"say {word!r}")
    assert got == "say 'hi'", f"render lieferte {got!r}: part.conversion mit convert() anwenden"


def test_same_as_fstring():
    """Der =-Spezifizierer und eine Breite ergeben dasselbe wie der f-String"""
    n = 5
    got = render(t"{n=} [{n:>4}]")
    want = f"{n=} [{n:>4}]"
    assert got == want, f"render lieferte {got!r}, der f-String ergibt {want!r}"

import html
from string.templatelib import Interpolation, Template, convert


def safe_html(template: Template) -> str:
    """Build HTML from a t-string, escaping every interpolated value."""
    # This escapes the static markup too, ignores the format specs,
    # and quietly accepts a plain str.
    text = "".join(str(part.value) if isinstance(part, Interpolation) else part for part in template)
    return html.escape(text)

from main import safe_html


def test_escapes_values():
    """Markup in einem Wert wird maskiert"""
    name = "<b>Ada</b>"
    got = safe_html(t"<p>{name}</p>")
    assert got == "<p>&lt;b&gt;Ada&lt;/b&gt;</p>", f"safe_html lieferte {got!r}"


def test_keeps_static_markup():
    """Das Markup im t-String selbst bleibt Markup"""
    city = "Bonn"
    got = safe_html(t'<a href="/map">{city}</a>')
    assert got == '<a href="/map">Bonn</a>', f"safe_html lieferte {got!r}: nur die Interpolationen maskieren"


def test_quotes_escaped():
    """Auch Anführungszeichen in einem Wert werden maskiert"""
    title = 'say "hi"'
    got = safe_html(t"<b>{title}</b>")
    assert got == "<b>say &quot;hi&quot;</b>", f"safe_html lieferte {got!r}"


def test_format_spec():
    """Die Formatangabe wird vor dem Maskieren angewendet"""
    total = 1234.5
    got = safe_html(t"<td>{total:,.2f}</td>")
    assert got == "<td>1,234.50</td>", f"safe_html lieferte {got!r}"


def test_rejects_str():
    """Ein einfacher str (ein fertiger f-String) löst TypeError aus"""
    name = "<b>Ada</b>"
    try:
        safe_html(f"<p>{name}</p>")
    except TypeError:
        pass
    else:
        assert False, "safe_html hat einen str angenommen; lösen Sie TypeError aus, wenn es kein Template ist"