polyxml 0.14.3__tar.gz → 0.16.0__tar.gz

{polyxml-0.14.3 → polyxml-0.16.0}/Cargo.lock

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

{polyxml-0.14.3 → polyxml-0.16.0}/Cargo.toml

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

{polyxml-0.14.3 → polyxml-0.16.0}/PKG-INFO

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

{polyxml-0.14.3 → polyxml-0.16.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.14.3 → polyxml-0.16.0}/crates/polyxml-core/src/codegen/java/mod.rs

@@ -10,11 +10,37 @@ use crate::ir::{
     TypeRef, UnionDef,
 };
 
+/// Target backend for Java code emission.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Default, Serialize, Deserialize)]
+pub enum JavaBackend {
+    /// Zero-dependency Java 21+ records (default).
+    #[default]
+    Standard,
+    /// Jackson-annotated records for Spring Boot / enterprise JSON+XML binding.
+    Jackson,
+}
+
+impl JavaBackend {
+    pub fn from_str_loose(s: &str) -> Option<Self> {
+        match s.to_lowercase().trim() {
+            "standard" | "std" | "default" => Some(Self::Standard),
+            "jackson" | "spring" | "spring-boot" | "enterprise" => Some(Self::Jackson),
+            _ => None,
+        }
+    }
+
+    pub fn is_jackson(self) -> bool {
+        matches!(self, Self::Jackson)
+    }
+}
+
 /// Options configuring Java 21+ code generation.
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct JavaOptions {
     /// Java package declaration for generated types (default: "generated.models")
     pub package_name: String,
+    /// Target serialization backend (default: Standard / zero-dependency).
+    pub backend: JavaBackend,
     /// Use Java 21 `record` instead of traditional classes (default: true)
     pub use_records: bool,
     /// Generate facet validation in compact constructors (default: true)
@@ -27,6 +53,7 @@ impl Default for JavaOptions {
     fn default() -> Self {
         Self {
             package_name: "generated.models".to_string(),
+            backend: JavaBackend::Standard,
             use_records: true,
             validate_facets: true,
             emit_root_aliases: true,
@@ -244,7 +271,11 @@ impl JavaCodegen {
 
     fn emit_file_header(&self, out: &mut String) {
         out.push_str("// Generated by PolyXML Compiler (https://github.com/nth-bailey/PolyXML)\n");
-        out.push_str("// Target: Java 21+ (Records, Sealed Interfaces, Pattern Matching)\n\n");
+        if self.options.backend.is_jackson() {
+            out.push_str("// Target: Java 21+ (Records, Jackson XML/JSON Annotations)\n\n");
+        } else {
+            out.push_str("// Target: Java 21+ (Records, Sealed Interfaces, Pattern Matching)\n\n");
+        }
 
         if !self.options.package_name.is_empty() {
             let _ = writeln!(out, "package {};\n", self.options.package_name);
@@ -253,7 +284,15 @@ impl JavaCodegen {
         out.push_str("import java.util.*;\n");
         out.push_str("import java.time.*;\n");
         out.push_str("import java.math.*;\n");
-        out.push_str("import java.util.regex.Pattern;\n\n");
+        out.push_str("import java.util.regex.Pattern;\n");
+
+        if self.options.backend.is_jackson() {
+            out.push('\n');
+            out.push_str("import com.fasterxml.jackson.annotation.*;\n");
+            out.push_str("import com.fasterxml.jackson.dataformat.xml.annotation.*;\n");
+        }
+
+        out.push('\n');
     }
 
     fn generate_single_type(&self, type_def: &TypeDef, is_nested: bool) -> (String, String) {
@@ -300,6 +339,25 @@ impl JavaCodegen {
             self.emit_docstring(out, doc, indent);
         }
 
+        let jackson = self.options.backend.is_jackson();
+
+        // Jackson class-level annotations
+        if jackson {
+            let _ = writeln!(out, "{}@JsonIgnoreProperties(ignoreUnknown = true)", indent);
+            let _ = writeln!(out, "{}@JsonInclude(JsonInclude.Include.NON_EMPTY)", indent);
+            let ns_attr = s
+                .qname
+                .namespace
+                .as_deref()
+                .map(|ns| format!(", namespace = {:?}", ns))
+                .unwrap_or_default();
+            let _ = writeln!(
+                out,
+                "{}@JacksonXmlRootElement(localName = {:?}{})",
+                indent, s.qname.local, ns_attr
+            );
+        }
+
         let mut seen_fields = HashSet::new();
         let mut components = Vec::new();
         let mut validation_checks = Vec::new();
@@ -323,7 +381,38 @@ impl JavaCodegen {
                 self.context.map_type_ref(&field.type_ref)
             };
 
-            components.push(format!("{} {}", field_type, field_id));
+            if jackson {
+                let mut annotations = Vec::new();
+                // @JsonProperty
+                annotations.push(format!("@JsonProperty({:?})", field.xml_name));
+
+                // @JacksonXmlProperty
+                let is_attr = field.kind == crate::ir::FieldKind::Attribute;
+                let ns_part = field
+                    .namespace
+                    .as_deref()
+                    .map(|ns| format!(", namespace = {:?}", ns))
+                    .unwrap_or_default();
+                annotations.push(format!(
+                    "@JacksonXmlProperty(localName = {:?}, isAttribute = {}{})",
+                    field.xml_name, is_attr, ns_part
+                ));
+
+                // List fields: @JacksonXmlElementWrapper(useWrapping = false)
+                if is_list {
+                    annotations.push("@JacksonXmlElementWrapper(useWrapping = false)".to_string());
+                }
+
+                // Optional/list fields: @JsonInclude(NON_EMPTY)
+                if is_optional || is_list {
+                    annotations.push("@JsonInclude(JsonInclude.Include.NON_EMPTY)".to_string());
+                }
+
+                let annotation_str = annotations.join(" ");
+                components.push(format!("{} {} {}", annotation_str, field_type, field_id));
+            } else {
+                components.push(format!("{} {}", field_type, field_id));
+            }
 
             if self.options.validate_facets {
                 if let Some(ref facets) = field.facets {
@@ -373,6 +462,8 @@ impl JavaCodegen {
             self.emit_docstring(out, doc, indent);
         }
 
+        let jackson = self.options.backend.is_jackson();
+
         let modifier = if indent.is_empty() {
             "public "
         } else {
@@ -404,10 +495,18 @@ impl JavaCodegen {
         let _ = writeln!(out, "{}        this.value = value;", indent);
         let _ = writeln!(out, "{}    }}\n", indent);
 
+        // @JsonValue on getValue()
+        if jackson {
+            let _ = writeln!(out, "{}    @JsonValue", indent);
+        }
         let _ = writeln!(out, "{}    public String getValue() {{", indent);
         let _ = writeln!(out, "{}        return this.value;", indent);
         let _ = writeln!(out, "{}    }}\n", indent);
 
+        // @JsonCreator on fromValue()
+        if jackson {
+            let _ = writeln!(out, "{}    @JsonCreator", indent);
+        }
         let _ = writeln!(
             out,
             "{}    public static {} fromValue(String value) {{",
@@ -433,6 +532,8 @@ impl JavaCodegen {
             self.emit_docstring(out, doc, indent);
         }
 
+        let jackson = self.options.backend.is_jackson();
+
         let modifier = if indent.is_empty() {
             "public "
         } else {
@@ -451,6 +552,29 @@ impl JavaCodegen {
             .collect::<Vec<_>>()
             .join(", ");
 
+        // Jackson polymorphic type annotations
+        if jackson {
+            let _ = writeln!(
+                out,
+                "{}@JsonTypeInfo(use = JsonTypeInfo.Id.NAME, include = JsonTypeInfo.As.PROPERTY, property = \"@type\")",
+                indent
+            );
+
+            let subtypes: Vec<String> = u
+                .branches
+                .iter()
+                .map(|b| {
+                    let vn = to_java_type_name(&b.variant_name);
+                    format!(
+                        "@JsonSubTypes.Type(value = {}.{}.class, name = {:?})",
+                        java_name, vn, b.xml_name
+                    )
+                })
+                .collect();
+
+            let _ = writeln!(out, "{}@JsonSubTypes({{{}}})", indent, subtypes.join(", "));
+        }
+
         let _ = writeln!(
             out,
             "{}{}sealed interface {} permits {} {{",
@@ -465,6 +589,10 @@ impl JavaCodegen {
                 self.emit_docstring(out, doc, &format!("{}    ", indent));
             }
 
+            if jackson {
+                let _ = writeln!(out, "{}    @JsonTypeName({:?})", indent, branch.xml_name);
+            }
+
             let _ = writeln!(
                 out,
                 "{}    record {}({} value) implements {} {{}}",
@@ -480,6 +608,7 @@ impl JavaCodegen {
             self.emit_docstring(out, doc, indent);
         }
 
+        let jackson = self.options.backend.is_jackson();
         let base_type = self.context.map_type_ref(&s.base_type);
         let modifier = if indent.is_empty() {
             "public "
@@ -493,25 +622,48 @@ impl JavaCodegen {
             Vec::new()
         };
 
-        if checks.is_empty() {
+        // Build the value component with optional Jackson annotations
+        let value_component = if jackson {
+            format!("@JsonValue @JacksonXmlText {} value", base_type)
+        } else {
+            format!("{} value", base_type)
+        };
+
+        if checks.is_empty() && !jackson {
             let _ = writeln!(
                 out,
-                "{}{}record {}({} value) {{}}",
-                indent, modifier, java_name, base_type
+                "{}{}record {}({}) {{}}",
+                indent, modifier, java_name, value_component
             );
             return;
         }
 
         let _ = writeln!(
             out,
-            "{}{}record {}({} value) {{",
-            indent, modifier, java_name, base_type
+            "{}{}record {}({}) {{",
+            indent, modifier, java_name, value_component
         );
-        let _ = writeln!(out, "{}    public {} {{", indent, java_name);
-        for check in checks {
-            let _ = writeln!(out, "{}        {}", indent, check);
+
+        // Jackson @JsonCreator factory method
+        if jackson {
+            let _ = writeln!(out, "{}    @JsonCreator", indent);
+            let _ = writeln!(
+                out,
+                "{}    public static {} of({} value) {{",
+                indent, java_name, base_type
+            );
+            let _ = writeln!(out, "{}        return new {}(value);", indent, java_name);
+            let _ = writeln!(out, "{}    }}", indent);
         }
-        let _ = writeln!(out, "{}    }}", indent);
+
+        if !checks.is_empty() {
+            let _ = writeln!(out, "{}    public {} {{", indent, java_name);
+            for check in checks {
+                let _ = writeln!(out, "{}        {}", indent, check);
+            }
+            let _ = writeln!(out, "{}    }}", indent);
+        }
+
         let _ = writeln!(out, "{}}}", indent);
     }
 

{polyxml-0.14.3 → polyxml-0.16.0}/crates/polyxml-core/src/codegen/mod.rs

@@ -13,10 +13,10 @@ 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 java::{JavaCodegen, JavaOptions};
+pub use java::{JavaBackend, JavaCodegen, JavaOptions};
 pub use python::{PythonBackend, PythonCodegen, PythonOptions};
 pub use rust::{RustCodegen, RustOptions};
 pub use typescript::{TypeScriptCodegen, TypeScriptOptions};

{polyxml-0.14.3 → polyxml-0.16.0}/crates/polyxml-core/tests/test_cpp_codegen.rs

@@ -3,8 +3,8 @@ use std::process::Command;
 use tempfile::tempdir;
 
 use polyxml::codegen::cpp::{
-    to_cpp_enum_variant, to_cpp_field_name, to_cpp_namespace, to_cpp_type_name, CppCodegen,
-    CppMode, CppOptions,
+    to_cpp_enum_variant, to_cpp_field_name, to_cpp_namespace, to_cpp_type_name, CppBackend,
+    CppCodegen, CppMode, CppOptions,
 };
 use polyxml::ir::{
     Cardinality, EnumDef, EnumValue, FieldDef, FieldKind, PrimitiveType, QName, RestrictionFacets,
@@ -154,6 +154,7 @@ fn test_cpp_struct_and_enum_codegen_compilation() {
     let options = CppOptions {
         namespace: "crm::models".to_string(),
         mode: CppMode::HeaderOnly,
+        backend: CppBackend::Standard,
         standard: "c++20".to_string(),
         emit_equality_operators: true,
         emit_enum_converters: true,
@@ -862,3 +863,140 @@ int main() {
         "ISO 20022 test binary execution failed"
     );
 }
+
+#[test]
+fn test_cpp_mode_and_backend_from_str_loose() {
+    assert_eq!(CppMode::from_str_loose("header"), Some(CppMode::HeaderOnly));
+    assert_eq!(
+        CppMode::from_str_loose("header-only"),
+        Some(CppMode::HeaderOnly)
+    );
+    assert_eq!(CppMode::from_str_loose("hpp"), Some(CppMode::HeaderOnly));
+    assert_eq!(CppMode::from_str_loose("modules"), Some(CppMode::Module));
+    assert_eq!(CppMode::from_str_loose("module"), Some(CppMode::Module));
+    assert_eq!(CppMode::from_str_loose("cppm"), Some(CppMode::Module));
+    assert_eq!(CppMode::from_str_loose("unknown"), None);
+
+    assert_eq!(
+        CppBackend::from_str_loose("standard"),
+        Some(CppBackend::Standard)
+    );
+    assert_eq!(
+        CppBackend::from_str_loose("default"),
+        Some(CppBackend::Standard)
+    );
+    assert_eq!(CppBackend::from_str_loose("glaze"), Some(CppBackend::Glaze));
+    assert_eq!(CppBackend::from_str_loose("glz"), Some(CppBackend::Glaze));
+    assert_eq!(CppBackend::from_str_loose("unknown"), None);
+}
+
+#[test]
+fn test_cpp_glaze_backend_meta_generation() {
+    let mut ir = SchemaIR::new().with_target_namespace("https://example.com/shop");
+
+    // Enum
+    ir.add_type(TypeDef::Enum(EnumDef {
+        qname: QName::new(Some("https://example.com/shop"), "OrderStatus"),
+        base_type: TypeRef::Primitive(PrimitiveType::String),
+        variants: vec![
+            EnumValue {
+                name: "pending".into(),
+                value: "pending".into(),
+                documentation: None,
+            },
+            EnumValue {
+                name: "shipped".into(),
+                value: "shipped".into(),
+                documentation: None,
+            },
+        ],
+        documentation: None,
+    }));
+
+    // Struct
+    ir.add_type(TypeDef::Struct(StructDef {
+        qname: QName::new(Some("https://example.com/shop"), "Order"),
+        base_type: None,
+        is_abstract: false,
+        fields: vec![
+            FieldDef {
+                name: "order_id".into(),
+                xml_name: "orderId".into(),
+                namespace: None,
+                kind: FieldKind::Element,
+                type_ref: TypeRef::Primitive(PrimitiveType::Int),
+                cardinality: Cardinality::required_one(),
+                nillable: false,
+                default_value: None,
+                fixed_value: None,
+                documentation: None,
+                facets: None,
+                is_cycle_cut: false,
+            },
+            FieldDef {
+                name: "status".into(),
+                xml_name: "status".into(),
+                namespace: None,
+                kind: FieldKind::Element,
+                type_ref: TypeRef::Named(QName::new(
+                    Some("https://example.com/shop"),
+                    "OrderStatus",
+                )),
+                cardinality: Cardinality::required_one(),
+                nillable: false,
+                default_value: None,
+                fixed_value: None,
+                documentation: None,
+                facets: None,
+                is_cycle_cut: false,
+            },
+        ],
+        documentation: None,
+    }));
+
+    let options = CppOptions {
+        namespace: "shop".to_string(),
+        backend: CppBackend::Glaze,
+        ..Default::default()
+    };
+
+    let codegen = CppCodegen::new(options);
+    let header_code = codegen.generate_header(&ir);
+
+    // Includes Glaze header
+    assert!(header_code.contains("#include <glaze/glaze.hpp>"));
+
+    // Glaze enum reflection
+    assert!(header_code.contains("template <>"));
+    assert!(header_code.contains("struct glz::meta<shop::OrderStatus> {"));
+    assert!(header_code.contains("using T = shop::OrderStatus;"));
+    assert!(header_code.contains("static constexpr auto value = enumerate("));
+    assert!(header_code.contains("\"pending\", T::Pending,"));
+    assert!(header_code.contains("\"shipped\", T::Shipped"));
+
+    // Glaze struct reflection
+    assert!(header_code.contains("struct glz::meta<shop::Order> {"));
+    assert!(header_code.contains("using T = shop::Order;"));
+    assert!(header_code.contains("static constexpr auto value = object("));
+    assert!(header_code.contains("\"orderId\", &T::order_id,"));
+    assert!(header_code.contains("\"status\", &T::status"));
+}
+
+#[test]
+fn test_cpp_cmake_modules_file_set() {
+    let _ir = SchemaIR::new();
+
+    let options = CppOptions {
+        namespace: "telemetry".to_string(),
+        mode: CppMode::Module,
+        emit_cmake: true,
+        ..Default::default()
+    };
+
+    let codegen = CppCodegen::new(options);
+    let cmake = codegen.generate_cmake("telemetry");
+
+    assert!(cmake.contains("cmake_minimum_required(VERSION 3.28)"));
+    assert!(cmake.contains("FILE_SET CXX_MODULES FILES"));
+    assert!(cmake.contains("telemetry.cppm"));
+}

{polyxml-0.14.3 → polyxml-0.16.0}/crates/polyxml-core/tests/test_java_codegen.rs

@@ -3,7 +3,8 @@ use std::process::Command;
 use tempfile::tempdir;
 
 use polyxml::codegen::java::{
-    to_java_enum_constant, to_java_field_identifier, to_java_type_name, JavaCodegen, JavaOptions,
+    to_java_enum_constant, to_java_field_identifier, to_java_type_name, JavaBackend, JavaCodegen,
+    JavaOptions,
 };
 use polyxml::ir::{
     Cardinality, EnumDef, EnumValue, FieldDef, FieldKind, PrimitiveType, QName, RestrictionFacets,
@@ -153,6 +154,7 @@ fn test_java_records_and_enums_generation() {
 
     let options = JavaOptions {
         package_name: "com.example.shop".to_string(),
+        backend: JavaBackend::Standard,
         use_records: true,
         validate_facets: true,
         emit_root_aliases: true,
@@ -239,6 +241,7 @@ fn test_java_sealed_interface_choice() {
 
     let options = JavaOptions {
         package_name: "com.example.payment".to_string(),
+        backend: JavaBackend::Standard,
         use_records: true,
         validate_facets: true,
         emit_root_aliases: true,
@@ -291,6 +294,7 @@ fn test_java_module_container_class() {
 
     let options = JavaOptions {
         package_name: "com.example.banking".to_string(),
+        backend: JavaBackend::Standard,
         use_records: true,
         validate_facets: true,
         emit_root_aliases: true,
@@ -327,3 +331,278 @@ fn test_java_module_container_class() {
         );
     }
 }
+
+#[test]
+fn test_java_jackson_backend_struct_annotations() {
+    let mut ir = SchemaIR::new().with_target_namespace("https://example.com/crm");
+
+    ir.add_type(TypeDef::Struct(StructDef {
+        qname: QName::new(Some("https://example.com/crm"), "Contact"),
+        base_type: None,
+        is_abstract: false,
+        fields: vec![
+            FieldDef {
+                name: "id".into(),
+                xml_name: "id".into(),
+                namespace: None,
+                kind: FieldKind::Attribute,
+                type_ref: TypeRef::Primitive(PrimitiveType::Int),
+                cardinality: Cardinality::required_one(),
+                nillable: false,
+                default_value: None,
+                fixed_value: None,
+                documentation: None,
+                facets: None,
+                is_cycle_cut: false,
+            },
+            FieldDef {
+                name: "email".into(),
+                xml_name: "email".into(),
+                namespace: None,
+                kind: FieldKind::Element,
+                type_ref: TypeRef::Primitive(PrimitiveType::String),
+                cardinality: Cardinality::required_one(),
+                nillable: false,
+                default_value: None,
+                fixed_value: None,
+                documentation: None,
+                facets: None,
+                is_cycle_cut: false,
+            },
+            FieldDef {
+                name: "phone".into(),
+                xml_name: "phone".into(),
+                namespace: None,
+                kind: FieldKind::Element,
+                type_ref: TypeRef::Primitive(PrimitiveType::String),
+                cardinality: Cardinality::optional_one(),
+                nillable: true,
+                default_value: None,
+                fixed_value: None,
+                documentation: None,
+                facets: None,
+                is_cycle_cut: false,
+            },
+            FieldDef {
+                name: "tags".into(),
+                xml_name: "tag".into(),
+                namespace: None,
+                kind: FieldKind::Element,
+                type_ref: TypeRef::Primitive(PrimitiveType::String),
+                cardinality: Cardinality::unbounded(0),
+                nillable: false,
+                default_value: None,
+                fixed_value: None,
+                documentation: None,
+                facets: None,
+                is_cycle_cut: false,
+            },
+        ],
+        documentation: Some("CRM contact record".into()),
+    }));
+
+    let options = JavaOptions {
+        package_name: "com.example.crm".to_string(),
+        backend: JavaBackend::Jackson,
+        use_records: true,
+        validate_facets: true,
+        emit_root_aliases: true,
+    };
+    let codegen = JavaCodegen::new(options);
+    let files = codegen.generate_files(&ir);
+
+    assert_eq!(files.len(), 1);
+    let (filename, code) = &files[0];
+    assert_eq!(filename, "Contact.java");
+
+    // Jackson imports
+    assert!(code.contains("import com.fasterxml.jackson.annotation.*;"));
+    assert!(code.contains("import com.fasterxml.jackson.dataformat.xml.annotation.*;"));
+
+    // Class-level annotations
+    assert!(code.contains("@JsonIgnoreProperties(ignoreUnknown = true)"));
+    assert!(code.contains("@JsonInclude(JsonInclude.Include.NON_EMPTY)"));
+    assert!(code.contains("@JacksonXmlRootElement(localName = \"Contact\""));
+
+    // Field annotations — attribute
+    assert!(code.contains("@JsonProperty(\"id\")"));
+    assert!(code.contains("@JacksonXmlProperty(localName = \"id\", isAttribute = true)"));
+
+    // Field annotations — element
+    assert!(code.contains("@JsonProperty(\"email\")"));
+    assert!(code.contains("@JacksonXmlProperty(localName = \"email\", isAttribute = false)"));
+
+    // Optional field gets NON_EMPTY
+    assert!(code.contains("@JsonProperty(\"phone\")"));
+
+    // List field gets wrapper suppression
+    assert!(code.contains("@JacksonXmlElementWrapper(useWrapping = false)"));
+}
+
+#[test]
+fn test_java_jackson_backend_enum_annotations() {
+    let mut ir = SchemaIR::new().with_target_namespace("https://example.com/orders");
+
+    ir.add_type(TypeDef::Enum(EnumDef {
+        qname: QName::new(Some("https://example.com/orders"), "Priority"),
+        base_type: TypeRef::Primitive(PrimitiveType::String),
+        variants: vec![
+            EnumValue {
+                name: "low".into(),
+                value: "low".into(),
+                documentation: None,
+            },
+            EnumValue {
+                name: "high".into(),
+                value: "high".into(),
+                documentation: None,
+            },
+        ],
+        documentation: None,
+    }));
+
+    let options = JavaOptions {
+        package_name: "com.example.orders".to_string(),
+        backend: JavaBackend::Jackson,
+        use_records: true,
+        validate_facets: true,
+        emit_root_aliases: true,
+    };
+    let codegen = JavaCodegen::new(options);
+    let files = codegen.generate_files(&ir);
+
+    assert_eq!(files.len(), 1);
+    let (_, code) = &files[0];
+
+    // @JsonValue on getValue()
+    assert!(code.contains("@JsonValue"));
+    assert!(code.contains("public String getValue()"));
+
+    // @JsonCreator on fromValue()
+    assert!(code.contains("@JsonCreator"));
+    assert!(code.contains("public static Priority fromValue(String value)"));
+}
+
+#[test]
+fn test_java_jackson_backend_union_annotations() {
+    let mut ir = SchemaIR::new().with_target_namespace("https://example.com/messaging");
+
+    ir.add_type(TypeDef::Union(UnionDef {
+        qname: QName::new(Some("https://example.com/messaging"), "MessageChannel"),
+        branches: vec![
+            UnionBranch {
+                variant_name: "sms".into(),
+                xml_name: "sms".into(),
+                namespace: None,
+                type_ref: TypeRef::Primitive(PrimitiveType::String),
+                documentation: None,
+            },
+            UnionBranch {
+                variant_name: "email".into(),
+                xml_name: "email".into(),
+                namespace: None,
+                type_ref: TypeRef::Primitive(PrimitiveType::String),
+                documentation: None,
+            },
+        ],
+        documentation: None,
+    }));
+
+    let options = JavaOptions {
+        package_name: "com.example.messaging".to_string(),
+        backend: JavaBackend::Jackson,
+        use_records: true,
+        validate_facets: true,
+        emit_root_aliases: true,
+    };
+    let codegen = JavaCodegen::new(options);
+    let files = codegen.generate_files(&ir);
+
+    assert_eq!(files.len(), 1);
+    let (_, code) = &files[0];
+
+    // Polymorphic type info
+    assert!(code.contains("@JsonTypeInfo(use = JsonTypeInfo.Id.NAME"));
+    assert!(code.contains("@JsonSubTypes({"));
+    assert!(code.contains("@JsonSubTypes.Type(value = MessageChannel.Sms.class, name = \"sms\")"));
+    assert!(
+        code.contains("@JsonSubTypes.Type(value = MessageChannel.Email.class, name = \"email\")")
+    );
+
+    // Variant type names
+    assert!(code.contains("@JsonTypeName(\"sms\")"));
+    assert!(code.contains("@JsonTypeName(\"email\")"));
+}
+
+#[test]
+fn test_java_jackson_backend_simple_type_annotations() {
+    let mut ir = SchemaIR::new().with_target_namespace("https://example.com/types");
+
+    ir.add_type(TypeDef::Simple(Box::new(SimpleTypeDef {
+        qname: QName::new(Some("https://example.com/types"), "CurrencyCode"),
+        base_type: TypeRef::Primitive(PrimitiveType::String),
+        facets: RestrictionFacets {
+            length: Some(3),
+            patterns: vec!["^[A-Z]{3}$".into()],
+            ..Default::default()
+        },
+        documentation: Some("ISO 4217 currency code".into()),
+    })));
+
+    let options = JavaOptions {
+        package_name: "com.example.types".to_string(),
+        backend: JavaBackend::Jackson,
+        use_records: true,
+        validate_facets: true,
+        emit_root_aliases: true,
+    };
+    let codegen = JavaCodegen::new(options);
+    let files = codegen.generate_files(&ir);
+
+    assert_eq!(files.len(), 1);
+    let (_, code) = &files[0];
+
+    // @JsonValue @JacksonXmlText on value component
+    assert!(code.contains("@JsonValue @JacksonXmlText String value"));
+
+    // @JsonCreator factory method
+    assert!(code.contains("@JsonCreator"));
+    assert!(code.contains("public static CurrencyCode of(String value)"));
+    assert!(code.contains("return new CurrencyCode(value);"));
+
+    // Validation still present
+    assert!(code.contains("if (value.length() != 3)"));
+}
+
+#[test]
+fn test_java_jackson_backend_from_str_loose() {
+    assert_eq!(
+        JavaBackend::from_str_loose("jackson"),
+        Some(JavaBackend::Jackson)
+    );
+    assert_eq!(
+        JavaBackend::from_str_loose("Jackson"),
+        Some(JavaBackend::Jackson)
+    );
+    assert_eq!(
+        JavaBackend::from_str_loose("spring"),
+        Some(JavaBackend::Jackson)
+    );
+    assert_eq!(
+        JavaBackend::from_str_loose("spring-boot"),
+        Some(JavaBackend::Jackson)
+    );
+    assert_eq!(
+        JavaBackend::from_str_loose("enterprise"),
+        Some(JavaBackend::Jackson)
+    );
+    assert_eq!(
+        JavaBackend::from_str_loose("standard"),
+        Some(JavaBackend::Standard)
+    );
+    assert_eq!(
+        JavaBackend::from_str_loose("std"),
+        Some(JavaBackend::Standard)
+    );
+    assert_eq!(JavaBackend::from_str_loose("unknown"), None);
+}

{polyxml-0.14.3 → polyxml-0.16.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "maturin"
 
 [project]
 name = "polyxml"
-version = "0.14.3"
+version = "0.16.0"
 description = "High-performance, polyglot XML data-binding engine built in Rust"
 authors = [
     { name = "Bailey Nguyen", email = "bailey.tan.nguyen@gmail.com" }