polyxml 0.30.5__tar.gz → 0.30.7__tar.gz

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

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

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

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

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

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

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

@@ -189,7 +189,12 @@ impl XsdParser {
 
         let mut ir = SchemaIR::new();
         let mut target_namespace = None;
-        let mut prefixes = HashMap::new();
+        // The `xml` prefix is bound by XML itself, even when the schema omits
+        // an explicit xmlns:xml declaration (as Dublin Core's dc.xsd does).
+        let mut prefixes = HashMap::from([(
+            "xml".to_string(),
+            "http://www.w3.org/XML/1998/namespace".to_string(),
+        )]);
         let mut buf = Vec::new();
 
         // Pass 1: Parse root schema attributes and build prefix table
@@ -255,6 +260,11 @@ impl XsdParser {
                                             }
                                         }
                                         merge_ir(&mut ir, sub_ir);
+                                    } else {
+                                        return Err(SchemaError::Resolution(format!(
+                                            "included schema not found: {}",
+                                            inc_path.display()
+                                        )));
                                     }
                                 }
                             }
@@ -366,6 +376,11 @@ impl XsdParser {
                                             }
                                         }
                                         merge_ir(&mut ir, sub_ir);
+                                    } else {
+                                        return Err(SchemaError::Resolution(format!(
+                                            "included schema not found: {}",
+                                            inc_path.display()
+                                        )));
                                     }
                                 }
                             }
@@ -688,7 +703,10 @@ impl XsdParser {
                             if frame.kind == CompositorKind::Choice {
                                 let choice_is_unbounded = frame.is_unbounded
                                     || compositor_stack.iter().any(|c| c.is_unbounded);
-                                if choice_is_unbounded && !frame.choice_branches.is_empty() {
+                                if (choice_is_unbounded
+                                    || (compositor_stack.is_empty() && base_type.is_some()))
+                                    && !frame.choice_branches.is_empty()
+                                {
                                     let choice_name =
                                         unique_type_name(ir, target_ns, &format!("{}Choice", name));
                                     let choice_qname = QName::new(target_ns, choice_name);
@@ -700,10 +718,15 @@ impl XsdParser {
                                     ir.add_type(TypeDef::Union(choice_def));
 
                                     fields.truncate(frame.fields_start);
-                                    let mut item_field_name = "items".to_string();
+                                    let field_base = if choice_is_unbounded {
+                                        "items"
+                                    } else {
+                                        "choice"
+                                    };
+                                    let mut item_field_name = field_base.to_string();
                                     let mut counter = 2;
                                     while fields.iter().any(|f| f.name == item_field_name) {
-                                        item_field_name = format!("items_{}", counter);
+                                        item_field_name = format!("{field_base}_{counter}");
                                         counter += 1;
                                     }
                                     fields.push(FieldDef {
@@ -712,7 +735,13 @@ impl XsdParser {
                                         namespace: None,
                                         kind: FieldKind::Element,
                                         type_ref: TypeRef::Named(choice_qname),
-                                        cardinality: Cardinality::unbounded(frame.min_occurs),
+                                        cardinality: if choice_is_unbounded {
+                                            Cardinality::unbounded(frame.min_occurs)
+                                        } else if frame.min_occurs == 0 {
+                                            Cardinality::optional_one()
+                                        } else {
+                                            Cardinality::required_one()
+                                        },
                                         nillable: false,
                                         default_value: None,
                                         fixed_value: None,

{polyxml-0.30.5 → polyxml-0.30.7}/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() {
@@ -68,6 +92,62 @@ fn global_attribute_reference_uses_declared_type() {
     );
 }
 
+#[test]
+fn xml_prefix_is_available_without_explicit_declaration() {
+    let dir = tempdir().unwrap();
+    std::fs::write(
+        dir.path().join("xml.xsd"),
+        r#"<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" targetNamespace="http://www.w3.org/XML/1998/namespace">
+          <xs:attribute name="lang" type="xs:language"/>
+        </xs:schema>"#,
+    )
+    .unwrap();
+    let main = dir.path().join("dc.xsd");
+    std::fs::write(
+        &main,
+        r#"<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" targetNamespace="urn:dc">
+          <xs:import namespace="http://www.w3.org/XML/1998/namespace" schemaLocation="xml.xsd"/>
+          <xs:complexType name="SimpleLiteral"><xs:attribute ref="xml:lang"/></xs:complexType>
+        </xs:schema>"#,
+    )
+    .unwrap();
+    let ir = XsdParser::new().parse_file(&main).unwrap();
+    let TypeDef::Struct(literal) = &ir.types[&QName::new(Some("urn:dc"), "SimpleLiteral")] else {
+        panic!("expected SimpleLiteral struct");
+    };
+    assert_eq!(
+        literal.fields[0].type_ref,
+        TypeRef::Primitive(PrimitiveType::Language)
+    );
+}
+
+#[test]
+fn derived_complex_type_keeps_base_and_bounded_choice() {
+    let xsd = r#"<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" xmlns:t="urn:test" targetNamespace="urn:test">
+      <xs:complexType name="Base"><xs:attribute name="id" type="xs:string"/></xs:complexType>
+      <xs:complexType name="Node"><xs:complexContent><xs:extension base="t:Base"><xs:choice>
+        <xs:element name="left" type="xs:string"/><xs:element name="right" type="xs:int"/>
+      </xs:choice></xs:extension></xs:complexContent></xs:complexType>
+      <xs:complexType name="Child"><xs:complexContent><xs:extension base="t:Node">
+        <xs:attribute name="flag" type="xs:boolean"/>
+      </xs:extension></xs:complexContent></xs:complexType>
+    </xs:schema>"#;
+    let ir = XsdParser::new().parse_str(xsd).unwrap();
+    let TypeDef::Struct(node) = &ir.types[&QName::new(Some("urn:test"), "Node")] else {
+        panic!("derived choice must remain a struct");
+    };
+    assert_eq!(node.base_type, Some(QName::new(Some("urn:test"), "Base")));
+    assert_eq!(node.fields.len(), 1);
+    assert_eq!(node.fields[0].name, "choice");
+    let TypeRef::Named(choice_name) = &node.fields[0].type_ref else {
+        panic!("choice field must refer to a union");
+    };
+    let TypeDef::Union(choice) = &ir.types[choice_name] else {
+        panic!("choice field must refer to a union");
+    };
+    assert_eq!(choice.branches.len(), 2);
+}
+
 #[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.5 → polyxml-0.30.7}/pyproject.toml

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