polyxml 0.34.2__tar.gz → 0.34.4__tar.gz

{polyxml-0.34.2 → polyxml-0.34.4}/Cargo.lock

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

{polyxml-0.34.2 → polyxml-0.34.4}/Cargo.toml

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

{polyxml-0.34.2 → polyxml-0.34.4}/PKG-INFO

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

{polyxml-0.34.2 → polyxml-0.34.4}/crates/polyxml-core/src/codegen/csharp/mod.rs

@@ -1099,6 +1099,53 @@ impl CSharpCodegen {
         true
     }
 
+    fn emit_optional_enum_attribute_proxy(
+        &self,
+        out: &mut String,
+        field: &FieldDef,
+        name: &str,
+        ir: &SchemaIR,
+        indent: &str,
+    ) -> bool {
+        if !self.options.emit_xml_attributes
+            || field.kind != FieldKind::Attribute
+            || !field.cardinality.is_optional()
+            || field.cardinality.is_list()
+        {
+            return false;
+        }
+        let TypeRef::Named(qname) = &field.type_ref else {
+            return false;
+        };
+        if !matches!(ir.types.get(qname), Some(TypeDef::Enum(_))) {
+            return false;
+        }
+        let ty = self.map_field_type(field, ir);
+        let base = ty.trim_end_matches('?');
+        let namespace = field
+            .namespace
+            .as_ref()
+            .map(|ns| format!(", Namespace = {ns:?}"))
+            .unwrap_or_default();
+        if self.options.emit_json_attributes {
+            writeln!(out, "{indent}    [JsonPropertyName({:?})]", field.xml_name).unwrap();
+        }
+        writeln!(
+            out,
+            "{indent}    [XmlIgnore] public {ty} {name} {{ get; set; }}"
+        )
+        .unwrap();
+        if self.options.emit_json_attributes {
+            // Keep the XML lexical proxy out of JSON, preserving the typed property.
+            writeln!(out, "{indent}    [JsonIgnore]").unwrap();
+        }
+        writeln!(out, "{indent}    [XmlAttribute({:?}{namespace})] public string? {name}Xml {{
+{indent}        get => {name}?.ToXmlValue();
+{indent}        set => {name} = value is null ? null : ({base})new XmlSerializer(typeof({base}), new XmlRootAttribute(\"value\")).Deserialize(new System.IO.StringReader(\"<value>\" + System.Security.SecurityElement.Escape(value) + \"</value>\"))!;
+{indent}    }}", field.xml_name).unwrap();
+        true
+    }
+
     fn emit_default_scalar_proxy(
         &self,
         out: &mut String,
@@ -1379,7 +1426,10 @@ impl CSharpCodegen {
             format!(" : {}", base_clause.join(", "))
         };
 
-        let mut seen_props = HashSet::new();
+        // Reserve the actual generated names on every ancestor. Distinct
+        // XML members (e.g. nameOfClass attribute and NameOfClass element)
+        // can normalize to the same C# identifier.
+        let mut seen_props = self.inherited_property_names(s, ir, &mut HashSet::new());
         let prop_names: Vec<String> = s
             .fields
             .iter()
@@ -1392,6 +1442,8 @@ impl CSharpCodegen {
         }
 
         let has_lexical_union = self.options.emit_xml_attributes && s.fields.iter().any(|f| {
+            (f.kind == FieldKind::Attribute && f.cardinality.is_optional()
+                && matches!(&f.type_ref, TypeRef::Named(q) if matches!(ir.types.get(q), Some(TypeDef::Enum(_))))) ||
             matches!(f.type_ref, TypeRef::Primitive(p) if p.is_unbounded_integer()) || matches!(f.type_ref, TypeRef::Primitive(PrimitiveType::Date | PrimitiveType::DateTime | PrimitiveType::Time | PrimitiveType::Duration)) || f.default_value.is_some() || f.fixed_value.is_some() || matches!(&f.type_ref, TypeRef::Named(q) if matches!(ir.types.get(q), Some(TypeDef::Union(u)) if u.is_lexical()))
         });
 
@@ -1404,6 +1456,7 @@ impl CSharpCodegen {
             .unwrap();
             for (f, name) in s.fields.iter().zip(&prop_names) {
                 if self.emit_default_scalar_proxy(out, f, name, ir, indent)
+                    || self.emit_optional_enum_attribute_proxy(out, f, name, ir, indent)
                     || self.emit_integer_proxy(out, f, name, ir, indent)
                     || self.emit_temporal_proxy(out, f, name, ir, indent)
                 {
@@ -1471,6 +1524,7 @@ impl CSharpCodegen {
             writeln!(out, "{}    public {}() {{ }}", indent, struct_name).unwrap();
             for (f, name) in s.fields.iter().zip(&prop_names) {
                 if self.emit_default_scalar_proxy(out, f, name, ir, indent)
+                    || self.emit_optional_enum_attribute_proxy(out, f, name, ir, indent)
                     || self.emit_integer_proxy(out, f, name, ir, indent)
                     || self.emit_temporal_proxy(out, f, name, ir, indent)
                 {
@@ -1627,6 +1681,51 @@ impl CSharpCodegen {
         writeln!(out, "{}}}\n", indent).unwrap();
     }
 
+    fn inherited_property_names(
+        &self,
+        s: &StructDef,
+        ir: &SchemaIR,
+        visited: &mut HashSet<QName>,
+    ) -> HashSet<String> {
+        let Some(base) = s.base_type.as_ref() else {
+            return HashSet::new();
+        };
+        if !visited.insert(base.clone()) {
+            return HashSet::new();
+        }
+        let Some(TypeDef::Struct(parent)) = ir.types.get(base) else {
+            return HashSet::new();
+        };
+        let mut names = self.inherited_property_names(parent, ir, visited);
+        let mut ancestor_fields = Vec::new();
+        let mut next = parent.base_type.as_ref();
+        let mut seen = HashSet::new();
+        while let Some(qname) = next {
+            if !seen.insert(qname.clone()) {
+                break;
+            }
+            let Some(TypeDef::Struct(ancestor)) = ir.types.get(qname) else {
+                break;
+            };
+            ancestor_fields.extend(ancestor.fields.iter());
+            next = ancestor.base_type.as_ref();
+        }
+        let enclosing = type_ident(&parent.qname);
+        for field in &parent.fields {
+            let inherited = ancestor_fields.iter().any(|f| {
+                (field.kind == FieldKind::Text && f.kind == FieldKind::Text)
+                    || (field.kind == f.kind
+                        && field.xml_name == f.xml_name
+                        && field.namespace == f.namespace
+                        && field.name == f.name)
+            });
+            if !inherited {
+                self.unique_property_name(&field.name, &mut names, Some(&enclosing));
+            }
+        }
+        names
+    }
+
     fn unique_property_name(
         &self,
         name: &str,

{polyxml-0.34.2 → polyxml-0.34.4}/crates/polyxml-core/src/codegen/rust/mod.rs

@@ -1333,7 +1333,10 @@ impl RustCodegen {
                 if field.kind != FieldKind::Element {
                     continue;
                 }
-                let tags: Vec<String> = match self.resolve_union_def(&field.type_ref, ir) {
+                let tags: Vec<String> = match self
+                    .resolve_union_def(&field.type_ref, ir)
+                    .filter(|_| field.xml_name.is_empty())
+                {
                     Some(u) => u
                         .branches
                         .iter()
@@ -1495,7 +1498,10 @@ impl RustCodegen {
             }
 
             for meta in &elem_fields {
-                if let Some(union_def) = self.resolve_union_def(&meta.field.type_ref, ir) {
+                if let Some(union_def) = self
+                    .resolve_union_def(&meta.field.type_ref, ir)
+                    .filter(|_| meta.field.xml_name.is_empty())
+                {
                     let branch_tags: Vec<_> = union_def
                         .branches
                         .iter()
@@ -1575,7 +1581,10 @@ impl RustCodegen {
                 );
             }
             for meta in &elem_fields {
-                if let Some(union_def) = self.resolve_union_def(&meta.field.type_ref, ir) {
+                if let Some(union_def) = self
+                    .resolve_union_def(&meta.field.type_ref, ir)
+                    .filter(|_| meta.field.xml_name.is_empty())
+                {
                     let branch_tags: Vec<_> = union_def
                         .branches
                         .iter()
@@ -2069,10 +2078,14 @@ impl RustCodegen {
         } else {
             let target_type = self.format_rust_type_ref(&field.type_ref, types_with_lifetime);
             let target_clean = target_type.split('<').next().unwrap_or(&target_type);
+            let decode = if self.resolve_union_def(&field.type_ref, ir).is_some() {
+                "decode_xml_wrapped"
+            } else {
+                "decode_xml"
+            };
             let _ = writeln!(
                 out,
-                "                        let val = {}::decode_xml(reader, &e)?;",
-                target_clean
+                "                        let val = {target_clean}::{decode}(reader, &e)?;"
             );
             let final_val = if is_boxed { "Box::new(val)" } else { "val" };
             if is_list {
@@ -2102,6 +2115,10 @@ impl RustCodegen {
         let is_list = field.cardinality.is_list() || field.type_ref.is_list();
         let is_boxed = field.is_cycle_cut || field.type_ref.is_boxed();
 
+        if self.resolve_union_def(&field.type_ref, ir).is_some() {
+            let _ = writeln!(out, "                        return Err(PolyXmlError::SchemaError(\"Missing choice in {}\".into()));", field.xml_name);
+            return;
+        }
         if self.field_is_string(&field.type_ref, ir) {
             self.emit_pattern_check(out, field, "\"\"", ir);
             if self.options.zero_copy {
@@ -2399,7 +2416,15 @@ impl RustCodegen {
                     field.xml_name
                 );
             } else if self.resolve_union_def(&field.type_ref, ir).is_some() {
-                let _ = writeln!(out, "            item.encode_xml(writer, None)?;",);
+                if field.xml_name.is_empty() {
+                    let _ = writeln!(out, "            item.encode_xml(writer, None)?;");
+                } else {
+                    let _ = writeln!(
+                        out,
+                        "            item.encode_xml_wrapped(writer, {:?})?;",
+                        field.xml_name
+                    );
+                }
             } else {
                 let _ = writeln!(
                     out,
@@ -2451,7 +2476,15 @@ impl RustCodegen {
                     field.xml_name
                 );
             } else if self.resolve_union_def(&field.type_ref, ir).is_some() {
-                let _ = writeln!(out, "            val.encode_xml(writer, None)?;",);
+                if field.xml_name.is_empty() {
+                    let _ = writeln!(out, "            val.encode_xml(writer, None)?;");
+                } else {
+                    let _ = writeln!(
+                        out,
+                        "            val.encode_xml_wrapped(writer, {:?})?;",
+                        field.xml_name
+                    );
+                }
             } else {
                 let _ = writeln!(
                     out,
@@ -2506,7 +2539,15 @@ impl RustCodegen {
                     field.xml_name
                 );
             } else if self.resolve_union_def(&field.type_ref, ir).is_some() {
-                let _ = writeln!(out, "        self.{}.encode_xml(writer, None)?;", rust_name);
+                if field.xml_name.is_empty() {
+                    let _ = writeln!(out, "        self.{}.encode_xml(writer, None)?;", rust_name);
+                } else {
+                    let _ = writeln!(
+                        out,
+                        "        self.{}.encode_xml_wrapped(writer, {:?})?;",
+                        rust_name, field.xml_name
+                    );
+                }
             } else {
                 let _ = writeln!(
                     out,
@@ -2540,6 +2581,35 @@ impl RustCodegen {
         out.push('\n');
         let _ = writeln!(out, "{} {{", impl_header);
 
+        let reader_lifetime = if needs_lifetime { "'a" } else { "'_" };
+        let _ = writeln!(out, "    pub fn decode_xml_wrapped(reader: &mut Reader<&{reader_lifetime} [u8]>, start: &BytesStart<'_>) -> Result<Self> {{");
+        out.push_str(r#"        let mut value = None;
+        loop {
+            match reader.read_event()? {
+                Event::Start(e) => {
+                    if value.is_some() { return Err(PolyXmlError::SchemaError("Multiple choice alternatives".into())); }
+                    value = Some(Self::decode_xml(reader, &e)?);
+                }
+                Event::Empty(e) => {
+                    if value.is_some() { return Err(PolyXmlError::SchemaError("Multiple choice alternatives".into())); }
+                    let mut empty_reader = Reader::from_str("");
+                    value = Some(Self::decode_xml(&mut empty_reader, &e)?);
+                }
+                Event::End(e) if e.name() == start.name() => break,
+                Event::Eof => return Err(PolyXmlError::SchemaError("Unclosed choice wrapper".into())),
+                _ => {}
+            }
+        }
+        value.ok_or_else(|| PolyXmlError::SchemaError("Missing choice alternative".into()))
+    }
+    pub fn encode_xml_wrapped<W: std::io::Write>(&self, writer: &mut Writer<W>, tag: &str) -> Result<()> {
+        writer.write_event(Event::Start(BytesStart::new(tag)))?;
+        self.encode_xml(writer, None)?;
+        writer.write_event(Event::End(BytesEnd::new(tag)))?;
+        Ok(())
+    }
+"#);
+
         let from_xml_sig = if needs_lifetime {
             "pub fn from_xml(xml: &'a str) -> Result<Self>"
         } else {

{polyxml-0.34.2 → polyxml-0.34.4}/crates/polyxml-core/src/schema_parser/mod.rs

@@ -350,20 +350,13 @@ impl XsdParser {
                             }
                         }
                         "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)?;
+                            self.parse_global_attribute(
+                                &mut reader,
+                                e,
+                                target_namespace.as_deref(),
+                                &prefixes,
+                                &mut ir,
+                            )?;
                         }
                         "group" => {
                             // Named model group definition.
@@ -445,18 +438,19 @@ impl XsdParser {
                             }
                         }
                         "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(|| {
+                            if let Some(name) = get_attr_value(e, "name") {
+                                let type_ref = get_attr_value(e, "type")
+                                    .map(|ty| {
                                         resolve_type_ref(
                                             &ty,
                                             target_namespace.as_deref(),
                                             &prefixes,
                                         )
-                                    });
+                                    })
+                                    .unwrap_or_else(TypeRef::string);
+                                ir.attributes
+                                    .entry(QName::new(target_namespace.as_deref(), name))
+                                    .or_insert(type_ref);
                             }
                         }
                         "group" => {
@@ -1225,6 +1219,7 @@ impl XsdParser {
         let mut facets = RestrictionFacets::default();
         let mut enum_values = Vec::new();
         let mut union_branches: Option<Vec<UnionBranch>> = None;
+        let mut list_requires_inline = false;
         let mut documentation = None;
         let mut buf = Vec::new();
 
@@ -1252,14 +1247,30 @@ impl XsdParser {
                                     &item, target_ns, prefixes,
                                 )));
                             } else {
-                                return Err(SchemaError::Malformed(
-                                    "xs:list requires a supported itemType".into(),
-                                ));
+                                list_requires_inline = true;
                             }
                         }
                         "union" => {
                             union_branches = Some(parse_union_members(e, target_ns, prefixes));
                         }
+                        "simpleType" if list_requires_inline => {
+                            let item_name =
+                                unique_type_name(ir, target_ns, &format!("{}Item", qname.local));
+                            if let Some(item) = self.parse_simple_type(
+                                reader,
+                                e,
+                                target_ns,
+                                prefixes,
+                                Some(item_name),
+                                ir,
+                            )? {
+                                base_type =
+                                    TypeRef::List(Box::new(TypeRef::Named(item.qname().clone())));
+                                ir.add_type(item);
+                                list_requires_inline = false;
+                            }
+                            depth -= 1;
+                        }
                         "simpleType" if union_branches.is_some() => {
                             let branch_index = union_branches.as_ref().unwrap().len() + 1;
                             let inline_name = unique_type_name(
@@ -1380,7 +1391,12 @@ impl XsdParser {
                         _ => {}
                     }
                 }
-                Event::End(_) => {
+                Event::End(ref e) => {
+                    if strip_prefix(e.name().into_inner()) == "list" && list_requires_inline {
+                        return Err(SchemaError::Malformed(
+                            "xs:list requires itemType or an inline simpleType".into(),
+                        ));
+                    }
                     depth -= 1;
                 }
                 Event::Eof => break,
@@ -1465,6 +1481,46 @@ impl XsdParser {
         }
     }
 
+    fn parse_global_attribute(
+        &self,
+        reader: &mut Reader<&[u8]>,
+        start: &BytesStart,
+        target_ns: Option<&str>,
+        prefixes: &HashMap<String, String>,
+        ir: &mut SchemaIR,
+    ) -> Result<(), SchemaError> {
+        let Some(name) = get_attr_value(start, "name") else {
+            return skip_subtree(reader);
+        };
+        let mut type_ref = get_attr_value(start, "type")
+            .map(|ty| resolve_type_ref(&ty, target_ns, prefixes))
+            .unwrap_or_else(TypeRef::string);
+        loop {
+            match reader.read_event()? {
+                Event::Start(e) if strip_prefix(e.name().into_inner()) == "simpleType" => {
+                    let anonymous_name =
+                        unique_type_name(ir, target_ns, &format!("{name}AttributeType"));
+                    if let Some(definition) = self.parse_simple_type(
+                        reader,
+                        &e,
+                        target_ns,
+                        prefixes,
+                        Some(anonymous_name),
+                        ir,
+                    )? {
+                        type_ref = TypeRef::Named(definition.qname().clone());
+                        ir.add_type(definition);
+                    }
+                }
+                Event::Start(_) => skip_subtree(reader)?,
+                Event::End(_) | Event::Eof => break,
+                _ => {}
+            }
+        }
+        ir.attributes.insert(QName::new(target_ns, name), type_ref);
+        Ok(())
+    }
+
     fn parse_global_element(
         &mut self,
         reader: &mut Reader<&[u8]>,
@@ -2728,6 +2784,7 @@ fn validate_type_references(ir: &SchemaIR, xml: &str) -> Result<(), SchemaError>
 }
 fn validate_schema_grammar(xml: &str) -> Result<(), SchemaError> {
     let mut reader = Reader::from_str(xml);
+    let mut schema_namespace = None;
     let mut stack = Vec::<(String, HashMap<String, String>)>::new();
     let mut line = 1;
     let mut line_position = 0;
@@ -2754,6 +2811,9 @@ fn validate_schema_grammar(xml: &str) -> Result<(), SchemaError> {
             }
         }
         let local = strip_prefix(element.name().into_inner());
+        if stack.is_empty() && local == "schema" {
+            schema_namespace = get_attr_value(&element, "targetNamespace");
+        }
         let position = reader.buffer_position() as usize;
         line += xml[line_position..position]
             .bytes()
@@ -2804,6 +2864,9 @@ fn validate_schema_grammar(xml: &str) -> Result<(), SchemaError> {
                             )));
                         };
                         if namespace == "http://www.w3.org/2001/XMLSchema"
+                            // The schema-for-schemas declares named types in this
+                            // namespace; the resolved IR validates their existence.
+                            && schema_namespace.as_deref() != Some(namespace.as_str())
                             && attr.key.as_ref() != "ref"
                             && PrimitiveType::from_xsd_name(local).is_none()
                         {