polyxml 0.27.0__tar.gz → 0.29.0__tar.gz

{polyxml-0.27.0 → polyxml-0.29.0}/Cargo.lock

@@ -608,7 +608,7 @@ dependencies = [
 
 [[package]]
 name = "polyxml"
-version = "0.27.0"
+version = "0.29.0"
 dependencies = [
  "criterion",
  "heck",
@@ -619,6 +619,7 @@ dependencies = [
  "phf_codegen",
  "pretty_assertions",
  "quick-xml",
+ "regex",
  "serde",
  "serde_json",
  "smallvec",
@@ -628,14 +629,14 @@ dependencies = [
 
 [[package]]
 name = "polyxml-c"
-version = "0.27.0"
+version = "0.29.0"
 dependencies = [
  "polyxml",
 ]
 
 [[package]]
 name = "polyxml-cli"
-version = "0.27.0"
+version = "0.29.0"
 dependencies = [
  "clap",
  "glob",
@@ -649,7 +650,7 @@ dependencies = [
 
 [[package]]
 name = "polyxml-js"
-version = "0.27.0"
+version = "0.29.0"
 dependencies = [
  "napi",
  "napi-build",
@@ -659,7 +660,7 @@ dependencies = [
 
 [[package]]
 name = "polyxml-python"
-version = "0.27.0"
+version = "0.29.0"
 dependencies = [
  "lexical-core",
  "polyxml",
@@ -669,7 +670,7 @@ dependencies = [
 
 [[package]]
 name = "polyxml-wasm"
-version = "0.27.0"
+version = "0.29.0"
 dependencies = [
  "polyxml",
  "quick-xml",

{polyxml-0.27.0 → polyxml-0.29.0}/Cargo.toml

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

{polyxml-0.27.0 → polyxml-0.29.0}/PKG-INFO

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

{polyxml-0.27.0 → polyxml-0.29.0}/crates/polyxml-core/Cargo.toml

@@ -21,6 +21,7 @@ serde_json = "1.0"
 minijinja = { version = "2.8", features = ["builtins"] }
 heck = "0.5"
 phf_codegen = "0.14.0"
+regex = "1.11"
 
 [dev-dependencies]
 criterion = { version = "0.8", default-features = false, features = ["cargo_bench_support"] }

{polyxml-0.27.0 → polyxml-0.29.0}/crates/polyxml-core/src/codegen/csharp/mod.rs

@@ -15,7 +15,7 @@ use crate::codegen::{
 };
 use crate::ir::{
     EnumDef, FieldDef, FieldKind, PrimitiveType, QName, RestrictionFacets, SchemaIR, SimpleTypeDef,
-    StructDef, TypeDef, TypeRef, UnionDef,
+    StructDef, TypeDef, TypeRef, UnionBranch, UnionDef,
 };
 
 /// Record emission kind: class vs struct.
@@ -242,6 +242,15 @@ fn type_ident(q: &QName) -> String {
     lookup_type_name(q, || to_csharp_type_name(&q.local))
 }
 
+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) {
+        format!("{name}Branch")
+    } else {
+        name
+    }
+}
+
 impl CSharpCodegen {
     /// Creates a new C# code generator with the given configuration options.
     pub fn new(options: CSharpOptions) -> Self {
@@ -313,7 +322,7 @@ impl CSharpCodegen {
         // Emit Unions (Choices)
         for def in ir.types.values() {
             if let TypeDef::Union(u) = def {
-                self.emit_union(&mut out, u, indent);
+                self.emit_union(&mut out, u, ir, indent);
             }
         }
 
@@ -577,16 +586,16 @@ impl CSharpCodegen {
         }
     }
 
-    fn emit_union(&self, out: &mut String, u: &UnionDef, indent: &str) {
+    fn emit_union(&self, out: &mut String, u: &UnionDef, ir: &SchemaIR, indent: &str) {
         let choice_name = type_ident(&u.qname);
         if let Some(ref doc) = u.documentation {
             self.emit_docstring(out, doc, indent);
         }
 
-        // XmlInclude attributes for polymorphism
-        if self.options.emit_xml_attributes {
+        // XmlInclude attributes for element-choice polymorphism.
+        if self.options.emit_xml_attributes && !u.is_lexical() && !u.is_mixed_content() {
             for branch in &u.branches {
-                let variant_name = to_csharp_type_name(&branch.variant_name);
+                let variant_name = choice_variant_name(branch);
                 writeln!(
                     out,
                     "{}[XmlInclude(typeof({}.{}))]",
@@ -603,7 +612,7 @@ impl CSharpCodegen {
                     "{}[JsonDerivedType(typeof({}.{}), {:?})]",
                     indent,
                     choice_name,
-                    to_csharp_type_name(&branch.variant_name),
+                    choice_variant_name(branch),
                     branch.xml_name
                 )
                 .unwrap();
@@ -624,7 +633,7 @@ impl CSharpCodegen {
         writeln!(out, "{}{{", indent).unwrap();
 
         for branch in &u.branches {
-            let variant_name = to_csharp_type_name(&branch.variant_name);
+            let variant_name = choice_variant_name(branch);
             let branch_type = self.context.map_type_ref(&branch.type_ref);
 
             if let Some(ref doc) = branch.documentation {
@@ -632,10 +641,10 @@ impl CSharpCodegen {
             }
 
             let mut branch_attrs = Vec::new();
-            if self.options.emit_xml_attributes {
+            if self.options.emit_xml_attributes && !u.is_lexical() && !u.is_mixed_content() {
                 branch_attrs.push(format!("XmlElement(\"{}\")", branch.xml_name));
             }
-            if self.options.emit_json_attributes {
+            if self.options.emit_json_attributes && !u.is_lexical() {
                 branch_attrs.push(format!("JsonPropertyName(\"{}\")", branch.xml_name));
             }
             let xml_attr = if branch_attrs.is_empty() {
@@ -679,9 +688,234 @@ impl CSharpCodegen {
             writeln!(out).unwrap();
         }
 
+        if u.is_lexical() {
+            self.emit_lexical_union_helpers(out, u, ir, indent);
+        }
         writeln!(out, "{}}}\n", indent).unwrap();
     }
 
+    fn emit_lexical_union_helpers(
+        &self,
+        out: &mut String,
+        u: &UnionDef,
+        ir: &SchemaIR,
+        indent: &str,
+    ) {
+        let name = type_ident(&u.qname);
+        let _ = writeln!(
+            out,
+            "{}    public static {} Parse(string text)",
+            indent, name
+        );
+        let _ = writeln!(out, "{}    {{", indent);
+        let _ = writeln!(out, "{}        var value = text.Trim();", indent);
+        for (idx, branch) in u.branches.iter().enumerate() {
+            let variant = choice_variant_name(branch);
+            let mapped = self.context.map_type_ref(&branch.type_ref);
+            if let TypeRef::Named(qname) = &branch.type_ref {
+                if let Some(TypeDef::Enum(def)) = ir.types.get(qname) {
+                    for item in &def.variants {
+                        let item_name = to_csharp_variant_name(&item.name);
+                        let _ = writeln!(
+                            out,
+                            "{}        if (value == {:?}) return new {}({}.{});",
+                            indent, item.value, variant, mapped, item_name
+                        );
+                    }
+                    continue;
+                }
+            }
+            let simple = match &branch.type_ref {
+                TypeRef::Named(qname) => ir.types.get(qname).and_then(|def| match def {
+                    TypeDef::Simple(s) => Some(s.as_ref()),
+                    _ => None,
+                }),
+                _ => None,
+            };
+            let base = super::primitive_base(&branch.type_ref, ir);
+            let base_name = self.context.map_type_ref(base);
+            let wrap = if simple.is_some() {
+                format!("new {}(candidate{})", mapped, idx)
+            } else {
+                format!("candidate{}", idx)
+            };
+            if base_name == "string" {
+                if let Some(simple) = simple.filter(|s| !s.facets.patterns.is_empty()) {
+                    let checks = simple
+                        .facets
+                        .patterns
+                        .iter()
+                        .map(|pattern| {
+                            format!("Regex.IsMatch(value, {:?})", format!(r"\A(?:{pattern})\z"))
+                        })
+                        .collect::<Vec<_>>()
+                        .join(" && ");
+                    let _ = writeln!(
+                        out,
+                        "{}        if ({}) {{ var candidate{} = value; return new {}({}); }}",
+                        indent, checks, idx, variant, wrap
+                    );
+                } else {
+                    let _ = writeln!(
+                        out,
+                        "{}        {{ var candidate{} = value; return new {}({}); }}",
+                        indent, idx, variant, wrap
+                    );
+                }
+            } else if base_name == "bool" {
+                let _ = writeln!(out, "{}        if (value == \"true\" || value == \"1\") {{ var candidate{} = true; return new {}({}); }}", indent, idx, variant, wrap);
+                let _ = writeln!(out, "{}        if (value == \"false\" || value == \"0\") {{ var candidate{} = false; return new {}({}); }}", indent, idx, variant, wrap);
+            } else if base_name == "DateOnly" {
+                let _ = writeln!(out, "{}        if (DateOnly.TryParseExact(value, \"yyyy-MM-dd\", System.Globalization.CultureInfo.InvariantCulture, System.Globalization.DateTimeStyles.None, out var candidate{})) return new {}({});", indent, idx, variant, wrap);
+            } else {
+                let _ = writeln!(
+                    out,
+                    "{}        if ({}.TryParse(value, out var candidate{})) return new {}({});",
+                    indent, base_name, idx, variant, wrap
+                );
+            }
+        }
+        let _ = writeln!(
+            out,
+            "{}        throw new FormatException(\"No {} union member accepts the value\");",
+            indent, name
+        );
+        let _ = writeln!(out, "{}    }}", indent);
+        let _ = writeln!(
+            out,
+            "{}    public string ToXmlString() => this switch",
+            indent
+        );
+        let _ = writeln!(out, "{}    {{", indent);
+        for branch in &u.branches {
+            let variant = choice_variant_name(branch);
+            let value = if matches!(
+                super::primitive_base(&branch.type_ref, ir),
+                TypeRef::Primitive(PrimitiveType::Date)
+            ) {
+                "item.Value.ToString(\"yyyy-MM-dd\", System.Globalization.CultureInfo.InvariantCulture)".to_string()
+            } else {
+                match &branch.type_ref {
+                TypeRef::Named(qname) if matches!(ir.types.get(qname), Some(TypeDef::Enum(_))) => "item.Value.ToXmlValue()".to_string(),
+                TypeRef::Named(qname) if matches!(ir.types.get(qname), Some(TypeDef::Simple(_))) => "Convert.ToString(item.Value.Value, System.Globalization.CultureInfo.InvariantCulture) ?? \"\"".to_string(),
+                _ => "Convert.ToString(item.Value, System.Globalization.CultureInfo.InvariantCulture) ?? \"\"".to_string(),
+            }
+            };
+            let _ = writeln!(out, "{}        {} item => {},", indent, variant, value);
+        }
+        let _ = writeln!(
+            out,
+            "{}        _ => throw new InvalidOperationException()",
+            indent
+        );
+        let _ = writeln!(out, "{}    }};", indent);
+    }
+
+    fn emit_mixed_struct(
+        &self,
+        out: &mut String,
+        s: &StructDef,
+        ir: &SchemaIR,
+        indent: &str,
+        struct_name: &str,
+        prop_names: &[String],
+    ) {
+        let Some((item_index, union)) =
+            s.fields
+                .iter()
+                .enumerate()
+                .find_map(|(index, field)| match &field.type_ref {
+                    TypeRef::Named(qname) => match ir.types.get(qname) {
+                        Some(TypeDef::Union(union)) if union.is_mixed_content() => {
+                            Some((index, union))
+                        }
+                        _ => None,
+                    },
+                    _ => None,
+                })
+        else {
+            return;
+        };
+        let item_name = &prop_names[item_index];
+        let union_name = type_ident(&union.qname);
+        let class_kind = if self.options.use_records {
+            "record"
+        } else {
+            "class"
+        };
+        let _ = writeln!(out, "{indent}public {class_kind} {struct_name} : System.Xml.Serialization.IXmlSerializable\n{indent}{{");
+        for (field, prop_name) in s.fields.iter().zip(prop_names) {
+            let ty = self.map_field_type(field, ir);
+            if field.kind == FieldKind::Attribute {
+                if self.options.emit_json_attributes {
+                    let _ = writeln!(out, "{indent}    [JsonPropertyName({:?})]", field.xml_name);
+                }
+                let _ = writeln!(
+                    out,
+                    "{indent}    public {ty} {prop_name} {{ get; set; }} = default!;"
+                );
+            } else if field.kind == FieldKind::Element && prop_name == item_name {
+                let _ = writeln!(out, "{indent}    [XmlIgnore]\n{indent}    public List<{union_name}> {item_name} {{ get; set; }} = new();");
+            }
+        }
+        let _ = writeln!(
+            out,
+            "{indent}    public System.Xml.Schema.XmlSchema? GetSchema() => null;"
+        );
+        let _ = writeln!(
+            out,
+            "{indent}    public void ReadXml(System.Xml.XmlReader reader)\n{indent}    {{"
+        );
+        out.push_str("        reader.MoveToContent();\n");
+        for (field, prop_name) in s.fields.iter().zip(prop_names) {
+            if field.kind == FieldKind::Attribute {
+                let ty = self.map_field_type(field, ir);
+                let base_type = ty.trim_end_matches('?');
+                let _ = writeln!(out, "        {{ var raw = reader.GetAttribute({:?}); if (raw is not null) {prop_name} = ({ty})System.Convert.ChangeType(raw, typeof({base_type}), System.Globalization.CultureInfo.InvariantCulture); }}", field.xml_name);
+            }
+        }
+        let _ = writeln!(out, "        {item_name} = new List<{union_name}>();");
+        out.push_str("        bool empty = reader.IsEmptyElement;\n        reader.ReadStartElement();\n        if (empty) return;\n        while (reader.NodeType != System.Xml.XmlNodeType.EndElement && !reader.EOF)\n        {\n            switch (reader.NodeType)\n            {\n                case System.Xml.XmlNodeType.Text:\n                case System.Xml.XmlNodeType.CDATA:\n                case System.Xml.XmlNodeType.Whitespace:\n                case System.Xml.XmlNodeType.SignificantWhitespace:\n");
+        let _ = writeln!(
+            out,
+            "                    {item_name}.Add(new {union_name}.Text(reader.Value));"
+        );
+        out.push_str("                    reader.Read();\n                    break;\n                case System.Xml.XmlNodeType.Element:\n                    switch (reader.LocalName)\n                    {\n");
+        for branch in &union.branches {
+            if branch.xml_name == "#text" {
+                continue;
+            }
+            let branch_type = self.context.map_type_ref(&branch.type_ref);
+            let variant = choice_variant_name(branch);
+            let namespace = branch.namespace.as_deref().unwrap_or("");
+            let _ = writeln!(out, "                        case {:?}:\n                            {{ var serializer = new XmlSerializer(typeof({branch_type}), new XmlRootAttribute({:?}) {{ Namespace = {:?} }}); {item_name}.Add(new {union_name}.{variant}(({branch_type})serializer.Deserialize(reader)!)); break; }}", branch.xml_name, branch.xml_name, namespace);
+        }
+        out.push_str("                        default: reader.Skip(); break;\n                    }\n                    break;\n                default: reader.Read(); break;\n            }\n        }\n        reader.ReadEndElement();\n");
+        let _ = writeln!(out, "{indent}    }}");
+        let _ = writeln!(
+            out,
+            "{indent}    public void WriteXml(System.Xml.XmlWriter writer)\n{indent}    {{"
+        );
+        for (field, prop_name) in s.fields.iter().zip(prop_names) {
+            if field.kind == FieldKind::Attribute {
+                let _ = writeln!(out, "        if ({prop_name} is not null) writer.WriteAttributeString({:?}, System.Convert.ToString({prop_name}, System.Globalization.CultureInfo.InvariantCulture));", field.xml_name);
+            }
+        }
+        let _ = writeln!(out, "        foreach (var item in {item_name})\n        {{\n            switch (item)\n            {{");
+        for branch in &union.branches {
+            let variant = choice_variant_name(branch);
+            if branch.xml_name == "#text" {
+                let _ = writeln!(out, "                case {union_name}.{variant} text: writer.WriteString(text.Value); break;");
+            } else {
+                let branch_type = self.context.map_type_ref(&branch.type_ref);
+                let namespace = branch.namespace.as_deref().unwrap_or("");
+                let _ = writeln!(out, "                case {union_name}.{variant} value: new XmlSerializer(typeof({branch_type}), new XmlRootAttribute({:?}) {{ Namespace = {:?} }}).Serialize(writer, value.Value); break;", branch.xml_name, namespace);
+            }
+        }
+        out.push_str("            }\n        }\n");
+        let _ = writeln!(out, "{indent}    }}\n{indent}}}\n");
+    }
+
     fn emit_struct(&self, out: &mut String, s: &StructDef, ir: &SchemaIR, indent: &str) {
         let struct_name = type_ident(&s.qname);
         if let Some(ref doc) = s.documentation {
@@ -732,6 +966,60 @@ impl CSharpCodegen {
             .map(|f| self.unique_property_name(&f.name, &mut seen_props, Some(&struct_name)))
             .collect();
 
+        if s.is_mixed && self.options.emit_xml_attributes {
+            self.emit_mixed_struct(out, s, ir, indent, &struct_name, &prop_names);
+            return;
+        }
+
+        let has_lexical_union = self.options.emit_xml_attributes && s.fields.iter().any(|f| {
+            matches!(&f.type_ref, TypeRef::Named(q) if matches!(ir.types.get(q), Some(TypeDef::Union(u)) if u.is_lexical()))
+        });
+
+        if self.options.use_records && has_lexical_union {
+            writeln!(
+                out,
+                "{}public record {}{}\n{}{{",
+                indent, struct_name, implements_str, indent
+            )
+            .unwrap();
+            for (f, name) in s.fields.iter().zip(&prop_names) {
+                let ty = self.map_field_type(f, ir);
+                if let TypeRef::Named(q) = &f.type_ref {
+                    if matches!(ir.types.get(q), Some(TypeDef::Union(u)) if u.is_lexical()) {
+                        let _ = writeln!(out, "{}    [XmlIgnore]", indent);
+                        if self.options.emit_json_attributes {
+                            let _ =
+                                writeln!(out, "{}    [JsonPropertyName({:?})]", indent, f.xml_name);
+                        }
+                        let _ = writeln!(
+                            out,
+                            "{}    public {} {} {{ get; set; }} = default!;",
+                            indent, ty, name
+                        );
+                        let _ = writeln!(out, "{}    [XmlElement({:?})]", indent, f.xml_name);
+                        if self.options.emit_json_attributes {
+                            let _ = writeln!(out, "{}    [JsonIgnore]", indent);
+                        }
+                        let _ = writeln!(out, "{}    public string? {}Xml {{ get => {}?.ToXmlString(); set => {} = value is null ? default! : {}.Parse(value); }}", indent, name, name, name, type_ident(q));
+                        continue;
+                    }
+                }
+                let attrs = self
+                    .build_field_attributes(f, ir)
+                    .replace("[property: ", "[");
+                let _ = writeln!(
+                    out,
+                    "{}    {}public {} {} {{ get; set; }} = default!;",
+                    indent, attrs, ty, name
+                );
+            }
+            if self.options.emit_validation {
+                self.emit_struct_validator(out, s, &prop_names, indent);
+            }
+            writeln!(out, "{}}}\n", indent).unwrap();
+            return;
+        }
+
         if !self.options.use_records {
             writeln!(
                 out,
@@ -742,6 +1030,28 @@ impl CSharpCodegen {
             writeln!(out, "{}    public {}() {{ }}", indent, struct_name).unwrap();
             for (f, name) in s.fields.iter().zip(&prop_names) {
                 let ty = self.map_field_type(f, ir);
+                if let TypeRef::Named(q) = &f.type_ref {
+                    if self.options.emit_xml_attributes
+                        && matches!(ir.types.get(q), Some(TypeDef::Union(u)) if u.is_lexical())
+                    {
+                        let _ = writeln!(out, "{}    [XmlIgnore]", indent);
+                        if self.options.emit_json_attributes {
+                            let _ =
+                                writeln!(out, "{}    [JsonPropertyName({:?})]", indent, f.xml_name);
+                        }
+                        let _ = writeln!(
+                            out,
+                            "{}    public {} {} {{ get; set; }} = default!;",
+                            indent, ty, name
+                        );
+                        let _ = writeln!(out, "{}    [XmlElement({:?})]", indent, f.xml_name);
+                        if self.options.emit_json_attributes {
+                            let _ = writeln!(out, "{}    [JsonIgnore]", indent);
+                        }
+                        let _ = writeln!(out, "{}    public string? {}Xml {{ get => {}?.ToXmlString(); set => {} = value is null ? default! : {}.Parse(value); }}", indent, name, name, name, type_ident(q));
+                        continue;
+                    }
+                }
                 let attrs = self
                     .build_field_attributes(f, ir)
                     .replace("[property: ", "[");
@@ -1041,7 +1351,7 @@ impl CSharpCodegen {
                 if let Some(TypeDef::Union(u)) = ir.types.get(qname) {
                     let choice_name = type_ident(&u.qname);
                     for branch in &u.branches {
-                        let variant_name = to_csharp_type_name(&branch.variant_name);
+                        let variant_name = choice_variant_name(branch);
                         parts.push(format!(
                             "XmlElement(\"{}\", typeof({}.{}))",
                             branch.xml_name, choice_name, variant_name