polyxml 0.12.0__tar.gz → 0.14.0__tar.gz

{polyxml-0.12.0 → polyxml-0.14.0}/Cargo.lock

@@ -549,7 +549,7 @@ dependencies = [
 
 [[package]]
 name = "polyxml"
-version = "0.12.0"
+version = "0.14.0"
 dependencies = [
  "criterion",
  "heck",
@@ -559,6 +559,7 @@ dependencies = [
  "pretty_assertions",
  "quick-xml",
  "serde",
+ "serde_json",
  "smallvec",
  "tempfile",
  "thiserror",
@@ -566,14 +567,14 @@ dependencies = [
 
 [[package]]
 name = "polyxml-c"
-version = "0.12.0"
+version = "0.14.0"
 dependencies = [
  "polyxml",
 ]
 
 [[package]]
 name = "polyxml-cli"
-version = "0.12.0"
+version = "0.14.0"
 dependencies = [
  "clap",
  "glob",
@@ -587,7 +588,7 @@ dependencies = [
 
 [[package]]
 name = "polyxml-js"
-version = "0.12.0"
+version = "0.14.0"
 dependencies = [
  "napi",
  "napi-build",
@@ -597,7 +598,7 @@ dependencies = [
 
 [[package]]
 name = "polyxml-python"
-version = "0.12.0"
+version = "0.14.0"
 dependencies = [
  "lexical-core",
  "polyxml",

{polyxml-0.12.0 → polyxml-0.14.0}/Cargo.toml

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

{polyxml-0.12.0 → polyxml-0.14.0}/PKG-INFO

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

{polyxml-0.12.0 → polyxml-0.14.0}/crates/polyxml-core/Cargo.toml

@@ -17,6 +17,7 @@ memchr = "2.8"
 thiserror = "2.0"
 smallvec = "1.16"
 serde = { version = "1.0", features = ["derive"] }
+serde_json = "1.0"
 minijinja = { version = "2.8", features = ["builtins"] }
 heck = "0.5"
 

{polyxml-0.12.0 → polyxml-0.14.0}/crates/polyxml-core/src/codegen/csharp/mod.rs

@@ -31,6 +31,8 @@ pub struct CSharpOptions {
     pub namespace: String,
     /// Emit System.Xml.Serialization attributes ([XmlElement], [XmlAttribute], etc.)
     pub emit_xml_attributes: bool,
+    /// Emit System.Text.Json.Serialization attributes ([JsonPropertyName], etc.)
+    pub emit_json_attributes: bool,
     /// Emit IValidatableObject and restriction facet validation logic
     pub emit_validation: bool,
     /// Record emission kind (record class vs record struct)
@@ -46,6 +48,7 @@ impl Default for CSharpOptions {
         Self {
             namespace: "Generated".to_string(),
             emit_xml_attributes: true,
+            emit_json_attributes: true,
             emit_validation: true,
             record_kind: CSharpRecordKind::Class,
             use_file_scoped_namespaces: true,
@@ -225,6 +228,9 @@ impl CSharpCodegen {
         if self.options.emit_xml_attributes {
             writeln!(out, "using System.Xml.Serialization;").unwrap();
         }
+        if self.options.emit_json_attributes {
+            writeln!(out, "using System.Text.Json.Serialization;").unwrap();
+        }
         writeln!(out).unwrap();
 
         let ns = to_csharp_namespace(&self.options.namespace);
@@ -288,6 +294,14 @@ impl CSharpCodegen {
             self.emit_docstring(out, doc, indent);
         }
 
+        if self.options.emit_json_attributes {
+            writeln!(
+                out,
+                "{}[JsonConverter(typeof(JsonStringEnumConverter))]",
+                indent
+            )
+            .unwrap();
+        }
         writeln!(out, "{}public enum {}", indent, enum_name).unwrap();
         writeln!(out, "{}{{", indent).unwrap();
 
@@ -425,10 +439,17 @@ impl CSharpCodegen {
                 self.emit_docstring(out, doc, &format!("{}    ", indent));
             }
 
-            let xml_attr = if self.options.emit_xml_attributes {
-                format!("[property: XmlElement(\"{}\")] ", branch.xml_name)
-            } else {
+            let mut branch_attrs = Vec::new();
+            if self.options.emit_xml_attributes {
+                branch_attrs.push(format!("XmlElement(\"{}\")", branch.xml_name));
+            }
+            if self.options.emit_json_attributes {
+                branch_attrs.push(format!("JsonPropertyName(\"{}\")", branch.xml_name));
+            }
+            let xml_attr = if branch_attrs.is_empty() {
                 String::new()
+            } else {
+                format!("[property: {}] ", branch_attrs.join(", "))
             };
 
             writeln!(
@@ -529,11 +550,7 @@ impl CSharpCodegen {
 
             let default_val = if can_have_default { " = null" } else { "" };
 
-            let xml_attr = if self.options.emit_xml_attributes {
-                self.build_field_xml_attribute(f, ir)
-            } else {
-                String::new()
-            };
+            let field_attrs = self.build_field_attributes(f, ir);
 
             if let Some(ref doc) = f.documentation {
                 self.emit_docstring(out, doc, &format!("{}    ", indent));
@@ -542,7 +559,7 @@ impl CSharpCodegen {
             writeln!(
                 out,
                 "{}    {}{} {}{}{}",
-                indent, xml_attr, field_type, prop_name, default_val, comma
+                indent, field_attrs, field_type, prop_name, default_val, comma
             )
             .unwrap();
         }
@@ -709,31 +726,48 @@ impl CSharpCodegen {
         }
     }
 
-    fn build_field_xml_attribute(&self, f: &FieldDef, ir: &SchemaIR) -> String {
-        // If the field is a choice (UnionDef), emit [property: XmlElement("branchXml", typeof(BranchType))]
-        if let TypeRef::Named(ref qname) = f.type_ref {
-            if let Some(TypeDef::Union(u)) = ir.types.get(qname) {
-                let choice_name = to_csharp_type_name(&u.qname.local);
-                let mut attrs = Vec::new();
-                for branch in &u.branches {
-                    let variant_name = to_csharp_type_name(&branch.variant_name);
-                    attrs.push(format!(
-                        "[property: XmlElement(\"{}\", typeof({}.{}))]",
-                        branch.xml_name, choice_name, variant_name
-                    ));
+    fn build_field_attributes(&self, f: &FieldDef, ir: &SchemaIR) -> String {
+        let mut parts = Vec::new();
+
+        if self.options.emit_xml_attributes {
+            // If the field is a choice (UnionDef), emit XmlElement("branchXml", typeof(BranchType))
+            if let TypeRef::Named(ref qname) = f.type_ref {
+                if let Some(TypeDef::Union(u)) = ir.types.get(qname) {
+                    let choice_name = to_csharp_type_name(&u.qname.local);
+                    for branch in &u.branches {
+                        let variant_name = to_csharp_type_name(&branch.variant_name);
+                        parts.push(format!(
+                            "XmlElement(\"{}\", typeof({}.{}))",
+                            branch.xml_name, choice_name, variant_name
+                        ));
+                    }
                 }
-                if !attrs.is_empty() {
-                    return format!("{} ", attrs.join(" "));
+            }
+            if parts.is_empty() {
+                match f.kind {
+                    FieldKind::Attribute => parts.push(format!("XmlAttribute(\"{}\")", f.xml_name)),
+                    FieldKind::Text => parts.push("XmlText".to_string()),
+                    FieldKind::Any => parts.push("XmlAnyElement".to_string()),
+                    FieldKind::AnyAttribute => parts.push("XmlAnyAttribute".to_string()),
+                    FieldKind::Element => parts.push(format!("XmlElement(\"{}\")", f.xml_name)),
                 }
             }
         }
 
-        match f.kind {
-            FieldKind::Attribute => format!("[property: XmlAttribute(\"{}\")] ", f.xml_name),
-            FieldKind::Text => "[property: XmlText] ".to_string(),
-            FieldKind::Any => "[property: XmlAnyElement] ".to_string(),
-            FieldKind::AnyAttribute => "[property: XmlAnyAttribute] ".to_string(),
-            FieldKind::Element => format!("[property: XmlElement(\"{}\")] ", f.xml_name),
+        if self.options.emit_json_attributes {
+            let json_name = match f.kind {
+                FieldKind::Text => "value",
+                _ => &f.xml_name,
+            };
+            if f.kind != FieldKind::Any && f.kind != FieldKind::AnyAttribute {
+                parts.push(format!("JsonPropertyName(\"{}\")", json_name));
+            }
+        }
+
+        if parts.is_empty() {
+            String::new()
+        } else {
+            format!("[property: {}] ", parts.join(", "))
         }
     }
 

{polyxml-0.12.0 → polyxml-0.14.0}/crates/polyxml-core/src/codegen/go/mod.rs

@@ -16,6 +16,8 @@ pub struct GoOptions {
     pub package_name: String,
     /// Emit encoding/xml tags (default: true)
     pub emit_xml_tags: bool,
+    /// Emit encoding/json tags (default: true)
+    pub emit_json_tags: bool,
     /// Emit custom UnmarshalXML/MarshalXML for xs:choice mutual exclusivity validation (default: true)
     pub validate_choice_exclusivity: bool,
     /// Emit Validate() error method for restriction facets (default: true)
@@ -29,6 +31,7 @@ impl Default for GoOptions {
         Self {
             package_name: "models".to_string(),
             emit_xml_tags: true,
+            emit_json_tags: true,
             validate_choice_exclusivity: true,
             validate_facets: true,
             emit_root_aliases: true,
@@ -540,7 +543,11 @@ impl GoCodegen {
 
         // Emit XMLName if xml tags enabled
         if self.options.emit_xml_tags {
-            writeln!(out, "    XMLName xml.Name").unwrap();
+            if self.options.emit_json_tags {
+                writeln!(out, "    XMLName xml.Name `json:\"-\"`").unwrap();
+            } else {
+                writeln!(out, "    XMLName xml.Name").unwrap();
+            }
         }
 
         // Struct composition / inheritance if base struct exists
@@ -562,10 +569,17 @@ impl GoCodegen {
                 .iter()
                 .any(|f| f.name == "value" || f.kind == FieldKind::Text);
             if !has_value_field {
-                let tag = if self.options.emit_xml_tags {
-                    " `xml:\",chardata\"`"
+                let mut parts = Vec::new();
+                if self.options.emit_xml_tags {
+                    parts.push("xml:\",chardata\"".to_string());
+                }
+                if self.options.emit_json_tags {
+                    parts.push("json:\"value,omitempty\"".to_string());
+                }
+                let tag = if parts.is_empty() {
+                    String::new()
                 } else {
-                    ""
+                    format!(" `{}`", parts.join(" "))
                 };
                 writeln!(out, "    Value {}{}", base_type_str, tag).unwrap();
             }
@@ -579,7 +593,7 @@ impl GoCodegen {
 
             let field_name = to_go_field_name(&f.name);
             let field_type = self.resolve_field_type(f);
-            let tag = self.build_field_xml_tag(f);
+            let tag = self.build_field_struct_tags(f);
             writeln!(out, "    {} {}{}", field_name, field_type, tag).unwrap();
         }
 
@@ -606,30 +620,52 @@ impl GoCodegen {
         }
     }
 
-    fn build_field_xml_tag(&self, f: &FieldDef) -> String {
-        if !self.options.emit_xml_tags {
-            return String::new();
-        }
+    fn build_field_struct_tags(&self, f: &FieldDef) -> String {
+        let mut parts = Vec::new();
 
-        let is_opt = f.cardinality.is_optional() || f.nillable;
-        match f.kind {
-            FieldKind::Attribute => {
-                if is_opt {
-                    format!(" `xml:\"{},attr,omitempty\"`", f.xml_name)
-                } else {
-                    format!(" `xml:\"{},attr\"`", f.xml_name)
+        if self.options.emit_xml_tags {
+            let is_opt = f.cardinality.is_optional() || f.nillable;
+            let xml_val = match f.kind {
+                FieldKind::Attribute => {
+                    if is_opt {
+                        format!("{},attr,omitempty", f.xml_name)
+                    } else {
+                        format!("{},attr", f.xml_name)
+                    }
                 }
-            }
-            FieldKind::Text => " `xml:\",chardata\"`".to_string(),
-            FieldKind::Any => " `xml:\",any\"`".to_string(),
-            FieldKind::AnyAttribute => " `xml:\",any,attr\"`".to_string(),
-            FieldKind::Element => {
-                if is_opt {
-                    format!(" `xml:\"{},omitempty\"`", f.xml_name)
-                } else {
-                    format!(" `xml:\"{}\"`", f.xml_name)
+                FieldKind::Text => ",chardata".to_string(),
+                FieldKind::Any => ",any".to_string(),
+                FieldKind::AnyAttribute => ",any,attr".to_string(),
+                FieldKind::Element => {
+                    if is_opt {
+                        format!("{},omitempty", f.xml_name)
+                    } else {
+                        f.xml_name.clone()
+                    }
                 }
-            }
+            };
+            parts.push(format!("xml:\"{}\"", xml_val));
+        }
+
+        if self.options.emit_json_tags {
+            let is_opt = f.cardinality.is_optional() || f.nillable;
+            let json_name = if f.kind == FieldKind::Text {
+                "value".to_string()
+            } else {
+                f.xml_name.clone()
+            };
+            let json_val = if is_opt {
+                format!("{},omitempty", json_name)
+            } else {
+                json_name
+            };
+            parts.push(format!("json:\"{}\"", json_val));
+        }
+
+        if parts.is_empty() {
+            String::new()
+        } else {
+            format!(" `{}`", parts.join(" "))
         }
     }
 

{polyxml-0.12.0 → polyxml-0.14.0}/crates/polyxml-core/src/codegen/python/mod.rs

@@ -38,6 +38,7 @@ pub struct PythonOptions {
     pub emit_meta: bool,
     pub emit_root_aliases: bool,
     pub emit_codecs: bool,
+    pub emit_json_metadata: bool,
 }
 
 impl Default for PythonOptions {
@@ -50,6 +51,7 @@ impl Default for PythonOptions {
             emit_meta: true,
             emit_root_aliases: true,
             emit_codecs: true,
+            emit_json_metadata: true,
         }
     }
 }
@@ -529,7 +531,23 @@ impl PythonCodegen {
             out.push_str("    ) -> bytes:\n");
             out.push_str("        \"\"\"Serialize this model instance into XML bytes.\"\"\"\n");
             out.push_str("        import polyxml\n");
-            out.push_str("        return polyxml.serialize(self, indent=indent, namespaces=namespaces, ns_map=ns_map)\n");
+            out.push_str("        return polyxml.serialize(self, indent=indent, namespaces=namespaces, ns_map=ns_map)\n\n");
+            out.push_str("    @classmethod\n");
+            out.push_str("    def from_json(cls, data: bytes | str) -> Self:\n");
+            out.push_str("        \"\"\"Deserialize JSON bytes or string into this model.\"\"\"\n");
+            out.push_str("        import polyxml\n");
+            out.push_str("        return polyxml.deserialize_json(data, cls)\n\n");
+            out.push_str("    def to_json(\n");
+            out.push_str("        self,\n");
+            out.push_str("        *,\n");
+            out.push_str("        indent: int | None = None,\n");
+            out.push_str("        by_alias: bool = True,\n");
+            out.push_str("    ) -> bytes:\n");
+            out.push_str("        \"\"\"Serialize this model instance into JSON bytes.\"\"\"\n");
+            out.push_str("        import polyxml\n");
+            out.push_str(
+                "        return polyxml.serialize_json(self, indent=indent, by_alias=by_alias)\n",
+            );
             has_body = true;
         }
 
@@ -563,7 +581,7 @@ impl PythonCodegen {
                 self.format_dataclass_field(field, is_list, &inner_type, &meta_dict)
             }
             PythonBackend::Pydantic => {
-                self.format_pydantic_field(field, is_list, &inner_type, &meta_dict)
+                self.format_pydantic_field(field, py_name, is_list, &inner_type, &meta_dict)
             }
         };
 
@@ -616,6 +634,7 @@ impl PythonCodegen {
     fn format_pydantic_field(
         &self,
         field: &FieldDef,
+        py_name: &str,
         is_list: bool,
         base_type: &str,
         meta_dict: &str,
@@ -626,11 +645,16 @@ impl PythonCodegen {
             .map(|f| self.format_pydantic_facets(f))
             .unwrap_or_default();
 
-        let extra_clause = if facet_args.is_empty() {
-            format!("json_schema_extra={}", meta_dict)
-        } else {
-            format!("json_schema_extra={}, {}", meta_dict, facet_args)
-        };
+        let mut clauses = Vec::new();
+        if self.options.emit_json_metadata && py_name != field.xml_name {
+            clauses.push(format!("alias=\"{}\"", field.xml_name));
+            clauses.push(format!("serialization_alias=\"{}\"", field.xml_name));
+        }
+        clauses.push(format!("json_schema_extra={}", meta_dict));
+        if !facet_args.is_empty() {
+            clauses.push(facet_args);
+        }
+        let extra_clause = clauses.join(", ");
 
         if is_list {
             (
@@ -675,6 +699,9 @@ impl PythonCodegen {
         let mut parts = Vec::new();
         parts.push(format!("\"type\": \"{}\"", kind_str));
         parts.push(format!("\"name\": \"{}\"", field.xml_name));
+        if self.options.emit_json_metadata {
+            parts.push(format!("\"json_name\": \"{}\"", field.xml_name));
+        }
 
         if let Some(ref ns) = field.namespace {
             parts.push(format!("\"namespace\": \"{}\"", ns));

{polyxml-0.12.0 → polyxml-0.14.0}/crates/polyxml-core/src/codegen/rust/mod.rs

@@ -1240,6 +1240,36 @@ impl RustCodegen {
         out.push_str("        String::from_utf8(bytes).map_err(|e| PolyXmlError::Utf8Error(e.utf8_error()))\n");
         out.push_str("    }\n\n");
 
+        if self.options.derive_serde {
+            let from_json_sig = if needs_lifetime {
+                "pub fn from_json_str(json_str: &'a str) -> std::result::Result<Self, serde_json::Error>"
+            } else {
+                "pub fn from_json_str(json_str: &str) -> std::result::Result<Self, serde_json::Error>"
+            };
+            let _ = writeln!(out, "    {}", from_json_sig);
+            out.push_str("    {\n");
+            out.push_str("        serde_json::from_str(json_str)\n");
+            out.push_str("    }\n\n");
+
+            let from_json_slice_sig = if needs_lifetime {
+                "pub fn from_json_slice(bytes: &'a [u8]) -> std::result::Result<Self, serde_json::Error>"
+            } else {
+                "pub fn from_json_slice(bytes: &[u8]) -> std::result::Result<Self, serde_json::Error>"
+            };
+            let _ = writeln!(out, "    {}", from_json_slice_sig);
+            out.push_str("    {\n");
+            out.push_str("        serde_json::from_slice(bytes)\n");
+            out.push_str("    }\n\n");
+
+            out.push_str("    pub fn to_json_string(&self) -> std::result::Result<String, serde_json::Error> {\n");
+            out.push_str("        serde_json::to_string(self)\n");
+            out.push_str("    }\n\n");
+
+            out.push_str("    pub fn to_json_vec(&self) -> std::result::Result<Vec<u8>, serde_json::Error> {\n");
+            out.push_str("        serde_json::to_vec(self)\n");
+            out.push_str("    }\n\n");
+        }
+
         out.push_str("    pub fn encode_xml<W: std::io::Write>(&self, writer: &mut Writer<W>, tag_name: Option<&str>) -> Result<()> {\n");
         let _ = writeln!(
             out,
@@ -1860,13 +1890,40 @@ impl RustCodegen {
         out.push_str("    }\n\n");
 
         out.push_str("    pub fn to_xml_string(&self) -> Result<String> {\n");
-        out.push_str(
-            "        let bytes = self.to_xml()?;
-",
-        );
+        out.push_str("        let bytes = self.to_xml()?;\n");
         out.push_str("        String::from_utf8(bytes).map_err(|e| PolyXmlError::Utf8Error(e.utf8_error()))\n");
         out.push_str("    }\n\n");
 
+        if self.options.derive_serde {
+            let from_json_sig = if needs_lifetime {
+                "pub fn from_json_str(json_str: &'a str) -> std::result::Result<Self, serde_json::Error>"
+            } else {
+                "pub fn from_json_str(json_str: &str) -> std::result::Result<Self, serde_json::Error>"
+            };
+            let _ = writeln!(out, "    {}", from_json_sig);
+            out.push_str("    {\n");
+            out.push_str("        serde_json::from_str(json_str)\n");
+            out.push_str("    }\n\n");
+
+            let from_json_slice_sig = if needs_lifetime {
+                "pub fn from_json_slice(bytes: &'a [u8]) -> std::result::Result<Self, serde_json::Error>"
+            } else {
+                "pub fn from_json_slice(bytes: &[u8]) -> std::result::Result<Self, serde_json::Error>"
+            };
+            let _ = writeln!(out, "    {}", from_json_slice_sig);
+            out.push_str("    {\n");
+            out.push_str("        serde_json::from_slice(bytes)\n");
+            out.push_str("    }\n\n");
+
+            out.push_str("    pub fn to_json_string(&self) -> std::result::Result<String, serde_json::Error> {\n");
+            out.push_str("        serde_json::to_string(self)\n");
+            out.push_str("    }\n\n");
+
+            out.push_str("    pub fn to_json_vec(&self) -> std::result::Result<Vec<u8>, serde_json::Error> {\n");
+            out.push_str("        serde_json::to_vec(self)\n");
+            out.push_str("    }\n\n");
+        }
+
         out.push_str("    pub fn encode_xml<W: std::io::Write>(&self, writer: &mut Writer<W>, tag_name: Option<&str>) -> Result<()> {\n");
         out.push_str("        match self {\n");
         for branch in &u.branches {

{polyxml-0.12.0 → polyxml-0.14.0}/crates/polyxml-core/src/error.rs

@@ -49,6 +49,9 @@ pub enum PolyXmlError {
 
     #[error("I/O error: {0}")]
     IoError(#[from] std::io::Error),
+
+    #[error("JSON error: {0}")]
+    JsonError(#[from] serde_json::Error),
 }
 
 pub type Result<T> = std::result::Result<T, PolyXmlError>;