polyxml 0.30.4__tar.gz → 0.30.6__tar.gz

{polyxml-0.30.4 → polyxml-0.30.6}/Cargo.lock

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

{polyxml-0.30.4 → polyxml-0.30.6}/Cargo.toml

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

{polyxml-0.30.4 → polyxml-0.30.6}/PKG-INFO

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

{polyxml-0.30.4 → polyxml-0.30.6}/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.4 → polyxml-0.30.6}/crates/polyxml-core/src/schema_parser/mod.rs

@@ -255,6 +255,11 @@ impl XsdParser {
                                             }
                                         }
                                         merge_ir(&mut ir, sub_ir);
+                                    } else {
+                                        return Err(SchemaError::Resolution(format!(
+                                            "included schema not found: {}",
+                                            inc_path.display()
+                                        )));
                                     }
                                 }
                             }
@@ -366,6 +371,11 @@ impl XsdParser {
                                             }
                                         }
                                         merge_ir(&mut ir, sub_ir);
+                                    } else {
+                                        return Err(SchemaError::Resolution(format!(
+                                            "included schema not found: {}",
+                                            inc_path.display()
+                                        )));
                                     }
                                 }
                             }

{polyxml-0.30.4 → polyxml-0.30.6}/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.4 → polyxml-0.30.6}/crates/polyxml-core/tests/test_schema_ir.rs

@@ -6,6 +6,30 @@ use polyxml::ir::{
     TypeDef, TypeRef,
 };
 use polyxml::schema_parser::XsdParser;
+use tempfile::tempdir;
+
+#[test]
+fn missing_included_schema_is_an_error() {
+    let dir = tempdir().unwrap();
+    for (name, include) in [
+        ("empty.xsd", r#"<xs:include schemaLocation="missing.xsd"/>"#),
+        (
+            "start.xsd",
+            r#"<xs:include schemaLocation="missing.xsd"></xs:include>"#,
+        ),
+    ] {
+        let path = dir.path().join(name);
+        std::fs::write(
+            &path,
+            format!(
+                r#"<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">{include}</xs:schema>"#
+            ),
+        )
+        .unwrap();
+        let error = XsdParser::new().parse_file(&path).unwrap_err();
+        assert!(error.to_string().contains("missing.xsd"), "{error}");
+    }
+}
 
 #[test]
 fn consumed_child_subtrees_do_not_swallow_following_types() {

{polyxml-0.30.4 → polyxml-0.30.6}/pyproject.toml

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