polyxml 0.14.3__tar.gz → 0.15.0__tar.gz

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

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

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

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

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

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

{polyxml-0.14.3 → polyxml-0.15.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.15.0}/crates/polyxml-core/src/codegen/mod.rs

@@ -16,7 +16,7 @@ pub mod typescript;
 pub use cpp::{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.15.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.15.0}/pyproject.toml

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