polyxml 0.30.2__tar.gz → 0.30.4__tar.gz

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

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

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

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

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

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

{polyxml-0.30.2 → polyxml-0.30.4}/crates/polyxml-core/src/codegen/cpp/mod.rs

@@ -656,9 +656,13 @@ concept XmlModel = requires(T a) {{
     }
 
     fn emit_types(&self, out: &mut String, ir: &SchemaIR) {
-        // Emit simple type aliases first
-        for type_def in ir.emitted_types() {
-            if let TypeDef::Simple(simple) = type_def {
+        let sorted_qnames = self.topological_sort_types(ir);
+
+        // Aliases must follow their base aliases, which may sort later by name.
+        for qname in &sorted_qnames {
+            if let Some(TypeDef::Simple(simple)) =
+                ir.types.get(qname).filter(|_| !ir.is_external_type(qname))
+            {
                 self.emit_simple_type(out, simple, ir);
             }
         }
@@ -671,8 +675,6 @@ concept XmlModel = requires(T a) {{
         }
 
         // Topologically sort structs and unions (DAG order)
-        let sorted_qnames = self.topological_sort_types(ir);
-
         for qname in sorted_qnames {
             if ir.is_external_type(&qname) {
                 continue;

{polyxml-0.30.2 → polyxml-0.30.4}/crates/polyxml-core/src/codegen/csharp/mod.rs

@@ -244,13 +244,34 @@ fn type_ident(q: &QName) -> String {
 
 fn choice_variant_name(branch: &UnionBranch) -> String {
     let name = to_csharp_type_name(&branch.variant_name);
-    if matches!(&branch.type_ref, TypeRef::Named(qname) if type_ident(qname) == name) {
+    if matches!(
+        name.as_str(),
+        "Value" | "Equals" | "GetHashCode" | "ToString"
+    ) || matches!(&branch.type_ref, TypeRef::Named(qname) if type_ident(qname) == name)
+    {
         format!("{name}Branch")
     } else {
         name
     }
 }
 
+fn simple_value_target(base: &TypeRef, ir: &SchemaIR) -> String {
+    let mut target = "Value".to_string();
+    let mut current = base;
+    let mut seen = HashSet::new();
+    while let TypeRef::Named(qname) = current {
+        if !seen.insert(qname.clone()) {
+            break;
+        }
+        let Some(TypeDef::Simple(simple)) = ir.types.get(qname) else {
+            break;
+        };
+        target.push_str(".Value");
+        current = &simple.base_type;
+    }
+    target
+}
+
 impl CSharpCodegen {
     /// Creates a new C# code generator with the given configuration options.
     pub fn new(options: CSharpOptions) -> Self {
@@ -315,7 +336,7 @@ impl CSharpCodegen {
                 if !simple.facets.patterns.is_empty() {
                     simple.base_type = super::primitive_base(&simple.base_type, ir).clone();
                 }
-                self.emit_simple(&mut out, &simple, indent);
+                self.emit_simple(&mut out, &simple, ir, indent);
             }
         }
 
@@ -510,8 +531,10 @@ impl CSharpCodegen {
         writeln!(out, "{}}}\n", indent).unwrap();
     }
 
-    fn emit_simple(&self, out: &mut String, s: &SimpleTypeDef, indent: &str) {
-        if !s.facets.is_empty() || !self.options.use_records {
+    fn emit_simple(&self, out: &mut String, s: &SimpleTypeDef, ir: &SchemaIR, indent: &str) {
+        // Named simple types may be referenced by structs and choices even
+        // when they have no facets, so every one needs a declaration.
+        {
             let type_name = type_ident(&s.qname);
             let base_type = self.context.map_type_ref(&s.base_type);
 
@@ -550,7 +573,8 @@ impl CSharpCodegen {
                 .unwrap();
                 if self.options.emit_validation {
                     writeln!(out, "{}    public IEnumerable<ValidationResult> Validate(ValidationContext validationContext)\n{}    {{", indent, indent).unwrap();
-                    self.emit_facet_checks(out, &s.facets, "Value", &format!("{}        ", indent));
+                    let value = simple_value_target(&s.base_type, ir);
+                    self.emit_facet_checks(out, &s.facets, &value, &format!("{}        ", indent));
                     writeln!(out, "{}        yield break;\n{}    }}", indent, indent).unwrap();
                 }
                 writeln!(out, "{}}}\n", indent).unwrap();
@@ -579,7 +603,8 @@ impl CSharpCodegen {
             )
             .unwrap();
             writeln!(out, "{}    {{", indent).unwrap();
-            self.emit_facet_checks(out, &s.facets, "Value", &format!("{}        ", indent));
+            let value = simple_value_target(&s.base_type, ir);
+            self.emit_facet_checks(out, &s.facets, &value, &format!("{}        ", indent));
             writeln!(out, "{}        yield break;", indent).unwrap();
             writeln!(out, "{}    }}", indent).unwrap();
             writeln!(out, "{}}}\n", indent).unwrap();
@@ -1076,12 +1101,24 @@ impl CSharpCodegen {
 
         // Collect fields and parameters
         if s.fields.is_empty() {
-            writeln!(
-                out,
-                "{}public {} {}{};",
-                indent, record_keyword, struct_name, implements_str
-            )
-            .unwrap();
+            if self.options.emit_validation {
+                writeln!(
+                    out,
+                    "{}public {} {}{}",
+                    indent, record_keyword, struct_name, implements_str
+                )
+                .unwrap();
+                writeln!(out, "{}{{", indent).unwrap();
+                self.emit_struct_validator(out, s, &prop_names, indent);
+                writeln!(out, "{}}}", indent).unwrap();
+            } else {
+                writeln!(
+                    out,
+                    "{}public {} {}{};",
+                    indent, record_keyword, struct_name, implements_str
+                )
+                .unwrap();
+            }
             writeln!(out).unwrap();
             return;
         }

{polyxml-0.30.2 → polyxml-0.30.4}/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.2 → polyxml-0.30.4}/crates/polyxml-core/src/codegen/mod.rs

@@ -24,6 +24,16 @@ pub use python::{
 pub use rust::{RustCodegen, RustOptions};
 pub use typescript::{TypeScriptBackend, TypeScriptCodegen, TypeScriptOptions};
 
+/// Prefix every physical XSD documentation line so embedded newlines cannot
+/// escape a generated source comment.
+pub(crate) fn write_documentation_lines(out: &mut String, prefix: &str, doc: &str) {
+    for line in doc.trim().lines() {
+        out.push_str(prefix);
+        out.push_str(line.trim_end_matches('\r'));
+        out.push('\n');
+    }
+}
+
 use crate::ir::{FieldDef, PrimitiveType, QName, SchemaIR, StructDef, TypeRef};
 
 #[derive(Debug, Error)]

{polyxml-0.30.2 → polyxml-0.30.4}/crates/polyxml-core/src/codegen/python/mod.rs

@@ -6,7 +6,7 @@ use serde::{Deserialize, Serialize};
 
 use crate::codegen::{
     build_type_name_map, lookup_type_name, normalize_symbol_name, sanitize_keyword,
-    set_type_name_map, LanguageContext,
+    set_type_name_map, write_documentation_lines, LanguageContext,
 };
 use crate::ir::{
     EnumDef, FieldDef, FieldKind, PrimitiveType, QName, RestrictionFacets, SchemaIR, SimpleTypeDef,
@@ -32,6 +32,15 @@ const PATTERN_VALIDATOR_HELPER: &str = r#"def _polyxml_patterns(*patterns: str):
 pub mod aot;
 pub use aot::{PythonAotCodegen, PythonAotCrate, PythonAotOptions};
 
+fn write_python_docstring(out: &mut String, indent: &str, doc: &str) {
+    let escaped = doc
+        .trim()
+        .replace('\\', "\\\\")
+        .replace("\"\"\"", "\\\"\\\"\\\"")
+        .replace('\r', "");
+    let _ = writeln!(out, "{indent}\"\"\"{escaped}\"\"\"");
+}
+
 /// Target backend for Python code emission.
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Default, Serialize, Deserialize)]
 pub enum PythonBackend {
@@ -444,7 +453,7 @@ impl PythonCodegen {
         let base_type = self.context.map_type_ref(&s.base_type);
 
         if let Some(ref doc) = s.documentation {
-            let _ = writeln!(out, "# {}", doc.trim());
+            write_documentation_lines(out, "# ", doc);
         }
 
         if self.options.backend == PythonBackend::Pydantic && !s.facets.is_empty() {
@@ -492,7 +501,7 @@ impl PythonCodegen {
         let _ = writeln!(out, "class {}(StrEnum):", enum_name);
 
         if let Some(ref doc) = e.documentation {
-            let _ = writeln!(out, "    \"\"\"{}\"\"\"", doc.trim());
+            write_python_docstring(out, "    ", doc);
         }
 
         if e.variants.is_empty() {
@@ -549,7 +558,7 @@ impl PythonCodegen {
         }
 
         if let Some(ref doc) = u.documentation {
-            let _ = writeln!(out, "# {}", doc.trim());
+            write_documentation_lines(out, "# ", doc);
         }
 
         if u.branches.is_empty() {
@@ -613,7 +622,8 @@ impl PythonCodegen {
         let mut has_body = false;
 
         if let Some(ref doc) = s.documentation {
-            let _ = writeln!(out, "    \"\"\"{}\"\"\"\n", doc.trim());
+            write_python_docstring(out, "    ", doc);
+            out.push('\n');
             has_body = true;
         }
 
@@ -763,7 +773,7 @@ impl PythonCodegen {
         };
 
         if let Some(ref doc) = field.documentation {
-            let _ = writeln!(out, "    # {}", doc.trim());
+            write_documentation_lines(out, "    # ", doc);
         }
 
         let _ = writeln!(out, "    {}: {} = {}", py_name, field_type, field_call);

{polyxml-0.30.2 → polyxml-0.30.4}/crates/polyxml-core/src/codegen/rust/mod.rs

@@ -6,7 +6,7 @@ use serde::{Deserialize, Serialize};
 
 use crate::codegen::{
     build_type_name_map, flatten_fields, lookup_type_name, primitive_base, sanitize_keyword,
-    set_type_name_map, LanguageContext,
+    set_type_name_map, write_documentation_lines, LanguageContext,
 };
 use crate::ir::{
     EnumDef, FieldDef, FieldKind, PrimitiveType, QName, SchemaIR, SimpleTypeDef, StructDef,
@@ -279,7 +279,10 @@ impl RustCodegen {
             self.emit_pymodule(&mut out, ir, &sorted_types);
         }
 
-        out
+        // A field may use a raw identifier such as `r#type`. Local codec
+        // variables have a `var_` prefix, so the raw marker is neither needed
+        // nor valid there (`var_r#type` is not a Rust identifier).
+        out.replace("var_r#", "var_")
     }
 
     /// Fixed-point analysis determining which types in SchemaIR require a lifetime parameter `<'a>`.
@@ -456,7 +459,7 @@ impl RustCodegen {
         let needs_lifetime = types_with_lifetime.contains(&s.qname);
 
         if let Some(ref doc) = s.documentation {
-            let _ = writeln!(out, "/// {}", doc.trim());
+            write_documentation_lines(out, "/// ", doc);
         }
 
         let base_type = self.format_rust_type_ref(&s.base_type, types_with_lifetime);
@@ -482,7 +485,7 @@ impl RustCodegen {
         let enum_name = type_ident(&e.qname);
 
         if let Some(ref doc) = e.documentation {
-            let _ = writeln!(out, "/// {}", doc.trim());
+            write_documentation_lines(out, "/// ", doc);
         }
 
         let mut derives = vec!["Debug", "Clone", "Copy", "PartialEq", "Eq", "Hash"];
@@ -520,7 +523,7 @@ impl RustCodegen {
             seen_variants.insert(var_id.clone());
 
             if let Some(ref doc) = variant.documentation {
-                let _ = writeln!(out, "    /// {}", doc.trim());
+                write_documentation_lines(out, "    /// ", doc);
             }
             if self.options.derive_serde {
                 let _ = writeln!(out, "    #[serde(rename = \"{}\")]", variant.value);
@@ -595,7 +598,7 @@ impl RustCodegen {
         let needs_lifetime = types_with_lifetime.contains(&u.qname);
 
         if let Some(ref doc) = u.documentation {
-            let _ = writeln!(out, "/// {}", doc.trim());
+            write_documentation_lines(out, "/// ", doc);
         }
 
         let mut derives = vec!["Debug", "Clone", "PartialEq"];
@@ -640,7 +643,7 @@ impl RustCodegen {
             let branch_type = self.format_rust_type_ref(&branch.type_ref, types_with_lifetime);
 
             if let Some(ref doc) = branch.documentation {
-                let _ = writeln!(out, "    /// {}", doc.trim());
+                write_documentation_lines(out, "    /// ", doc);
             }
             if self.options.derive_serde && !u.is_lexical() {
                 let _ = writeln!(out, "    #[serde(rename = \"{}\")]", branch.xml_name);
@@ -685,7 +688,7 @@ impl RustCodegen {
         let needs_lifetime = types_with_lifetime.contains(&s.qname);
 
         if let Some(ref doc) = s.documentation {
-            let _ = writeln!(out, "/// {}", doc.trim());
+            write_documentation_lines(out, "/// ", doc);
         }
 
         let mut derives = vec!["Debug", "Clone", "PartialEq"];
@@ -763,7 +766,7 @@ impl RustCodegen {
         has_boxed: bool,
     ) {
         if let Some(ref doc) = field.documentation {
-            let _ = writeln!(out, "    /// {}", doc.trim());
+            write_documentation_lines(out, "    /// ", doc);
         }
 
         let is_list = field.cardinality.is_list() || field.type_ref.is_list();

{polyxml-0.30.2 → polyxml-0.30.4}/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.2 → polyxml-0.30.4}/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.