tstring-bindings 0.1.1__tar.gz → 0.2.1__tar.gz

{tstring_bindings-0.1.1 → tstring_bindings-0.2.1}/Cargo.lock

@@ -11,6 +11,15 @@ dependencies = [
  "memchr",
 ]
 
+[[package]]
+name = "alloca"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e5a7d05ea6aea7e9e64d25b9156ba2fee3fdd659e34e41063cd2fc7cd020d7f4"
+dependencies = [
+ "cc",
+]
+
 [[package]]
 name = "anes"
 version = "0.1.6"
@@ -47,6 +56,16 @@ version = "0.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "37b2a672a2cb129a2e41c10b1224bb368f9f37a2b16b612598138befd7b37eb5"
 
+[[package]]
+name = "cc"
+version = "1.2.57"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7a0dd1ca384932ff3641c8718a02769f1698e7563dc6974ffd03346116310423"
+dependencies = [
+ "find-msvc-tools",
+ "shlex",
+]
+
 [[package]]
 name = "cfg-if"
 version = "1.0.4"
@@ -107,25 +126,24 @@ checksum = "c8d4a3bb8b1e0c1050499d1815f5ab16d04f0959b233085fb31653fbfc9d98f9"
 
 [[package]]
 name = "criterion"
-version = "0.5.1"
+version = "0.8.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f2b12d017a929603d80db1831cd3a24082f8137ce19c69e6447f54f5fc8d692f"
+checksum = "950046b2aa2492f9a536f5f4f9a3de7b9e2476e575e05bd6c333371add4d98f3"
 dependencies = [
+ "alloca",
  "anes",
  "cast",
  "ciborium",
  "clap",
  "criterion-plot",
- "is-terminal",
  "itertools",
  "num-traits",
- "once_cell",
  "oorandom",
+ "page_size",
  "plotters",
  "rayon",
  "regex",
  "serde",
- "serde_derive",
  "serde_json",
  "tinytemplate",
  "walkdir",
@@ -133,9 +151,9 @@ dependencies = [
 
 [[package]]
 name = "criterion-plot"
-version = "0.5.0"
+version = "0.8.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6b50826342786a51a89e2da3a28f1c32b06e387201bc2d19791f622c673706b1"
+checksum = "d8d80a2f4f5b554395e47b5d8305bc3d27813bacb73493eb1001e8f76dae29ea"
 dependencies = [
  "cast",
  "itertools",
@@ -193,6 +211,12 @@ version = "1.0.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "877a4ace8713b0bcf2a4e7eec82529c029f1d0619886d18145fea96c3ffe5c0f"
 
+[[package]]
+name = "find-msvc-tools"
+version = "0.1.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5baebc0774151f905a1a2cc41989300b1e6fbb29aff0ceffa1064fdd3088d582"
+
 [[package]]
 name = "foldhash"
 version = "0.1.5"
@@ -240,12 +264,6 @@ version = "0.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea"
 
-[[package]]
-name = "hermit-abi"
-version = "0.5.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fc0fef456e4baa96da950455cd02c081ca953b141298e41db3fc7e36b1da849c"
-
 [[package]]
 name = "indexmap"
 version = "2.13.0"
@@ -265,22 +283,11 @@ dependencies = [
  "rustversion",
 ]
 
-[[package]]
-name = "is-terminal"
-version = "0.4.17"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3640c1c38b8e4e43584d8df18be5fc6b0aa314ce6ebf51b53313d4306cca8e46"
-dependencies = [
- "hermit-abi",
- "libc",
- "windows-sys",
-]
-
 [[package]]
 name = "itertools"
-version = "0.10.5"
+version = "0.13.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b0fd2260e829bddf4cb6ea802289de2f86d6a7a690192fbe91b3f46e0f2c8473"
+checksum = "413ee7dfc52ee1a4949ceeb7dbc8a33f2d6c088194d9f922fb8318faf1f01186"
 dependencies = [
  "either",
 ]
@@ -371,6 +378,16 @@ dependencies = [
  "num-traits",
 ]
 
+[[package]]
+name = "page_size"
+version = "0.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "30d5b2194ed13191c1999ae0704b7839fb18384fa22e49b57eeaa97d79ce40da"
+dependencies = [
+ "libc",
+ "winapi",
+]
+
 [[package]]
 name = "plotters"
 version = "0.3.7"
@@ -634,6 +651,12 @@ dependencies = [
  "serde_core",
 ]
 
+[[package]]
+name = "shlex"
+version = "1.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0fda2ff0d084019ba4d7c6f371c95d8fd75ce3524c3cb8fb653a3023f6323e64"
+
 [[package]]
 name = "syn"
 version = "2.0.117"
@@ -702,7 +725,7 @@ checksum = "ab16f14aed21ee8bfd8ec22513f7287cd4a91aa92e44edfe2c17ddd004e92607"
 
 [[package]]
 name = "tstring-backend-e2e-tests"
-version = "0.1.1"
+version = "0.2.1"
 dependencies = [
  "tstring-json",
  "tstring-syntax",
@@ -712,7 +735,7 @@ dependencies = [
 
 [[package]]
 name = "tstring-bindings"
-version = "0.1.1"
+version = "0.2.1"
 dependencies = [
  "pyo3",
  "pythonize",
@@ -728,7 +751,7 @@ dependencies = [
 
 [[package]]
 name = "tstring-json"
-version = "0.1.1"
+version = "0.2.1"
 dependencies = [
  "serde_json",
  "toml",
@@ -737,7 +760,7 @@ dependencies = [
 
 [[package]]
 name = "tstring-pyo3-bindings"
-version = "0.1.1"
+version = "0.2.1"
 dependencies = [
  "criterion",
  "pyo3",
@@ -753,14 +776,14 @@ dependencies = [
 
 [[package]]
 name = "tstring-syntax"
-version = "0.1.1"
+version = "0.2.1"
 dependencies = [
  "num-bigint",
 ]
 
 [[package]]
 name = "tstring-toml"
-version = "0.1.1"
+version = "0.2.1"
 dependencies = [
  "serde_json",
  "toml",
@@ -769,7 +792,7 @@ dependencies = [
 
 [[package]]
 name = "tstring-yaml"
-version = "0.1.1"
+version = "0.2.1"
 dependencies = [
  "saphyr",
  "saphyr-parser",
@@ -780,7 +803,7 @@ dependencies = [
 
 [[package]]
 name = "tstring-yaml-pyo3-tests"
-version = "0.1.1"
+version = "0.2.1"
 dependencies = [
  "pyo3",
  "saphyr",
@@ -865,6 +888,22 @@ dependencies = [
  "wasm-bindgen",
 ]
 
+[[package]]
+name = "winapi"
+version = "0.3.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419"
+dependencies = [
+ "winapi-i686-pc-windows-gnu",
+ "winapi-x86_64-pc-windows-gnu",
+]
+
+[[package]]
+name = "winapi-i686-pc-windows-gnu"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6"
+
 [[package]]
 name = "winapi-util"
 version = "0.1.11"
@@ -874,6 +913,12 @@ dependencies = [
  "windows-sys",
 ]
 
+[[package]]
+name = "winapi-x86_64-pc-windows-gnu"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
+
 [[package]]
 name = "windows-link"
 version = "0.2.1"

{tstring_bindings-0.1.1 → tstring_bindings-0.2.1}/Cargo.toml

@@ -9,7 +9,7 @@ homepage = "https://github.com/koxudaxi/tstring-structured-data"
 license = "MIT"
 repository = "https://github.com/koxudaxi/tstring-structured-data"
 rust-version = "1.94.0"
-version = "0.1.1"
+version = "0.2.1"
 
 [workspace.dependencies]
 num-bigint = "0.4.6"

{tstring_bindings-0.1.1 → tstring_bindings-0.2.1}/PKG-INFO

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

{tstring_bindings-0.1.1 → tstring_bindings-0.2.1}/json-tstring-rs/Cargo.toml

@@ -18,7 +18,7 @@ test = false
 
 [dependencies]
 serde_json = { workspace = true }
-tstring-syntax = { version = "0.1.1", path = "../tstring-core-rs" }
+tstring-syntax = { version = "0.2.1", path = "../tstring-core-rs" }
 
 [dev-dependencies]
 toml = { workspace = true }

{tstring_bindings-0.1.1 → tstring_bindings-0.2.1}/json-tstring-rs/src/lib.rs

@@ -600,11 +600,36 @@ pub fn parse_template(template: &TemplateInput) -> BackendResult<JsonDocumentNod
     parse_template_with_profile(template, JsonProfile::default())
 }
 
+pub fn parse_validated_template_with_profile(
+    template: &TemplateInput,
+    profile: JsonProfile,
+) -> BackendResult<JsonDocumentNode> {
+    // JSON does not add format-specific post-parse validation yet. Keep the
+    // validated entry point aligned with the other backends so callers can rely
+    // on one API shape as backend-specific validation rules are introduced.
+    parse_template_with_profile(template, profile)
+}
+
+pub fn parse_validated_template(template: &TemplateInput) -> BackendResult<JsonDocumentNode> {
+    parse_validated_template_with_profile(template, JsonProfile::default())
+}
+
+pub fn validate_template_with_profile(
+    template: &TemplateInput,
+    profile: JsonProfile,
+) -> BackendResult<()> {
+    parse_validated_template_with_profile(template, profile).map(|_| ())
+}
+
+pub fn validate_template(template: &TemplateInput) -> BackendResult<()> {
+    validate_template_with_profile(template, JsonProfile::default())
+}
+
 pub fn check_template_with_profile(
     template: &TemplateInput,
     profile: JsonProfile,
 ) -> BackendResult<()> {
-    parse_template_with_profile(template, profile).map(|_| ())
+    validate_template_with_profile(template, profile)
 }
 
 pub fn check_template(template: &TemplateInput) -> BackendResult<()> {
@@ -615,7 +640,7 @@ pub fn format_template_with_profile(
     template: &TemplateInput,
     profile: JsonProfile,
 ) -> BackendResult<String> {
-    let document = parse_template_with_profile(template, profile)?;
+    let document = parse_validated_template_with_profile(template, profile)?;
     format_json_value(template, &document.value)
 }
 
@@ -774,9 +799,9 @@ fn normalize_number(number: &serde_json::Number) -> BackendResult<NormalizedValu
 
 #[cfg(test)]
 mod tests {
-    use super::{parse_template, JsonKeyValue, JsonStringPart, JsonValueNode};
+    use super::{JsonKeyValue, JsonStringPart, JsonValueNode, parse_template};
     use pyo3::prelude::*;
-    use serde_json::{json, Map, Number, Value};
+    use serde_json::{Map, Number, Value, json};
     use tstring_pyo3_bindings::{extract_template, json::render_document};
     use tstring_syntax::{BackendError, BackendResult, ErrorKind};
 

{tstring_bindings-0.1.1 → tstring_bindings-0.2.1}/json-tstring-rs/tests/parser.rs

@@ -1,5 +1,6 @@
 use tstring_json::{
     JsonKeyValue, JsonStringPart, JsonValueNode, check_template, format_template, parse_template,
+    parse_validated_template, validate_template,
 };
 use tstring_syntax::{TemplateInput, TemplateInterpolation, TemplateSegment};
 
@@ -68,6 +69,18 @@ fn checks_valid_json_templates() {
     check_template(&template).expect("expected check success");
 }
 
+#[test]
+fn validates_json_templates_with_supported_interpolations() {
+    let template = TemplateInput::from_segments(vec![
+        TemplateSegment::StaticText("{\"name\": ".to_owned()),
+        interpolation(0, "name"),
+        TemplateSegment::StaticText(", \"active\": true}".to_owned()),
+    ]);
+
+    validate_template(&template).expect("expected validate success");
+    parse_validated_template(&template).expect("expected validated parse success");
+}
+
 #[test]
 fn formats_json_templates_with_raw_interpolations() {
     let template = TemplateInput::from_segments(vec![

{tstring_bindings-0.1.1 → tstring_bindings-0.2.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "tstring-bindings"
-version = "0.1.1"
+version = "0.2.1"
 description = "Native Python bindings for t-string structured data backends"
 readme = "README.md"
 license = { text = "MIT" }

{tstring_bindings-0.1.1 → tstring_bindings-0.2.1}/python/tstring_bindings/__init__.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 from string.templatelib import Template
-from typing import Protocol, cast
+from typing import Annotated, Protocol, cast
 
 from . import tstring_bindings as _bindings
 from ._profiles import (
@@ -14,29 +14,33 @@ from ._profiles import (
 )
 from ._types import JsonValue, TomlValue, YamlValue
 
+type JsonTemplate = Annotated[Template, "json"]
+type TomlTemplate = Annotated[Template, "toml"]
+type YamlTemplate = Annotated[Template, "yaml"]
+
 
 class _RenderJson(Protocol):
-    def __call__(self, template: Template, profile: JsonProfile) -> JsonValue: ...
+    def __call__(self, template: JsonTemplate, profile: JsonProfile) -> JsonValue: ...
 
 
 class _RenderJsonText(Protocol):
-    def __call__(self, template: Template, profile: JsonProfile) -> str: ...
+    def __call__(self, template: JsonTemplate, profile: JsonProfile) -> str: ...
 
 
 class _RenderToml(Protocol):
-    def __call__(self, template: Template, profile: TomlProfile) -> TomlValue: ...
+    def __call__(self, template: TomlTemplate, profile: TomlProfile) -> TomlValue: ...
 
 
 class _RenderTomlText(Protocol):
-    def __call__(self, template: Template, profile: TomlProfile) -> str: ...
+    def __call__(self, template: TomlTemplate, profile: TomlProfile) -> str: ...
 
 
 class _RenderYaml(Protocol):
-    def __call__(self, template: Template, profile: YamlProfile) -> YamlValue: ...
+    def __call__(self, template: YamlTemplate, profile: YamlProfile) -> YamlValue: ...
 
 
 class _RenderYamlText(Protocol):
-    def __call__(self, template: Template, profile: YamlProfile) -> str: ...
+    def __call__(self, template: YamlTemplate, profile: YamlProfile) -> str: ...
 
 
 class _BindingsContract(Protocol):
@@ -101,37 +105,37 @@ _render_yaml_text = _EXTENSION.render_yaml_text
 
 
 def render_json(
-    template: Template, *, profile: JsonProfile | str | None = None
+    template: JsonTemplate, *, profile: JsonProfile | str | None = None
 ) -> JsonValue:
     return _render_json(template, resolve_json_profile(profile))
 
 
 def render_json_text(
-    template: Template, *, profile: JsonProfile | str | None = None
+    template: JsonTemplate, *, profile: JsonProfile | str | None = None
 ) -> str:
     return _render_json_text(template, resolve_json_profile(profile))
 
 
 def render_toml(
-    template: Template, *, profile: TomlProfile | str | None = None
+    template: TomlTemplate, *, profile: TomlProfile | str | None = None
 ) -> TomlValue:
     return _render_toml(template, resolve_toml_profile(profile))
 
 
 def render_toml_text(
-    template: Template, *, profile: TomlProfile | str | None = None
+    template: TomlTemplate, *, profile: TomlProfile | str | None = None
 ) -> str:
     return _render_toml_text(template, resolve_toml_profile(profile))
 
 
 def render_yaml(
-    template: Template, *, profile: YamlProfile | str | None = None
+    template: YamlTemplate, *, profile: YamlProfile | str | None = None
 ) -> YamlValue:
     return _render_yaml(template, resolve_yaml_profile(profile))
 
 
 def render_yaml_text(
-    template: Template, *, profile: YamlProfile | str | None = None
+    template: YamlTemplate, *, profile: YamlProfile | str | None = None
 ) -> str:
     return _render_yaml_text(template, resolve_yaml_profile(profile))
 

{tstring_bindings-0.1.1 → tstring_bindings-0.2.1}/python/tstring_bindings/__init__.pyi

@@ -1,10 +1,14 @@
 from __future__ import annotations
 
 from string.templatelib import Template
-from typing import Any
+from typing import Annotated, Any
 
 from ._profiles import JsonProfile, TomlProfile, YamlProfile
 
+type JsonTemplate = Annotated[Template, "json"]
+type TomlTemplate = Annotated[Template, "toml"]
+type YamlTemplate = Annotated[Template, "yaml"]
+
 type ExceptionSpan = tuple[tuple[int, int], tuple[int, int]]
 type ExceptionDiagnostic = dict[str, object]
 
@@ -19,20 +23,20 @@ class TemplateSemanticError(TemplateError): ...
 class UnrepresentableValueError(TemplateSemanticError): ...
 
 def render_json(
-    template: Template, *, profile: JsonProfile | str | None = ...
+    template: JsonTemplate, *, profile: JsonProfile | str | None = ...
 ) -> Any: ...
 def render_json_text(
-    template: Template, *, profile: JsonProfile | str | None = ...
+    template: JsonTemplate, *, profile: JsonProfile | str | None = ...
 ) -> str: ...
 def render_toml(
-    template: Template, *, profile: TomlProfile | str | None = ...
+    template: TomlTemplate, *, profile: TomlProfile | str | None = ...
 ) -> Any: ...
 def render_toml_text(
-    template: Template, *, profile: TomlProfile | str | None = ...
+    template: TomlTemplate, *, profile: TomlProfile | str | None = ...
 ) -> str: ...
 def render_yaml(
-    template: Template, *, profile: YamlProfile | str | None = ...
+    template: YamlTemplate, *, profile: YamlProfile | str | None = ...
 ) -> Any: ...
 def render_yaml_text(
-    template: Template, *, profile: YamlProfile | str | None = ...
+    template: YamlTemplate, *, profile: YamlProfile | str | None = ...
 ) -> str: ...

{tstring_bindings-0.1.1 → tstring_bindings-0.2.1}/python/tstring_bindings/tstring_bindings.pyi

@@ -1,11 +1,14 @@
 from __future__ import annotations
 
 from string.templatelib import Template
-from typing import Any
+from typing import Annotated, Any
 
 # Non-public extension module retained for internal imports and packaging
 # compatibility. Public callers should use `tstring_bindings`.
 
+type JsonTemplate = Annotated[Template, "json"]
+type TomlTemplate = Annotated[Template, "toml"]
+type YamlTemplate = Annotated[Template, "yaml"]
 type ExceptionSpan = tuple[tuple[int, int], tuple[int, int]]
 type ExceptionDiagnostic = dict[str, object]
 
@@ -22,18 +25,18 @@ class UnrepresentableValueError(TemplateSemanticError): ...
 __contract_version__: int
 __contract_symbols__: tuple[str, ...]
 
-def render_json(template: Template, profile: str = ...) -> Any: ...
-def render_json_text(template: Template, profile: str = ...) -> str: ...
+def render_json(template: JsonTemplate, profile: str = ...) -> Any: ...
+def render_json_text(template: JsonTemplate, profile: str = ...) -> str: ...
 def _render_json_result_payload(
-    template: Template, profile: str = ...
+    template: JsonTemplate, profile: str = ...
 ) -> tuple[str, Any]: ...
-def render_toml(template: Template, profile: str = ...) -> Any: ...
-def render_toml_text(template: Template, profile: str = ...) -> str: ...
+def render_toml(template: TomlTemplate, profile: str = ...) -> Any: ...
+def render_toml_text(template: TomlTemplate, profile: str = ...) -> str: ...
 def _render_toml_result_payload(
-    template: Template, profile: str = ...
+    template: TomlTemplate, profile: str = ...
 ) -> tuple[str, Any]: ...
-def render_yaml(template: Template, profile: str = ...) -> Any: ...
-def render_yaml_text(template: Template, profile: str = ...) -> str: ...
+def render_yaml(template: YamlTemplate, profile: str = ...) -> Any: ...
+def render_yaml_text(template: YamlTemplate, profile: str = ...) -> str: ...
 def _render_yaml_result_payload(
-    template: Template, profile: str = ...
+    template: YamlTemplate, profile: str = ...
 ) -> tuple[str, Any]: ...

{tstring_bindings-0.1.1 → tstring_bindings-0.2.1}/python-bindings/Cargo.toml

@@ -24,12 +24,12 @@ pyo3 = { workspace = true, features = ["abi3-py314"] }
 pythonize = { workspace = true }
 saphyr = { workspace = true }
 serde_json = { workspace = true }
-tstring-json = { version = "0.1.1", path = "../json-tstring-rs" }
-tstring-pyo3-bindings = { version = "0.1.1", path = "../tstring-pyo3-bindings" }
-tstring-syntax = { version = "0.1.1", path = "../tstring-core-rs" }
+tstring-json = { version = "0.2.1", path = "../json-tstring-rs" }
+tstring-pyo3-bindings = { version = "0.2.1", path = "../tstring-pyo3-bindings" }
+tstring-syntax = { version = "0.2.1", path = "../tstring-core-rs" }
 toml = { workspace = true }
-tstring-toml = { version = "0.1.1", path = "../toml-tstring-rs" }
-tstring-yaml = { version = "0.1.1", path = "../yaml-tstring-rs" }
+tstring-toml = { version = "0.2.1", path = "../toml-tstring-rs" }
+tstring-yaml = { version = "0.2.1", path = "../yaml-tstring-rs" }
 
 [dev-dependencies]
 pyo3 = { workspace = true, features = ["auto-initialize"] }

{tstring_bindings-0.1.1 → tstring_bindings-0.2.1}/python-bindings/src/lib.rs

@@ -160,7 +160,7 @@ fn parse_json_template(
 ) -> PyResult<Arc<JsonDocumentNode>> {
     json_parse_cache()
         .get_or_try_insert_with(&template_cache_key(template, profile.as_str()), || {
-            tstring_json::parse_template_with_profile(template.input(), profile)
+            tstring_json::parse_validated_template_with_profile(template.input(), profile)
         })
         .map_err(backend_error_to_py)
 }
@@ -171,7 +171,7 @@ fn parse_toml_template(
 ) -> PyResult<Arc<TomlDocumentNode>> {
     toml_parse_cache()
         .get_or_try_insert_with(&template_cache_key(template, profile.as_str()), || {
-            tstring_toml::parse_template_with_profile(template.input(), profile)
+            tstring_toml::parse_validated_template_with_profile(template.input(), profile)
         })
         .map_err(backend_error_to_py)
 }
@@ -182,7 +182,7 @@ fn parse_yaml_template(
 ) -> PyResult<Arc<YamlStreamNode>> {
     yaml_parse_cache()
         .get_or_try_insert_with(&template_cache_key(template, profile.as_str()), || {
-            tstring_yaml::parse_template_with_profile(template.input(), profile)
+            tstring_yaml::parse_validated_template_with_profile(template.input(), profile)
         })
         .map_err(backend_error_to_py)
 }
@@ -627,7 +627,7 @@ fn normalized_offset_to_python(py: Python<'_>, offset_minutes: i16) -> PyResult<
 
 #[pymodule]
 fn tstring_bindings(py: Python<'_>, module: &Bound<'_, PyModule>) -> PyResult<()> {
-    module.add("__version__", "0.1.1")?;
+    module.add("__version__", "0.2.1")?;
     module.add("__contract_version__", CONTRACT_VERSION)?;
     module.add("__contract_symbols__", PyTuple::new(py, CONTRACT_SYMBOLS)?)?;
     module.add("TemplateError", py.get_type::<TemplateError>())?;

{tstring_bindings-0.1.1 → tstring_bindings-0.2.1}/toml-tstring-rs/Cargo.toml

@@ -19,4 +19,4 @@ test = false
 [dependencies]
 serde_json = { workspace = true }
 toml = { workspace = true }
-tstring-syntax = { version = "0.1.1", path = "../tstring-core-rs" }
+tstring-syntax = { version = "0.2.1", path = "../tstring-core-rs" }

{tstring_bindings-0.1.1 → tstring_bindings-0.2.1}/toml-tstring-rs/src/lib.rs

@@ -1110,11 +1110,36 @@ pub fn parse_template(template: &TemplateInput) -> BackendResult<TomlDocumentNod
     parse_template_with_profile(template, TomlProfile::default())
 }
 
+pub fn parse_validated_template_with_profile(
+    template: &TemplateInput,
+    profile: TomlProfile,
+) -> BackendResult<TomlDocumentNode> {
+    // TOML does not add format-specific post-parse validation yet. Keep the
+    // validated entry point aligned with the other backends so callers can rely
+    // on one API shape as backend-specific validation rules are introduced.
+    parse_template_with_profile(template, profile)
+}
+
+pub fn parse_validated_template(template: &TemplateInput) -> BackendResult<TomlDocumentNode> {
+    parse_validated_template_with_profile(template, TomlProfile::default())
+}
+
+pub fn validate_template_with_profile(
+    template: &TemplateInput,
+    profile: TomlProfile,
+) -> BackendResult<()> {
+    parse_validated_template_with_profile(template, profile).map(|_| ())
+}
+
+pub fn validate_template(template: &TemplateInput) -> BackendResult<()> {
+    validate_template_with_profile(template, TomlProfile::default())
+}
+
 pub fn check_template_with_profile(
     template: &TemplateInput,
     profile: TomlProfile,
 ) -> BackendResult<()> {
-    parse_template_with_profile(template, profile).map(|_| ())
+    validate_template_with_profile(template, profile)
 }
 
 pub fn check_template(template: &TemplateInput) -> BackendResult<()> {
@@ -1125,7 +1150,7 @@ pub fn format_template_with_profile(
     template: &TemplateInput,
     profile: TomlProfile,
 ) -> BackendResult<String> {
-    let document = parse_template_with_profile(template, profile)?;
+    let document = parse_validated_template_with_profile(template, profile)?;
     format_toml_document(template, &document)
 }
 
@@ -1390,7 +1415,7 @@ fn normalize_time(value: toml::value::Time) -> NormalizedTime {
 
 #[cfg(test)]
 mod tests {
-    use super::{parse_template, TomlKeySegmentValue, TomlStatementNode, TomlValueNode};
+    use super::{TomlKeySegmentValue, TomlStatementNode, TomlValueNode, parse_template};
     use pyo3::prelude::*;
     use tstring_pyo3_bindings::{extract_template, toml::render_document};
     use tstring_syntax::{BackendError, BackendResult, ErrorKind};
@@ -1901,10 +1926,12 @@ mod tests {
             );
             let special_floats = table["special_float_array"].as_array().expect("array");
             assert!(special_floats[0].as_float().expect("float").is_infinite());
-            assert!(special_floats[1]
-                .as_float()
-                .expect("float")
-                .is_sign_negative());
+            assert!(
+                special_floats[1]
+                    .as_float()
+                    .expect("float")
+                    .is_sign_negative()
+            );
             assert!(special_floats[2].as_float().expect("float").is_nan());
             assert_eq!(
                 table["special_float_nested_arrays"]
@@ -1916,18 +1943,24 @@ mod tests {
             let special_float_deeper_arrays = table["special_float_deeper_arrays"]
                 .as_array()
                 .expect("array");
-            assert!(special_float_deeper_arrays[0][0][0]
-                .as_float()
-                .expect("float")
-                .is_infinite());
-            assert!(special_float_deeper_arrays[1][0][0]
-                .as_float()
-                .expect("float")
-                .is_sign_negative());
-            assert!(special_float_deeper_arrays[2][0][0]
-                .as_float()
-                .expect("float")
-                .is_nan());
+            assert!(
+                special_float_deeper_arrays[0][0][0]
+                    .as_float()
+                    .expect("float")
+                    .is_infinite()
+            );
+            assert!(
+                special_float_deeper_arrays[1][0][0]
+                    .as_float()
+                    .expect("float")
+                    .is_sign_negative()
+            );
+            assert!(
+                special_float_deeper_arrays[2][0][0]
+                    .as_float()
+                    .expect("float")
+                    .is_nan()
+            );
             assert_eq!(
                 table["upper_exp_nested_mixed"]
                     .as_array()
@@ -1935,14 +1968,18 @@ mod tests {
                     .len(),
                 2
             );
-            assert!(table["special_float_inline_table"]["pos"]
-                .as_float()
-                .expect("float")
-                .is_infinite());
-            assert!(table["special_float_inline_table"]["nan"]
-                .as_float()
-                .expect("float")
-                .is_nan());
+            assert!(
+                table["special_float_inline_table"]["pos"]
+                    .as_float()
+                    .expect("float")
+                    .is_infinite()
+            );
+            assert!(
+                table["special_float_inline_table"]["nan"]
+                    .as_float()
+                    .expect("float")
+                    .is_nan()
+            );
             assert_eq!(
                 table["special_float_mixed_nested"]
                     .as_array()
@@ -2026,9 +2063,10 @@ mod tests {
                 Err(err) => err,
             };
             assert_eq!(err.kind, ErrorKind::Parse);
-            assert!(err
-                .message
-                .contains("single-line basic strings cannot contain newlines"));
+            assert!(
+                err.message
+                    .contains("single-line basic strings cannot contain newlines")
+            );
         });
     }
 
@@ -2920,30 +2958,42 @@ mod tests {
                 rendered.text,
                 "special_float_inline_table = { pos = +inf, neg = -inf, nan = nan }\nspecial_float_mixed_nested = [[+inf, -inf], [nan]]"
             );
-            assert!(rendered.data["special_float_inline_table"]["pos"]
-                .as_float()
-                .expect("pos float")
-                .is_infinite());
-            assert!(rendered.data["special_float_inline_table"]["neg"]
-                .as_float()
-                .expect("neg float")
-                .is_sign_negative());
-            assert!(rendered.data["special_float_inline_table"]["nan"]
-                .as_float()
-                .expect("nan float")
-                .is_nan());
-            assert!(rendered.data["special_float_mixed_nested"][0][0]
-                .as_float()
-                .expect("nested pos")
-                .is_infinite());
-            assert!(rendered.data["special_float_mixed_nested"][0][1]
-                .as_float()
-                .expect("nested neg")
-                .is_sign_negative());
-            assert!(rendered.data["special_float_mixed_nested"][1][0]
-                .as_float()
-                .expect("nested nan")
-                .is_nan());
+            assert!(
+                rendered.data["special_float_inline_table"]["pos"]
+                    .as_float()
+                    .expect("pos float")
+                    .is_infinite()
+            );
+            assert!(
+                rendered.data["special_float_inline_table"]["neg"]
+                    .as_float()
+                    .expect("neg float")
+                    .is_sign_negative()
+            );
+            assert!(
+                rendered.data["special_float_inline_table"]["nan"]
+                    .as_float()
+                    .expect("nan float")
+                    .is_nan()
+            );
+            assert!(
+                rendered.data["special_float_mixed_nested"][0][0]
+                    .as_float()
+                    .expect("nested pos")
+                    .is_infinite()
+            );
+            assert!(
+                rendered.data["special_float_mixed_nested"][0][1]
+                    .as_float()
+                    .expect("nested neg")
+                    .is_sign_negative()
+            );
+            assert!(
+                rendered.data["special_float_mixed_nested"][1][0]
+                    .as_float()
+                    .expect("nested nan")
+                    .is_nan()
+            );
         });
     }
 

{tstring_bindings-0.1.1 → tstring_bindings-0.2.1}/toml-tstring-rs/tests/parser.rs

@@ -1,6 +1,7 @@
 use tstring_syntax::{TemplateInput, TemplateInterpolation, TemplateSegment};
 use tstring_toml::{
-    check_template, format_template, parse_template, TomlStatementNode, TomlValueNode,
+    TomlStatementNode, TomlValueNode, check_template, format_template, parse_template,
+    parse_validated_template, validate_template,
 };
 
 fn interpolation(index: usize, expression: &str) -> TemplateSegment {
@@ -64,6 +65,24 @@ fn checks_valid_toml_templates() {
     check_template(&template).expect("expected check success");
 }
 
+#[test]
+fn validates_toml_templates_with_supported_interpolations() {
+    let template = TemplateInput::from_segments(vec![
+        TemplateSegment::StaticText("title = ".to_owned()),
+        TemplateSegment::Interpolation(TemplateInterpolation {
+            expression: "title".to_owned(),
+            conversion: None,
+            format_spec: String::new(),
+            interpolation_index: 0,
+            raw_source: Some("{title}".to_owned()),
+        }),
+        TemplateSegment::StaticText("\n".to_owned()),
+    ]);
+
+    validate_template(&template).expect("expected validate success");
+    parse_validated_template(&template).expect("expected validated parse success");
+}
+
 #[test]
 fn formats_toml_templates_with_raw_interpolations() {
     let template = TemplateInput::from_segments(vec![

{tstring_bindings-0.1.1 → tstring_bindings-0.2.1}/tstring-pyo3-bindings/Cargo.toml

@@ -16,13 +16,13 @@ serde_json = { workspace = true }
 saphyr = { workspace = true }
 saphyr-parser = { workspace = true }
 toml = { workspace = true }
-tstring-json = { version = "0.1.1", path = "../json-tstring-rs" }
-tstring-syntax = { version = "0.1.1", path = "../tstring-core-rs" }
-tstring-toml = { version = "0.1.1", path = "../toml-tstring-rs" }
-tstring-yaml = { version = "0.1.1", path = "../yaml-tstring-rs" }
+tstring-json = { version = "0.2.1", path = "../json-tstring-rs" }
+tstring-syntax = { version = "0.2.1", path = "../tstring-core-rs" }
+tstring-toml = { version = "0.2.1", path = "../toml-tstring-rs" }
+tstring-yaml = { version = "0.2.1", path = "../yaml-tstring-rs" }
 
 [dev-dependencies]
-criterion = "0.5.1"
+criterion = "0.8.2"
 pyo3 = { workspace = true, features = ["auto-initialize"] }
 
 [[bench]]

{tstring_bindings-0.1.1 → tstring_bindings-0.2.1}/yaml-tstring-rs/Cargo.toml

@@ -20,7 +20,7 @@ test = false
 saphyr = { workspace = true }
 saphyr-parser = { workspace = true }
 serde_json = { workspace = true }
-tstring-syntax = { version = "0.1.1", path = "../tstring-core-rs" }
+tstring-syntax = { version = "0.2.1", path = "../tstring-core-rs" }
 
 [dev-dependencies]
 toml = { workspace = true }

{tstring_bindings-0.1.1 → tstring_bindings-0.2.1}/yaml-tstring-rs/src/lib.rs

@@ -2048,11 +2048,36 @@ pub fn parse_template(template: &TemplateInput) -> BackendResult<YamlStreamNode>
     parse_template_with_profile(template, YamlProfile::default())
 }
 
+pub fn parse_validated_template_with_profile(
+    template: &TemplateInput,
+    profile: YamlProfile,
+) -> BackendResult<YamlStreamNode> {
+    let stream = parse_template_with_profile(template, profile)?;
+    validate_template_stream(&stream)?;
+    Ok(stream)
+}
+
+pub fn parse_validated_template(template: &TemplateInput) -> BackendResult<YamlStreamNode> {
+    parse_validated_template_with_profile(template, YamlProfile::default())
+}
+
+pub fn validate_template_with_profile(
+    template: &TemplateInput,
+    profile: YamlProfile,
+) -> BackendResult<()> {
+    let stream = parse_template_with_profile(template, profile)?;
+    validate_template_stream(&stream)
+}
+
+pub fn validate_template(template: &TemplateInput) -> BackendResult<()> {
+    validate_template_with_profile(template, YamlProfile::default())
+}
+
 pub fn check_template_with_profile(
     template: &TemplateInput,
     profile: YamlProfile,
 ) -> BackendResult<()> {
-    parse_template_with_profile(template, profile).map(|_| ())
+    validate_template_with_profile(template, profile)
 }
 
 pub fn check_template(template: &TemplateInput) -> BackendResult<()> {
@@ -2063,7 +2088,7 @@ pub fn format_template_with_profile(
     template: &TemplateInput,
     profile: YamlProfile,
 ) -> BackendResult<String> {
-    let stream = parse_template_with_profile(template, profile)?;
+    let stream = parse_validated_template_with_profile(template, profile)?;
     format_yaml_stream(template, &stream)
 }
 
@@ -2071,6 +2096,74 @@ pub fn format_template(template: &TemplateInput) -> BackendResult<String> {
     format_template_with_profile(template, YamlProfile::default())
 }
 
+fn validate_template_stream(stream: &YamlStreamNode) -> BackendResult<()> {
+    for document in &stream.documents {
+        validate_value_node(&document.value)?;
+    }
+    Ok(())
+}
+
+fn validate_value_node(node: &YamlValueNode) -> BackendResult<()> {
+    match node {
+        YamlValueNode::Scalar(YamlScalarNode::Plain(node)) => validate_plain_scalar_node(node),
+        YamlValueNode::Mapping(node) => {
+            for entry in &node.entries {
+                validate_key_node(&entry.key)?;
+                validate_value_node(&entry.value)?;
+            }
+            Ok(())
+        }
+        YamlValueNode::Sequence(node) => {
+            for item in &node.items {
+                validate_value_node(item)?;
+            }
+            Ok(())
+        }
+        YamlValueNode::Decorated(node) => validate_value_node(&node.value),
+        YamlValueNode::Interpolation(_)
+        | YamlValueNode::Scalar(
+            YamlScalarNode::DoubleQuoted(_)
+            | YamlScalarNode::SingleQuoted(_)
+            | YamlScalarNode::Block(_)
+            | YamlScalarNode::Alias(_),
+        ) => Ok(()),
+    }
+}
+
+fn validate_key_node(node: &YamlKeyNode) -> BackendResult<()> {
+    match &node.value {
+        YamlKeyValue::Scalar(YamlScalarNode::Plain(node)) => validate_plain_scalar_node(node),
+        YamlKeyValue::Complex(node) => validate_value_node(node),
+        YamlKeyValue::Interpolation(_)
+        | YamlKeyValue::Scalar(
+            YamlScalarNode::DoubleQuoted(_)
+            | YamlScalarNode::SingleQuoted(_)
+            | YamlScalarNode::Block(_)
+            | YamlScalarNode::Alias(_),
+        ) => Ok(()),
+    }
+}
+
+fn validate_plain_scalar_node(node: &YamlPlainScalarNode) -> BackendResult<()> {
+    let has_interpolation = node
+        .chunks
+        .iter()
+        .any(|chunk| matches!(chunk, YamlChunk::Interpolation(_)));
+    let has_whitespace_text = node.chunks.iter().any(|chunk| {
+        matches!(chunk, YamlChunk::Text(text) if text.value.chars().any(char::is_whitespace))
+    });
+
+    if has_interpolation && has_whitespace_text {
+        return Err(BackendError::parse_at(
+            "yaml.parse",
+            "Quote YAML plain scalars that mix whitespace and interpolations.",
+            Some(node.span.clone()),
+        ));
+    }
+
+    Ok(())
+}
+
 pub fn normalize_documents_with_profile(
     documents: &[YamlOwned],
     _profile: YamlProfile,

{tstring_bindings-0.1.1 → tstring_bindings-0.2.1}/yaml-tstring-rs/tests/parser.rs

@@ -1,5 +1,7 @@
 use tstring_syntax::{TemplateInput, TemplateInterpolation, TemplateSegment};
-use tstring_yaml::{YamlValueNode, check_template, format_template, parse_template};
+use tstring_yaml::{
+    YamlValueNode, check_template, format_template, parse_template, validate_template,
+};
 
 fn interpolation(index: usize, expression: &str) -> TemplateSegment {
     TemplateSegment::Interpolation(TemplateInterpolation {
@@ -62,6 +64,71 @@ fn checks_valid_yaml_templates() {
     check_template(&template).expect("expected check success");
 }
 
+#[test]
+fn rejects_plain_scalars_that_mix_whitespace_and_interpolation() {
+    let template = TemplateInput::from_segments(vec![
+        TemplateSegment::StaticText("replicas: fdsa fff fds".to_owned()),
+        TemplateSegment::Interpolation(TemplateInterpolation {
+            expression: "replicas".to_owned(),
+            conversion: None,
+            format_spec: String::new(),
+            interpolation_index: 0,
+            raw_source: Some("{replicas}".to_owned()),
+        }),
+        TemplateSegment::StaticText("\n".to_owned()),
+    ]);
+
+    let error = check_template(&template).expect_err("expected YAML validation failure");
+    assert_eq!(error.diagnostics[0].code, "yaml.parse");
+    assert!(
+        error
+            .message
+            .contains("Quote YAML plain scalars that mix whitespace and interpolations")
+    );
+}
+
+#[test]
+fn validates_token_like_plain_scalars_with_interpolation() {
+    let template = TemplateInput::from_segments(vec![
+        TemplateSegment::StaticText("plain: item-".to_owned()),
+        TemplateSegment::Interpolation(TemplateInterpolation {
+            expression: "user".to_owned(),
+            conversion: None,
+            format_spec: String::new(),
+            interpolation_index: 0,
+            raw_source: Some("{user}".to_owned()),
+        }),
+        TemplateSegment::StaticText("\n".to_owned()),
+    ]);
+
+    validate_template(&template).expect("expected YAML validation success");
+}
+
+#[test]
+fn validates_plain_scalars_with_multiple_interpolations_and_no_whitespace() {
+    let template = TemplateInput::from_segments(vec![
+        TemplateSegment::StaticText("plain: ".to_owned()),
+        TemplateSegment::Interpolation(TemplateInterpolation {
+            expression: "foo".to_owned(),
+            conversion: None,
+            format_spec: String::new(),
+            interpolation_index: 0,
+            raw_source: Some("{foo}".to_owned()),
+        }),
+        TemplateSegment::StaticText("-".to_owned()),
+        TemplateSegment::Interpolation(TemplateInterpolation {
+            expression: "bar".to_owned(),
+            conversion: None,
+            format_spec: String::new(),
+            interpolation_index: 1,
+            raw_source: Some("{bar}".to_owned()),
+        }),
+        TemplateSegment::StaticText("\n".to_owned()),
+    ]);
+
+    validate_template(&template).expect("expected YAML validation success");
+}
+
 #[test]
 fn formats_yaml_templates_with_raw_interpolations() {
     let template = TemplateInput::from_segments(vec![