polyxml 0.33.4__tar.gz → 0.33.5__tar.gz

{polyxml-0.33.4 → polyxml-0.33.5}/Cargo.lock

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

{polyxml-0.33.4 → polyxml-0.33.5}/Cargo.toml

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

{polyxml-0.33.4 → polyxml-0.33.5}/PKG-INFO

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

{polyxml-0.33.4 → polyxml-0.33.5}/crates/polyxml-core/src/codegen/go/mod.rs

@@ -1162,7 +1162,9 @@ impl GoCodegen {
             let xml_val = match f.kind {
                 FieldKind::Attribute => {
                     let attr_name = match &f.namespace {
-                        Some(ns) if !ns.is_empty() => format!("{} {}", ns, f.xml_name),
+                        Some(ns) if !ns.is_empty() && is_namespaced_ref(f, s, ir) => {
+                            format!("{} {}", ns, f.xml_name)
+                        }
                         _ => f.xml_name.clone(),
                     };
                     if is_opt {
@@ -1175,10 +1177,11 @@ impl GoCodegen {
                 FieldKind::Any => ",any".to_string(),
                 FieldKind::AnyAttribute => ",any,attr".to_string(),
                 FieldKind::Element => {
-                    let elem_name = if is_namespaced_ref(f, s, ir) {
-                        format!("{} {}", f.namespace.as_ref().unwrap(), f.xml_name)
-                    } else {
-                        f.xml_name.clone()
+                    let elem_name = match &f.namespace {
+                        Some(ns) if !ns.is_empty() && is_namespaced_ref(f, s, ir) => {
+                            format!("{} {}", ns, f.xml_name)
+                        }
+                        _ => f.xml_name.clone(),
                     };
                     if f.xml_name.is_empty() {
                         ",any".to_string()

{polyxml-0.33.4 → polyxml-0.33.5}/crates/polyxml-core/src/schema_parser/mod.rs

@@ -501,6 +501,8 @@ impl XsdParser {
 
         let mut is_top_level_choice = false;
         let mut top_level_choice_branches: Vec<UnionBranch> = Vec::new();
+        let mut top_level_choice_fields_start = 0;
+        let mut top_level_choice_fields_count = 0;
         let mut compositor_stack: Vec<CompositorFrame> = Vec::new();
         let mut depth = 1;
         while depth > 0 {
@@ -599,9 +601,16 @@ impl XsdParser {
                                 .last()
                                 .map(|c| c.kind == CompositorKind::Choice)
                                 .unwrap_or(false);
-                            if let Some(mut field) =
-                                parse_element_field(e, target_ns, prefixes, in_choice, in_unbounded)
-                            {
+                            let in_any_choice = compositor_stack
+                                .iter()
+                                .any(|c| c.kind == CompositorKind::Choice);
+                            if let Some(mut field) = parse_element_field(
+                                e,
+                                target_ns,
+                                prefixes,
+                                in_any_choice,
+                                in_unbounded,
+                            ) {
                                 // Consume inline type definitions so nested
                                 // fields cannot leak into the parent struct;
                                 // extracted types are registered in `ir`.
@@ -690,9 +699,16 @@ impl XsdParser {
                                 .last()
                                 .map(|c| c.kind == CompositorKind::Choice)
                                 .unwrap_or(false);
-                            if let Some(field) =
-                                parse_element_field(e, target_ns, prefixes, in_choice, in_unbounded)
-                            {
+                            let in_any_choice = compositor_stack
+                                .iter()
+                                .any(|c| c.kind == CompositorKind::Choice);
+                            if let Some(field) = parse_element_field(
+                                e,
+                                target_ns,
+                                prefixes,
+                                in_any_choice,
+                                in_unbounded,
+                            ) {
                                 if in_choice {
                                     if let Some(frame) = compositor_stack.last_mut() {
                                         if frame.kind == CompositorKind::Choice {
@@ -748,10 +764,58 @@ impl XsdParser {
                     let local = strip_prefix(e.name().into_inner());
                     if local == "sequence" || local == "choice" || local == "all" {
                         if let Some(frame) = compositor_stack.pop() {
-                            if frame.kind == CompositorKind::Choice {
+                            if frame.kind == CompositorKind::Sequence {
+                                if let Some(parent) = compositor_stack.last_mut() {
+                                    if parent.kind == CompositorKind::Choice {
+                                        let seq_fields = fields[frame.fields_start..].to_vec();
+                                        if !seq_fields.is_empty() {
+                                            let seq_name = unique_type_name(
+                                                ir,
+                                                target_ns,
+                                                &format!("{}Sequence", name),
+                                            );
+                                            let seq_qname = QName::new(target_ns, seq_name);
+                                            ir.add_type(TypeDef::Struct(StructDef {
+                                                qname: seq_qname.clone(),
+                                                base_type: None,
+                                                is_abstract: false,
+                                                is_mixed: false,
+                                                fields: seq_fields,
+                                                documentation: None,
+                                            }));
+                                            let branch_variant = if let Some(first_field) =
+                                                fields.get(frame.fields_start)
+                                            {
+                                                format!(
+                                                    "{}Sequence",
+                                                    sanitize_field_name(&first_field.name)
+                                                )
+                                            } else {
+                                                "Sequence".to_string()
+                                            };
+                                            let branch_xml = if let Some(first_field) =
+                                                fields.get(frame.fields_start)
+                                            {
+                                                first_field.xml_name.clone()
+                                            } else {
+                                                String::new()
+                                            };
+                                            parent.choice_branches.push(UnionBranch {
+                                                variant_name: branch_variant,
+                                                xml_name: branch_xml,
+                                                namespace: target_ns.map(Into::into),
+                                                type_ref: TypeRef::Named(seq_qname),
+                                                documentation: None,
+                                            });
+                                        }
+                                    }
+                                }
+                            } else if frame.kind == CompositorKind::Choice {
                                 let choice_is_unbounded = frame.is_unbounded
                                     || compositor_stack.iter().any(|c| c.is_unbounded);
+                                let is_nested_choice = !compositor_stack.is_empty();
                                 if (choice_is_unbounded
+                                    || is_nested_choice
                                     || (compositor_stack.is_empty() && base_type.is_some()))
                                     && !frame.choice_branches.is_empty()
                                 {
@@ -799,6 +863,9 @@ impl XsdParser {
                                     });
                                 } else if !choice_is_unbounded && compositor_stack.is_empty() {
                                     top_level_choice_branches = frame.choice_branches;
+                                    top_level_choice_fields_start = frame.fields_start;
+                                    top_level_choice_fields_count =
+                                        fields.len() - frame.fields_start;
                                     is_top_level_choice = true;
                                 }
                             }
@@ -818,7 +885,8 @@ impl XsdParser {
             && is_top_level_choice
             && !top_level_choice_branches.is_empty()
             && group_refs.is_empty()
-            && fields.len() == top_level_choice_branches.len();
+            && top_level_choice_fields_start == 0
+            && fields.len() == top_level_choice_fields_count;
 
         // Record group refs for post-parse expansion.
         if !is_union {

{polyxml-0.33.4 → polyxml-0.33.5}/crates/polyxml-core/tests/test_csharp_codegen.rs

@@ -1083,3 +1083,29 @@ fn test_csharp_any_attribute_codegen() {
     assert!(class_code
         .contains("public System.Xml.XmlAttribute[]? AnyAttribute { get; set; } = default!;"));
 }
+
+#[test]
+fn test_csharp_sequence_nested_inside_choice_codegen() {
+    use polyxml::schema_parser::XsdParser;
+
+    let xsd = r#"<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
+      <xs:element name="Root"><xs:complexType><xs:choice>
+        <xs:sequence>
+          <xs:element name="First" type="xs:string"/>
+          <xs:element name="Second" type="xs:string"/>
+        </xs:sequence>
+        <xs:element name="Alternative" type="xs:string"/>
+      </xs:choice></xs:complexType></xs:element>
+    </xs:schema>"#;
+
+    let ir = XsdParser::new()
+        .parse_str(xsd)
+        .expect("schema parse failed");
+    let codegen = CSharpCodegen::new(CSharpOptions::default());
+    let code = codegen.generate_module(&ir);
+
+    assert!(code.contains("public abstract record RootType"));
+    assert!(code.contains("public sealed record FirstSequence([property: XmlElement(\"First\"), JsonPropertyName(\"First\")] RootTypeSequence Value) : RootType"));
+    assert!(code.contains("public sealed record Alternative([property: XmlElement(\"Alternative\"), JsonPropertyName(\"Alternative\")] string Value) : RootType"));
+    assert!(code.contains("public record RootTypeSequence"));
+}

{polyxml-0.33.4 → polyxml-0.33.5}/crates/polyxml-core/tests/test_python_codegen.rs

@@ -768,3 +768,27 @@ fn test_python_any_element_codegen() {
         "Generated Python model must define xs:any field as optional object"
     );
 }
+
+#[test]
+fn test_python_sequence_nested_inside_choice_codegen() {
+    let xsd = r#"<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
+      <xs:element name="Root"><xs:complexType><xs:choice>
+        <xs:sequence>
+          <xs:element name="First" type="xs:string"/>
+          <xs:element name="Second" type="xs:string"/>
+        </xs:sequence>
+        <xs:element name="Alternative" type="xs:string"/>
+      </xs:choice></xs:complexType></xs:element>
+    </xs:schema>"#;
+
+    let ir = XsdParser::new()
+        .parse_str(xsd)
+        .expect("schema parse failed");
+    let codegen = PythonCodegen::new(PythonOptions::default());
+    let code = codegen.generate_module(&ir);
+
+    assert!(code.contains("type RootType = RootTypeSequence | str"));
+    assert!(code.contains("class RootTypeSequence:"));
+    assert!(code.contains("first: str | None = field("));
+    assert!(code.contains("second: str | None = field("));
+}

{polyxml-0.33.4 → polyxml-0.33.5}/crates/polyxml-core/tests/test_schema_ir.rs

@@ -602,3 +602,52 @@ fn test_language_context_adapter() {
     let list_ref = TypeRef::List(Box::new(TypeRef::Primitive(PrimitiveType::Int)));
     assert_eq!(ctx.map_type_ref(&list_ref), "Vec<i32>");
 }
+
+#[test]
+fn test_sequence_nested_inside_choice_preserved_in_ir() {
+    let xsd = r#"<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
+      <xs:element name="Root"><xs:complexType><xs:choice>
+        <xs:sequence>
+          <xs:element name="First" type="xs:string"/>
+          <xs:element name="Second" type="xs:string"/>
+        </xs:sequence>
+        <xs:element name="Alternative" type="xs:string"/>
+      </xs:choice></xs:complexType></xs:element>
+    </xs:schema>"#;
+
+    let ir = XsdParser::new().parse_str(xsd).unwrap();
+    let root_type_qname = QName::local("RootType");
+    let TypeDef::Union(root_choice) = ir
+        .types
+        .get(&root_type_qname)
+        .expect("RootType must be UnionDef")
+    else {
+        panic!("RootType must be a UnionDef");
+    };
+
+    assert_eq!(root_choice.branches.len(), 2);
+    // Sequence branch
+    let seq_branch = &root_choice.branches[0];
+    assert!(seq_branch.variant_name.contains("Sequence"));
+    let TypeRef::Named(seq_qname) = &seq_branch.type_ref else {
+        panic!("Sequence branch must reference a synthetic struct type");
+    };
+    let TypeDef::Struct(seq_struct) = ir
+        .types
+        .get(seq_qname)
+        .expect("Synthetic sequence struct must exist")
+    else {
+        panic!("Sequence branch must be a StructDef");
+    };
+    assert_eq!(seq_struct.fields.len(), 2);
+    assert_eq!(seq_struct.fields[0].xml_name, "First");
+    assert_eq!(seq_struct.fields[1].xml_name, "Second");
+
+    // Alternative branch
+    let alt_branch = &root_choice.branches[1];
+    assert_eq!(alt_branch.xml_name, "Alternative");
+    assert_eq!(
+        alt_branch.type_ref,
+        TypeRef::Primitive(PrimitiveType::String)
+    );
+}

{polyxml-0.33.4 → polyxml-0.33.5}/pyproject.toml

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