polyxml 0.34.3__tar.gz → 0.34.4__tar.gz

{polyxml-0.34.3 → polyxml-0.34.4}/Cargo.lock

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

{polyxml-0.34.3 → polyxml-0.34.4}/Cargo.toml

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

{polyxml-0.34.3 → polyxml-0.34.4}/PKG-INFO

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

{polyxml-0.34.3 → polyxml-0.34.4}/crates/polyxml-core/src/codegen/csharp/mod.rs

@@ -1426,7 +1426,10 @@ impl CSharpCodegen {
             format!(" : {}", base_clause.join(", "))
         };
 
-        let mut seen_props = HashSet::new();
+        // Reserve the actual generated names on every ancestor. Distinct
+        // XML members (e.g. nameOfClass attribute and NameOfClass element)
+        // can normalize to the same C# identifier.
+        let mut seen_props = self.inherited_property_names(s, ir, &mut HashSet::new());
         let prop_names: Vec<String> = s
             .fields
             .iter()
@@ -1678,6 +1681,51 @@ impl CSharpCodegen {
         writeln!(out, "{}}}\n", indent).unwrap();
     }
 
+    fn inherited_property_names(
+        &self,
+        s: &StructDef,
+        ir: &SchemaIR,
+        visited: &mut HashSet<QName>,
+    ) -> HashSet<String> {
+        let Some(base) = s.base_type.as_ref() else {
+            return HashSet::new();
+        };
+        if !visited.insert(base.clone()) {
+            return HashSet::new();
+        }
+        let Some(TypeDef::Struct(parent)) = ir.types.get(base) else {
+            return HashSet::new();
+        };
+        let mut names = self.inherited_property_names(parent, ir, visited);
+        let mut ancestor_fields = Vec::new();
+        let mut next = parent.base_type.as_ref();
+        let mut seen = HashSet::new();
+        while let Some(qname) = next {
+            if !seen.insert(qname.clone()) {
+                break;
+            }
+            let Some(TypeDef::Struct(ancestor)) = ir.types.get(qname) else {
+                break;
+            };
+            ancestor_fields.extend(ancestor.fields.iter());
+            next = ancestor.base_type.as_ref();
+        }
+        let enclosing = type_ident(&parent.qname);
+        for field in &parent.fields {
+            let inherited = ancestor_fields.iter().any(|f| {
+                (field.kind == FieldKind::Text && f.kind == FieldKind::Text)
+                    || (field.kind == f.kind
+                        && field.xml_name == f.xml_name
+                        && field.namespace == f.namespace
+                        && field.name == f.name)
+            });
+            if !inherited {
+                self.unique_property_name(&field.name, &mut names, Some(&enclosing));
+            }
+        }
+        names
+    }
+
     fn unique_property_name(
         &self,
         name: &str,

{polyxml-0.34.3 → polyxml-0.34.4}/crates/polyxml-core/src/codegen/rust/mod.rs

@@ -1333,7 +1333,10 @@ impl RustCodegen {
                 if field.kind != FieldKind::Element {
                     continue;
                 }
-                let tags: Vec<String> = match self.resolve_union_def(&field.type_ref, ir) {
+                let tags: Vec<String> = match self
+                    .resolve_union_def(&field.type_ref, ir)
+                    .filter(|_| field.xml_name.is_empty())
+                {
                     Some(u) => u
                         .branches
                         .iter()
@@ -1495,7 +1498,10 @@ impl RustCodegen {
             }
 
             for meta in &elem_fields {
-                if let Some(union_def) = self.resolve_union_def(&meta.field.type_ref, ir) {
+                if let Some(union_def) = self
+                    .resolve_union_def(&meta.field.type_ref, ir)
+                    .filter(|_| meta.field.xml_name.is_empty())
+                {
                     let branch_tags: Vec<_> = union_def
                         .branches
                         .iter()
@@ -1575,7 +1581,10 @@ impl RustCodegen {
                 );
             }
             for meta in &elem_fields {
-                if let Some(union_def) = self.resolve_union_def(&meta.field.type_ref, ir) {
+                if let Some(union_def) = self
+                    .resolve_union_def(&meta.field.type_ref, ir)
+                    .filter(|_| meta.field.xml_name.is_empty())
+                {
                     let branch_tags: Vec<_> = union_def
                         .branches
                         .iter()
@@ -2069,10 +2078,14 @@ impl RustCodegen {
         } else {
             let target_type = self.format_rust_type_ref(&field.type_ref, types_with_lifetime);
             let target_clean = target_type.split('<').next().unwrap_or(&target_type);
+            let decode = if self.resolve_union_def(&field.type_ref, ir).is_some() {
+                "decode_xml_wrapped"
+            } else {
+                "decode_xml"
+            };
             let _ = writeln!(
                 out,
-                "                        let val = {}::decode_xml(reader, &e)?;",
-                target_clean
+                "                        let val = {target_clean}::{decode}(reader, &e)?;"
             );
             let final_val = if is_boxed { "Box::new(val)" } else { "val" };
             if is_list {
@@ -2102,6 +2115,10 @@ impl RustCodegen {
         let is_list = field.cardinality.is_list() || field.type_ref.is_list();
         let is_boxed = field.is_cycle_cut || field.type_ref.is_boxed();
 
+        if self.resolve_union_def(&field.type_ref, ir).is_some() {
+            let _ = writeln!(out, "                        return Err(PolyXmlError::SchemaError(\"Missing choice in {}\".into()));", field.xml_name);
+            return;
+        }
         if self.field_is_string(&field.type_ref, ir) {
             self.emit_pattern_check(out, field, "\"\"", ir);
             if self.options.zero_copy {
@@ -2399,7 +2416,15 @@ impl RustCodegen {
                     field.xml_name
                 );
             } else if self.resolve_union_def(&field.type_ref, ir).is_some() {
-                let _ = writeln!(out, "            item.encode_xml(writer, None)?;",);
+                if field.xml_name.is_empty() {
+                    let _ = writeln!(out, "            item.encode_xml(writer, None)?;");
+                } else {
+                    let _ = writeln!(
+                        out,
+                        "            item.encode_xml_wrapped(writer, {:?})?;",
+                        field.xml_name
+                    );
+                }
             } else {
                 let _ = writeln!(
                     out,
@@ -2451,7 +2476,15 @@ impl RustCodegen {
                     field.xml_name
                 );
             } else if self.resolve_union_def(&field.type_ref, ir).is_some() {
-                let _ = writeln!(out, "            val.encode_xml(writer, None)?;",);
+                if field.xml_name.is_empty() {
+                    let _ = writeln!(out, "            val.encode_xml(writer, None)?;");
+                } else {
+                    let _ = writeln!(
+                        out,
+                        "            val.encode_xml_wrapped(writer, {:?})?;",
+                        field.xml_name
+                    );
+                }
             } else {
                 let _ = writeln!(
                     out,
@@ -2506,7 +2539,15 @@ impl RustCodegen {
                     field.xml_name
                 );
             } else if self.resolve_union_def(&field.type_ref, ir).is_some() {
-                let _ = writeln!(out, "        self.{}.encode_xml(writer, None)?;", rust_name);
+                if field.xml_name.is_empty() {
+                    let _ = writeln!(out, "        self.{}.encode_xml(writer, None)?;", rust_name);
+                } else {
+                    let _ = writeln!(
+                        out,
+                        "        self.{}.encode_xml_wrapped(writer, {:?})?;",
+                        rust_name, field.xml_name
+                    );
+                }
             } else {
                 let _ = writeln!(
                     out,
@@ -2540,6 +2581,35 @@ impl RustCodegen {
         out.push('\n');
         let _ = writeln!(out, "{} {{", impl_header);
 
+        let reader_lifetime = if needs_lifetime { "'a" } else { "'_" };
+        let _ = writeln!(out, "    pub fn decode_xml_wrapped(reader: &mut Reader<&{reader_lifetime} [u8]>, start: &BytesStart<'_>) -> Result<Self> {{");
+        out.push_str(r#"        let mut value = None;
+        loop {
+            match reader.read_event()? {
+                Event::Start(e) => {
+                    if value.is_some() { return Err(PolyXmlError::SchemaError("Multiple choice alternatives".into())); }
+                    value = Some(Self::decode_xml(reader, &e)?);
+                }
+                Event::Empty(e) => {
+                    if value.is_some() { return Err(PolyXmlError::SchemaError("Multiple choice alternatives".into())); }
+                    let mut empty_reader = Reader::from_str("");
+                    value = Some(Self::decode_xml(&mut empty_reader, &e)?);
+                }
+                Event::End(e) if e.name() == start.name() => break,
+                Event::Eof => return Err(PolyXmlError::SchemaError("Unclosed choice wrapper".into())),
+                _ => {}
+            }
+        }
+        value.ok_or_else(|| PolyXmlError::SchemaError("Missing choice alternative".into()))
+    }
+    pub fn encode_xml_wrapped<W: std::io::Write>(&self, writer: &mut Writer<W>, tag: &str) -> Result<()> {
+        writer.write_event(Event::Start(BytesStart::new(tag)))?;
+        self.encode_xml(writer, None)?;
+        writer.write_event(Event::End(BytesEnd::new(tag)))?;
+        Ok(())
+    }
+"#);
+
         let from_xml_sig = if needs_lifetime {
             "pub fn from_xml(xml: &'a str) -> Result<Self>"
         } else {

{polyxml-0.34.3 → polyxml-0.34.4}/crates/polyxml-core/tests/test_qualified_attributes.rs

@@ -125,3 +125,46 @@ if(json.Contains("TypeXml"))throw new Exception("XML proxy leaked to JSON: "+jso
         );
     }
 }
+
+#[test]
+fn inherited_attribute_and_distinct_element_keep_separate_property_names() {
+    let ir = XsdParser::new().parse_str(r#"<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
+      <xs:complexType name="Entity"><xs:attribute name="nameOfClass" type="xs:string"/></xs:complexType>
+      <xs:complexType name="Assignment"><xs:complexContent><xs:extension base="Entity"><xs:sequence><xs:element name="NameOfClass" type="xs:string" minOccurs="0"/></xs:sequence></xs:extension></xs:complexContent></xs:complexType>
+      <xs:complexType name="SpecialAssignment"><xs:complexContent><xs:extension base="Assignment"><xs:sequence><xs:element name="name_of_class" type="xs:string" minOccurs="0"/></xs:sequence></xs:extension></xs:complexContent></xs:complexType>
+    </xs:schema>"#).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><WarningsAsErrors>CS0108;CS8866;CS0657;CS8907</WarningsAsErrors></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 System.Xml.Serialization;using System.Xml.Linq;using Models;
+var serializer=new XmlSerializer(typeof(SpecialAssignment));
+var value=(SpecialAssignment)serializer.Deserialize(new StringReader("<SpecialAssignment nameOfClass='attribute'><NameOfClass>element</NameOfClass><name_of_class>grandchild</name_of_class></SpecialAssignment>"))!;
+if(((Entity)value).NameOfClass!="attribute"||value.NameOfClass2!="element"||value.NameOfClass3!="grandchild")throw new Exception("inherited values lost");
+var writer=new StringWriter();serializer.Serialize(writer,value);var xml=XDocument.Parse(writer.ToString()).Root!;
+if((string?)xml.Attribute("nameOfClass")!="attribute"||(string?)xml.Element("NameOfClass")!="element"||(string?)xml.Element("name_of_class")!="grandchild")throw new Exception(writer.ToString());
+var json=System.Text.Json.JsonSerializer.Serialize(value);if(!json.Contains("attribute")||!json.Contains("element")||!json.Contains("grandchild"))throw new Exception(json);
+"#).unwrap();
+        let result = Command::new("dotnet")
+            .args(["run", "--disable-build-servers"])
+            .env("DOTNET_CLI_USE_MSBUILD_SERVER", "0")
+            .current_dir(temp.path())
+            .output()
+            .unwrap();
+        assert!(
+            result.status.success(),
+            "records={use_records}: {}{}",
+            String::from_utf8_lossy(&result.stdout),
+            String::from_utf8_lossy(&result.stderr)
+        );
+    }
+}

{polyxml-0.34.3 → polyxml-0.34.4}/crates/polyxml-core/tests/test_rust_codegen.rs

@@ -1087,7 +1087,7 @@ fn test_rust_phf_dispatch_union_groups_branch_tags() {
         is_mixed: false,
         fields: vec![FieldDef::new(
             "method",
-            "method",
+            "",
             FieldKind::Element,
             TypeRef::Named(QName::local("PaymentMethod")),
         )],
@@ -1364,3 +1364,62 @@ fn main() {
         );
     }
 }
+
+#[test]
+fn named_choice_wrappers_round_trip_without_unreachable_dispatch() {
+    let schema = r#"<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
+      <xs:complexType name="Position"><xs:choice><xs:element name="Percentage" type="xs:double"/><xs:element name="NumberOfSteps" type="xs:unsignedInt"/><xs:element name="Label" type="xs:string"/></xs:choice></xs:complexType>
+      <xs:complexType name="Sweep"><xs:sequence><xs:element name="StartingPosition" type="Position"/><xs:element name="StepIncrement" type="Position"/><xs:element name="Optional" type="Position" minOccurs="0"/><xs:element name="Repeated" type="Position" minOccurs="0" maxOccurs="unbounded"/></xs:sequence></xs:complexType>
+    </xs:schema>"#;
+    let ir = XsdParser::new().parse_str(schema).unwrap();
+    let core = std::path::Path::new(env!("CARGO_MANIFEST_DIR"));
+    for (zero_copy, phf) in [(true, false), (false, false), (true, true)] {
+        let dir = tempfile::tempdir().unwrap();
+        std::fs::create_dir(dir.path().join("src")).unwrap();
+        std::fs::write(dir.path().join("Cargo.toml"), format!("[package]\nname=\"binary-lexical-test\"\nversion=\"0.0.0\"\nedition=\"2021\"\n[dependencies]\npolyxml={{path={core:?}}}\nquick-xml={{version=\"0.42\",features=[\"serialize\"]}}\nserde={{version=\"1\",features=[\"derive\"]}}\nserde_json=\"1\"\nregex=\"1\"\nphf={{version=\"0.14.0\",features=[\"macros\"]}}\n")).unwrap();
+        let code = RustCodegen::new(RustOptions {
+            zero_copy,
+            phf,
+            ..Default::default()
+        })
+        .generate_module(&ir);
+        std::fs::write(dir.path().join("src/models.rs"), code).unwrap();
+        std::fs::write(dir.path().join("src/main.rs"), r#"mod models;
+use models::*;
+fn main() {
+ let xml="<Sweep><StartingPosition><Percentage>25</Percentage></StartingPosition><StepIncrement><NumberOfSteps>3</NumberOfSteps></StepIncrement><Optional><Label>focus</Label></Optional><Repeated><Percentage>2</Percentage></Repeated><Repeated><NumberOfSteps>4</NumberOfSteps></Repeated></Sweep>";
+ let value=Sweep::from_xml(xml).unwrap();
+ assert!(matches!(value.starting_position, Position::Percentage(25.0)));
+ assert!(matches!(value.step_increment, Position::NumberOfSteps(3)));
+ assert_eq!(value.repeated.len(),2);
+ assert_eq!(value.to_xml_string().unwrap(),xml);
+ let xml="<Sweep><StartingPosition><Label/></StartingPosition><StepIncrement><NumberOfSteps>3</NumberOfSteps></StepIncrement></Sweep>";
+ let value=Sweep::from_xml(xml).unwrap();
+ assert!(matches!(&value.starting_position,Position::Label(text) if text.is_empty()));
+ assert!(value.optional.is_none());
+ let round_trip=value.to_xml_string().unwrap(); assert!(round_trip.contains("<StartingPosition><Label></Label></StartingPosition>"));
+ for inner in ["", "<Percentage>1</Percentage><NumberOfSteps>2</NumberOfSteps>", "<Unknown/>"] {
+ let xml=format!("<Sweep><StartingPosition>{inner}</StartingPosition><StepIncrement><NumberOfSteps>3</NumberOfSteps></StepIncrement></Sweep>");
+ assert!(Sweep::from_xml(&xml).is_err(),"accepted {xml}");
+ }
+ assert!(Sweep::from_xml("<Sweep><StartingPosition/><StepIncrement><NumberOfSteps>3</NumberOfSteps></StepIncrement></Sweep>").is_err());
+}
+"#).unwrap();
+        let output = std::process::Command::new("cargo")
+            .args(["run", "--quiet", "--offline"])
+            .env("RUSTFLAGS", "-D unreachable-patterns")
+            .env(
+                "CARGO_TARGET_DIR",
+                core.join("../../target/binary-lexical-tests"),
+            )
+            .current_dir(dir.path())
+            .output()
+            .unwrap();
+        assert!(
+            output.status.success(),
+            "zero_copy={zero_copy}, phf={phf}: {}\n{}",
+            String::from_utf8_lossy(&output.stdout),
+            String::from_utf8_lossy(&output.stderr)
+        );
+    }
+}

{polyxml-0.34.3 → polyxml-0.34.4}/pyproject.toml

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