polyxml 0.30.6__tar.gz → 0.31.0__tar.gz

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

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

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

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

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

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

{polyxml-0.30.6 → polyxml-0.31.0}/crates/polyxml-core/src/ir/mod.rs

@@ -1,7 +1,7 @@
 pub mod tarjan;
 
 use serde::{Deserialize, Serialize};
-use std::collections::{BTreeMap, HashMap};
+use std::collections::{BTreeMap, BTreeSet, HashMap};
 use std::fmt;
 
 /// Fully qualified XML Name (Namespace URI + Local Name).
@@ -467,6 +467,161 @@ pub struct SchemaIR {
 }
 
 impl SchemaIR {
+    /// Keep the selected global elements and all types that can occur beneath them.
+    /// The schema is parsed in full before this operation, so references can be
+    /// followed across imports and includes.
+    pub fn select_root_elements(&self, roots: &[String]) -> Result<Self, String> {
+        if roots.is_empty() {
+            return Ok(self.clone());
+        }
+
+        let mut selected_elements = BTreeSet::new();
+        for name in roots {
+            let matches: Vec<_> = if let Some(qualified) = name.strip_prefix('{') {
+                let (namespace, local) = qualified.split_once('}').ok_or_else(|| {
+                    format!("Invalid root element '{name}': expected {{namespace}}local-name")
+                })?;
+                if local.is_empty() {
+                    return Err(format!("Invalid root element '{name}': missing local name"));
+                }
+                self.elements
+                    .keys()
+                    .filter(|q| {
+                        q.namespace.as_deref().unwrap_or("") == namespace && q.local == local
+                    })
+                    .cloned()
+                    .collect()
+            } else {
+                self.elements
+                    .keys()
+                    .filter(|q| q.local == *name)
+                    .cloned()
+                    .collect()
+            };
+            match matches.as_slice() {
+                [] => return Err(format!("Root element '{name}' was not found in the schema")),
+                [qname] => {
+                    selected_elements.insert(qname.clone());
+                }
+                _ => {
+                    return Err(format!(
+                        "Root element '{name}' is ambiguous; use {{namespace}}local-name"
+                    ))
+                }
+            }
+        }
+
+        let mut descendants: HashMap<QName, Vec<QName>> = HashMap::new();
+        for (qname, def) in &self.types {
+            let base = match def {
+                TypeDef::Struct(s) => s.base_type.as_ref(),
+                TypeDef::Simple(s) => named_ref(&s.base_type),
+                TypeDef::Enum(e) => named_ref(&e.base_type),
+                TypeDef::Union(_) => None,
+            };
+            if let Some(base) = base {
+                descendants
+                    .entry(base.clone())
+                    .or_default()
+                    .push(qname.clone());
+            }
+        }
+
+        let mut selected_types = BTreeSet::new();
+        let mut pending_elements: Vec<_> = selected_elements.iter().cloned().collect();
+        let mut pending_types: Vec<(QName, bool)> = Vec::new();
+        let mut expanded_polymorphic = BTreeSet::new();
+        while !pending_elements.is_empty() || !pending_types.is_empty() {
+            while let Some(qname) = pending_elements.pop() {
+                if let Some(element) = self.elements.get(&qname) {
+                    push_named_ref(&element.type_ref, true, &mut pending_types);
+                    if let Some(head) = &element.substitution_group {
+                        if selected_elements.insert(head.clone()) {
+                            pending_elements.push(head.clone());
+                        }
+                    }
+                }
+                if let Some(members) = self.substitution_groups.get(&qname) {
+                    for member in members {
+                        if selected_elements.insert(member.clone()) {
+                            pending_elements.push(member.clone());
+                        }
+                    }
+                }
+            }
+            if let Some((qname, polymorphic)) = pending_types.pop() {
+                if polymorphic && expanded_polymorphic.insert(qname.clone()) {
+                    if let Some(children) = descendants.get(&qname) {
+                        pending_types.extend(children.iter().cloned().map(|child| (child, true)));
+                    }
+                }
+                if !selected_types.insert(qname.clone()) {
+                    continue;
+                }
+                if let Some(def) = self.types.get(&qname) {
+                    match def {
+                        TypeDef::Struct(s) => {
+                            if let Some(base) = &s.base_type {
+                                pending_types.push((base.clone(), false));
+                            }
+                            for field in &s.fields {
+                                push_named_ref(&field.type_ref, true, &mut pending_types);
+                                if field.kind == FieldKind::Element {
+                                    let element = referenced_element_name(
+                                        field.namespace.as_deref(),
+                                        &field.xml_name,
+                                    );
+                                    if self.substitution_groups.contains_key(&element)
+                                        && selected_elements.insert(element.clone())
+                                    {
+                                        pending_elements.push(element);
+                                    }
+                                }
+                            }
+                        }
+                        TypeDef::Simple(s) => {
+                            push_named_ref(&s.base_type, false, &mut pending_types)
+                        }
+                        TypeDef::Enum(e) => push_named_ref(&e.base_type, false, &mut pending_types),
+                        TypeDef::Union(u) => {
+                            for branch in &u.branches {
+                                push_named_ref(&branch.type_ref, true, &mut pending_types);
+                                let element = referenced_element_name(
+                                    branch.namespace.as_deref(),
+                                    &branch.xml_name,
+                                );
+                                if self.substitution_groups.contains_key(&element)
+                                    && selected_elements.insert(element.clone())
+                                {
+                                    pending_elements.push(element);
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        let mut result = self.clone();
+        result
+            .types
+            .retain(|qname, _| selected_types.contains(qname));
+        result
+            .elements
+            .retain(|qname, _| selected_elements.contains(qname));
+        result
+            .external_types
+            .retain(|qname, _| selected_types.contains(qname));
+        result.substitution_groups.retain(|head, members| {
+            if !selected_elements.contains(head) {
+                return false;
+            }
+            members.retain(|member| selected_elements.contains(member));
+            !members.is_empty()
+        });
+        Ok(result)
+    }
+
     pub fn is_external_type(&self, qname: &QName) -> bool {
         if qname
             .namespace
@@ -520,3 +675,165 @@ impl SchemaIR {
         tarjan::resolve_cycles(self);
     }
 }
+
+fn named_ref(type_ref: &TypeRef) -> Option<&QName> {
+    match type_ref {
+        TypeRef::Named(qname) => Some(qname),
+        TypeRef::Boxed(inner) | TypeRef::List(inner) => named_ref(inner),
+        TypeRef::Primitive(_) => None,
+    }
+}
+
+fn push_named_ref(type_ref: &TypeRef, polymorphic: bool, pending: &mut Vec<(QName, bool)>) {
+    if let Some(qname) = named_ref(type_ref) {
+        pending.push((qname.clone(), polymorphic));
+    }
+}
+
+fn referenced_element_name(namespace: Option<&str>, xml_name: &str) -> QName {
+    let local = xml_name.rsplit(':').next().unwrap_or(xml_name);
+    QName::new(namespace, local)
+}
+
+#[cfg(test)]
+mod root_selection_tests {
+    use super::*;
+
+    fn structure(name: &str, base: Option<&str>, fields: Vec<FieldDef>) -> TypeDef {
+        TypeDef::Struct(StructDef {
+            qname: QName::new(Some("urn:test"), name),
+            base_type: base.map(|name| QName::new(Some("urn:test"), name)),
+            is_abstract: false,
+            is_mixed: false,
+            fields,
+            documentation: None,
+        })
+    }
+
+    fn element(name: &str, ty: &str) -> ElementDef {
+        ElementDef {
+            qname: QName::new(Some("urn:test"), name),
+            type_ref: TypeRef::named(QName::new(Some("urn:test"), ty)),
+            substitution_group: None,
+            nillable: false,
+            documentation: None,
+        }
+    }
+
+    #[test]
+    fn keeps_references_descendants_and_substitutions() {
+        let mut ir = SchemaIR::new();
+        let mut field = FieldDef::new(
+            "item",
+            "Item",
+            FieldKind::Element,
+            TypeRef::List(Box::new(TypeRef::named(QName::new(
+                Some("urn:test"),
+                "Choice",
+            )))),
+        );
+        field.namespace = Some("urn:test".to_string());
+        ir.add_type(structure("RootType", None, vec![field]));
+        ir.add_type(structure("Base", None, vec![]));
+        ir.add_type(structure("Derived", Some("Base"), vec![]));
+        ir.add_type(TypeDef::Union(UnionDef {
+            qname: QName::new(Some("urn:test"), "Choice"),
+            branches: vec![UnionBranch {
+                variant_name: "Base".into(),
+                xml_name: "Base".into(),
+                namespace: Some("urn:test".into()),
+                type_ref: TypeRef::named(QName::new(Some("urn:test"), "Base")),
+                documentation: None,
+            }],
+            documentation: None,
+        }));
+        ir.add_type(structure("Unrelated", None, vec![]));
+        ir.add_element(element("Root", "RootType"));
+        ir.add_element(element("UnrelatedRoot", "Unrelated"));
+        let mut member = element("Member", "Derived");
+        member.substitution_group = Some(QName::new(Some("urn:test"), "Root"));
+        ir.add_element(member);
+
+        let selected = ir.select_root_elements(&["Root".into()]).unwrap();
+        assert_eq!(selected.elements.len(), 2);
+        assert_eq!(selected.types.len(), 4);
+        assert!(selected
+            .types
+            .contains_key(&QName::new(Some("urn:test"), "Derived")));
+        assert!(!selected
+            .types
+            .contains_key(&QName::new(Some("urn:test"), "Unrelated")));
+        let combined = ir
+            .select_root_elements(&["Root".into(), "UnrelatedRoot".into()])
+            .unwrap();
+        assert_eq!(combined.elements.len(), 3);
+        assert!(combined
+            .types
+            .contains_key(&QName::new(Some("urn:test"), "Unrelated")));
+    }
+
+    #[test]
+    fn rejects_missing_and_ambiguous_roots() {
+        let mut ir = SchemaIR::new();
+        ir.add_element(element("Root", "RootType"));
+        let mut second = element("Root", "RootType");
+        second.qname.namespace = Some("urn:other".into());
+        ir.add_element(second);
+        assert!(ir
+            .select_root_elements(&["Root".into()])
+            .unwrap_err()
+            .contains("ambiguous"));
+        assert_eq!(
+            ir.select_root_elements(&["{urn:test}Root".into()])
+                .unwrap()
+                .elements
+                .len(),
+            1
+        );
+        assert!(ir
+            .select_root_elements(&["Missing".into()])
+            .unwrap_err()
+            .contains("not found"));
+    }
+
+    #[test]
+    fn inherited_base_does_not_select_sibling_types() {
+        let mut ir = SchemaIR::new();
+        ir.add_type(structure("CommonBase", None, vec![]));
+        ir.add_type(structure("SelectedType", Some("CommonBase"), vec![]));
+        ir.add_type(structure("SiblingType", Some("CommonBase"), vec![]));
+        ir.add_element(element("Selected", "SelectedType"));
+        let selected = ir.select_root_elements(&["Selected".into()]).unwrap();
+        assert!(selected
+            .types
+            .contains_key(&QName::new(Some("urn:test"), "CommonBase")));
+        assert!(selected
+            .types
+            .contains_key(&QName::new(Some("urn:test"), "SelectedType")));
+        assert!(!selected
+            .types
+            .contains_key(&QName::new(Some("urn:test"), "SiblingType")));
+    }
+
+    #[test]
+    fn field_reference_keeps_substitution_group_members() {
+        let xsd = r#"<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
+            xmlns:t="urn:test" targetNamespace="urn:test" elementFormDefault="qualified">
+            <xs:element name="Head" type="xs:string" abstract="true"/>
+            <xs:element name="Member" type="xs:string" substitutionGroup="t:Head"/>
+            <xs:complexType name="ContainerType"><xs:sequence>
+                <xs:element ref="t:Head"/>
+            </xs:sequence></xs:complexType>
+            <xs:element name="Container" type="t:ContainerType"/>
+        </xs:schema>"#;
+        let mut parser = crate::schema_parser::XsdParser::new();
+        let ir = parser.parse_str(xsd).unwrap();
+        let selected = ir.select_root_elements(&["Container".into()]).unwrap();
+        assert!(selected
+            .elements
+            .contains_key(&QName::new(Some("urn:test"), "Head")));
+        assert!(selected
+            .elements
+            .contains_key(&QName::new(Some("urn:test"), "Member")));
+    }
+}

{polyxml-0.30.6 → polyxml-0.31.0}/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
@@ -698,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);
@@ -710,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 {
@@ -722,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.6 → polyxml-0.31.0}/crates/polyxml-core/tests/test_schema_ir.rs

@@ -92,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.6 → polyxml-0.31.0}/pyproject.toml

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