polyxml 0.33.3__tar.gz → 0.33.4__tar.gz

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

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

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

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

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

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

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

@@ -586,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));
@@ -1026,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();
         }
 
@@ -1144,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
                     }
                 }
             };
@@ -1311,7 +1330,7 @@ impl GoCodegen {
         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, &mut seen_json);
+            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();
@@ -1647,3 +1666,19 @@ fn concrete_derivations<'a>(s: &'a StructDef, ir: &'a SchemaIR) -> Vec<&'a Struc
     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.3 → 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.3 → polyxml-0.33.4}/crates/polyxml-core/tests/test_go_codegen.rs

@@ -966,3 +966,115 @@ func TestAbstractDocumentRoundTrip(t *testing.T) {
         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.3 → polyxml-0.33.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "maturin"
 
 [project]
 name = "polyxml"
-version = "0.33.3"
+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" }