polyxml 0.30.3__tar.gz → 0.30.5__tar.gz

{polyxml-0.30.3 → polyxml-0.30.5}/Cargo.lock

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

{polyxml-0.30.3 → polyxml-0.30.5}/Cargo.toml

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

{polyxml-0.30.3 → polyxml-0.30.5}/PKG-INFO

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

{polyxml-0.30.3 → polyxml-0.30.5}/crates/polyxml-core/src/codegen/cpp/mod.rs

@@ -674,15 +674,19 @@ concept XmlModel = requires(T a) {{
             }
         }
 
-        // Topologically sort structs and unions (DAG order)
+        // Cut cyclic value dependencies through struct fields or union branches,
+        // then emit types in dependency order.
+        let mut prepared = ir.clone();
+        let sorted_qnames = self.order_with_forward_cuts(&mut prepared);
+
         for qname in sorted_qnames {
-            if ir.is_external_type(&qname) {
+            if prepared.is_external_type(&qname) {
                 continue;
             }
-            if let Some(type_def) = ir.types.get(&qname) {
+            if let Some(type_def) = prepared.types.get(&qname) {
                 match type_def {
                     TypeDef::Union(u) => self.emit_union(out, u),
-                    TypeDef::Struct(s) => self.emit_struct(out, s, ir),
+                    TypeDef::Struct(s) => self.emit_struct(out, s, &prepared),
                     TypeDef::Simple(_) | TypeDef::Enum(_) => {}
                 }
             }
@@ -1126,7 +1130,120 @@ concept XmlModel = requires(T a) {{
         }
     }
 
-    /// Topologically sort types (DAG) to ensure value types are declared before use.
+    /// Box cyclic value edges until the C++ dependency graph can be ordered.
+    fn order_with_forward_cuts(&self, ir: &mut SchemaIR) -> Vec<QName> {
+        loop {
+            let order = self.topological_sort_types(ir);
+            let mut candidate: Option<(bool, QName, usize)> = None;
+            for (owner, def) in &ir.types {
+                let TypeDef::Struct(structure) = def else {
+                    continue;
+                };
+                for (index, field) in structure.fields.iter().enumerate() {
+                    if field.is_cycle_cut || field.cardinality.is_list() {
+                        continue;
+                    }
+                    let TypeRef::Named(target) = &field.type_ref else {
+                        continue;
+                    };
+                    if !matches!(ir.types.get(target), Some(TypeDef::Struct(_)))
+                        || !self.has_cpp_dependency_path(ir, target, owner, &mut HashSet::new())
+                    {
+                        continue;
+                    }
+                    let optional = field.cardinality.is_optional() || field.nillable;
+                    if candidate
+                        .as_ref()
+                        .is_none_or(|(was_optional, _, _)| optional && !was_optional)
+                    {
+                        candidate = Some((optional, owner.clone(), index));
+                    }
+                }
+            }
+            let Some((_, owner, index)) = candidate else {
+                let union_cut = ir.types.iter().find_map(|(owner, def)| {
+                    let TypeDef::Union(union) = def else {
+                        return None;
+                    };
+                    union
+                        .branches
+                        .iter()
+                        .enumerate()
+                        .find_map(|(index, branch)| {
+                            let TypeRef::Named(target) = &branch.type_ref else {
+                                return None;
+                            };
+                            (matches!(ir.types.get(target), Some(TypeDef::Struct(_)))
+                                && self.has_cpp_dependency_path(
+                                    ir,
+                                    target,
+                                    owner,
+                                    &mut HashSet::new(),
+                                ))
+                            .then(|| (owner.clone(), index))
+                        })
+                });
+                let Some((owner, index)) = union_cut else {
+                    return order;
+                };
+                if let Some(TypeDef::Union(union)) = ir.types.get_mut(&owner) {
+                    let branch = &mut union.branches[index];
+                    branch.type_ref = TypeRef::Boxed(Box::new(branch.type_ref.clone()));
+                }
+                continue;
+            };
+            if let Some(TypeDef::Struct(structure)) = ir.types.get_mut(&owner) {
+                structure.fields[index].is_cycle_cut = true;
+            }
+        }
+    }
+
+    fn has_cpp_dependency_path(
+        &self,
+        ir: &SchemaIR,
+        current: &QName,
+        goal: &QName,
+        seen: &mut HashSet<QName>,
+    ) -> bool {
+        if current == goal {
+            return true;
+        }
+        if !seen.insert(current.clone()) {
+            return false;
+        }
+        let mut deps = Vec::new();
+        match ir.types.get(current) {
+            Some(TypeDef::Struct(structure)) => {
+                if let Some(base) = &structure.base_type {
+                    deps.push(base.clone());
+                }
+                for field in &structure.fields {
+                    if !field.is_cycle_cut
+                        && !(field.cardinality.is_list()
+                            && matches!(&field.type_ref, TypeRef::Named(target) if matches!(ir.types.get(target), Some(TypeDef::Struct(_)))))
+                    {
+                        self.collect_type_dependencies(&field.type_ref, ir, current, &mut deps);
+                    }
+                }
+            }
+            Some(TypeDef::Union(union)) => {
+                for branch in &union.branches {
+                    if !matches!(&branch.type_ref, TypeRef::Boxed(inner) if matches!(inner.as_ref(), TypeRef::Named(target) if matches!(ir.types.get(target), Some(TypeDef::Struct(_)))))
+                    {
+                        self.collect_type_dependencies(&branch.type_ref, ir, current, &mut deps);
+                    }
+                }
+            }
+            Some(TypeDef::Simple(simple)) => {
+                self.collect_type_dependencies(&simple.base_type, ir, current, &mut deps);
+            }
+            _ => {}
+        }
+        deps.iter()
+            .any(|dep| self.has_cpp_dependency_path(ir, dep, goal, seen))
+    }
+
+    /// Put definitions before every value use that requires a complete type.
     fn topological_sort_types(&self, ir: &SchemaIR) -> Vec<QName> {
         let mut in_degree: HashMap<QName, usize> = HashMap::new();
         let mut adj: HashMap<QName, Vec<QName>> = HashMap::new();
@@ -1147,14 +1264,20 @@ concept XmlModel = requires(T a) {{
                     }
                     for f in &s.fields {
                         // Skip cycle cuts because they use std::unique_ptr (only need forward declarations)
-                        if !f.is_cycle_cut {
+                        if !f.is_cycle_cut
+                            && !(f.cardinality.is_list()
+                                && matches!(&f.type_ref, TypeRef::Named(target) if matches!(ir.types.get(target), Some(TypeDef::Struct(_)))))
+                        {
                             self.collect_type_dependencies(&f.type_ref, ir, qname, &mut deps);
                         }
                     }
                 }
                 TypeDef::Union(u) => {
                     for b in &u.branches {
-                        self.collect_type_dependencies(&b.type_ref, ir, qname, &mut deps);
+                        if !matches!(&b.type_ref, TypeRef::Boxed(inner) if matches!(inner.as_ref(), TypeRef::Named(target) if matches!(ir.types.get(target), Some(TypeDef::Struct(_)))))
+                        {
+                            self.collect_type_dependencies(&b.type_ref, ir, qname, &mut deps);
+                        }
                     }
                 }
                 TypeDef::Simple(s) => {

{polyxml-0.30.3 → polyxml-0.30.5}/crates/polyxml-core/src/codegen/go/mod.rs

@@ -379,8 +379,12 @@ impl GoCodegen {
             .values()
             .any(|def| matches!(def, TypeDef::Union(u) if u.is_lexical()))
         {
-            imports.push("\"strconv\"");
-            imports.push("\"strings\"");
+            if body.contains("strconv.") {
+                imports.push("\"strconv\"");
+            }
+            if body.contains("strings.") {
+                imports.push("\"strings\"");
+            }
         }
         if has_time {
             imports.push("\"time\"");
@@ -765,6 +769,11 @@ impl GoCodegen {
         for (branch, field) in u.branches.iter().zip(&fields) {
             let mapped = self.context.map_type_ref(&branch.type_ref);
             if let TypeRef::Named(qname) = &branch.type_ref {
+                if matches!(ir.types.get(qname), Some(TypeDef::Union(inner)) if inner.is_lexical())
+                {
+                    let _ = writeln!(out, "    {{ var escaped strings.Builder; if err := xml.EscapeText(&escaped, []byte(value)); err != nil {{ return err }}; var v {mapped}; if err := xml.Unmarshal([]byte(\"<v>\"+escaped.String()+\"</v>\"), &v); err == nil {{ c.{field} = &v; return nil }} }}");
+                    continue;
+                }
                 if let Some(TypeDef::Enum(def)) = ir.types.get(qname) {
                     let comparisons = def
                         .variants
@@ -861,6 +870,11 @@ impl GoCodegen {
         );
         out.push_str("    count := 0\n    var value string\n");
         for (branch, field) in u.branches.iter().zip(&fields) {
+            if matches!(&branch.type_ref, TypeRef::Named(qname) if matches!(ir.types.get(qname), Some(TypeDef::Union(inner)) if inner.is_lexical()))
+            {
+                let _ = writeln!(out, "    if c.{field} != nil {{ data, err := xml.Marshal(c.{field}); if err != nil {{ return err }}; if err := xml.Unmarshal(data, &value); err != nil {{ return err }}; count++ }}");
+                continue;
+            }
             let expr = if matches!(
                 super::primitive_base(&branch.type_ref, ir),
                 TypeRef::Primitive(PrimitiveType::Date)
@@ -1264,10 +1278,15 @@ impl GoCodegen {
         }
 
         writeln!(out, "// Root XML Element Type Aliases").unwrap();
+        let mut declared: HashSet<String> = ir
+            .types
+            .values()
+            .map(|def| type_ident(def.qname()))
+            .collect();
         for elem in ir.elements.values() {
             let elem_alias = to_go_type_name(&elem.qname.local);
             let target_type = self.context.map_type_ref(&elem.type_ref);
-            if elem_alias != target_type {
+            if elem_alias != target_type && declared.insert(elem_alias.clone()) {
                 if let Some(ref doc) = elem.documentation {
                     for line in doc.lines() {
                         let trimmed = line.trim();

{polyxml-0.30.3 → polyxml-0.30.5}/crates/polyxml-core/src/codegen/typescript/mod.rs

@@ -599,11 +599,30 @@ impl TypeScriptCodegen {
             self.emit_docstring(out, doc, "");
         }
 
-        let mut extends_clause = String::new();
-        if let Some(ref base) = s.base_type {
-            let base_name = type_ident(base);
-            extends_clause = format!(" extends {}", base_name);
+        let base_name = s.base_type.as_ref().map(type_ident);
+        let mut inherited_fields = HashSet::new();
+        let mut current_base = s.base_type.as_ref();
+        let mut visited_bases = HashSet::new();
+        while let Some(base_qname) = current_base {
+            if !visited_bases.insert(base_qname.clone()) {
+                break;
+            }
+            let Some(TypeDef::Struct(base)) = ir.types.get(base_qname) else {
+                break;
+            };
+            let mut seen = HashSet::new();
+            for field in &base.fields {
+                inherited_fields.insert(self.unique_field_name(&field.name, &mut seen));
+            }
+            current_base = base.base_type.as_ref();
         }
+        let mut own_seen = HashSet::new();
+        let overridden = s
+            .fields
+            .iter()
+            .map(|field| self.unique_field_name(&field.name, &mut own_seen))
+            .filter(|name| inherited_fields.contains(name))
+            .collect::<Vec<_>>();
 
         let readonly_prefix = if self.options.readonly_fields {
             "readonly "
@@ -611,13 +630,29 @@ impl TypeScriptCodegen {
             ""
         };
 
-        if self.options.use_interface {
-            let _ = writeln!(out, "export interface {}{} {{", ts_name, extends_clause);
-        } else if extends_clause.is_empty() {
-            let _ = writeln!(out, "export type {} = {{", ts_name);
+        if let Some(base_name) = &base_name {
+            if overridden.is_empty() {
+                if self.options.use_interface {
+                    let _ = writeln!(out, "export interface {} extends {} {{", ts_name, base_name);
+                } else {
+                    let _ = writeln!(out, "export type {} = {} & {{", ts_name, base_name);
+                }
+            } else {
+                let keys = overridden
+                    .iter()
+                    .map(|name| format!("{name:?}"))
+                    .collect::<Vec<_>>()
+                    .join(" | ");
+                let _ = writeln!(
+                    out,
+                    "export type {} = Omit<{}, {}> & {{",
+                    ts_name, base_name, keys
+                );
+            }
+        } else if self.options.use_interface {
+            let _ = writeln!(out, "export interface {} {{", ts_name);
         } else {
-            let base_name = type_ident(s.base_type.as_ref().unwrap());
-            let _ = writeln!(out, "export type {} = {} & {{", ts_name, base_name);
+            let _ = writeln!(out, "export type {} = {{", ts_name);
         }
 
         let mut seen_fields = HashSet::new();

{polyxml-0.30.3 → polyxml-0.30.5}/crates/polyxml-core/src/ir/mod.rs

@@ -456,6 +456,9 @@ pub struct SchemaIR {
     pub namespaces: Vec<NamespaceDeclaration>,
     pub types: BTreeMap<QName, TypeDef>,
     pub elements: BTreeMap<QName, ElementDef>,
+    /// Declared types of global attributes, used to resolve `<xs:attribute ref>`.
+    #[serde(default)]
+    pub attributes: BTreeMap<QName, TypeRef>,
     pub substitution_groups: HashMap<QName, Vec<QName>>,
     /// Type owners outside the module currently being emitted. Definitions
     /// remain in `types` so generators can resolve their field semantics.

{polyxml-0.30.3 → polyxml-0.30.5}/crates/polyxml-core/src/schema_parser/mod.rs

@@ -171,6 +171,7 @@ impl XsdParser {
         inherit_pattern_facets(&mut ir);
         self.expand_group_refs(&mut ir, self.frame_depth == 0);
         if self.frame_depth == 0 {
+            resolve_global_field_refs(&mut ir);
             compile_mixed_types(&mut ir);
         }
         ir.resolve_cycles();
@@ -304,6 +305,22 @@ impl XsdParser {
                                 ir.add_element(elem_def);
                             }
                         }
+                        "attribute" => {
+                            if let (Some(name), Some(ty)) =
+                                (get_attr_value(e, "name"), get_attr_value(e, "type"))
+                            {
+                                ir.attributes
+                                    .entry(QName::new(target_namespace.as_deref(), name))
+                                    .or_insert_with(|| {
+                                        resolve_type_ref(
+                                            &ty,
+                                            target_namespace.as_deref(),
+                                            &prefixes,
+                                        )
+                                    });
+                            }
+                            skip_subtree(&mut reader)?;
+                        }
                         "group" => {
                             // Named model group definition.
                             if let Some(gname) = get_attr_value(e, "name") {
@@ -373,6 +390,21 @@ impl XsdParser {
                                 ir.add_element(elem_def);
                             }
                         }
+                        "attribute" => {
+                            if let (Some(name), Some(ty)) =
+                                (get_attr_value(e, "name"), get_attr_value(e, "type"))
+                            {
+                                ir.attributes
+                                    .entry(QName::new(target_namespace.as_deref(), name))
+                                    .or_insert_with(|| {
+                                        resolve_type_ref(
+                                            &ty,
+                                            target_namespace.as_deref(),
+                                            &prefixes,
+                                        )
+                                    });
+                            }
+                        }
                         "group" => {
                             // Empty named model group (no particles).
                             if let Some(gname) = get_attr_value(e, "name") {
@@ -1497,6 +1529,68 @@ fn parse_union_members(
         .collect()
 }
 
+/// Replace element-reference placeholders with their global element's declared type.
+/// Referenced elements may be defined in an included file parsed later.
+fn resolve_global_field_refs(ir: &mut SchemaIR) {
+    let elements = &ir.elements;
+    let attributes = &ir.attributes;
+    let type_names: HashSet<QName> = ir.types.keys().cloned().collect();
+    fn resolve(
+        reference: &mut TypeRef,
+        elements: &BTreeMap<QName, ElementDef>,
+        types: &HashSet<QName>,
+    ) {
+        let TypeRef::Named(qname) = reference else {
+            return;
+        };
+        if types.contains(qname) {
+            return;
+        }
+        let mut current = qname.clone();
+        let mut seen = HashSet::new();
+        while seen.insert(current.clone()) {
+            let Some(element) = elements.get(&current) else {
+                break;
+            };
+            if let TypeRef::Named(next) = &element.type_ref {
+                if !types.contains(next) && elements.contains_key(next) {
+                    current = next.clone();
+                    continue;
+                }
+            }
+            *reference = element.type_ref.clone();
+            break;
+        }
+    }
+    for def in ir.types.values_mut() {
+        match def {
+            TypeDef::Struct(structure) => {
+                for field in &mut structure.fields {
+                    match field.kind {
+                        FieldKind::Element => resolve(&mut field.type_ref, elements, &type_names),
+                        FieldKind::Attribute => {
+                            if let TypeRef::Named(qname) = &field.type_ref {
+                                if !type_names.contains(qname) {
+                                    if let Some(type_ref) = attributes.get(qname) {
+                                        field.type_ref = type_ref.clone();
+                                    }
+                                }
+                            }
+                        }
+                        _ => {}
+                    }
+                }
+            }
+            TypeDef::Union(union) if !union.is_lexical() => {
+                for branch in &mut union.branches {
+                    resolve(&mut branch.type_ref, elements, &type_names);
+                }
+            }
+            _ => {}
+        }
+    }
+}
+
 /// Give XSD Gregorian primitives named, validated types in every target.
 /// The original primitive remains the base of each synthesized simple type.
 fn add_gregorian_types(ir: &mut SchemaIR) {
@@ -1540,6 +1634,9 @@ fn add_gregorian_types(ir: &mut SchemaIR) {
         rewrite(&mut element.type_ref, &mut used);
     }
     for def in ir.types.values_mut() {
+        if def.qname().namespace.as_deref() == Some(NS) {
+            continue;
+        }
         match def {
             TypeDef::Struct(s) => {
                 for field in &mut s.fields {
@@ -1884,6 +1981,15 @@ fn rekey_to_namespace(ir: &mut SchemaIR, ns: &str) {
     }
     ir.elements = elements;
 
+    let old_attributes = std::mem::take(&mut ir.attributes);
+    for (mut qname, mut type_ref) in old_attributes {
+        if qname.namespace.is_none() {
+            qname = QName::new(Some(ns.to_string()), qname.local);
+        }
+        rekey_type_ref(&mut type_ref, ns);
+        ir.attributes.insert(qname, type_ref);
+    }
+
     let old_subs = std::mem::take(&mut ir.substitution_groups);
     let mut subs = HashMap::new();
     for (k, v) in old_subs {
@@ -2040,6 +2146,9 @@ fn merge_ir(dest: &mut SchemaIR, src: SchemaIR) {
     for (k, v) in src.elements {
         dest.elements.insert(k, v);
     }
+    for (k, v) in src.attributes {
+        dest.attributes.insert(k, v);
+    }
     for (k, v) in src.substitution_groups {
         dest.substitution_groups.entry(k).or_default().extend(v);
     }

polyxml-0.30.5/crates/polyxml-core/tests/fixtures/ts_mixed_content_inheritance.xsd

@@ -0,0 +1,17 @@
+<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
+           targetNamespace="urn:polyxml:ts-mixed" xmlns:m="urn:polyxml:ts-mixed"
+           elementFormDefault="qualified">
+  <xs:complexType name="Bin" mixed="true" abstract="true">
+    <xs:sequence/>
+  </xs:complexType>
+  <xs:complexType name="Ed" mixed="true">
+    <xs:complexContent mixed="true">
+      <xs:extension base="m:Bin">
+        <xs:sequence>
+          <xs:element name="reference" type="xs:string" minOccurs="0"/>
+          <xs:element name="thumbnail" type="xs:string" minOccurs="0"/>
+        </xs:sequence>
+      </xs:extension>
+    </xs:complexContent>
+  </xs:complexType>
+</xs:schema>

{polyxml-0.30.3 → polyxml-0.30.5}/crates/polyxml-core/tests/test_cpp_codegen.rs

@@ -33,6 +33,64 @@ fn simple_aliases_follow_their_base_types() {
     );
 }
 
+#[test]
+fn mixed_content_mutual_cycle_compiles() {
+    use polyxml::schema_parser::XsdParser;
+    let schema = r#"<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" targetNamespace="urn:test" xmlns:t="urn:test">
+      <xs:complexType name="Cd"><xs:sequence><xs:element name="originalText" type="t:Ed" minOccurs="0"/></xs:sequence></xs:complexType>
+      <xs:complexType name="Ed" mixed="true"><xs:sequence><xs:element name="concept" type="t:Cd" minOccurs="0"/></xs:sequence></xs:complexType>
+    </xs:schema>"#;
+    let ir = XsdParser::new().parse_str(schema).unwrap();
+    let code = CppCodegen::new(CppOptions::default()).generate_header(&ir);
+    let dir = tempdir().unwrap();
+    let header = dir.path().join("model.hpp");
+    fs::write(&header, code).unwrap();
+    fs::write(
+        dir.path().join("main.cpp"),
+        "#include \"model.hpp\"\nint main() { return 0; }\n",
+    )
+    .unwrap();
+    let result = Command::new("g++")
+        .args(["-std=c++20", "-fsyntax-only", "-fmax-errors=3"])
+        .arg(dir.path().join("main.cpp"))
+        .output()
+        .unwrap();
+    assert!(
+        result.status.success(),
+        "{}",
+        String::from_utf8_lossy(&result.stderr)
+    );
+}
+
+#[test]
+fn mixed_content_self_cycle_compiles() {
+    use polyxml::schema_parser::XsdParser;
+    let schema = r#"<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" targetNamespace="urn:test" xmlns:t="urn:test">
+      <xs:complexType name="Thumbnail" mixed="true"><xs:sequence>
+        <xs:element name="thumbnail" type="t:Thumbnail" minOccurs="0" maxOccurs="unbounded"/>
+      </xs:sequence></xs:complexType>
+    </xs:schema>"#;
+    let ir = XsdParser::new().parse_str(schema).unwrap();
+    let code = CppCodegen::new(CppOptions::default()).generate_header(&ir);
+    let dir = tempdir().unwrap();
+    fs::write(dir.path().join("model.hpp"), code).unwrap();
+    fs::write(
+        dir.path().join("main.cpp"),
+        "#include \"model.hpp\"\nint main() { return 0; }\n",
+    )
+    .unwrap();
+    let result = Command::new("g++")
+        .args(["-std=c++20", "-fsyntax-only", "-fmax-errors=3"])
+        .arg(dir.path().join("main.cpp"))
+        .output()
+        .unwrap();
+    assert!(
+        result.status.success(),
+        "{}",
+        String::from_utf8_lossy(&result.stderr)
+    );
+}
+
 #[test]
 fn test_cpp_sanitization() {
     assert_eq!(to_cpp_field_name("class"), "class_");

{polyxml-0.30.3 → polyxml-0.30.5}/crates/polyxml-core/tests/test_go_codegen.rs

@@ -10,6 +10,99 @@ use polyxml::ir::{
     Cardinality, EnumDef, EnumValue, FieldDef, FieldKind, PrimitiveType, QName, RestrictionFacets,
     SchemaIR, StructDef, TypeDef, TypeRef, UnionBranch, UnionDef,
 };
+use polyxml::schema_parser::XsdParser;
+
+#[test]
+fn referenced_element_uses_declared_type_after_includes() {
+    let dir = tempdir().unwrap();
+    fs::write(
+        dir.path().join("base.xsd"),
+        r#"<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" targetNamespace="urn:test" xmlns:t="urn:test">
+        <xs:complexType name="Base"><xs:sequence><xs:element ref="t:description"/></xs:sequence></xs:complexType>
+        <xs:element name="description" type="xs:string"/>
+        <xs:element name="day" type="xs:gDay"/>
+        </xs:schema>"#,
+    )
+    .unwrap();
+    fs::write(
+        dir.path().join("main.xsd"),
+        r#"<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" targetNamespace="urn:test" xmlns:t="urn:test">
+        <xs:include schemaLocation="base.xsd"/>
+        <xs:complexType name="Derived"><xs:complexContent><xs:extension base="t:Base"/></xs:complexContent></xs:complexType>
+        </xs:schema>"#,
+    )
+    .unwrap();
+    let ir = XsdParser::new()
+        .parse_file(dir.path().join("main.xsd"))
+        .unwrap();
+    let base = match ir.types.get(&QName::new(Some("urn:test"), "Base")).unwrap() {
+        TypeDef::Struct(value) => value,
+        _ => panic!("expected struct"),
+    };
+    assert_eq!(
+        base.fields[0].type_ref,
+        TypeRef::Primitive(PrimitiveType::String)
+    );
+    let go = GoCodegen::new(GoOptions::default()).generate_module(&ir);
+    assert!(go.contains("type GDay string"));
+    assert!(!go.contains("type GDay GDay"));
+}
+
+#[test]
+fn nested_lexical_unions_compile_and_round_trip_in_go() {
+    if Command::new("go").arg("version").output().is_err() {
+        return;
+    }
+    let schema = r#"<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" targetNamespace="urn:test">
+      <xs:simpleType name="Inner"><xs:union memberTypes="xs:int xs:string"/></xs:simpleType>
+      <xs:simpleType name="Outer"><xs:union memberTypes="Inner xs:boolean"/></xs:simpleType>
+    </xs:schema>"#;
+    let ir = XsdParser::new().parse_str(schema).unwrap();
+    let dir = tempdir().unwrap();
+    fs::write(dir.path().join("go.mod"), "module nested\n\ngo 1.22\n").unwrap();
+    fs::write(
+        dir.path().join("models.go"),
+        GoCodegen::new(GoOptions::default()).generate_module(&ir),
+    )
+    .unwrap();
+    fs::write(
+        dir.path().join("models_test.go"),
+        r#"package models
+import ("encoding/xml"; "testing")
+func TestNestedUnion(t *testing.T) {
+    var value Outer
+    if err := xml.Unmarshal([]byte("<value>42</value>"), &value); err != nil { t.Fatal(err) }
+    if value.InnerValue == nil || value.InnerValue.IntValue == nil { t.Fatalf("wrong branch: %+v", value) }
+    data, err := xml.Marshal(value)
+    if err != nil { t.Fatal(err) }
+    if string(data) != "<Outer>42</Outer>" { t.Fatalf("wrong XML: %s", data) }
+}"#,
+    )
+    .unwrap();
+    let result = Command::new("go")
+        .args(["test", "./..."])
+        .current_dir(dir.path())
+        .output()
+        .unwrap();
+    assert!(
+        result.status.success(),
+        "{}",
+        String::from_utf8_lossy(&result.stderr)
+    );
+}
+
+#[test]
+fn root_alias_names_are_unique_after_go_normalization() {
+    let schema = r#"<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" targetNamespace="urn:test">
+      <xs:complexType name="FirstType"/>
+      <xs:complexType name="SecondType"/>
+      <xs:element name="item" type="FirstType"/>
+      <xs:element name="item_" type="SecondType"/>
+    </xs:schema>"#;
+    let ir = XsdParser::new().parse_str(schema).unwrap();
+    let code = GoCodegen::new(GoOptions::default()).generate_module(&ir);
+    assert_eq!(code.matches("type Item = ").count(), 1);
+}
 
 #[test]
 fn test_go_sanitization() {

{polyxml-0.30.3 → polyxml-0.30.5}/crates/polyxml-core/tests/test_schema_ir.rs

@@ -27,6 +27,47 @@ fn consumed_child_subtrees_do_not_swallow_following_types() {
         .contains_key(&QName::new(Some("urn:test"), "Second")));
 }
 
+#[test]
+fn consumed_particles_do_not_swallow_following_declarations() {
+    let xsd = r#"<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" targetNamespace="urn:test" xmlns:t="urn:test">
+      <xs:group name="Shared"><xs:sequence>
+        <xs:element name="inside"><xs:annotation><xs:documentation>text</xs:documentation></xs:annotation></xs:element>
+      </xs:sequence></xs:group>
+      <xs:complexType name="First"><xs:sequence>
+        <xs:group ref="t:Shared"><xs:annotation/></xs:group>
+        <xs:element name="child" type="xs:string"><xs:annotation/></xs:element>
+      </xs:sequence></xs:complexType>
+      <xs:complexType name="Second"><xs:sequence><xs:element name="value" type="xs:string"/></xs:sequence></xs:complexType>
+    </xs:schema>"#;
+    let ir = XsdParser::new().parse_str(xsd).unwrap();
+    let first = match &ir.types[&QName::new(Some("urn:test"), "First")] {
+        TypeDef::Struct(value) => value,
+        _ => panic!("expected struct"),
+    };
+    assert!(first.fields.iter().any(|field| field.name == "inside"));
+    assert!(first.fields.iter().any(|field| field.name == "child"));
+    assert!(ir
+        .types
+        .contains_key(&QName::new(Some("urn:test"), "Second")));
+}
+
+#[test]
+fn global_attribute_reference_uses_declared_type() {
+    let xsd = r#"<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" targetNamespace="urn:test" xmlns:t="urn:test">
+      <xs:complexType name="Object"><xs:attribute ref="t:id" use="required"/></xs:complexType>
+      <xs:attribute name="id" type="xs:ID"><xs:annotation><xs:documentation>identifier</xs:documentation></xs:annotation></xs:attribute>
+    </xs:schema>"#;
+    let ir = XsdParser::new().parse_str(xsd).unwrap();
+    let object = match &ir.types[&QName::new(Some("urn:test"), "Object")] {
+        TypeDef::Struct(value) => value,
+        _ => panic!("expected struct"),
+    };
+    assert_eq!(
+        object.fields[0].type_ref,
+        TypeRef::Primitive(PrimitiveType::Id)
+    );
+}
+
 #[test]
 fn test_parse_lexical_union_member_types_and_inline_members() {
     let xsd = r#"<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" xmlns:t="urn:test" targetNamespace="urn:test">

{polyxml-0.30.3 → polyxml-0.30.5}/crates/polyxml-core/tests/test_ts_codegen.rs

@@ -6,6 +6,35 @@ use polyxml::ir::{
     Cardinality, EnumDef, EnumValue, FieldDef, FieldKind, PrimitiveType, QName, RestrictionFacets,
     SchemaIR, SimpleTypeDef, StructDef, TypeDef, TypeRef, UnionBranch, UnionDef,
 };
+use polyxml::schema_parser::XsdParser;
+use std::{fs, process::Command};
+use tempfile::tempdir;
+
+#[test]
+fn mixed_content_inheritance_compiles_with_widened_items() {
+    let schema = concat!(
+        env!("CARGO_MANIFEST_DIR"),
+        "/tests/fixtures/ts_mixed_content_inheritance.xsd"
+    );
+    let ir = XsdParser::new().parse_file(schema).unwrap();
+    let code = TypeScriptCodegen::new(TypeScriptOptions::default()).generate_module(&ir);
+    assert!(code.contains("export type Ed = Omit<Bin, \"items\"> & {"));
+    if Command::new("tsc").arg("--version").output().is_ok() {
+        let dir = tempdir().unwrap();
+        let source = dir.path().join("models.ts");
+        fs::write(&source, code).unwrap();
+        let result = Command::new("tsc")
+            .args(["--noEmit", "--skipLibCheck", "--target", "ES2020"])
+            .arg(&source)
+            .output()
+            .unwrap();
+        assert!(
+            result.status.success(),
+            "{}",
+            String::from_utf8_lossy(&result.stdout)
+        );
+    }
+}
 
 #[test]
 fn test_ts_identifier_sanitization() {

{polyxml-0.30.3 → polyxml-0.30.5}/pyproject.toml

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