polyxml 0.25.0__tar.gz → 0.26.0__tar.gz

{polyxml-0.25.0 → polyxml-0.26.0}/Cargo.lock

@@ -608,7 +608,7 @@ dependencies = [
 
 [[package]]
 name = "polyxml"
-version = "0.25.0"
+version = "0.26.0"
 dependencies = [
  "criterion",
  "heck",
@@ -628,14 +628,14 @@ dependencies = [
 
 [[package]]
 name = "polyxml-c"
-version = "0.25.0"
+version = "0.26.0"
 dependencies = [
  "polyxml",
 ]
 
 [[package]]
 name = "polyxml-cli"
-version = "0.25.0"
+version = "0.26.0"
 dependencies = [
  "clap",
  "glob",
@@ -649,7 +649,7 @@ dependencies = [
 
 [[package]]
 name = "polyxml-js"
-version = "0.25.0"
+version = "0.26.0"
 dependencies = [
  "napi",
  "napi-build",
@@ -659,7 +659,7 @@ dependencies = [
 
 [[package]]
 name = "polyxml-python"
-version = "0.25.0"
+version = "0.26.0"
 dependencies = [
  "lexical-core",
  "polyxml",
@@ -669,7 +669,7 @@ dependencies = [
 
 [[package]]
 name = "polyxml-wasm"
-version = "0.25.0"
+version = "0.26.0"
 dependencies = [
  "polyxml",
  "quick-xml",

{polyxml-0.25.0 → polyxml-0.26.0}/Cargo.toml

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

{polyxml-0.25.0 → polyxml-0.26.0}/PKG-INFO

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

{polyxml-0.25.0 → polyxml-0.26.0}/crates/polyxml-core/src/codegen/java/mod.rs

@@ -57,6 +57,9 @@ pub struct JavaOptions {
     pub emit_direct_codec: bool,
     /// Generate facet validation in compact constructors (default: true)
     pub validate_facets: bool,
+    /// Emit Jakarta Bean Validation annotations (adds an optional API dependency).
+    #[serde(default)]
+    pub bean_validation: bool,
     /// Emit top-level aliases for root elements (default: true)
     pub emit_root_aliases: bool,
     /// Custom header text to prepend to generated files (default: None)
@@ -72,6 +75,7 @@ impl Default for JavaOptions {
             emit_builder: false,
             emit_direct_codec: false,
             validate_facets: true,
+            bean_validation: false,
             emit_root_aliases: true,
             custom_header: None,
         }
@@ -345,6 +349,9 @@ impl JavaCodegen {
         out.push_str("import java.time.*;\n");
         out.push_str("import java.math.*;\n");
         out.push_str("import java.util.regex.Pattern;\n");
+        if self.options.bean_validation {
+            out.push_str("import jakarta.validation.constraints.*;\n");
+        }
 
         if self.options.backend.is_jackson() {
             out.push('\n');
@@ -454,6 +461,12 @@ impl JavaCodegen {
 
             let field_type = self.field_type(field);
 
+            let bean_annotations = self.bean_annotations(field).join(" ");
+            let bean_prefix = if bean_annotations.is_empty() {
+                String::new()
+            } else {
+                format!("{bean_annotations} ")
+            };
             if jackson {
                 let mut annotations = Vec::new();
                 // @JsonProperty
@@ -482,9 +495,12 @@ impl JavaCodegen {
                 }
 
                 let annotation_str = annotations.join(" ");
-                components.push(format!("{} {} {}", annotation_str, field_type, field_id));
+                components.push(format!(
+                    "{}{} {} {}",
+                    bean_prefix, annotation_str, field_type, field_id
+                ));
             } else {
-                components.push(format!("{} {}", field_type, field_id));
+                components.push(format!("{}{} {}", bean_prefix, field_type, field_id));
             }
 
             if self.options.validate_facets {
@@ -714,10 +730,26 @@ impl JavaCodegen {
         };
 
         // Build the value component with optional Jackson annotations
+        let mut value_field = crate::ir::FieldDef::new(
+            "value",
+            "value",
+            crate::ir::FieldKind::Text,
+            s.base_type.clone(),
+        );
+        value_field.facets = Some(s.facets.clone());
+        let bean_prefix = self.bean_annotations(&value_field).join(" ");
+        let bean_prefix = if bean_prefix.is_empty() {
+            String::new()
+        } else {
+            format!("{bean_prefix} ")
+        };
         let value_component = if jackson {
-            format!("@JsonValue @JacksonXmlText {} value", base_type)
+            format!(
+                "{bean_prefix}@JsonValue @JacksonXmlText {} value",
+                base_type
+            )
         } else {
-            format!("{} value", base_type)
+            format!("{bean_prefix}{} value", base_type)
         };
 
         if checks.is_empty() && !jackson {
@@ -758,6 +790,124 @@ impl JavaCodegen {
         let _ = writeln!(out, "{}}}", indent);
     }
 
+    fn bean_annotations(&self, field: &crate::ir::FieldDef) -> Vec<String> {
+        if !self.options.bean_validation {
+            return Vec::new();
+        }
+        let mut annotations = Vec::new();
+        let is_list = field.cardinality.is_list() || field.type_ref.is_list();
+        let is_optional = field.cardinality.is_optional() || field.nillable;
+        if !is_optional
+            && !matches!(
+                self.field_type(field).as_str(),
+                "boolean" | "byte" | "short" | "int" | "long" | "float" | "double"
+            )
+        {
+            // Java primitive fields cannot be null; reference fields can.
+            annotations.push("@NotNull".to_string());
+        }
+        if matches!(&field.type_ref, TypeRef::Named(_) | TypeRef::List(_)) {
+            annotations.push("@jakarta.validation.Valid".to_string());
+        }
+        let facets = field.facets.as_ref();
+        let Some(facets) = facets else {
+            return annotations;
+        };
+        let primitive = &field.type_ref;
+        let is_string = matches!(
+            primitive,
+            TypeRef::Primitive(
+                PrimitiveType::String
+                    | PrimitiveType::NormalizedString
+                    | PrimitiveType::Token
+                    | PrimitiveType::Name
+                    | PrimitiveType::NCName
+                    | PrimitiveType::QName
+                    | PrimitiveType::Language
+                    | PrimitiveType::NMTOKEN
+                    | PrimitiveType::NMTOKENS
+                    | PrimitiveType::AnyUri
+                    | PrimitiveType::Id
+                    | PrimitiveType::IdRef
+                    | PrimitiveType::IdRefs
+                    | PrimitiveType::Entity
+                    | PrimitiveType::Entities
+            )
+        );
+        let is_numeric = matches!(
+            primitive,
+            TypeRef::Primitive(
+                PrimitiveType::Byte
+                    | PrimitiveType::Short
+                    | PrimitiveType::Int
+                    | PrimitiveType::Integer
+                    | PrimitiveType::Long
+                    | PrimitiveType::Decimal
+                    | PrimitiveType::UnsignedByte
+                    | PrimitiveType::UnsignedShort
+                    | PrimitiveType::UnsignedInt
+                    | PrimitiveType::UnsignedLong
+                    | PrimitiveType::PositiveInteger
+                    | PrimitiveType::NegativeInteger
+                    | PrimitiveType::NonPositiveInteger
+                    | PrimitiveType::NonNegativeInteger
+                    | PrimitiveType::Float
+                    | PrimitiveType::Double
+            )
+        );
+        if is_list || (is_string && !is_optional) {
+            if let Some(length) = facets.length {
+                annotations.push(format!("@Size(min = {length}, max = {length})"));
+            } else if facets.min_length.is_some() || facets.max_length.is_some() {
+                annotations.push(format!(
+                    "@Size(min = {}, max = {})",
+                    facets.min_length.unwrap_or(0),
+                    facets.max_length.unwrap_or(i32::MAX as usize)
+                ));
+            }
+        }
+        if is_string && !is_optional {
+            for pattern in &facets.patterns {
+                annotations.push(format!(
+                    "@jakarta.validation.constraints.Pattern(regexp = {pattern:?})"
+                ));
+            }
+        }
+        if is_numeric
+            && !is_list
+            && !is_optional
+            && !matches!(
+                primitive,
+                TypeRef::Primitive(PrimitiveType::Float | PrimitiveType::Double)
+            )
+        {
+            for (value, minimum, inclusive) in [
+                (facets.min_inclusive.as_ref(), true, true),
+                (facets.max_inclusive.as_ref(), false, true),
+                (facets.min_exclusive.as_ref(), true, false),
+                (facets.max_exclusive.as_ref(), false, false),
+            ] {
+                if let Some(value) = value {
+                    if inclusive && !matches!(primitive, TypeRef::Primitive(PrimitiveType::Decimal))
+                    {
+                        if let Ok(integer) = value.parse::<i64>() {
+                            annotations.push(format!(
+                                "@{}({integer})",
+                                if minimum { "Min" } else { "Max" }
+                            ));
+                            continue;
+                        }
+                    }
+                    let annotation = if minimum { "DecimalMin" } else { "DecimalMax" };
+                    annotations.push(format!(
+                        "@{annotation}(value = {value:?}, inclusive = {inclusive})"
+                    ));
+                }
+            }
+        }
+        annotations
+    }
+
     fn build_facet_checks(
         &self,
         var_name: &str,

{polyxml-0.25.0 → polyxml-0.26.0}/crates/polyxml-core/src/codegen/java/models.rs

@@ -16,6 +16,13 @@ impl JavaCodegen {
         let implements = interface.map(|v| format!(", {v}")).unwrap_or_default();
         let ty_name = self.context.map_type_ref(ty);
         let _ = writeln!(out, "{indent}public {nested}final class {name} implements java.io.Serializable{implements} {{\n{indent}    private static final long serialVersionUID = 1L;");
+        if self.options.bean_validation {
+            let mut value_field = FieldDef::new("value", "value", FieldKind::Text, ty.clone());
+            value_field.facets = facets.cloned();
+            for annotation in self.bean_annotations(&value_field) {
+                let _ = writeln!(out, "{indent}    {annotation}");
+            }
+        }
         if self.options.backend.is_jackson() {
             let _ = writeln!(out, "{indent}    @JsonValue @JacksonXmlText");
         }
@@ -153,6 +160,9 @@ impl JavaCodegen {
         let own = &fields[fields.len() - s.fields.len()..];
         for (f, id) in own {
             self.emit_property_annotations(out, f, &format!("{indent}    "));
+            for annotation in self.bean_annotations(f) {
+                let _ = writeln!(out, "{indent}    {annotation}");
+            }
             let _ = writeln!(
                 out,
                 "{indent}    private {} {id} = {};",

{polyxml-0.25.0 → polyxml-0.26.0}/crates/polyxml-core/src/parser.rs

@@ -355,6 +355,14 @@ impl XmlDeserializer {
                                     }
                                 }
                                 ValueType::Nested(sub_schema) => {
+                                    if is_nil {
+                                        stack
+                                            .last_mut()
+                                            .unwrap()
+                                            .push_list_item(field_idx, PolyValue::Null);
+                                        unknown_depth = 1;
+                                        continue;
+                                    }
                                     let frame_schema = resolve_record_schema(
                                         sub_schema,
                                         e,
@@ -367,6 +375,12 @@ impl XmlDeserializer {
                                 _ => {}
                             },
                             ValueType::Nested(sub_schema) => {
+                                if is_nil {
+                                    stack.last_mut().unwrap().values[field_idx] =
+                                        Some(PolyValue::Null);
+                                    unknown_depth = 1;
+                                    continue;
+                                }
                                 let frame_schema = resolve_record_schema(
                                     sub_schema,
                                     e,
@@ -414,6 +428,13 @@ impl XmlDeserializer {
                                     stack.last_mut().unwrap().push_list_item(field_idx, val);
                                 }
                                 ValueType::Nested(sub_schema) => {
+                                    if is_nil {
+                                        stack
+                                            .last_mut()
+                                            .unwrap()
+                                            .push_list_item(field_idx, PolyValue::Null);
+                                        continue;
+                                    }
                                     let frame_schema =
                                         resolve_record_schema(sub_schema, e, &scope)?;
                                     let mut frame = StackFrame::new(frame_schema);
@@ -427,6 +448,11 @@ impl XmlDeserializer {
                                 _ => {}
                             },
                             ValueType::Nested(sub_schema) => {
+                                if is_nil {
+                                    stack.last_mut().unwrap().values[field_idx] =
+                                        Some(PolyValue::Null);
+                                    continue;
+                                }
                                 let frame_schema = resolve_record_schema(sub_schema, e, &scope)?;
                                 let mut frame = StackFrame::new(frame_schema);
                                 Self::parse_attributes(e, &mut frame)?;

{polyxml-0.25.0 → polyxml-0.26.0}/crates/polyxml-core/tests/test_java_codegen.rs

@@ -159,6 +159,7 @@ fn test_java_records_and_enums_generation() {
         emit_builder: false,
         emit_direct_codec: false,
         validate_facets: true,
+        bean_validation: false,
         emit_root_aliases: true,
         custom_header: None,
     };
@@ -249,6 +250,7 @@ fn test_java_sealed_interface_choice() {
         emit_builder: false,
         emit_direct_codec: false,
         validate_facets: true,
+        bean_validation: false,
         emit_root_aliases: true,
         custom_header: None,
     };
@@ -305,6 +307,7 @@ fn test_java_module_container_class() {
         emit_builder: false,
         emit_direct_codec: false,
         validate_facets: true,
+        bean_validation: false,
         emit_root_aliases: true,
         custom_header: None,
     };
@@ -417,6 +420,7 @@ fn test_java_jackson_backend_struct_annotations() {
         emit_builder: false,
         emit_direct_codec: false,
         validate_facets: true,
+        bean_validation: false,
         emit_root_aliases: true,
         custom_header: None,
     };
@@ -480,6 +484,7 @@ fn test_java_jackson_backend_enum_annotations() {
         emit_builder: false,
         emit_direct_codec: false,
         validate_facets: true,
+        bean_validation: false,
         emit_root_aliases: true,
         custom_header: None,
     };
@@ -530,6 +535,7 @@ fn test_java_jackson_backend_union_annotations() {
         emit_builder: false,
         emit_direct_codec: false,
         validate_facets: true,
+        bean_validation: false,
         emit_root_aliases: true,
         custom_header: None,
     };
@@ -574,6 +580,7 @@ fn test_java_jackson_backend_simple_type_annotations() {
         emit_builder: false,
         emit_direct_codec: false,
         validate_facets: true,
+        bean_validation: false,
         emit_root_aliases: true,
         custom_header: None,
     };
@@ -628,6 +635,55 @@ fn test_java_jackson_backend_from_str_loose() {
     assert_eq!(JavaBackend::from_str_loose("unknown"), None);
 }
 
+#[test]
+fn test_java_bean_validation_annotations_are_opt_in() {
+    let schema = r#"<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
+      <xs:simpleType name="Code"><xs:restriction base="xs:string">
+        <xs:minLength value="2"/><xs:maxLength value="8"/><xs:pattern value="[A-Z]+"/>
+      </xs:restriction></xs:simpleType>
+      <xs:simpleType name="Count"><xs:restriction base="xs:int">
+        <xs:minInclusive value="1"/><xs:maxInclusive value="10"/>
+      </xs:restriction></xs:simpleType>
+      <xs:simpleType name="Price"><xs:restriction base="xs:decimal">
+        <xs:minExclusive value="0.0"/><xs:maxExclusive value="99.9"/>
+      </xs:restriction></xs:simpleType>
+      <xs:complexType name="Order"><xs:sequence>
+        <xs:element name="code" type="Code"/>
+        <xs:element name="count" type="Count"/>
+        <xs:element name="price" type="Price"/>
+      </xs:sequence></xs:complexType>
+    </xs:schema>"#;
+    let ir = polyxml::schema_parser::XsdParser::new()
+        .parse_str(schema)
+        .unwrap();
+    let plain = JavaCodegen::new(JavaOptions::default()).generate_files(&ir);
+    assert!(plain
+        .iter()
+        .all(|(_, code)| !code.contains("jakarta.validation")));
+    let files = JavaCodegen::new(JavaOptions {
+        bean_validation: true,
+        ..Default::default()
+    })
+    .generate_files(&ir);
+    let source = |name: &str| {
+        files
+            .iter()
+            .find(|(file, _)| file == name)
+            .unwrap()
+            .1
+            .as_str()
+    };
+    assert!(source("Code.java").contains("@Size(min = 2, max = 8)"));
+    assert!(source("Code.java")
+        .contains("@jakarta.validation.constraints.Pattern(regexp = \"[A-Z]+\")"));
+    assert!(source("Count.java").contains("@Min(1)"));
+    assert!(source("Count.java").contains("@Max(10)"));
+    assert!(source("Price.java").contains("@DecimalMin(value = \"0.0\", inclusive = false)"));
+    assert!(source("Price.java").contains("@DecimalMax(value = \"99.9\", inclusive = false)"));
+    assert!(source("Order.java").contains("@NotNull"));
+    assert!(source("Order.java").contains("@jakarta.validation.Valid"));
+}
+
 #[test]
 fn test_java_mutable_builders_and_direct_codecs_execute() {
     let schema = r#"<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">

{polyxml-0.25.0 → polyxml-0.26.0}/crates/polyxml-core/tests/test_xsi_type.rs

@@ -42,9 +42,9 @@ const VEHICLE_XSD: &str = r#"<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSche
     <xs:element name="Root">
         <xs:complexType>
             <xs:sequence>
-                <xs:element name="vehicle" type="t:Vehicle"/>
+                <xs:element name="vehicle" type="t:Vehicle" nillable="true"/>
                 <xs:element name="spare" type="t:Vehicle"
-                            minOccurs="0" maxOccurs="unbounded"/>
+                            minOccurs="0" maxOccurs="unbounded" nillable="true"/>
             </xs:sequence>
         </xs:complexType>
     </xs:element>
@@ -330,6 +330,19 @@ fn abstract_type_requires_concrete_selector() {
     }
 }
 
+#[test]
+fn nil_abstract_complex_type_skips_concrete_dispatch() {
+    let root = schema_for(Some("Root"));
+    for xml in [
+        br#"<Root xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"><vehicle xsi:nil="true"/><spare xsi:nil="true"/></Root>"#.as_slice(),
+        br#"<Root xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"><vehicle xsi:nil="true"></vehicle><spare xsi:nil="true"></spare></Root>"#.as_slice(),
+    ] {
+        let value = polyxml::deserialize(xml, Arc::clone(&root)).expect("nil abstract field");
+        assert!(matches!(rec_field(&value, "vehicle"), Some(PolyValue::Null)));
+        assert!(matches!(rec_field(&value, "spare"), Some(PolyValue::List(items)) if matches!(items.as_slice(), [PolyValue::Null])));
+    }
+}
+
 #[test]
 fn xsi_type_resolves_namespace_inherited_from_parent() {
     let root = schema_for(Some("Root"));

{polyxml-0.25.0 → polyxml-0.26.0}/crates/polyxml-python/tests/test_xsi_type.py

@@ -58,6 +58,17 @@ class Fleet:
     )
 
 
+@dataclass
+class NullableFleet:
+    class Meta:
+        name = "Fleet"
+
+    vehicle: Vehicle | None = field(
+        default=None,
+        metadata={"type": "Element", "name": "vehicle", "nillable": True},
+    )
+
+
 @dataclass
 class LonelyBase:
     class Meta:
@@ -85,6 +96,14 @@ FLEET_XML = (
 )
 
 
+def test_nil_abstract_complex_type_without_selector():
+    xml = (
+        b'<Fleet xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">'
+        b'<vehicle xsi:nil="true"/></Fleet>'
+    )
+    assert polyxml.deserialize(xml, NullableFleet).vehicle is None
+
+
 def make_fleet() -> Fleet:
     return Fleet(
         vehicle=Car(id="V1", doors=4),

{polyxml-0.25.0 → polyxml-0.26.0}/pyproject.toml

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