polyxml 0.28.0__tar.gz → 0.29.0__tar.gz

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

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

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

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

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

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

{polyxml-0.28.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 {
@@ -584,9 +593,9 @@ impl CSharpCodegen {
         }
 
         // XmlInclude attributes for element-choice polymorphism.
-        if self.options.emit_xml_attributes && !u.is_lexical() {
+        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,7 +641,7 @@ impl CSharpCodegen {
             }
 
             let mut branch_attrs = Vec::new();
-            if self.options.emit_xml_attributes && !u.is_lexical() {
+            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 && !u.is_lexical() {
@@ -701,7 +710,7 @@ impl CSharpCodegen {
         let _ = writeln!(out, "{}    {{", indent);
         let _ = writeln!(out, "{}        var value = text.Trim();", indent);
         for (idx, branch) in u.branches.iter().enumerate() {
-            let variant = to_csharp_type_name(&branch.variant_name);
+            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) {
@@ -779,7 +788,7 @@ impl CSharpCodegen {
         );
         let _ = writeln!(out, "{}    {{", indent);
         for branch in &u.branches {
-            let variant = to_csharp_type_name(&branch.variant_name);
+            let variant = choice_variant_name(branch);
             let value = if matches!(
                 super::primitive_base(&branch.type_ref, ir),
                 TypeRef::Primitive(PrimitiveType::Date)
@@ -802,6 +811,111 @@ impl CSharpCodegen {
         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 {
@@ -852,6 +966,11 @@ 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()))
         });
@@ -1232,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

{polyxml-0.28.0 → polyxml-0.29.0}/crates/polyxml-core/src/codegen/go/mod.rs

@@ -279,6 +279,11 @@ impl GoCodegen {
         for type_def in ir.types.values() {
             match type_def {
                 TypeDef::Struct(s) => {
+                    if s.is_mixed && self.options.emit_xml_tags {
+                        has_xml = true;
+                        has_fmt = true;
+                        has_io = true;
+                    }
                     for f in &s.fields {
                         if self.references_time(&f.type_ref) {
                             has_time = true;
@@ -352,6 +357,14 @@ impl GoCodegen {
         if has_xml {
             imports.push("\"encoding/xml\"");
         }
+        if self.options.emit_xml_tags
+            && ir
+                .types
+                .values()
+                .any(|def| matches!(def, TypeDef::Struct(s) if s.is_mixed))
+        {
+            imports.push("\"bytes\"");
+        }
         if has_fmt {
             imports.push("\"fmt\"");
         }
@@ -977,11 +990,90 @@ impl GoCodegen {
 
         writeln!(out, "}}\n").unwrap();
 
+        if s.is_mixed && self.options.emit_xml_tags {
+            self.emit_mixed_struct_xml(out, s, ir, &field_names);
+        }
+
         if self.options.validate_facets {
             self.emit_struct_validator(out, s, ir, &field_names);
         }
     }
 
+    fn emit_mixed_struct_xml(
+        &self,
+        out: &mut String,
+        s: &StructDef,
+        ir: &SchemaIR,
+        field_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 struct_name = type_ident(&s.qname);
+        let item_field = &field_names[item_index];
+        let union_name = type_ident(&union.qname);
+        let mut seen = HashSet::new();
+        let branch_fields = union
+            .branches
+            .iter()
+            .map(|branch| self.unique_field_name(&branch.variant_name, &mut seen))
+            .collect::<Vec<_>>();
+
+        let _ = writeln!(
+            out,
+            "func (v *{struct_name}) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error {{"
+        );
+        let _ = writeln!(out, "    type Alias {struct_name}");
+        out.push_str("    var attrBytes bytes.Buffer\n    attrEncoder := xml.NewEncoder(&attrBytes)\n    if err := attrEncoder.EncodeToken(start); err != nil { return err }\n    if err := attrEncoder.EncodeToken(start.End()); err != nil { return err }\n    if err := attrEncoder.Flush(); err != nil { return err }\n    var attrs Alias\n    if err := xml.Unmarshal(attrBytes.Bytes(), &attrs); err != nil { return err }\n");
+        let _ = writeln!(out, "    *v = {struct_name}(attrs)");
+        let _ = writeln!(out, "    v.{item_field} = nil");
+        out.push_str("    for {\n        token, err := d.Token()\n        if err != nil { if err == io.EOF { return io.ErrUnexpectedEOF }; return err }\n        switch element := token.(type) {\n        case xml.CharData:\n            if len(element) > 0 {\n                value := string(element)\n");
+        let _ = writeln!(out, "                v.{item_field} = append(v.{item_field}, {union_name}{{{text_field}: &value}})", text_field=branch_fields[0]);
+        out.push_str("            }\n        case xml.StartElement:\n            switch element.Name.Local {\n");
+        for (branch, branch_field) in union.branches.iter().zip(&branch_fields) {
+            if branch.xml_name == "#text" {
+                continue;
+            }
+            let mapped = self.context.map_type_ref(&branch.type_ref);
+            let _ = writeln!(out, "            case {:?}:\n                var value {mapped}\n                if err := d.DecodeElement(&value, &element); err != nil {{ return err }}\n                v.{item_field} = append(v.{item_field}, {union_name}{{{branch_field}: &value}})", branch.xml_name);
+        }
+        out.push_str("            default:\n                if err := d.Skip(); err != nil { return err }\n            }\n        case xml.EndElement:\n            if element.Name == start.Name { return nil }\n        }\n    }\n}\n\n");
+
+        let _ = writeln!(
+            out,
+            "func (v {struct_name}) MarshalXML(e *xml.Encoder, start xml.StartElement) error {{"
+        );
+        let _ = writeln!(
+            out,
+            "    type Alias {struct_name}\n    attrs := Alias(v)\n    attrs.{item_field} = nil"
+        );
+        out.push_str("    raw, err := xml.Marshal(attrs)\n    if err != nil { return err }\n    decoder := xml.NewDecoder(bytes.NewReader(raw))\n    token, err := decoder.Token()\n    if err != nil { return err }\n    start.Attr = token.(xml.StartElement).Attr\n    if err := e.EncodeToken(start); err != nil { return err }\n");
+        let _ = writeln!(out, "    for _, item := range v.{item_field} {{");
+        for (branch, branch_field) in union.branches.iter().zip(&branch_fields) {
+            let _ = writeln!(out, "        if item.{branch_field} != nil {{");
+            if branch.xml_name == "#text" {
+                let _ = writeln!(out, "            if err := e.EncodeToken(xml.CharData(*item.{branch_field})); err != nil {{ return err }}");
+            } else {
+                let _ = writeln!(out, "            if err := e.EncodeElement(item.{branch_field}, xml.StartElement{{Name: xml.Name{{Local: {:?}}}}}); err != nil {{ return err }}", branch.xml_name);
+            }
+            out.push_str("            continue\n        }\n");
+        }
+        out.push_str("        return fmt.Errorf(\"mixed content item has no selected branch\")\n    }\n    return e.EncodeToken(start.End())\n}\n\n");
+    }
+
     fn resolve_field_type(&self, f: &FieldDef) -> String {
         let base_type = self.context.map_type_ref(&f.type_ref);
 

{polyxml-0.28.0 → polyxml-0.29.0}/crates/polyxml-core/src/codegen/java/codec.rs

@@ -179,7 +179,7 @@ impl JavaCodegen {
                     out.push_str("            String text = reader.getElementText();\n");
                     for b in &u.branches {
                         let expr = self.parse_scalar(&b.type_ref, "text", ir);
-                        let variant = to_java_type_name(&b.variant_name);
+                        let variant = union_variant_name(b);
                         let _ = writeln!(out, "            try {{ return new {name}.{variant}({expr}); }} catch (RuntimeException ignored) {{ }}");
                     }
                     let _ = writeln!(out, "            throw new XMLStreamException(\"No {} union member accepts: \" + text);", name);
@@ -187,7 +187,7 @@ impl JavaCodegen {
                     let _=writeln!(out,"            {name} result = null;\n            while (reader.hasNext()) {{\n                int event = reader.next();\n                if (event == XMLStreamConstants.END_ELEMENT) return result;\n                if (event != XMLStreamConstants.START_ELEMENT) continue;");
                     for (i, b) in u.branches.iter().enumerate() {
                         let expr = self.read_value(&b.type_ref, ir);
-                        let variant = to_java_type_name(&b.variant_name);
+                        let variant = union_variant_name(b);
                         let _=writeln!(out,"                {}if (reader.getLocalName().equals({:?})) result = new {name}.{variant}({expr});",if i==0 {""}else{"else "},b.xml_name);
                     }
                     out.push_str("                else skip(reader);\n            }\n            return result;\n");
@@ -228,7 +228,7 @@ impl JavaCodegen {
             }
             TypeDef::Union(u) => {
                 for (i, b) in u.branches.iter().enumerate() {
-                    let variant = to_java_type_name(&b.variant_name);
+                    let variant = union_variant_name(b);
                     let _ = writeln!(
                         out,
                         "        {}if (value instanceof {name}.{variant} branch) {{",
@@ -242,6 +242,8 @@ impl JavaCodegen {
                     if u.is_lexical() {
                         let text = self.format_scalar(&b.type_ref, access, ir);
                         let _ = writeln!(out, "            writer.writeCharacters({text});");
+                    } else if u.is_mixed_content() && b.xml_name == "#text" {
+                        let _ = writeln!(out, "            writer.writeCharacters({access});");
                     } else {
                         self.emit_write_value(
                             &mut out,
@@ -296,6 +298,26 @@ impl JavaCodegen {
         if text_field.is_some() {
             out.push_str("                if (event == XMLStreamConstants.CHARACTERS || event == XMLStreamConstants.CDATA) text.append(reader.getText());\n");
         }
+        if s.is_mixed {
+            if let Some((field, id, union)) = fields.iter().find_map(|(field, id)| {
+                self.resolve_union_def(&field.type_ref, ir)
+                    .filter(|union| union.is_mixed_content())
+                    .map(|union| (field, id, union))
+            }) {
+                let union_name = type_ident(&union.qname);
+                let text_branch = union
+                    .branches
+                    .iter()
+                    .find(|branch| branch.xml_name == "#text");
+                if let Some(text_branch) = text_branch {
+                    let variant = union_variant_name(text_branch);
+                    let val = format!("new {union_name}.{variant}(reader.getText())");
+                    out.push_str("                if (event == XMLStreamConstants.CHARACTERS || event == XMLStreamConstants.CDATA || event == XMLStreamConstants.SPACE) {\n");
+                    self.assign_value(out, field, id, &val, "                    ");
+                    out.push_str("                    continue;\n                }\n");
+                }
+            }
+        }
         out.push_str("                if (event != XMLStreamConstants.START_ELEMENT) continue;\n");
         let mut first = true;
         for (f, id) in &fields {
@@ -306,6 +328,9 @@ impl JavaCodegen {
                 if let Some(u) = self.resolve_union_def(&f.type_ref, ir) {
                     let union_name = type_ident(&u.qname);
                     for branch in &u.branches {
+                        if branch.xml_name == "#text" {
+                            continue;
+                        }
                         let _ = writeln!(
                             out,
                             "                {}if (reader.getLocalName().equals({:?})) {{",
@@ -314,7 +339,7 @@ impl JavaCodegen {
                         );
                         first = false;
                         let expr = self.read_value(&branch.type_ref, ir);
-                        let variant = to_java_type_name(&branch.variant_name);
+                        let variant = union_variant_name(branch);
                         let union_val = format!("new {union_name}.{variant}({expr})");
                         self.assign_value(out, f, id, &union_val, "                    ");
                         out.push_str("                }\n");

{polyxml-0.28.0 → polyxml-0.29.0}/crates/polyxml-core/src/codegen/java/mod.rs

@@ -13,7 +13,7 @@ use crate::codegen::{
 };
 use crate::ir::{
     EnumDef, PrimitiveType, QName, RestrictionFacets, SchemaIR, SimpleTypeDef, StructDef, TypeDef,
-    TypeRef, UnionDef,
+    TypeRef, UnionBranch, UnionDef,
 };
 
 /// Target backend for Java code emission.
@@ -218,6 +218,15 @@ pub(super) fn type_ident(q: &QName) -> String {
     lookup_type_name(q, || to_java_type_name(&q.local))
 }
 
+fn union_variant_name(branch: &UnionBranch) -> String {
+    let name = to_java_type_name(&branch.variant_name);
+    if matches!(&branch.type_ref, TypeRef::Named(qname) if type_ident(qname) == name) {
+        format!("{name}Branch")
+    } else {
+        name
+    }
+}
+
 /// Convert an XML enumeration variant name to SCREAMING_SNAKE_CASE for Java enum constants.
 pub fn to_java_enum_constant(name: &str) -> String {
     let normalized = normalize_symbol_name(name);
@@ -632,11 +641,7 @@ impl JavaCodegen {
             "public static "
         };
 
-        let variant_names: Vec<String> = u
-            .branches
-            .iter()
-            .map(|b| to_java_type_name(&b.variant_name))
-            .collect();
+        let variant_names: Vec<String> = u.branches.iter().map(union_variant_name).collect();
 
         let permits_clause = variant_names
             .iter()
@@ -656,7 +661,7 @@ impl JavaCodegen {
                 .branches
                 .iter()
                 .map(|b| {
-                    let vn = to_java_type_name(&b.variant_name);
+                    let vn = union_variant_name(b);
                     format!(
                         "@JsonSubTypes.Type(value = {}.{}.class, name = {:?})",
                         java_name, vn, b.xml_name
@@ -674,7 +679,7 @@ impl JavaCodegen {
         );
 
         for branch in &u.branches {
-            let variant_name = to_java_type_name(&branch.variant_name);
+            let variant_name = union_variant_name(branch);
             let branch_type = self.context.map_type_ref(&branch.type_ref);
 
             if let Some(ref doc) = branch.documentation {

{polyxml-0.28.0 → polyxml-0.29.0}/crates/polyxml-core/src/codegen/python/mod.rs

@@ -519,6 +519,32 @@ impl PythonCodegen {
     fn emit_union(&self, out: &mut String, u: &UnionDef) {
         let union_name = type_ident(&u.qname);
 
+        if u.is_mixed_content() {
+            let value_types = u
+                .branches
+                .iter()
+                .map(|branch| self.context.map_type_ref(&branch.type_ref))
+                .collect::<Vec<_>>();
+            let value_type = value_types
+                .into_iter()
+                .collect::<std::collections::BTreeSet<_>>()
+                .into_iter()
+                .collect::<Vec<_>>()
+                .join(" | ");
+            if self.options.backend == PythonBackend::Pydantic {
+                let _ = writeln!(out, "class {}(BaseModel):", union_name);
+            } else {
+                let _ = writeln!(
+                    out,
+                    "@dataclass(slots=True, kw_only=True)\nclass {}:",
+                    union_name
+                );
+            }
+            out.push_str("    kind: str\n");
+            let _ = writeln!(out, "    value: {}", value_type);
+            return;
+        }
+
         if let Some(ref doc) = u.documentation {
             let _ = writeln!(out, "# {}", doc.trim());
         }
@@ -595,7 +621,7 @@ impl PythonCodegen {
             has_body = true;
         }
 
-        if self.options.emit_meta {
+        if self.options.emit_meta || s.is_mixed {
             if has_body {
                 out.push('\n');
             }
@@ -610,6 +636,38 @@ impl PythonCodegen {
             if s.is_abstract {
                 out.push_str("        abstract = True\n");
             }
+            if s.is_mixed {
+                if let Some(item_field) = s
+                    .fields
+                    .iter()
+                    .find(|field| field.xml_name.is_empty() && field.kind == FieldKind::Element)
+                {
+                    let _ = writeln!(out, "        mixed_items = {:?}", item_field.name);
+                }
+                if let Some(union) = s.fields.iter().find_map(|field| match &field.type_ref {
+                    TypeRef::Named(qname) => match ir.types.get(qname) {
+                        Some(TypeDef::Union(union)) if union.is_mixed_content() => Some(union),
+                        _ => None,
+                    },
+                    _ => None,
+                }) {
+                    out.push_str("        mixed_branches = (\n");
+                    for branch in &union.branches {
+                        let branch_type = self.context.map_type_ref(&branch.type_ref);
+                        let namespace = branch
+                            .namespace
+                            .as_ref()
+                            .map(|ns| format!("{ns:?}"))
+                            .unwrap_or_else(|| "None".into());
+                        let _ = writeln!(
+                            out,
+                            "            ({:?}, {:?}, {}, {:?}),",
+                            branch.variant_name, branch.xml_name, namespace, branch_type
+                        );
+                    }
+                    out.push_str("        )\n");
+                }
+            }
             has_body = true;
         }