polyxml 0.15.0__tar.gz → 0.17.0__tar.gz

{polyxml-0.15.0 → polyxml-0.17.0}/Cargo.lock

@@ -549,7 +549,7 @@ dependencies = [
 
 [[package]]
 name = "polyxml"
-version = "0.15.0"
+version = "0.17.0"
 dependencies = [
  "criterion",
  "heck",
@@ -567,14 +567,14 @@ dependencies = [
 
 [[package]]
 name = "polyxml-c"
-version = "0.15.0"
+version = "0.17.0"
 dependencies = [
  "polyxml",
 ]
 
 [[package]]
 name = "polyxml-cli"
-version = "0.15.0"
+version = "0.17.0"
 dependencies = [
  "clap",
  "glob",
@@ -588,7 +588,7 @@ dependencies = [
 
 [[package]]
 name = "polyxml-js"
-version = "0.15.0"
+version = "0.17.0"
 dependencies = [
  "napi",
  "napi-build",
@@ -598,7 +598,7 @@ dependencies = [
 
 [[package]]
 name = "polyxml-python"
-version = "0.15.0"
+version = "0.17.0"
 dependencies = [
  "lexical-core",
  "polyxml",

{polyxml-0.15.0 → polyxml-0.17.0}/Cargo.toml

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

{polyxml-0.15.0 → polyxml-0.17.0}/PKG-INFO

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

{polyxml-0.15.0 → polyxml-0.17.0}/crates/polyxml-core/src/codegen/cpp/mod.rs

@@ -20,6 +20,40 @@ pub enum CppMode {
     Module,
 }
 
+impl CppMode {
+    pub fn from_str_loose(s: &str) -> Option<Self> {
+        match s.to_lowercase().trim() {
+            "header" | "headeronly" | "header-only" | "headers" | "hpp" => Some(Self::HeaderOnly),
+            "module" | "modules" | "cppm" | "c++20-modules" => Some(Self::Module),
+            _ => None,
+        }
+    }
+}
+
+/// Target backend for C++ serialization/reflection metadata.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Default, Serialize, Deserialize)]
+pub enum CppBackend {
+    /// Zero-dependency standard C++20 (default)
+    #[default]
+    Standard,
+    /// Glaze compile-time reflectionless serde (`glz::meta`)
+    Glaze,
+}
+
+impl CppBackend {
+    pub fn from_str_loose(s: &str) -> Option<Self> {
+        match s.to_lowercase().trim() {
+            "standard" | "std" | "default" | "none" => Some(Self::Standard),
+            "glaze" | "glz" => Some(Self::Glaze),
+            _ => None,
+        }
+    }
+
+    pub fn is_glaze(self) -> bool {
+        matches!(self, Self::Glaze)
+    }
+}
+
 /// Options configuring modern C++20/C++23 code generation.
 #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
 pub struct CppOptions {
@@ -27,6 +61,8 @@ pub struct CppOptions {
     pub namespace: String,
     /// Header-only (.hpp) or C++20 Module (.cppm) mode (default: HeaderOnly)
     pub mode: CppMode,
+    /// Target serialization and metadata backend (default: Standard)
+    pub backend: CppBackend,
     /// Standard language dialect (default: "c++20")
     pub standard: String,
     /// Emit C++20 defaulted equality operators `bool operator==(const T&) const = default;` (default: true)
@@ -48,6 +84,7 @@ impl Default for CppOptions {
         Self {
             namespace: "polyxml::generated".to_string(),
             mode: CppMode::HeaderOnly,
+            backend: CppBackend::Standard,
             standard: "c++20".to_string(),
             emit_equality_operators: true,
             emit_enum_converters: true,
@@ -229,6 +266,11 @@ impl CppCodegen {
         self.emit_root_aliases(&mut out, ir);
 
         writeln!(out, "\n}} // namespace {}", ns).unwrap();
+
+        if self.options.backend.is_glaze() {
+            self.emit_glaze_meta(&mut out, ir);
+        }
+
         out
     }
 
@@ -261,6 +303,11 @@ impl CppCodegen {
         self.emit_root_aliases(&mut out, ir);
 
         writeln!(out, "\n}} // namespace {}", ns).unwrap();
+
+        if self.options.backend.is_glaze() {
+            self.emit_glaze_meta(&mut out, ir);
+        }
+
         out
     }
 
@@ -314,8 +361,26 @@ impl CppCodegen {
     /// Generate CMakeLists.txt definition for integration via add_subdirectory or FetchContent.
     pub fn generate_cmake(&self, project_name: &str) -> String {
         let safe_name = AsSnakeCase(project_name).to_string();
-        format!(
-            r#"cmake_minimum_required(VERSION 3.20)
+        if self.options.mode == CppMode::Module {
+            format!(
+                r#"cmake_minimum_required(VERSION 3.28)
+project({safe_name}_models LANGUAGES CXX)
+
+set(CMAKE_CXX_STANDARD 20)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+
+add_library({safe_name})
+target_sources({safe_name}
+    PUBLIC
+        FILE_SET CXX_MODULES FILES
+            {safe_name}.cppm
+)
+target_compile_features({safe_name} PUBLIC cxx_std_20)
+"#
+            )
+        } else {
+            format!(
+                r#"cmake_minimum_required(VERSION 3.20)
 project({safe_name}_models LANGUAGES CXX)
 
 set(CMAKE_CXX_STANDARD 20)
@@ -328,7 +393,8 @@ target_include_directories({safe_name} INTERFACE
 )
 target_compile_features({safe_name} INTERFACE cxx_std_20)
 "#
-        )
+            )
+        }
     }
 
     /// Generate standalone PolyXMLConfig.cmake for `find_package(PolyXML)`.
@@ -372,7 +438,93 @@ endif()
         writeln!(out, "#include <string>").unwrap();
         writeln!(out, "#include <string_view>").unwrap();
         writeln!(out, "#include <variant>").unwrap();
-        writeln!(out, "#include <vector>\n").unwrap();
+        writeln!(out, "#include <vector>").unwrap();
+
+        if self.options.backend.is_glaze() {
+            writeln!(out, "#include <glaze/glaze.hpp>").unwrap();
+        }
+        writeln!(out).unwrap();
+    }
+
+    fn emit_glaze_meta(&self, out: &mut String, ir: &SchemaIR) {
+        let ns = to_cpp_namespace(&self.options.namespace);
+        writeln!(out, "\n// Glaze compile-time reflection metadata\n").unwrap();
+
+        // 1. Enums
+        for type_def in ir.types.values() {
+            if let TypeDef::Enum(enum_def) = type_def {
+                let enum_name = to_cpp_type_name(&enum_def.qname.local);
+                let full_type = format!("{}::{}", ns, enum_name);
+                writeln!(out, "template <>").unwrap();
+                writeln!(out, "struct glz::meta<{}> {{", full_type).unwrap();
+                writeln!(out, "    using T = {};", full_type).unwrap();
+                if enum_def.variants.is_empty() {
+                    writeln!(out, "    static constexpr auto value = enumerate();").unwrap();
+                } else {
+                    writeln!(out, "    static constexpr auto value = enumerate(").unwrap();
+                    for (i, v) in enum_def.variants.iter().enumerate() {
+                        let var_name = to_cpp_enum_variant(&v.name);
+                        let comma = if i + 1 < enum_def.variants.len() {
+                            ","
+                        } else {
+                            ""
+                        };
+                        writeln!(out, "        {:?}, T::{}{}", v.value, var_name, comma).unwrap();
+                    }
+                    writeln!(out, "    );").unwrap();
+                }
+                writeln!(out, "}};\n").unwrap();
+            }
+        }
+
+        // 2. Structs
+        let sorted_qnames = self.topological_sort_types(ir);
+        for qname in sorted_qnames {
+            if let Some(TypeDef::Struct(s)) = ir.types.get(&qname) {
+                let struct_name = to_cpp_type_name(&s.qname.local);
+                let full_type = format!("{}::{}", ns, struct_name);
+                writeln!(out, "template <>").unwrap();
+                writeln!(out, "struct glz::meta<{}> {{", full_type).unwrap();
+                writeln!(out, "    using T = {};", full_type).unwrap();
+
+                let mut field_bindings = Vec::new();
+
+                // Check for simple_content_base "value"
+                if let Some(ref base_qname) = s.base_type {
+                    let has_value_field = s
+                        .fields
+                        .iter()
+                        .any(|f| f.name == "value" || f.kind == crate::ir::FieldKind::Text);
+                    if !has_value_field
+                        && (PrimitiveType::from_xsd_name(&base_qname.local).is_some()
+                            || matches!(ir.types.get(base_qname), Some(TypeDef::Simple(_))))
+                    {
+                        field_bindings.push(r#""value", &T::value"#.to_string());
+                    }
+                }
+
+                for f in &s.fields {
+                    let field_name = to_cpp_field_name(&f.name);
+                    field_bindings.push(format!("{:?}, &T::{}", f.xml_name, field_name));
+                }
+
+                if field_bindings.is_empty() {
+                    writeln!(out, "    static constexpr auto value = object();").unwrap();
+                } else {
+                    writeln!(out, "    static constexpr auto value = object(").unwrap();
+                    for (i, fb) in field_bindings.iter().enumerate() {
+                        let comma = if i + 1 < field_bindings.len() {
+                            ","
+                        } else {
+                            ""
+                        };
+                        writeln!(out, "        {}{}", fb, comma).unwrap();
+                    }
+                    writeln!(out, "    );").unwrap();
+                }
+                writeln!(out, "}};\n").unwrap();
+            }
+        }
     }
 
     fn emit_utilities(&self, out: &mut String) {

{polyxml-0.15.0 → polyxml-0.17.0}/crates/polyxml-core/src/codegen/csharp/mod.rs

@@ -24,6 +24,16 @@ pub enum CSharpRecordKind {
     Struct,
 }
 
+impl CSharpRecordKind {
+    pub fn from_str_loose(s: &str) -> Option<Self> {
+        match s.to_lowercase().trim() {
+            "class" | "record" | "record-class" | "reference" => Some(Self::Class),
+            "struct" | "record-struct" | "value" => Some(Self::Struct),
+            _ => None,
+        }
+    }
+}
+
 /// Options configuring C# 12 / .NET 8+ code generation.
 #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
 pub struct CSharpOptions {
@@ -33,6 +43,10 @@ pub struct CSharpOptions {
     pub emit_xml_attributes: bool,
     /// Emit System.Text.Json.Serialization attributes ([JsonPropertyName], etc.)
     pub emit_json_attributes: bool,
+    /// Emit System.Text.Json compile-time source generation context (JsonSerializerContext)
+    pub emit_source_gen: bool,
+    /// Name of the generated JsonSerializerContext partial class (default: "PolyXmlJsonContext")
+    pub source_gen_context_name: String,
     /// Emit IValidatableObject and restriction facet validation logic
     pub emit_validation: bool,
     /// Record emission kind (record class vs record struct)
@@ -49,6 +63,8 @@ impl Default for CSharpOptions {
             namespace: "Generated".to_string(),
             emit_xml_attributes: true,
             emit_json_attributes: true,
+            emit_source_gen: false,
+            source_gen_context_name: "PolyXmlJsonContext".to_string(),
             emit_validation: true,
             record_kind: CSharpRecordKind::Class,
             use_file_scoped_namespaces: true,
@@ -228,7 +244,7 @@ impl CSharpCodegen {
         if self.options.emit_xml_attributes {
             writeln!(out, "using System.Xml.Serialization;").unwrap();
         }
-        if self.options.emit_json_attributes {
+        if self.options.emit_json_attributes || self.options.emit_source_gen {
             writeln!(out, "using System.Text.Json.Serialization;").unwrap();
         }
         writeln!(out).unwrap();
@@ -274,6 +290,11 @@ impl CSharpCodegen {
             self.emit_root_elements(&mut out, ir, indent);
         }
 
+        // Emit Source Generator Context if requested
+        if self.options.emit_source_gen {
+            self.emit_source_gen_context(&mut out, ir, indent);
+        }
+
         if !self.options.use_file_scoped_namespaces {
             writeln!(out, "}}").unwrap();
         }
@@ -288,6 +309,64 @@ impl CSharpCodegen {
         vec![(filename, code)]
     }
 
+    fn emit_source_gen_context(&self, out: &mut String, ir: &SchemaIR, indent: &str) {
+        writeln!(out).unwrap();
+        writeln!(
+            out,
+            "{}/// <summary>\n{}/// Source-generated JsonSerializerContext for Native AOT and high-throughput serialization.\n{}/// </summary>",
+            indent, indent, indent
+        )
+        .unwrap();
+        writeln!(
+            out,
+            "{}[JsonSourceGenerationOptions(WriteIndented = true)]",
+            indent
+        )
+        .unwrap();
+
+        // Enums
+        for def in ir.types.values() {
+            if let TypeDef::Enum(e) = def {
+                let name = to_csharp_type_name(&e.qname.local);
+                writeln!(out, "{}[JsonSerializable(typeof({}))]", indent, name).unwrap();
+            }
+        }
+
+        // Simple types
+        for def in ir.types.values() {
+            if let TypeDef::Simple(s) = def {
+                let name = to_csharp_type_name(&s.qname.local);
+                writeln!(out, "{}[JsonSerializable(typeof({}))]", indent, name).unwrap();
+            }
+        }
+
+        // Unions
+        for def in ir.types.values() {
+            if let TypeDef::Union(u) = def {
+                let name = to_csharp_type_name(&u.qname.local);
+                writeln!(out, "{}[JsonSerializable(typeof({}))]", indent, name).unwrap();
+            }
+        }
+
+        // Structs
+        for def in ir.types.values() {
+            if let TypeDef::Struct(s) = def {
+                let name = to_csharp_type_name(&s.qname.local);
+                writeln!(out, "{}[JsonSerializable(typeof({}))]", indent, name).unwrap();
+                writeln!(out, "{}[JsonSerializable(typeof(List<{}>))]", indent, name).unwrap();
+            }
+        }
+
+        let ctx_name = &self.options.source_gen_context_name;
+        writeln!(
+            out,
+            "{}public partial class {} : JsonSerializerContext\n{}{{",
+            indent, ctx_name, indent
+        )
+        .unwrap();
+        writeln!(out, "{}}}", indent).unwrap();
+    }
+
     fn emit_enum(&self, out: &mut String, e: &EnumDef, indent: &str) {
         let enum_name = to_csharp_type_name(&e.qname.local);
         if let Some(ref doc) = e.documentation {

{polyxml-0.15.0 → polyxml-0.17.0}/crates/polyxml-core/src/codegen/go/mod.rs

@@ -9,9 +9,34 @@ use crate::ir::{
     StructDef, TypeDef, TypeRef, UnionDef,
 };
 
+/// Target serialization backend for Go codegen.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Default, Serialize, Deserialize)]
+pub enum GoBackend {
+    /// Standard library `encoding/json` and `encoding/xml` (default)
+    #[default]
+    Standard,
+    /// Mailru/EasyJSON static reflectionless serialization generator (`//easyjson:json`)
+    EasyJson,
+    /// ByteDance Sonic high-performance JIT serialization (`sonic:"..."` struct tags)
+    Sonic,
+}
+
+impl GoBackend {
+    pub fn from_str_loose(s: &str) -> Option<Self> {
+        match s.to_lowercase().trim() {
+            "standard" | "std" | "default" => Some(Self::Standard),
+            "easyjson" | "easy-json" | "easy_json" => Some(Self::EasyJson),
+            "sonic" | "bytedance" => Some(Self::Sonic),
+            _ => None,
+        }
+    }
+}
+
 /// Options configuring Go 1.22+ code generation.
 #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
 pub struct GoOptions {
+    /// Target serialization backend (default: GoBackend::Standard)
+    pub backend: GoBackend,
     /// Package name for generated Go code (default: "models")
     pub package_name: String,
     /// Emit encoding/xml tags (default: true)
@@ -29,6 +54,7 @@ pub struct GoOptions {
 impl Default for GoOptions {
     fn default() -> Self {
         Self {
+            backend: GoBackend::Standard,
             package_name: "models".to_string(),
             emit_xml_tags: true,
             emit_json_tags: true,
@@ -407,6 +433,10 @@ impl GoCodegen {
             }
         }
 
+        if self.options.backend == GoBackend::EasyJson {
+            writeln!(out, "//easyjson:json").unwrap();
+        }
+
         // Choice container struct
         writeln!(out, "type {} struct {{", choice_name).unwrap();
         for branch in &u.branches {
@@ -415,12 +445,22 @@ impl GoCodegen {
             }
             let field_name = to_go_field_name(&branch.variant_name);
             let mapped_type = self.context.map_type_ref(&branch.type_ref);
-            let xml_tag = if self.options.emit_xml_tags {
-                format!(" `xml:\"{},omitempty\"`", branch.xml_name)
-            } else {
+            let mut tag_parts = Vec::new();
+            if self.options.emit_xml_tags {
+                tag_parts.push(format!("xml:\"{},omitempty\"", branch.xml_name));
+            }
+            if self.options.emit_json_tags {
+                tag_parts.push(format!("json:\"{},omitempty\"", branch.xml_name));
+            }
+            if self.options.backend == GoBackend::Sonic {
+                tag_parts.push(format!("sonic:\"{},omitempty\"", branch.xml_name));
+            }
+            let tag = if tag_parts.is_empty() {
                 String::new()
+            } else {
+                format!(" `{}`", tag_parts.join(" "))
             };
-            writeln!(out, "    {} *{}{}", field_name, mapped_type, xml_tag).unwrap();
+            writeln!(out, "    {} *{}{}", field_name, mapped_type, tag).unwrap();
         }
         writeln!(out, "}}\n").unwrap();
 
@@ -539,14 +579,25 @@ impl GoCodegen {
             }
         }
 
+        if self.options.backend == GoBackend::EasyJson {
+            writeln!(out, "//easyjson:json").unwrap();
+        }
+
         writeln!(out, "type {} struct {{", struct_name).unwrap();
 
         // Emit XMLName if xml tags enabled
         if self.options.emit_xml_tags {
+            let mut xml_tags = Vec::new();
             if self.options.emit_json_tags {
-                writeln!(out, "    XMLName xml.Name `json:\"-\"`").unwrap();
-            } else {
+                xml_tags.push("json:\"-\"");
+            }
+            if self.options.backend == GoBackend::Sonic {
+                xml_tags.push("sonic:\"-\"");
+            }
+            if xml_tags.is_empty() {
                 writeln!(out, "    XMLName xml.Name").unwrap();
+            } else {
+                writeln!(out, "    XMLName xml.Name `{}`", xml_tags.join(" ")).unwrap();
             }
         }
 
@@ -576,6 +627,9 @@ impl GoCodegen {
                 if self.options.emit_json_tags {
                     parts.push("json:\"value,omitempty\"".to_string());
                 }
+                if self.options.backend == GoBackend::Sonic {
+                    parts.push("sonic:\"value,omitempty\"".to_string());
+                }
                 let tag = if parts.is_empty() {
                     String::new()
                 } else {
@@ -647,7 +701,7 @@ impl GoCodegen {
             parts.push(format!("xml:\"{}\"", xml_val));
         }
 
-        if self.options.emit_json_tags {
+        if self.options.emit_json_tags || self.options.backend == GoBackend::Sonic {
             let is_opt = f.cardinality.is_optional() || f.nillable;
             let json_name = if f.kind == FieldKind::Text {
                 "value".to_string()
@@ -659,7 +713,12 @@ impl GoCodegen {
             } else {
                 json_name
             };
-            parts.push(format!("json:\"{}\"", json_val));
+            if self.options.emit_json_tags {
+                parts.push(format!("json:\"{}\"", json_val));
+            }
+            if self.options.backend == GoBackend::Sonic {
+                parts.push(format!("sonic:\"{}\"", json_val));
+            }
         }
 
         if parts.is_empty() {

{polyxml-0.15.0 → polyxml-0.17.0}/crates/polyxml-core/src/codegen/mod.rs

@@ -13,13 +13,13 @@ pub mod python;
 pub mod rust;
 pub mod typescript;
 
-pub use cpp::{CppCodegen, CppMode, CppOptions};
+pub use cpp::{CppBackend, CppCodegen, CppMode, CppOptions};
 pub use csharp::{CSharpCodegen, CSharpOptions, CSharpRecordKind};
-pub use go::{GoCodegen, GoOptions};
+pub use go::{GoBackend, GoCodegen, GoOptions};
 pub use java::{JavaBackend, JavaCodegen, JavaOptions};
 pub use python::{PythonBackend, PythonCodegen, PythonOptions};
 pub use rust::{RustCodegen, RustOptions};
-pub use typescript::{TypeScriptCodegen, TypeScriptOptions};
+pub use typescript::{TypeScriptBackend, TypeScriptCodegen, TypeScriptOptions};
 
 use crate::ir::{PrimitiveType, TypeRef};
 

{polyxml-0.15.0 → polyxml-0.17.0}/crates/polyxml-core/src/codegen/rust/mod.rs

@@ -25,6 +25,8 @@ pub struct RustOptions {
     pub emit_root_aliases: bool,
     /// Emit streaming XML codecs (from_xml, to_xml, decode_xml, encode_xml) (default: true).
     pub emit_codecs: bool,
+    /// Derive rkyv::{Archive, Serialize, Deserialize} zero-copy wire format serialization (default: false).
+    pub emit_rkyv: bool,
 }
 
 impl Default for RustOptions {
@@ -36,6 +38,7 @@ impl Default for RustOptions {
             emit_polyxml_attrs: false,
             emit_root_aliases: true,
             emit_codecs: true,
+            emit_rkyv: false,
         }
     }
 }
@@ -431,6 +434,13 @@ impl RustCodegen {
         }
 
         let _ = writeln!(out, "#[derive({})]", derives.join(", "));
+        if self.options.emit_rkyv {
+            let _ = writeln!(
+                out,
+                "#[cfg_attr(feature = \"rkyv\", derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize))]"
+            );
+            let _ = writeln!(out, "#[cfg_attr(feature = \"rkyv\", rkyv(check_bytes))]");
+        }
         let _ = writeln!(out, "pub enum {} {{", enum_name);
 
         let mut seen_variants = HashSet::new();
@@ -520,6 +530,13 @@ impl RustCodegen {
         }
 
         let _ = writeln!(out, "#[derive({})]", derives.join(", "));
+        if self.options.emit_rkyv {
+            let _ = writeln!(
+                out,
+                "#[cfg_attr(feature = \"rkyv\", derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize))]"
+            );
+            let _ = writeln!(out, "#[cfg_attr(feature = \"rkyv\", rkyv(check_bytes))]");
+        }
         let type_signature = if needs_lifetime {
             format!("{}<'a>", union_name)
         } else {
@@ -587,6 +604,13 @@ impl RustCodegen {
         }
 
         let _ = writeln!(out, "#[derive({})]", derives.join(", "));
+        if self.options.emit_rkyv {
+            let _ = writeln!(
+                out,
+                "#[cfg_attr(feature = \"rkyv\", derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize))]"
+            );
+            let _ = writeln!(out, "#[cfg_attr(feature = \"rkyv\", rkyv(check_bytes))]");
+        }
 
         let struct_decl = if needs_lifetime {
             format!("pub struct {}<'a>", struct_name)