polyxml 0.33.2__tar.gz → 0.33.3__tar.gz

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

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

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

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

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

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

{polyxml-0.33.2 → polyxml-0.33.3}/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\"");
@@ -913,6 +912,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 +949,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) {
@@ -1270,6 +1278,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, &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 +1616,34 @@ 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
+}

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

@@ -837,3 +837,132 @@ 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)
+    );
+}

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

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