tstring-html-bindings 0.1.4__tar.gz → 0.1.6__tar.gz

{tstring_html_bindings-0.1.4 → tstring_html_bindings-0.1.6}/Cargo.lock

@@ -290,14 +290,14 @@ checksum = "5d99f8c9a7727884afe522e9bd5edbfc91a3312b36a77b5fb8926e4c31a41801"
 
 [[package]]
 name = "tstring-format-doc"
-version = "0.1.4"
+version = "0.1.6"
 dependencies = [
  "unicode-width",
 ]
 
 [[package]]
 name = "tstring-html"
-version = "0.1.4"
+version = "0.1.6"
 dependencies = [
  "tstring-format-doc",
  "tstring-syntax",
@@ -305,7 +305,7 @@ dependencies = [
 
 [[package]]
 name = "tstring-html-backend-e2e-tests"
-version = "0.1.4"
+version = "0.1.6"
 dependencies = [
  "serde",
  "toml",
@@ -316,7 +316,7 @@ dependencies = [
 
 [[package]]
 name = "tstring-html-bindings"
-version = "0.1.4"
+version = "0.1.6"
 dependencies = [
  "pyo3",
  "tstring-html",
@@ -335,7 +335,7 @@ dependencies = [
 
 [[package]]
 name = "tstring-thtml"
-version = "0.1.4"
+version = "0.1.6"
 dependencies = [
  "tstring-html",
  "tstring-syntax",

{tstring_html_bindings-0.1.4 → tstring_html_bindings-0.1.6}/Cargo.toml

@@ -9,7 +9,7 @@ homepage = "https://github.com/koxudaxi/tstring-html"
 license = "MIT"
 repository = "https://github.com/koxudaxi/tstring-html"
 rust-version = "1.94.0"
-version = "0.1.4"
+version = "0.1.6"
 
 [workspace.dependencies]
 pyo3 = "0.27.1"

{tstring_html_bindings-0.1.4 → tstring_html_bindings-0.1.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tstring-html-bindings
-Version: 0.1.4
+Version: 0.1.6
 Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License

{tstring_html_bindings-0.1.4 → tstring_html_bindings-0.1.6}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "tstring-html-bindings"
-version = "0.1.4"
+version = "0.1.6"
 description = "Native Python bindings for tstring-html"
 readme = "README.md"
 license = { text = "MIT" }

{tstring_html_bindings-0.1.4 → tstring_html_bindings-0.1.6}/tstring-html-bindings/Cargo.toml

@@ -19,8 +19,8 @@ extension-module = ["pyo3/extension-module"]
 
 [dependencies]
 pyo3 = { workspace = true, features = ["abi3-py314"] }
-tstring-html = { version = "0.1.4", path = "../tstring-html-rs" }
-tstring-thtml = { version = "0.1.4", path = "../tstring-thtml-rs" }
+tstring-html = { version = "0.1.6", path = "../tstring-html-rs" }
+tstring-thtml = { version = "0.1.6", path = "../tstring-thtml-rs" }
 tstring-syntax.workspace = true
 
 [dev-dependencies]

{tstring_html_bindings-0.1.4 → tstring_html_bindings-0.1.6}/tstring-html-bindings/src/lib.rs

@@ -607,6 +607,17 @@ fn render_thtml_node(
             for child in &element.children {
                 match child {
                     Node::Text(text) => out.push_str(&text.value),
+                    Node::Interpolation(interpolation)
+                        if element.name.eq_ignore_ascii_case("title") =>
+                    {
+                        let Some(value) = context.values.get(interpolation.interpolation_index)
+                        else {
+                            return Err(runtime_error_to_py(
+                                "Missing runtime value for interpolation.",
+                            ));
+                        };
+                        render_escaped_text_value(value, out).map_err(backend_error_to_py)?;
+                    }
                     _ => {
                         return Err(runtime_error_to_py(
                             "Invalid raw-text content in T-HTML render path.",
@@ -646,6 +657,43 @@ fn render_thtml_node(
     Ok(())
 }
 
+fn render_escaped_text_value(value: &RuntimeValue, out: &mut String) -> Result<(), BackendError> {
+    match value {
+        RuntimeValue::Null => {}
+        RuntimeValue::Bool(value) => out.push_str(&escape_html_text(&value.to_string())),
+        RuntimeValue::Int(value) => out.push_str(&escape_html_text(&value.to_string())),
+        RuntimeValue::Float(value) => out.push_str(&escape_html_text(&value.to_string())),
+        RuntimeValue::String(value) => out.push_str(&escape_html_text(value)),
+        RuntimeValue::RawHtml(value) => out.push_str(&escape_html_text(value)),
+        RuntimeValue::Fragment(values) | RuntimeValue::Sequence(values) => {
+            for value in values {
+                render_escaped_text_value(value, out)?;
+            }
+        }
+        RuntimeValue::Attributes(_) => {
+            return Err(tstring_html::runtime_error(
+                "html.runtime.child_type",
+                "Mapping-like values cannot be rendered as children.",
+                None,
+            ));
+        }
+    }
+    Ok(())
+}
+
+fn escape_html_text(value: &str) -> String {
+    let mut escaped = String::with_capacity(value.len());
+    for ch in value.chars() {
+        match ch {
+            '&' => escaped.push_str("&amp;"),
+            '<' => escaped.push_str("&lt;"),
+            '>' => escaped.push_str("&gt;"),
+            _ => escaped.push(ch),
+        }
+    }
+    escaped
+}
+
 fn render_attribute_value_for_component(
     py: Python<'_>,
     value: &tstring_html::AttributeValue,
@@ -883,7 +931,9 @@ fn tstring_html_bindings(py: Python<'_>, module: &Bound<'_, PyModule>) -> PyResu
 
 #[cfg(test)]
 mod tests {
-    use super::ParseCache;
+    use super::{ParseCache, render_thtml_node};
+    use pyo3::Python;
+    use tstring_html::{Node, RuntimeContext, RuntimeValue};
 
     #[test]
     fn parse_cache_reuses_entries() {
@@ -974,4 +1024,30 @@ mod tests {
         assert_eq!(*value, 7);
         assert_eq!(attempts, 2);
     }
+
+    #[test]
+    fn render_thtml_node_treats_uppercase_title_as_escaped_text() {
+        Python::attach(|py| {
+            let node = Node::RawTextElement(tstring_html::RawTextElementNode {
+                name: "TITLE".to_string(),
+                attributes: Vec::new(),
+                children: vec![Node::Interpolation(tstring_html::InterpolationNode {
+                    interpolation_index: 0,
+                    expression: "title".to_string(),
+                    raw_source: Some("{title}".to_string()),
+                    conversion: None,
+                    format_spec: String::new(),
+                    span: None,
+                })],
+                span: None,
+            });
+            let context = RuntimeContext {
+                values: vec![RuntimeValue::RawHtml("<safe>".to_string())],
+            };
+            let mut out = String::new();
+            render_thtml_node(py, &node, &context, None, None, &mut out)
+                .expect("render uppercase title");
+            assert_eq!(out, "<TITLE>&lt;safe&gt;</TITLE>");
+        });
+    }
 }

{tstring_html_bindings-0.1.4 → tstring_html_bindings-0.1.6}/tstring-html-rs/Cargo.toml

@@ -9,5 +9,5 @@ rust-version.workspace = true
 version.workspace = true
 
 [dependencies]
-tstring-format-doc = { version = "0.1.0", path = "../tstring-format-doc-rs" }
+tstring-format-doc = { version = "0.1.5", path = "../tstring-format-doc-rs" }
 tstring-syntax.workspace = true

{tstring_html_bindings-0.1.4 → tstring_html_bindings-0.1.6}/tstring-html-rs/src/lib.rs

@@ -829,6 +829,10 @@ pub fn is_raw_text_tag(name: &str) -> bool {
     matches!(name, "script" | "style" | "title" | "textarea")
 }
 
+fn raw_text_allows_interpolation(name: &str) -> bool {
+    name.eq_ignore_ascii_case("title")
+}
+
 fn validate_html_document(document: &Document) -> BackendResult<()> {
     for child in &document.children {
         validate_html_node(child)?;
@@ -913,32 +917,45 @@ fn validate_html_node(node: &Node) -> BackendResult<()> {
         }
         Node::RawTextElement(element) => {
             validate_attributes(&element.attributes)?;
-            for child in &element.children {
-                match child {
-                    Node::Interpolation(interpolation) => {
-                        return Err(semantic_error(
-                            "html.semantic.raw_text_interpolation",
-                            format!("Interpolations are not allowed inside <{}>.", element.name),
-                            interpolation.span.clone(),
-                        ));
-                    }
-                    Node::Text(_) => {}
-                    _ => {
-                        return Err(semantic_error(
-                            "html.semantic.raw_text_content",
-                            format!("Only text is allowed inside <{}>.", element.name),
-                            element.span.clone(),
-                        ));
-                    }
-                }
-            }
-            Ok(())
+            validate_raw_text_children(element)
         }
         Node::Fragment(fragment) => validate_children(&fragment.children),
         _ => Ok(()),
     }
 }
 
+fn validate_raw_text_children(element: &RawTextElementNode) -> BackendResult<()> {
+    for child in &element.children {
+        match child {
+            Node::Text(_) => {}
+            Node::Interpolation(_) if raw_text_allows_interpolation(&element.name) => {}
+            Node::Interpolation(interpolation) => {
+                return Err(semantic_error(
+                    "html.semantic.raw_text_interpolation",
+                    format!("Interpolations are not allowed inside <{}>.", element.name),
+                    interpolation.span.clone(),
+                ));
+            }
+            _ => {
+                let message = if raw_text_allows_interpolation(&element.name) {
+                    format!(
+                        "Only text and interpolations are allowed inside <{}>.",
+                        element.name
+                    )
+                } else {
+                    format!("Only text is allowed inside <{}>.", element.name)
+                };
+                return Err(semantic_error(
+                    "html.semantic.raw_text_content",
+                    message,
+                    element.span.clone(),
+                ));
+            }
+        }
+    }
+    Ok(())
+}
+
 fn validate_children(children: &[Node]) -> BackendResult<()> {
     for child in children {
         validate_html_node(child)?;
@@ -1030,28 +1047,7 @@ fn render_node(node: &Node, context: &RuntimeContext, out: &mut String) -> Backe
             context,
             out,
         )?,
-        Node::RawTextElement(element) => {
-            out.push('<');
-            out.push_str(&element.name);
-            let normalized = normalize_attributes(&element.attributes, context)?;
-            write_attributes(&normalized, out);
-            out.push('>');
-            for child in &element.children {
-                match child {
-                    Node::Text(text) => out.push_str(&text.value),
-                    _ => {
-                        return Err(semantic_error(
-                            "html.semantic.raw_text_render",
-                            format!("Only text can be rendered inside <{}>.", element.name),
-                            element.span.clone(),
-                        ));
-                    }
-                }
-            }
-            out.push_str("</");
-            out.push_str(&element.name);
-            out.push('>');
-        }
+        Node::RawTextElement(element) => render_raw_text_element(element, context, out)?,
         Node::ComponentTag(component) => {
             return Err(semantic_error(
                 "html.semantic.component_render",
@@ -1066,6 +1062,45 @@ fn render_node(node: &Node, context: &RuntimeContext, out: &mut String) -> Backe
     Ok(())
 }
 
+fn render_raw_text_element(
+    element: &RawTextElementNode,
+    context: &RuntimeContext,
+    out: &mut String,
+) -> BackendResult<()> {
+    out.push('<');
+    out.push_str(&element.name);
+    let normalized = normalize_attributes(&element.attributes, context)?;
+    write_attributes(&normalized, out);
+    out.push('>');
+    for child in &element.children {
+        match child {
+            Node::Text(text) => out.push_str(&text.value),
+            Node::Interpolation(interpolation) if raw_text_allows_interpolation(&element.name) => {
+                render_escaped_text_value(value_for_interpolation(context, interpolation)?, out)?;
+            }
+            _ => {
+                let message = if raw_text_allows_interpolation(&element.name) {
+                    format!(
+                        "Only text and interpolations can be rendered inside <{}>.",
+                        element.name
+                    )
+                } else {
+                    format!("Only text can be rendered inside <{}>.", element.name)
+                };
+                return Err(semantic_error(
+                    "html.semantic.raw_text_render",
+                    message,
+                    element.span.clone(),
+                ));
+            }
+        }
+    }
+    out.push_str("</");
+    out.push_str(&element.name);
+    out.push('>');
+    Ok(())
+}
+
 fn render_html_element(
     name: &str,
     attributes: &[AttributeLike],
@@ -1267,6 +1302,30 @@ pub fn render_child_value(value: &RuntimeValue, out: &mut String) -> BackendResu
     Ok(())
 }
 
+fn render_escaped_text_value(value: &RuntimeValue, out: &mut String) -> BackendResult<()> {
+    match value {
+        RuntimeValue::Null => {}
+        RuntimeValue::Bool(value) => out.push_str(&escape_html_text(&value.to_string())),
+        RuntimeValue::Int(value) => out.push_str(&escape_html_text(&value.to_string())),
+        RuntimeValue::Float(value) => out.push_str(&escape_html_text(&value.to_string())),
+        RuntimeValue::String(value) => out.push_str(&escape_html_text(value)),
+        RuntimeValue::RawHtml(value) => out.push_str(&escape_html_text(value)),
+        RuntimeValue::Fragment(values) | RuntimeValue::Sequence(values) => {
+            for value in values {
+                render_escaped_text_value(value, out)?;
+            }
+        }
+        RuntimeValue::Attributes(_) => {
+            return Err(runtime_error(
+                "html.runtime.child_type",
+                "Mapping-like values cannot be rendered as children.",
+                None,
+            ));
+        }
+    }
+    Ok(())
+}
+
 fn render_attribute_value_string(
     value: &AttributeValue,
     context: &RuntimeContext,
@@ -1664,4 +1723,34 @@ mod tests {
         .expect("normalize class");
         assert_eq!(values, vec!["foo", "bar", "baz"]);
     }
+
+    #[test]
+    fn title_interpolation_is_allowed_and_escaped_on_render() {
+        let input = TemplateInput::from_segments(vec![
+            TemplateSegment::StaticText("<title>".to_string()),
+            interpolation(0, "title", Some("{title}")),
+            TemplateSegment::StaticText("</title>".to_string()),
+        ]);
+        let compiled = compile_template(&input).expect("compile title template");
+        let rendered = render_html(
+            &compiled,
+            &RuntimeContext {
+                values: vec![RuntimeValue::RawHtml("<safe>".to_string())],
+            },
+        )
+        .expect("render title");
+        assert_eq!(rendered, "<title>&lt;safe&gt;</title>");
+    }
+
+    #[test]
+    fn script_interpolation_is_still_rejected() {
+        let input = TemplateInput::from_segments(vec![
+            TemplateSegment::StaticText("<script>".to_string()),
+            interpolation(0, "script", Some("{script}")),
+            TemplateSegment::StaticText("</script>".to_string()),
+        ]);
+        let err = check_template(&input).expect_err("script must still fail");
+        assert_eq!(err.kind, ErrorKind::Semantic);
+        assert!(err.message.contains("<script>"));
+    }
 }

{tstring_html_bindings-0.1.4 → tstring_html_bindings-0.1.6}/tstring-thtml-rs/Cargo.toml

@@ -9,5 +9,5 @@ rust-version.workspace = true
 version.workspace = true
 
 [dependencies]
-tstring-html = { version = "0.1.4", path = "../tstring-html-rs" }
+tstring-html = { version = "0.1.6", path = "../tstring-html-rs" }
 tstring-syntax.workspace = true

{tstring_html_bindings-0.1.4 → tstring_html_bindings-0.1.6}/tstring-thtml-rs/src/lib.rs

@@ -92,26 +92,7 @@ fn validate_thtml_node(node: &Node) -> BackendResult<()> {
         }
         Node::RawTextElement(element) => {
             validate_attributes(&element.attributes)?;
-            for child in &element.children {
-                match child {
-                    Node::Interpolation(interpolation) => {
-                        return Err(semantic_error(
-                            "html.semantic.raw_text_interpolation",
-                            format!("Interpolations are not allowed inside <{}>.", element.name),
-                            interpolation.span.clone(),
-                        ));
-                    }
-                    Node::Text(_) => {}
-                    _ => {
-                        return Err(semantic_error(
-                            "html.semantic.raw_text_content",
-                            format!("Only text is allowed inside <{}>.", element.name),
-                            element.span.clone(),
-                        ));
-                    }
-                }
-            }
-            Ok(())
+            validate_raw_text_children(element)
         }
         Node::ComponentTag(component) => {
             validate_attributes(&component.attributes)?;
@@ -130,6 +111,38 @@ fn validate_thtml_node(node: &Node) -> BackendResult<()> {
     }
 }
 
+fn validate_raw_text_children(element: &tstring_html::RawTextElementNode) -> BackendResult<()> {
+    for child in &element.children {
+        match child {
+            Node::Text(_) => {}
+            Node::Interpolation(_) if element.name.eq_ignore_ascii_case("title") => {}
+            Node::Interpolation(interpolation) => {
+                return Err(semantic_error(
+                    "html.semantic.raw_text_interpolation",
+                    format!("Interpolations are not allowed inside <{}>.", element.name),
+                    interpolation.span.clone(),
+                ));
+            }
+            _ => {
+                let message = if element.name.eq_ignore_ascii_case("title") {
+                    format!(
+                        "Only text and interpolations are allowed inside <{}>.",
+                        element.name
+                    )
+                } else {
+                    format!("Only text is allowed inside <{}>.", element.name)
+                };
+                return Err(semantic_error(
+                    "html.semantic.raw_text_content",
+                    message,
+                    element.span.clone(),
+                ));
+            }
+        }
+    }
+    Ok(())
+}
+
 fn validate_attributes(attributes: &[AttributeLike]) -> BackendResult<()> {
     for attribute in attributes {
         match attribute {
@@ -205,4 +218,24 @@ mod tests {
             "Component rendering requires the bindings layer runtime context."
         );
     }
+
+    #[test]
+    fn thtml_accepts_title_interpolation() {
+        let input = TemplateInput::from_segments(vec![
+            TemplateSegment::StaticText("<title>".to_string()),
+            TemplateSegment::Interpolation(tstring_syntax::TemplateInterpolation {
+                expression: "title".to_string(),
+                conversion: None,
+                format_spec: String::new(),
+                interpolation_index: 0,
+                raw_source: Some("{title}".to_string()),
+            }),
+            TemplateSegment::StaticText("</title>".to_string()),
+        ]);
+        check_template(&input).expect("title interpolation should be allowed");
+        assert_eq!(
+            format_template(&input).expect("format title"),
+            "<title>{title}</title>"
+        );
+    }
 }