polyxml 0.33.2__tar.gz → 0.33.4__tar.gz

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

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

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

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

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

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

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

@@ -1,7 +1,7 @@
 use std::collections::HashSet;
 use std::fmt::Write as FmtWrite;
 
-use heck::{AsPascalCase, AsSnakeCase};
+use heck::{AsLowerCamelCase, AsPascalCase, AsSnakeCase};
 use serde::{Deserialize, Serialize};
 
 use crate::codegen::{
@@ -361,7 +361,7 @@ impl GoCodegen {
         {
             imports.push("\"bytes\"");
         }
-        if has_fmt {
+        if has_fmt || body.contains("fmt.") {
             imports.push("\"fmt\"");
         }
         if has_io {
@@ -374,13 +374,12 @@ impl GoCodegen {
             .types
             .values()
             .any(|def| matches!(def, TypeDef::Union(u) if u.is_lexical()))
+            && body.contains("strconv.")
         {
-            if body.contains("strconv.") {
-                imports.push("\"strconv\"");
-            }
-            if body.contains("strings.") {
-                imports.push("\"strings\"");
-            }
+            imports.push("\"strconv\"");
+        }
+        if body.contains("strings.") {
+            imports.push("\"strings\"");
         }
         if has_time {
             imports.push("\"time\"");
@@ -587,7 +586,11 @@ impl GoCodegen {
             let mapped_type = self.context.map_type_ref(&branch.type_ref);
             let mut tag_parts = Vec::new();
             if self.options.emit_xml_tags {
-                tag_parts.push(format!("xml:\"{},omitempty\"", branch.xml_name));
+                let branch_xml = match &branch.namespace {
+                    Some(ns) if !ns.is_empty() => format!("{} {}", ns, branch.xml_name),
+                    _ => branch.xml_name.clone(),
+                };
+                tag_parts.push(format!("xml:\"{},omitempty\"", branch_xml));
             }
             if self.options.emit_json_tags {
                 tag_parts.push(format!("json:\"{},omitempty\"", branch.xml_name));
@@ -913,6 +916,11 @@ impl GoCodegen {
     }
 
     fn emit_struct(&self, out: &mut String, s: &StructDef, ir: &SchemaIR) {
+        if s.is_abstract {
+            self.emit_abstract_struct(out, s, ir);
+            return;
+        }
+
         let struct_name = type_ident(&s.qname);
         if let Some(ref doc) = s.documentation {
             for line in doc.lines() {
@@ -945,9 +953,13 @@ impl GoCodegen {
         // Struct composition / inheritance if base struct exists
         let mut simple_content_base: Option<String> = None;
         if let Some(ref base_qname) = s.base_type {
-            if matches!(ir.types.get(base_qname), Some(TypeDef::Struct(_))) {
+            if let Some(TypeDef::Struct(base_s)) = ir.types.get(base_qname) {
                 let base_name = type_ident(base_qname);
-                writeln!(out, "    {}", base_name).unwrap();
+                if base_s.is_abstract {
+                    writeln!(out, "    {}Base", base_name).unwrap();
+                } else {
+                    writeln!(out, "    {}", base_name).unwrap();
+                }
             } else if let Some(prim) = PrimitiveType::from_xsd_name(&base_qname.local) {
                 simple_content_base = Some(self.context.map_primitive(prim).to_string());
             } else if let Some(TypeDef::Simple(st)) = ir.types.get(base_qname) {
@@ -1018,7 +1030,7 @@ impl GoCodegen {
             }
 
             let field_type = self.resolve_field_type(f);
-            let tag = self.build_field_struct_tags(f, &mut seen_json);
+            let tag = self.build_field_struct_tags(f, s, ir, &mut seen_json);
             writeln!(out, "    {} {}{}", field_name, field_type, tag).unwrap();
         }
 
@@ -1136,29 +1148,44 @@ impl GoCodegen {
         }
     }
 
-    fn build_field_struct_tags(&self, f: &FieldDef, seen_json: &mut HashSet<String>) -> String {
+    fn build_field_struct_tags(
+        &self,
+        f: &FieldDef,
+        s: &StructDef,
+        ir: &SchemaIR,
+        seen_json: &mut HashSet<String>,
+    ) -> String {
         let mut parts = Vec::new();
 
         if self.options.emit_xml_tags {
             let is_opt = f.cardinality.is_optional() || f.nillable;
             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),
+                        _ => f.xml_name.clone(),
+                    };
                     if is_opt {
-                        format!("{},attr,omitempty", f.xml_name)
+                        format!("{},attr,omitempty", attr_name)
                     } else {
-                        format!("{},attr", f.xml_name)
+                        format!("{},attr", attr_name)
                     }
                 }
                 FieldKind::Text => ",chardata".to_string(),
                 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()
+                    };
                     if f.xml_name.is_empty() {
                         ",any".to_string()
                     } else if is_opt {
-                        format!("{},omitempty", f.xml_name)
+                        format!("{},omitempty", elem_name)
                     } else {
-                        f.xml_name.clone()
+                        elem_name
                     }
                 }
             };
@@ -1270,6 +1297,264 @@ impl GoCodegen {
         writeln!(out, "}}\n").unwrap();
     }
 
+    fn emit_abstract_struct(&self, out: &mut String, s: &StructDef, ir: &SchemaIR) {
+        let struct_name = type_ident(&s.qname);
+        let base_struct_name = format!("{}Base", struct_name);
+
+        if let Some(ref doc) = s.documentation {
+            for line in doc.lines() {
+                writeln!(out, "// {}", line).unwrap();
+            }
+        }
+
+        // 1. Base struct definition holding declared fields of the abstract type
+        writeln!(out, "type {} struct {{", base_struct_name).unwrap();
+        if let Some(ref base_qname) = s.base_type {
+            if let Some(TypeDef::Struct(base_s)) = ir.types.get(base_qname) {
+                let base_name = type_ident(base_qname);
+                if base_s.is_abstract {
+                    writeln!(out, "    {}Base", base_name).unwrap();
+                } else {
+                    writeln!(out, "    {}", base_name).unwrap();
+                }
+            }
+        }
+
+        let mut seen_fields = HashSet::new();
+        let field_names: Vec<String> = s
+            .fields
+            .iter()
+            .map(|f| self.unique_field_name(&f.name, &mut seen_fields))
+            .collect();
+
+        let mut seen_json = HashSet::new();
+        for (f, field_name) in s.fields.iter().zip(&field_names) {
+            let field_type = self.resolve_field_type(f);
+            let tag = self.build_field_struct_tags(f, s, ir, &mut seen_json);
+            writeln!(out, "    {} {}{}", field_name, field_type, tag).unwrap();
+        }
+        writeln!(out, "}}\n").unwrap();
+
+        writeln!(
+            out,
+            "func (s {}) Validate() error {{\n    return nil\n}}\n",
+            base_struct_name
+        )
+        .unwrap();
+
+        // 2. Discover concrete derivations
+        let derivations = concrete_derivations(s, ir);
+
+        // 3. Dispatch wrapper struct
+        writeln!(out, "type {} struct {{", struct_name).unwrap();
+        if self.options.emit_xml_tags {
+            let mut xml_tags = Vec::new();
+            if self.options.emit_json_tags {
+                xml_tags.push("json:\"-\"");
+            }
+            if self.options.backend == GoBackend::Sonic {
+                xml_tags.push("sonic:\"-\"");
+            }
+            if xml_tags.is_empty() {
+                writeln!(out, "    XMLName xml.Name").unwrap();
+            } else {
+                writeln!(out, "    XMLName xml.Name `{}`", xml_tags.join(" ")).unwrap();
+            }
+        }
+        writeln!(out, "    {}", base_struct_name).unwrap();
+
+        let mut seen_derives = HashSet::new();
+        let derive_fields: Vec<(String, String, String)> = derivations
+            .iter()
+            .map(|d| {
+                let type_name = type_ident(&d.qname);
+                let field_name = self.unique_field_name(&type_name, &mut seen_derives);
+                (d.qname.local.clone(), field_name, type_name)
+            })
+            .collect();
+
+        for (_local, field_name, type_name) in &derive_fields {
+            let json_name = AsLowerCamelCase(field_name).to_string();
+            writeln!(
+                out,
+                "    {} *{} `xml:\"-\" json:\"{},omitempty\"`",
+                field_name, type_name, json_name
+            )
+            .unwrap();
+        }
+        writeln!(out, "}}\n").unwrap();
+
+        // 4. Methods on dispatch wrapper
+        writeln!(out, "func (s {}) Selected() string {{", struct_name).unwrap();
+        for (local, field_name, _) in &derive_fields {
+            writeln!(
+                out,
+                "    if s.{} != nil {{ return {:?} }}",
+                field_name, local
+            )
+            .unwrap();
+        }
+        writeln!(out, "    return \"\"\n}}\n").unwrap();
+
+        writeln!(out, "func (s {}) Value() any {{", struct_name).unwrap();
+        for (_, field_name, _) in &derive_fields {
+            writeln!(
+                out,
+                "    if s.{} != nil {{ return s.{} }}",
+                field_name, field_name
+            )
+            .unwrap();
+        }
+        writeln!(out, "    return nil\n}}\n").unwrap();
+
+        // UnmarshalXML
+        writeln!(
+            out,
+            "func (s *{}) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error {{",
+            struct_name
+        )
+        .unwrap();
+        writeln!(out, "    s.XMLName = start.Name").unwrap();
+        writeln!(out, "    var typeAttr *xml.Attr").unwrap();
+        writeln!(out, "    for _, attr := range start.Attr {{").unwrap();
+        writeln!(out, "        if (attr.Name.Local == \"type\" && (attr.Name.Space == \"http://www.w3.org/2001/XMLSchema-instance\" || attr.Name.Space == \"xsi\")) || attr.Name.Local == \"xsi:type\" {{").unwrap();
+        writeln!(out, "            typeAttr = &attr").unwrap();
+        writeln!(out, "            break").unwrap();
+        writeln!(out, "        }}").unwrap();
+        writeln!(out, "    }}").unwrap();
+        writeln!(out, "    if typeAttr == nil {{").unwrap();
+        writeln!(
+            out,
+            "        return fmt.Errorf(\"abstract type '{}' requires xsi:type naming a concrete derivation\")",
+            struct_name
+        )
+        .unwrap();
+        writeln!(out, "    }}").unwrap();
+
+        if derive_fields.is_empty() {
+            writeln!(
+                out,
+                "    return fmt.Errorf(\"abstract type '{}' has no registered derivations; deserialize the concrete type directly (escape hatch)\")",
+                struct_name
+            )
+            .unwrap();
+        } else {
+            writeln!(out, "    localType := typeAttr.Value").unwrap();
+            writeln!(
+                out,
+                "    if idx := strings.Index(localType, \":\"); idx != -1 {{"
+            )
+            .unwrap();
+            writeln!(out, "        localType = localType[idx+1:]").unwrap();
+            writeln!(out, "    }}").unwrap();
+            writeln!(out, "    switch localType {{").unwrap();
+            for (local, field_name, type_name) in &derive_fields {
+                writeln!(out, "    case {:?}:", local).unwrap();
+                writeln!(out, "        var concrete {}", type_name).unwrap();
+                writeln!(
+                    out,
+                    "        if err := d.DecodeElement(&concrete, &start); err != nil {{ return err }}"
+                )
+                .unwrap();
+                writeln!(out, "        s.{} = &concrete", field_name).unwrap();
+                writeln!(
+                    out,
+                    "        s.{} = concrete.{}",
+                    base_struct_name, base_struct_name
+                )
+                .unwrap();
+                writeln!(out, "        return nil").unwrap();
+            }
+            let known = derive_fields
+                .iter()
+                .map(|(local, _, _)| local.as_str())
+                .collect::<Vec<_>>()
+                .join(", ");
+            writeln!(out, "    default:").unwrap();
+            writeln!(
+                    out,
+                    "        return fmt.Errorf(\"xsi:type=%q does not match any known derivation of '{}' (known: {})\", typeAttr.Value)",
+                    struct_name, known
+                )
+                .unwrap();
+            writeln!(out, "    }}").unwrap();
+        }
+        writeln!(out, "}}\n").unwrap();
+
+        // MarshalXML
+        writeln!(
+            out,
+            "func (s {}) MarshalXML(e *xml.Encoder, start xml.StartElement) error {{",
+            struct_name
+        )
+        .unwrap();
+        writeln!(
+            out,
+            "    if s.XMLName.Local != \"\" {{ start.Name = s.XMLName }}"
+        )
+        .unwrap();
+        for (local, field_name, _) in &derive_fields {
+            writeln!(out, "    if s.{} != nil {{", field_name).unwrap();
+            writeln!(out, "        hasXsiNs := false\n        hasType := false").unwrap();
+            writeln!(out, "        for _, attr := range start.Attr {{").unwrap();
+            writeln!(out, "            if attr.Name.Local == \"xmlns:xsi\" || (attr.Name.Local == \"xsi\" && attr.Name.Space == \"xmlns\") {{ hasXsiNs = true }}").unwrap();
+            writeln!(out, "            if attr.Name.Local == \"xsi:type\" || (attr.Name.Local == \"type\" && attr.Name.Space == \"http://www.w3.org/2001/XMLSchema-instance\") {{ hasType = true }}").unwrap();
+            writeln!(out, "        }}").unwrap();
+            writeln!(out, "        if !hasXsiNs {{ start.Attr = append(start.Attr, xml.Attr{{Name: xml.Name{{Local: \"xmlns:xsi\"}}, Value: \"http://www.w3.org/2001/XMLSchema-instance\"}}) }}").unwrap();
+            writeln!(out, "        if !hasType {{ start.Attr = append(start.Attr, xml.Attr{{Name: xml.Name{{Local: \"xsi:type\"}}, Value: {:?}}}) }}", local).unwrap();
+            writeln!(
+                out,
+                "        return e.EncodeElement(s.{}, start)",
+                field_name
+            )
+            .unwrap();
+            writeln!(out, "    }}").unwrap();
+        }
+        if derive_fields.is_empty() {
+            writeln!(
+                out,
+                "    return fmt.Errorf(\"abstract type '{}' has no registered derivations\")",
+                struct_name
+            )
+            .unwrap();
+        } else {
+            writeln!(
+                out,
+                "    return fmt.Errorf(\"cannot marshal abstract type '{}' without a concrete derivation\")",
+                struct_name
+            )
+            .unwrap();
+        }
+        writeln!(out, "}}\n").unwrap();
+
+        // Validate()
+        writeln!(out, "func (s {}) Validate() error {{", struct_name).unwrap();
+        for (_, field_name, _) in &derive_fields {
+            writeln!(
+                out,
+                "    if s.{} != nil {{ return s.{}.Validate() }}",
+                field_name, field_name
+            )
+            .unwrap();
+        }
+        if derive_fields.is_empty() {
+            writeln!(
+                out,
+                "    return fmt.Errorf(\"abstract type '{}' has no registered derivations\")",
+                struct_name
+            )
+            .unwrap();
+        } else {
+            writeln!(
+                out,
+                "    return fmt.Errorf(\"abstract type '{}' requires a concrete derivation\")",
+                struct_name
+            )
+            .unwrap();
+        }
+        writeln!(out, "}}\n").unwrap();
+    }
+
     fn emit_facet_checks(
         &self,
         out: &mut String,
@@ -1350,3 +1635,50 @@ impl GoCodegen {
         }
     }
 }
+
+fn derives_from(ir: &SchemaIR, d: &StructDef, base: &QName) -> bool {
+    let mut seen: HashSet<QName> = HashSet::new();
+    let mut cur = d.base_type.as_ref();
+    while let Some(q) = cur {
+        if q == base {
+            return true;
+        }
+        if !seen.insert(q.clone()) {
+            break;
+        }
+        cur = match ir.types.get(q) {
+            Some(TypeDef::Struct(b)) => b.base_type.as_ref(),
+            _ => None,
+        };
+    }
+    false
+}
+
+fn concrete_derivations<'a>(s: &'a StructDef, ir: &'a SchemaIR) -> Vec<&'a StructDef> {
+    let mut result = Vec::new();
+    for type_def in ir.types.values() {
+        if let TypeDef::Struct(d) = type_def {
+            if !d.is_abstract && d.qname != s.qname && derives_from(ir, d, &s.qname) {
+                result.push(d);
+            }
+        }
+    }
+    result.sort_by(|a, b| a.qname.local.cmp(&b.qname.local));
+    result
+}
+
+fn is_namespaced_ref(f: &FieldDef, s: &StructDef, ir: &SchemaIR) -> bool {
+    let Some(ref ns) = f.namespace else {
+        return false;
+    };
+    if ns.is_empty() {
+        return false;
+    }
+    // If field namespace is different from struct namespace, it's definitely an external ref
+    if s.qname.namespace.as_deref() != Some(ns.as_str()) {
+        return true;
+    }
+    // If it matches a global element definition, it's an element ref
+    let q = QName::new(Some(ns.as_str()), &f.xml_name);
+    ir.elements.contains_key(&q)
+}

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

@@ -1805,16 +1805,29 @@ fn parse_element_field(
     in_choice: bool,
     in_unbounded_compositor: bool,
 ) -> Option<FieldDef> {
-    let name = get_attr_value(e, "name")
-        .or_else(|| get_attr_value(e, "ref").map(|r| strip_prefix(&r).to_string()))?;
-
-    let xml_name = get_attr_value(e, "name")
-        .or_else(|| get_attr_value(e, "ref"))
-        .unwrap_or_else(|| name.clone());
+    let ref_attr = get_attr_value(e, "ref");
+    let name_attr = get_attr_value(e, "name");
+
+    let (name, xml_name, namespace) = if let Some(ref r) = ref_attr {
+        let qname = resolve_qname(r, target_ns, prefixes);
+        let field_name = name_attr.unwrap_or_else(|| qname.local.clone());
+        let xml_name = qname.local;
+        let namespace = qname.namespace;
+        (field_name, xml_name, namespace)
+    } else {
+        let n = name_attr?;
+        let xml_name = n.clone();
+        let namespace = target_ns.map(Into::into);
+        (n, xml_name, namespace)
+    };
 
     let type_ref = get_attr_value(e, "type")
         .map(|t| resolve_type_ref(&t, target_ns, prefixes))
-        .or_else(|| get_attr_value(e, "ref").map(|r| resolve_type_ref(&r, target_ns, prefixes)))
+        .or_else(|| {
+            ref_attr
+                .as_ref()
+                .map(|r| resolve_type_ref(r, target_ns, prefixes))
+        })
         .unwrap_or(TypeRef::Primitive(PrimitiveType::String));
 
     let min_occurs = if in_choice {
@@ -1845,7 +1858,7 @@ fn parse_element_field(
     Some(FieldDef {
         name: sanitize_field_name(&name),
         xml_name,
-        namespace: target_ns.map(Into::into),
+        namespace,
         kind: FieldKind::Element,
         type_ref,
         cardinality: Cardinality {
@@ -1866,16 +1879,28 @@ fn parse_attribute_field(
     target_ns: Option<&str>,
     prefixes: &HashMap<String, String>,
 ) -> Option<FieldDef> {
-    let name = get_attr_value(e, "name")
-        .or_else(|| get_attr_value(e, "ref").map(|r| strip_prefix(&r).to_string()))?;
-
-    let xml_name = get_attr_value(e, "name")
-        .or_else(|| get_attr_value(e, "ref"))
-        .unwrap_or_else(|| name.clone());
+    let ref_attr = get_attr_value(e, "ref");
+    let name_attr = get_attr_value(e, "name");
+
+    let (name, xml_name, namespace) = if let Some(ref r) = ref_attr {
+        let qname = resolve_qname(r, target_ns, prefixes);
+        let field_name = name_attr.unwrap_or_else(|| qname.local.clone());
+        let xml_name = qname.local;
+        let namespace = qname.namespace;
+        (field_name, xml_name, namespace)
+    } else {
+        let n = name_attr?;
+        let xml_name = n.clone();
+        (n, xml_name, None)
+    };
 
     let type_ref = get_attr_value(e, "type")
         .map(|t| resolve_type_ref(&t, target_ns, prefixes))
-        .or_else(|| get_attr_value(e, "ref").map(|r| resolve_type_ref(&r, target_ns, prefixes)))
+        .or_else(|| {
+            ref_attr
+                .as_ref()
+                .map(|r| resolve_type_ref(r, target_ns, prefixes))
+        })
         .unwrap_or(TypeRef::Primitive(PrimitiveType::String));
 
     let is_required = get_attr_value(e, "use")
@@ -1894,7 +1919,7 @@ fn parse_attribute_field(
     Some(FieldDef {
         name: sanitize_field_name(&name),
         xml_name,
-        namespace: None, // Attributes are unqualified by default unless form="qualified"
+        namespace,
         kind: FieldKind::Attribute,
         type_ref,
         cardinality,

{polyxml-0.33.2 → polyxml-0.33.4}/crates/polyxml-core/tests/test_go_codegen.rs

@@ -837,3 +837,244 @@ fn test_go_any_attribute_codegen() {
 
     assert!(code.contains("AnyAttribute []xml.Attr `xml:\",any,attr\" json:\"-\"`"));
 }
+
+#[test]
+fn test_go_abstract_xsi_type_dispatch() {
+    let xsd = r#"<?xml version="1.0" encoding="UTF-8"?>
+    <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" targetNamespace="urn:audit:abstract" xmlns:t="urn:audit:abstract" elementFormDefault="qualified">
+      <xs:complexType name="AbstractDocument" abstract="true">
+        <xs:sequence>
+          <xs:element name="Id" type="xs:string"/>
+        </xs:sequence>
+      </xs:complexType>
+
+      <xs:complexType name="InvoiceDocument">
+        <xs:complexContent>
+          <xs:extension base="t:AbstractDocument">
+            <xs:sequence>
+              <xs:element name="Amount" type="xs:decimal"/>
+            </xs:sequence>
+          </xs:extension>
+        </xs:complexContent>
+      </xs:complexType>
+
+      <xs:complexType name="ReceiptDocument">
+        <xs:complexContent>
+          <xs:extension base="t:AbstractDocument">
+            <xs:sequence>
+              <xs:element name="Store" type="xs:string"/>
+            </xs:sequence>
+          </xs:extension>
+        </xs:complexContent>
+      </xs:complexType>
+
+      <xs:element name="Document" type="t:AbstractDocument"/>
+    </xs:schema>"#;
+
+    let ir = XsdParser::new().parse_str(xsd).expect("parse failed");
+    let codegen = GoCodegen::new(GoOptions::default());
+    let code = codegen.generate_module(&ir);
+
+    assert!(code.contains("type AbstractDocumentBase struct"));
+    assert!(code.contains("type AbstractDocument struct"));
+    assert!(code.contains("InvoiceDocument *InvoiceDocument"));
+    assert!(code.contains("ReceiptDocument *ReceiptDocument"));
+    assert!(code.contains("func (s AbstractDocument) Selected() string"));
+    assert!(code.contains("func (s AbstractDocument) Value() any"));
+    assert!(code.contains("func (s *AbstractDocument) UnmarshalXML"));
+    assert!(code.contains("func (s AbstractDocument) MarshalXML"));
+
+    if Command::new("go").arg("version").output().is_err() {
+        return;
+    }
+
+    let dir = tempdir().unwrap();
+    fs::write(
+        dir.path().join("go.mod"),
+        "module abstract_test\n\ngo 1.22\n",
+    )
+    .unwrap();
+    fs::write(dir.path().join("models.go"), &code).unwrap();
+    fs::write(
+        dir.path().join("models_test.go"),
+        r#"package models
+
+import (
+	"encoding/xml"
+	"strings"
+	"testing"
+)
+
+func TestAbstractDocumentRoundTrip(t *testing.T) {
+	inputXml := `<Document xmlns="urn:audit:abstract" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:type="InvoiceDocument"><Id>INV-001</Id><Amount>199.99</Amount></Document>`
+	var doc Document
+	if err := xml.Unmarshal([]byte(inputXml), &doc); err != nil {
+		t.Fatalf("Unmarshal failed: %v", err)
+	}
+
+	if doc.Selected() != "InvoiceDocument" {
+		t.Fatalf("expected Selected() to be InvoiceDocument, got %q", doc.Selected())
+	}
+	if doc.InvoiceDocument == nil {
+		t.Fatalf("InvoiceDocument is nil")
+	}
+	if doc.InvoiceDocument.ID != "INV-001" {
+		t.Fatalf("expected ID 'INV-001', got %q", doc.InvoiceDocument.ID)
+	}
+	if doc.InvoiceDocument.Amount != 199.99 {
+		t.Fatalf("expected Amount 199.99, got %v", doc.InvoiceDocument.Amount)
+	}
+
+	marshaled, err := xml.Marshal(&doc)
+	if err != nil {
+		t.Fatalf("Marshal failed: %v", err)
+	}
+	marshaledStr := string(marshaled)
+	if !strings.Contains(marshaledStr, `xsi:type="InvoiceDocument"`) {
+		t.Fatalf("marshaled XML missing xsi:type: %s", marshaledStr)
+	}
+	if !strings.Contains(marshaledStr, `Amount`) {
+		t.Fatalf("marshaled XML missing Amount element: %s", marshaledStr)
+	}
+
+	// Missing xsi:type should fail
+	var missingDoc Document
+	if err := xml.Unmarshal([]byte(`<Document xmlns="urn:audit:abstract"><Id>INV-001</Id></Document>`), &missingDoc); err == nil {
+		t.Fatalf("expected error unmarshaling abstract type without xsi:type, got nil")
+	}
+
+	// Unknown xsi:type should fail
+	var unknownDoc Document
+	if err := xml.Unmarshal([]byte(`<Document xmlns="urn:audit:abstract" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:type="UnknownDoc"><Id>INV-001</Id></Document>`), &unknownDoc); err == nil {
+		t.Fatalf("expected error unmarshaling unknown xsi:type, got nil")
+	}
+}
+"#,
+    )
+    .unwrap();
+
+    let output = Command::new("go")
+        .args(["test", "-v", "./..."])
+        .current_dir(dir.path())
+        .output()
+        .expect("go test failed to execute");
+
+    assert!(
+        output.status.success(),
+        "go test failed: stdout:\n{}\nstderr:\n{}",
+        String::from_utf8_lossy(&output.stdout),
+        String::from_utf8_lossy(&output.stderr)
+    );
+}
+
+#[test]
+fn test_go_namespaced_element_ref_matching() {
+    let schema = r#"<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
+      xmlns:t="urn:audit:ref" targetNamespace="urn:audit:ref"
+      elementFormDefault="qualified">
+      <xs:element name="Child" type="xs:string"/>
+      <xs:element name="Container"><xs:complexType><xs:sequence>
+        <xs:element ref="t:Child"/>
+      </xs:sequence></xs:complexType></xs:element>
+    </xs:schema>"#;
+
+    let ir = XsdParser::new().parse_str(schema).unwrap();
+    let codegen = GoCodegen::new(GoOptions::default());
+    let code = codegen.generate_module(&ir);
+
+    // Code must NOT contain schema prefix t:Child
+    assert!(
+        !code.contains("\"t:Child\""),
+        "Go codegen must not emit schema lexical prefix in tags: {code}"
+    );
+    // Code must emit expanded namespace QName
+    assert!(
+        code.contains("`xml:\"urn:audit:ref Child\" json:\"Child\"`"),
+        "Go codegen must emit expanded QName and clean JSON name in tags: {code}"
+    );
+
+    if Command::new("go").arg("version").output().is_err() {
+        return;
+    }
+
+    let dir = tempdir().unwrap();
+    fs::write(dir.path().join("go.mod"), "module ref_test\n\ngo 1.22\n").unwrap();
+    fs::write(dir.path().join("models.go"), &code).unwrap();
+    fs::write(
+        dir.path().join("models_test.go"),
+        r#"package models
+
+import (
+	"encoding/xml"
+	"strings"
+	"testing"
+)
+
+func TestNamespacedElementRef(t *testing.T) {
+	// 1. Default namespace instance
+	xml1 := `<Container xmlns="urn:audit:ref"><Child>abc</Child></Container>`
+	var c1 Container
+	if err := xml.Unmarshal([]byte(xml1), &c1); err != nil {
+		t.Fatalf("unmarshal xml1 failed: %v", err)
+	}
+	if c1.Child != "abc" {
+		t.Fatalf("expected Child 'abc', got %q", c1.Child)
+	}
+
+	// 2. Prefixed namespace instance (schema prefix t)
+	xml2 := `<t:Container xmlns:t="urn:audit:ref"><t:Child>abc</t:Child></t:Container>`
+	var c2 Container
+	if err := xml.Unmarshal([]byte(xml2), &c2); err != nil {
+		t.Fatalf("unmarshal xml2 failed: %v", err)
+	}
+	if c2.Child != "abc" {
+		t.Fatalf("expected Child 'abc', got %q", c2.Child)
+	}
+
+	// 3. Alternate prefix instance (prefix p)
+	xml3 := `<p:Container xmlns:p="urn:audit:ref"><p:Child>abc</p:Child></p:Container>`
+	var c3 Container
+	if err := xml.Unmarshal([]byte(xml3), &c3); err != nil {
+		t.Fatalf("unmarshal xml3 failed: %v", err)
+	}
+	if c3.Child != "abc" {
+		t.Fatalf("expected Child 'abc', got %q", c3.Child)
+	}
+
+	// 4. Foreign namespace URI with same local child name -> must NOT populate Child
+	xml4 := `<Container xmlns="urn:audit:ref"><Child xmlns="urn:audit:other">abc</Child></Container>`
+	var c4 Container
+	if err := xml.Unmarshal([]byte(xml4), &c4); err != nil {
+		t.Fatalf("unmarshal xml4 failed: %v", err)
+	}
+	if c4.Child != "" {
+		t.Fatalf("expected Child to remain empty for foreign namespace, got %q", c4.Child)
+	}
+
+	// 5. Roundtrip serialization preserves namespace
+	data, err := xml.Marshal(c1)
+	if err != nil {
+		t.Fatalf("marshal failed: %v", err)
+	}
+	dataStr := string(data)
+	if !strings.Contains(dataStr, "Child") || !strings.Contains(dataStr, "urn:audit:ref") {
+		t.Fatalf("marshaled XML missing Child or namespace: %s", dataStr)
+	}
+}
+"#,
+    )
+    .unwrap();
+
+    let output = Command::new("go")
+        .args(["test", "-v", "./..."])
+        .current_dir(dir.path())
+        .output()
+        .expect("go test failed to execute");
+
+    assert!(
+        output.status.success(),
+        "go test failed: stdout:\n{}\nstderr:\n{}",
+        String::from_utf8_lossy(&output.stdout),
+        String::from_utf8_lossy(&output.stderr)
+    );
+}

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

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