polyxml 0.33.7__tar.gz → 0.33.8__tar.gz

{polyxml-0.33.7 → polyxml-0.33.8}/Cargo.lock

@@ -608,7 +608,7 @@ dependencies = [
 
 [[package]]
 name = "polyxml"
-version = "0.33.7"
+version = "0.33.8"
 dependencies = [
  "criterion",
  "heck",
@@ -629,14 +629,14 @@ dependencies = [
 
 [[package]]
 name = "polyxml-c"
-version = "0.33.7"
+version = "0.33.8"
 dependencies = [
  "polyxml",
 ]
 
 [[package]]
 name = "polyxml-cli"
-version = "0.33.7"
+version = "0.33.8"
 dependencies = [
  "clap",
  "glob",
@@ -650,7 +650,7 @@ dependencies = [
 
 [[package]]
 name = "polyxml-js"
-version = "0.33.7"
+version = "0.33.8"
 dependencies = [
  "napi",
  "napi-build",
@@ -660,7 +660,7 @@ dependencies = [
 
 [[package]]
 name = "polyxml-python"
-version = "0.33.7"
+version = "0.33.8"
 dependencies = [
  "lexical-core",
  "polyxml",
@@ -670,7 +670,7 @@ dependencies = [
 
 [[package]]
 name = "polyxml-wasm"
-version = "0.33.7"
+version = "0.33.8"
 dependencies = [
  "polyxml",
  "quick-xml",

{polyxml-0.33.7 → polyxml-0.33.8}/Cargo.toml

@@ -3,7 +3,7 @@ resolver = "2"
 members = ["crates/polyxml-core", "crates/polyxml-python"]
 
 [workspace.package]
-version = "0.33.7"
+version = "0.33.8"
 edition = "2021"
 rust-version = "1.80"
 license = "MIT"

{polyxml-0.33.7 → polyxml-0.33.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: polyxml
-Version: 0.33.7
+Version: 0.33.8
 Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License

{polyxml-0.33.7 → polyxml-0.33.8}/crates/polyxml-core/src/codegen/csharp/mod.rs

@@ -877,11 +877,11 @@ impl CSharpCodegen {
         ir: &SchemaIR,
         indent: &str,
     ) -> bool {
-        let Some(default) = field.default_value.as_ref() else {
+        let Some(default) = field.default_value.as_ref().or(field.fixed_value.as_ref()) else {
             return false;
         };
         if !self.options.emit_xml_attributes
-            || field.kind != FieldKind::Element
+            || !matches!(field.kind, FieldKind::Element | FieldKind::Attribute)
             || field.cardinality.is_list()
             || matches!(field.type_ref, TypeRef::Named(ref q) if matches!(ir.types.get(q), Some(TypeDef::Struct(_) | TypeDef::Union(_))))
         {
@@ -894,19 +894,49 @@ impl CSharpCodegen {
             .as_ref()
             .map(|ns| format!(", Namespace = {ns:?}"))
             .unwrap_or_default();
+        let parse = |text: &str| {
+            format!("({base})new XmlSerializer(typeof({base}), new XmlRootAttribute(\"value\")).Deserialize(new System.IO.StringReader(\"<value>\" + System.Security.SecurityElement.Escape({text}) + \"</value>\"))!")
+        };
+        if let Some(fixed) = &field.fixed_value {
+            let expected = parse(&format!("{fixed:?}"));
+            let initial = if field.cardinality.is_optional() && field.kind == FieldKind::Element {
+                "default!".to_string()
+            } else {
+                expected.clone()
+            };
+            writeln!(out, "{indent}    private {ty} _{name} = {initial};
+{indent}    [XmlIgnore] public {ty} {name} {{ get => _{name}; set {{ if (value is not null && !object.Equals(value, {expected})) throw new System.ComponentModel.DataAnnotations.ValidationException(\"Fixed value constraint violated for {name}\"); _{name} = value; }} }}").unwrap();
+        } else {
+            let initial = if field.kind == FieldKind::Attribute {
+                parse(&format!("{default:?}"))
+            } else {
+                "default!".to_string()
+            };
+            writeln!(
+                out,
+                "{indent}    [XmlIgnore] public {ty} {name} {{ get; set; }} = {initial};"
+            )
+            .unwrap();
+        }
+        let kind = if field.kind == FieldKind::Attribute {
+            "XmlAttribute"
+        } else {
+            "XmlElement"
+        };
         writeln!(
             out,
-            "{indent}    [XmlIgnore] public {ty} {name} {{ get; set; }} = default!;"
-        )
-        .unwrap();
-        writeln!(
-            out,
-            "{indent}    [XmlElement({:?}{namespace})] public string? {name}Xml {{",
+            "{indent}    [{kind}({:?}{namespace})] public string? {name}Xml {{",
             field.xml_name
         )
         .unwrap();
         writeln!(out, "{indent}        get {{ if ({name} is null) return null; var writer = new System.IO.StringWriter(System.Globalization.CultureInfo.InvariantCulture); new XmlSerializer(typeof({base}), new XmlRootAttribute(\"value\")).Serialize(writer, {name}); return System.Xml.Linq.XDocument.Parse(writer.ToString()).Root!.Value; }}").unwrap();
-        writeln!(out, "{indent}        set {{ if (value is null) {{ {name} = default!; return; }} var text = value.Length == 0 ? {default:?} : value; {name} = ({base})new XmlSerializer(typeof({base}), new XmlRootAttribute(\"value\")).Deserialize(new System.IO.StringReader(\"<value>\" + System.Security.SecurityElement.Escape(text) + \"</value>\"))!; }}
+        let text = if field.kind == FieldKind::Attribute {
+            "value".into()
+        } else {
+            format!("value.Length == 0 ? {default:?} : value")
+        };
+        let parsed = parse("text");
+        writeln!(out, "{indent}        set {{ if (value is null) {{ {name} = default!; return; }} var text = {text}; {name} = {parsed}; }}
 {indent}    }}").unwrap();
         if field.cardinality.is_optional() || field.nillable {
             writeln!(
@@ -1079,7 +1109,7 @@ impl CSharpCodegen {
         }
 
         let has_lexical_union = self.options.emit_xml_attributes && s.fields.iter().any(|f| {
-            f.default_value.is_some() || matches!(&f.type_ref, TypeRef::Named(q) if matches!(ir.types.get(q), Some(TypeDef::Union(u)) if u.is_lexical()))
+            f.default_value.is_some() || f.fixed_value.is_some() || matches!(&f.type_ref, TypeRef::Named(q) if matches!(ir.types.get(q), Some(TypeDef::Union(u)) if u.is_lexical()))
         });
 
         if self.options.use_records && has_lexical_union {

{polyxml-0.33.7 → polyxml-0.33.8}/crates/polyxml-core/src/codegen/python/mod.rs

@@ -993,6 +993,9 @@ impl PythonCodegen {
             parts.push(format!("\"namespace\": \"{}\"", ns));
         }
 
+        if let Some(ref fixed) = field.fixed_value {
+            parts.push(format!("\"fixed\": {fixed:?}"));
+        }
         if let Some(ref default) = field.default_value {
             parts.push(format!("\"default\": {default:?}"));
         }

{polyxml-0.33.7 → polyxml-0.33.8}/crates/polyxml-core/src/parser.rs

@@ -73,9 +73,10 @@ impl StackFrame {
     fn finish(mut self) -> Result<PolyValue> {
         for (index, field) in self.schema.fields.iter().enumerate() {
             if field.kind == FieldKind::Attribute && self.values[index].is_none() {
-                if let (Some(default), ValueType::Scalar(scalar)) =
-                    (&field.default_value, &field.val_type)
-                {
+                if let (Some(default), ValueType::Scalar(scalar)) = (
+                    &field.default_value.as_ref().or(field.fixed_value.as_ref()),
+                    &field.val_type,
+                ) {
                     self.values[index] = Some(ValueConverter::parse_scalar(
                         scalar,
                         default.as_bytes(),
@@ -113,6 +114,11 @@ impl StackFrame {
             }
         }
 
+        for (index, field) in self.schema.fields.iter().enumerate() {
+            if let Some(value) = self.values[index].as_ref() {
+                crate::schema::validate_fixed(field, value)?;
+            }
+        }
         Ok(PolyValue::Record {
             schema: self.schema,
             values: self.values.into_vec().into_boxed_slice(),
@@ -129,6 +135,7 @@ fn parse_field_scalar(
         field
             .default_value
             .as_ref()
+            .or(field.fixed_value.as_ref())
             .map_or(text, |value| value.as_bytes())
     } else {
         text

{polyxml-0.33.7 → polyxml-0.33.8}/crates/polyxml-core/src/schema.rs

@@ -66,6 +66,7 @@ pub struct FieldSchema {
     pub val_type: ValueType,
     pub required: bool,
     pub default_value: Option<String>,
+    pub fixed_value: Option<String>,
 }
 
 impl FieldSchema {
@@ -83,6 +84,7 @@ impl FieldSchema {
             val_type,
             required: false,
             default_value: None,
+            fixed_value: None,
         }
     }
 
@@ -354,6 +356,7 @@ impl ModelSchema {
 
             let mut field_schema = FieldSchema::new(&f.name, f.xml_name.as_bytes(), kind, val_type);
             field_schema.default_value = f.default_value.clone();
+            field_schema.fixed_value = f.fixed_value.clone();
             if let Some(ref ns) = f.namespace {
                 field_schema = field_schema.namespace(ns);
             }
@@ -633,3 +636,46 @@ impl ModelSchemaBuilder {
         })
     }
 }
+
+/// Validate fixed constraints in value space rather than comparing lexical spellings.
+pub(crate) fn validate_fixed(
+    field: &FieldSchema,
+    value: &crate::value::PolyValue,
+) -> crate::error::Result<()> {
+    use crate::value::PolyValue;
+    let Some(fixed) = &field.fixed_value else {
+        return Ok(());
+    };
+    fn check(
+        ty: &ValueType,
+        value: &PolyValue,
+        fixed: &str,
+        name: &str,
+    ) -> crate::error::Result<()> {
+        if matches!(value, PolyValue::Null) {
+            return Ok(());
+        }
+        match (ty, value) {
+            (ValueType::Scalar(scalar), value) => {
+                let expected = crate::converters::ValueConverter::parse_scalar(
+                    scalar,
+                    fixed.as_bytes(),
+                    name,
+                )?;
+                if *value != expected {
+                    return Err(crate::error::PolyXmlError::SchemaError(format!(
+                        "Fixed value constraint violated for {name}"
+                    )));
+                }
+            }
+            (ValueType::List(inner), PolyValue::List(items)) => {
+                for item in items {
+                    check(inner, item, fixed, name)?;
+                }
+            }
+            _ => {}
+        }
+        Ok(())
+    }
+    check(&field.val_type, value, fixed, &field.name)
+}

{polyxml-0.33.7 → polyxml-0.33.8}/crates/polyxml-core/src/serializer.rs

@@ -296,6 +296,12 @@ impl XmlSerializer {
             }
         };
 
+        for (index, field) in schema.fields.iter().enumerate() {
+            if let Some(value) = get_field(index, &field.name) {
+                crate::schema::validate_fixed(field, value)?;
+            }
+        }
+
         let local_tag = std::str::from_utf8(tag_name)?;
         let qualified_tag = if let Some(ctx) = ns_ctx {
             ctx.qualify_element(local_tag, element_ns)

{polyxml-0.33.7 → polyxml-0.33.8}/crates/polyxml-core/tests/test_csharp_codegen.rs

@@ -1278,3 +1278,47 @@ if(present&&!writer.ToString().Contains("<Flag>false</Flag>"))throw new Exceptio
         );
     }
 }
+
+#[test]
+fn fixed_values_are_enforced_on_read_and_write() {
+    let ir = polyxml::schema_parser::XsdParser::new()
+        .parse_str(include_str!("../../../research/fixtures/fixed_values.xsd"))
+        .unwrap();
+    for use_records in [true, false] {
+        let temp = tempdir().unwrap();
+        fs::write(temp.path().join("App.csproj"),r#"<Project Sdk="Microsoft.NET.Sdk"><PropertyGroup><OutputType>Exe</OutputType><TargetFramework>net8.0</TargetFramework><ImplicitUsings>enable</ImplicitUsings><Nullable>enable</Nullable></PropertyGroup></Project>"#).unwrap();
+        fs::write(
+            temp.path().join("Models.cs"),
+            CSharpCodegen::new(CSharpOptions {
+                namespace: "Models".into(),
+                use_records,
+                ..Default::default()
+            })
+            .generate_module(&ir),
+        )
+        .unwrap();
+        fs::write(temp.path().join("Program.cs"),r#"using Models;using System.Xml.Serialization;using System.ComponentModel.DataAnnotations;
+var serializer=new XmlSerializer(typeof(Root));
+foreach(var xml in new[]{"<Root><Code>0013</Code><Flag>1</Flag></Root>","<Root><Code/><Flag/></Root>"}){
+var root=(Root)serializer.Deserialize(new StringReader(xml))!;
+if(root.Code!="0013"||root.Flag!=true||root.Mode!="auto")throw new Exception("fixed defaults missing");
+var writer=new StringWriter();serializer.Serialize(writer,root);
+try{root.Code="wrong";throw new Exception("mutation accepted");}catch(ValidationException){}
+}
+foreach(var xml in new[]{"<Root><Code>wrong</Code></Root>","<Root mode='wrong'><Code>0013</Code></Root>","<Root><Code>0013</Code><Flag>false</Flag></Root>"}){
+try{serializer.Deserialize(new StringReader(xml));throw new Exception("invalid input accepted");}catch(InvalidOperationException){}
+}"#).unwrap();
+        let _lock = DOTNET_LOCK.lock().unwrap();
+        let result = dotnet_command()
+            .arg("run")
+            .current_dir(temp.path())
+            .output()
+            .unwrap();
+        assert!(
+            result.status.success(),
+            "{}{}",
+            String::from_utf8_lossy(&result.stdout),
+            String::from_utf8_lossy(&result.stderr)
+        );
+    }
+}

polyxml-0.33.8/crates/polyxml-core/tests/test_value_constraints.rs

@@ -0,0 +1,30 @@
+use polyxml::schema::ModelSchema;
+use polyxml::schema_parser::XsdParser;
+use polyxml::{deserialize, serialize};
+use std::sync::Arc;
+
+#[test]
+fn fixed_constraints_cover_input_and_output_in_value_space() {
+    let ir = XsdParser::new()
+        .parse_str(include_str!("../../../research/fixtures/fixed_values.xsd"))
+        .unwrap();
+    let schema = ModelSchema::from_ir(&ir, Some("Root")).unwrap();
+    for xml in [
+        "<Root><Code>0013</Code><Flag>1</Flag></Root>",
+        "<Root><Code/><Flag/></Root>",
+    ] {
+        let value = deserialize(xml.as_bytes(), Arc::clone(&schema)).unwrap();
+        let output = serialize("Root", &value, &schema, None).unwrap();
+        deserialize(&output, Arc::clone(&schema)).unwrap();
+    }
+    for xml in [
+        "<Root><Code>wrong</Code></Root>",
+        "<Root mode='wrong'><Code>0013</Code></Root>",
+        "<Root><Code>0013</Code><Flag>false</Flag></Root>",
+    ] {
+        assert!(deserialize(xml.as_bytes(), Arc::clone(&schema))
+            .unwrap_err()
+            .to_string()
+            .contains("Fixed value constraint"));
+    }
+}

{polyxml-0.33.7 → polyxml-0.33.8}/crates/polyxml-python/src/lib.rs

@@ -417,6 +417,10 @@ fn extract_schema_from_class<'py>(
             });
 
             let mut field_schema = FieldSchema::new(py_name, xml_name.as_bytes(), kind, val_type);
+            field_schema.fixed_value = meta
+                .as_ref()
+                .and_then(|m| m.get_item("fixed").ok())
+                .and_then(|v| v.extract::<String>().ok());
             field_schema.default_value = meta
                 .as_ref()
                 .and_then(|m| m.get_item("default").ok())
@@ -498,6 +502,11 @@ fn extract_schema_from_class<'py>(
             });
 
             let mut field_schema = FieldSchema::new(py_name, xml_name.as_bytes(), kind, val_type);
+            field_schema.fixed_value = field_obj
+                .getattr("metadata")
+                .ok()
+                .and_then(|m| m.get_item("fixed").ok())
+                .and_then(|v| v.extract::<String>().ok());
             field_schema.default_value = field_obj
                 .getattr("metadata")
                 .ok()

{polyxml-0.33.7 → polyxml-0.33.8}/crates/polyxml-python/tests/test_generated_models.py

@@ -598,3 +598,39 @@ def test_element_defaults_preserve_absence(tmp_path, backend):
         encoded = present.to_xml()
         assert ET.fromstring(encoded).findtext("Flag") == "false"
         assert module.Root.from_xml(encoded).count == 42
+
+
+@pytest.mark.parametrize("backend", ["dataclass", "pydantic"])
+def test_fixed_values_validate_input_and_output(tmp_path, backend):
+    schema = pathlib.Path(__file__).resolve().parents[3] / "research/fixtures/fixed_values.xsd"
+    subprocess.run(
+        [
+            str(_get_polyxml_bin()),
+            "generate",
+            str(schema),
+            "--lang",
+            "python",
+            "--backend",
+            backend,
+            "--out",
+            str(tmp_path),
+        ],
+        check=True,
+        capture_output=True,
+    )
+    module = _load_module_from_file(f"fixed_{backend}", tmp_path / "fixed_values.py")
+    for document in ["<Root><Code>0013</Code><Flag>1</Flag></Root>", "<Root><Code/><Flag/></Root>"]:
+        root = module.Root.from_xml(document)
+        assert (root.code, root.flag, root.mode) == ("0013", True, "auto")
+        assert module.Root.from_xml(root.to_xml()).code == "0013"
+    for document in [
+        "<Root><Code>wrong</Code></Root>",
+        "<Root mode='wrong'><Code>0013</Code></Root>",
+        "<Root><Code>0013</Code><Flag>false</Flag></Root>",
+    ]:
+        with pytest.raises(ValueError, match="Fixed value constraint"):
+            module.Root.from_xml(document)
+    root = module.Root.from_xml("<Root><Code>0013</Code></Root>")
+    root.code = "wrong"
+    with pytest.raises(ValueError, match="Fixed value constraint"):
+        root.to_xml()

{polyxml-0.33.7 → polyxml-0.33.8}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "maturin"
 
 [project]
 name = "polyxml"
-version = "0.33.7"
+version = "0.33.8"
 description = "High-performance, polyglot XML data-binding engine built in Rust"
 authors = [
     { name = "Bailey Nguyen", email = "bailey.tan.nguyen@gmail.com" }