polyxml 0.26.0__tar.gz → 0.27.0__tar.gz

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

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

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

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

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

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

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

@@ -832,6 +832,11 @@ impl JavaCodegen {
                     | PrimitiveType::IdRefs
                     | PrimitiveType::Entity
                     | PrimitiveType::Entities
+                    | PrimitiveType::GDay
+                    | PrimitiveType::GMonth
+                    | PrimitiveType::GYear
+                    | PrimitiveType::GYearMonth
+                    | PrimitiveType::GMonthDay
             )
         );
         let is_numeric = matches!(
@@ -939,6 +944,11 @@ impl JavaCodegen {
                     | PrimitiveType::IdRefs
                     | PrimitiveType::Entity
                     | PrimitiveType::Entities
+                    | PrimitiveType::GDay
+                    | PrimitiveType::GMonth
+                    | PrimitiveType::GYear
+                    | PrimitiveType::GYearMonth
+                    | PrimitiveType::GMonthDay
             ),
             _ => false,
         };

{polyxml-0.26.0 → polyxml-0.27.0}/crates/polyxml-core/src/codegen/typescript/mod.rs

@@ -759,6 +759,11 @@ impl TypeScriptCodegen {
                     | PrimitiveType::IdRefs
                     | PrimitiveType::Entity
                     | PrimitiveType::Entities
+                    | PrimitiveType::GDay
+                    | PrimitiveType::GMonth
+                    | PrimitiveType::GYear
+                    | PrimitiveType::GYearMonth
+                    | PrimitiveType::GMonthDay
             ),
             _ => false,
         };
@@ -836,6 +841,11 @@ impl TypeScriptCodegen {
                     | PrimitiveType::NCName
                     | PrimitiveType::Language
                     | PrimitiveType::AnyUri
+                    | PrimitiveType::GDay
+                    | PrimitiveType::GMonth
+                    | PrimitiveType::GYear
+                    | PrimitiveType::GYearMonth
+                    | PrimitiveType::GMonthDay
             ),
             _ => false,
         };
@@ -909,6 +919,11 @@ impl TypeScriptCodegen {
                     | PrimitiveType::NCName
                     | PrimitiveType::Language
                     | PrimitiveType::AnyUri
+                    | PrimitiveType::GDay
+                    | PrimitiveType::GMonth
+                    | PrimitiveType::GYear
+                    | PrimitiveType::GYearMonth
+                    | PrimitiveType::GMonthDay
             ),
             _ => false,
         };

polyxml-0.27.0/crates/polyxml-core/src/converters.rs

@@ -0,0 +1,178 @@
+use crate::error::{PolyXmlError, Result};
+use crate::ir::PrimitiveType;
+use crate::schema::ScalarType;
+use crate::value::PolyValue;
+
+#[inline(always)]
+pub fn trim_bytes(mut b: &[u8]) -> &[u8] {
+    while let Some((first, rest)) = b.split_first() {
+        if first.is_ascii_whitespace() {
+            b = rest;
+        } else {
+            break;
+        }
+    }
+    while let Some((last, rest)) = b.split_last() {
+        if last.is_ascii_whitespace() {
+            b = rest;
+        } else {
+            break;
+        }
+    }
+    b
+}
+
+pub struct ValueConverter;
+
+impl ValueConverter {
+    pub fn parse_scalar(
+        scalar_type: &ScalarType,
+        bytes: &[u8],
+        field_name: &str,
+    ) -> Result<PolyValue> {
+        match scalar_type {
+            ScalarType::String => {
+                let s = std::str::from_utf8(bytes)?;
+                Ok(PolyValue::String(s.to_string()))
+            }
+            ScalarType::Int => {
+                let trimmed = trim_bytes(bytes);
+                let val: i64 =
+                    lexical_core::parse(trimmed).map_err(|_| PolyXmlError::ScalarParseError {
+                        field: field_name.to_string(),
+                        expected: "integer",
+                        value: String::from_utf8_lossy(bytes).to_string(),
+                    })?;
+                Ok(PolyValue::Int(val))
+            }
+            ScalarType::Float => {
+                let trimmed = trim_bytes(bytes);
+                let val: f64 =
+                    lexical_core::parse(trimmed).map_err(|_| PolyXmlError::ScalarParseError {
+                        field: field_name.to_string(),
+                        expected: "float",
+                        value: String::from_utf8_lossy(bytes).to_string(),
+                    })?;
+                Ok(PolyValue::Float(val))
+            }
+            ScalarType::Bool => {
+                let trimmed = trim_bytes(bytes);
+                match trimmed {
+                    b"true" | b"1" => Ok(PolyValue::Bool(true)),
+                    b"false" | b"0" => Ok(PolyValue::Bool(false)),
+                    _ => Err(PolyXmlError::ScalarParseError {
+                        field: field_name.to_string(),
+                        expected: "boolean ('true', 'false', '1', '0')",
+                        value: String::from_utf8_lossy(bytes).to_string(),
+                    }),
+                }
+            }
+            ScalarType::Decimal
+            | ScalarType::XmlDate
+            | ScalarType::XmlDateTime
+            | ScalarType::XmlTime
+            | ScalarType::XmlDuration
+            | ScalarType::Any => {
+                let s = std::str::from_utf8(trim_bytes(bytes))?;
+                Ok(PolyValue::String(s.to_string()))
+            }
+            ScalarType::XmlGregorian(kind) => {
+                let value = std::str::from_utf8(trim_bytes(bytes))?;
+                if !valid_gregorian(*kind, value.as_bytes()) {
+                    return Err(PolyXmlError::ScalarParseError {
+                        field: field_name.to_string(),
+                        expected: "XML Schema Gregorian partial date",
+                        value: value.to_string(),
+                    });
+                }
+                Ok(PolyValue::String(value.to_string()))
+            }
+        }
+    }
+}
+
+fn two_digits(bytes: &[u8]) -> Option<u8> {
+    if bytes.len() == 2 && bytes.iter().all(u8::is_ascii_digit) {
+        Some((bytes[0] - b'0') * 10 + bytes[1] - b'0')
+    } else {
+        None
+    }
+}
+
+fn valid_timezone(bytes: &[u8]) -> Option<&[u8]> {
+    if let Some(value) = bytes.strip_suffix(b"Z") {
+        return Some(value);
+    }
+    let split = bytes
+        .iter()
+        .rposition(|byte| *byte == b'+' || *byte == b'-')?;
+    let suffix = &bytes[split..];
+    if suffix.len() != 6 || suffix[3] != b':' {
+        return None;
+    }
+    let hours = two_digits(&suffix[1..3])?;
+    let minutes = two_digits(&suffix[4..6])?;
+    if hours > 14 || minutes > 59 || (hours == 14 && minutes != 0) {
+        return None;
+    }
+    Some(&bytes[..split])
+}
+
+fn valid_gregorian(kind: PrimitiveType, bytes: &[u8]) -> bool {
+    let has_timezone = bytes.ends_with(b"Z")
+        || bytes.contains(&b'+')
+        || (bytes.len() >= 6 && bytes[bytes.len() - 6] == b'-' && bytes[bytes.len() - 3] == b':');
+    let value = if has_timezone {
+        match valid_timezone(bytes) {
+            Some(value) => value,
+            None => return false,
+        }
+    } else {
+        bytes
+    };
+    match kind {
+        PrimitiveType::GDay => {
+            value.len() == 5
+                && value.starts_with(b"---")
+                && two_digits(&value[3..]).is_some_and(|day| (1..=31).contains(&day))
+        }
+        PrimitiveType::GMonth => {
+            value.len() == 4
+                && value.starts_with(b"--")
+                && two_digits(&value[2..]).is_some_and(|month| (1..=12).contains(&month))
+        }
+        PrimitiveType::GMonthDay => {
+            if value.len() != 7 || !value.starts_with(b"--") || value[4] != b'-' {
+                return false;
+            }
+            let (Some(month), Some(day)) = (two_digits(&value[2..4]), two_digits(&value[5..7]))
+            else {
+                return false;
+            };
+            let max_day = match month {
+                2 => 29,
+                4 | 6 | 9 | 11 => 30,
+                1 | 3 | 5 | 7 | 8 | 10 | 12 => 31,
+                _ => return false,
+            };
+            day >= 1 && day <= max_day
+        }
+        PrimitiveType::GYear => valid_year(value),
+        PrimitiveType::GYearMonth => {
+            if value.len() < 7 || value[value.len() - 3] != b'-' {
+                return false;
+            }
+            valid_year(&value[..value.len() - 3])
+                && two_digits(&value[value.len() - 2..])
+                    .is_some_and(|month| (1..=12).contains(&month))
+        }
+        _ => false,
+    }
+}
+
+fn valid_year(value: &[u8]) -> bool {
+    let digits = value.strip_prefix(b"-").unwrap_or(value);
+    digits.len() >= 4
+        && digits.iter().all(u8::is_ascii_digit)
+        && (digits.len() == 4 || digits[0] != b'0')
+}

{polyxml-0.26.0 → polyxml-0.27.0}/crates/polyxml-core/src/schema.rs

@@ -19,6 +19,7 @@ pub enum ScalarType {
     XmlDateTime,
     XmlTime,
     XmlDuration,
+    XmlGregorian(crate::ir::PrimitiveType),
     Any,
 }
 
@@ -218,6 +219,11 @@ impl ModelSchema {
                 PrimitiveType::DateTime => ScalarType::XmlDateTime,
                 PrimitiveType::Time => ScalarType::XmlTime,
                 PrimitiveType::Date => ScalarType::XmlDate,
+                PrimitiveType::GDay
+                | PrimitiveType::GMonth
+                | PrimitiveType::GYear
+                | PrimitiveType::GYearMonth
+                | PrimitiveType::GMonthDay => ScalarType::XmlGregorian(prim),
                 PrimitiveType::Int
                 | PrimitiveType::Integer
                 | PrimitiveType::NonPositiveInteger

{polyxml-0.26.0 → polyxml-0.27.0}/crates/polyxml-core/src/schema_parser/mod.rs

@@ -167,6 +167,7 @@ impl XsdParser {
         // Frame post-passes: inherit pattern facets up derivation chains
         // and expand named model group references. Both are idempotent.
         // Cycle detection runs last so fields spliced in from groups are covered.
+        add_gregorian_types(&mut ir);
         inherit_pattern_facets(&mut ir);
         self.expand_group_refs(&mut ir, self.frame_depth == 0);
         ir.resolve_cycles();
@@ -1290,6 +1291,80 @@ impl XsdParser {
     }
 }
 
+/// Give XSD Gregorian primitives named, validated types in every target.
+/// The original primitive remains the base of each synthesized simple type.
+fn add_gregorian_types(ir: &mut SchemaIR) {
+    const NS: &str = "urn:polyxml:builtins:gregorian";
+    const TZ: &str = r"(?:Z|[+-](?:(?:0[0-9]|1[0-3]):[0-5][0-9]|14:00))?";
+    fn pattern(kind: PrimitiveType) -> Option<String> {
+        let body = match kind {
+            PrimitiveType::GDay => r"---(?:0[1-9]|[12][0-9]|3[01])",
+            PrimitiveType::GMonth => r"--(?:0[1-9]|1[0-2])",
+            PrimitiveType::GYear => r"-?(?:[0-9]{4}|[1-9][0-9]{4,})",
+            PrimitiveType::GYearMonth => r"-?(?:[0-9]{4}|[1-9][0-9]{4,})-(?:0[1-9]|1[0-2])",
+            PrimitiveType::GMonthDay => {
+                r"--(?:02-(?:0[1-9]|1[0-9]|2[0-9])|(?:04|06|09|11)-(?:0[1-9]|[12][0-9]|30)|(?:01|03|05|07|08|10|12)-(?:0[1-9]|[12][0-9]|3[01]))"
+            }
+            _ => return None,
+        };
+        Some(format!("{body}{TZ}"))
+    }
+    fn name(kind: PrimitiveType) -> &'static str {
+        match kind {
+            PrimitiveType::GDay => "GDay",
+            PrimitiveType::GMonth => "GMonth",
+            PrimitiveType::GYear => "GYear",
+            PrimitiveType::GYearMonth => "GYearMonth",
+            PrimitiveType::GMonthDay => "GMonthDay",
+            _ => unreachable!(),
+        }
+    }
+    fn rewrite(ty: &mut TypeRef, used: &mut HashSet<PrimitiveType>) {
+        match ty {
+            TypeRef::Primitive(kind) if pattern(*kind).is_some() => {
+                used.insert(*kind);
+                *ty = TypeRef::Named(QName::new(Some(NS), name(*kind)));
+            }
+            TypeRef::Boxed(inner) | TypeRef::List(inner) => rewrite(inner, used),
+            _ => {}
+        }
+    }
+    let mut used = HashSet::new();
+    for element in ir.elements.values_mut() {
+        rewrite(&mut element.type_ref, &mut used);
+    }
+    for def in ir.types.values_mut() {
+        match def {
+            TypeDef::Struct(s) => {
+                for field in &mut s.fields {
+                    rewrite(&mut field.type_ref, &mut used);
+                }
+            }
+            TypeDef::Enum(e) => rewrite(&mut e.base_type, &mut used),
+            TypeDef::Union(u) => {
+                for branch in &mut u.branches {
+                    rewrite(&mut branch.type_ref, &mut used);
+                }
+            }
+            TypeDef::Simple(s) => rewrite(&mut s.base_type, &mut used),
+        }
+    }
+    for kind in used {
+        let qname = QName::new(Some(NS), name(kind));
+        ir.types.entry(qname.clone()).or_insert_with(|| {
+            TypeDef::Simple(Box::new(SimpleTypeDef {
+                qname,
+                base_type: TypeRef::Primitive(kind),
+                facets: RestrictionFacets {
+                    patterns: vec![pattern(kind).unwrap()],
+                    ..Default::default()
+                },
+                documentation: Some("Validated W3C Gregorian partial date".into()),
+            }))
+        });
+    }
+}
+
 // Helpers
 
 fn strip_prefix(s: &str) -> &str {

{polyxml-0.26.0 → polyxml-0.27.0}/crates/polyxml-core/src/serializer.rs

@@ -5,8 +5,9 @@ use std::io::Cursor;
 use quick_xml::events::{BytesEnd, BytesStart, BytesText, Event};
 use quick_xml::Writer;
 
+use crate::converters::ValueConverter;
 use crate::error::{PolyXmlError, Result};
-use crate::schema::{FieldKind, ModelSchema, ValueType};
+use crate::schema::{FieldKind, ModelSchema, ScalarType, ValueType};
 use crate::value::PolyValue;
 
 /// XML Schema Instance namespace, needed to write `xsi:type` selectors.
@@ -219,6 +220,13 @@ impl XmlSerializer {
         }
     }
 
+    fn validate_scalar(ty: &ValueType, text: &str, field_name: &str) -> Result<()> {
+        if let ValueType::Scalar(scalar @ ScalarType::XmlGregorian(_)) = ty {
+            ValueConverter::parse_scalar(scalar, text.as_bytes(), field_name)?;
+        }
+        Ok(())
+    }
+
     fn write_model<W: std::io::Write>(
         writer: &mut Writer<W>,
         tag_name: &[u8],
@@ -305,6 +313,7 @@ impl XmlSerializer {
                         };
                         let mut buf = [0u8; lexical_core::BUFFER_SIZE];
                         if let Some(attr_str) = Self::format_scalar_to(val, &mut buf) {
+                            Self::validate_scalar(&field.val_type, attr_str, &field.name)?;
                             elem.push_attribute((attr_name.as_ref(), attr_str));
                         }
                     }
@@ -343,6 +352,7 @@ impl XmlSerializer {
             if let Some(val) = get_field(text_idx, &field.name) {
                 let mut buf = [0u8; lexical_core::BUFFER_SIZE];
                 if let Some(text_content) = Self::format_scalar_to(val, &mut buf) {
+                    Self::validate_scalar(&field.val_type, text_content, &field.name)?;
                     if !text_content.is_empty() {
                         writer
                             .write_event(Event::Text(BytesText::new(text_content)))
@@ -352,6 +362,9 @@ impl XmlSerializer {
                     for item in items {
                         let mut item_buf = [0u8; lexical_core::BUFFER_SIZE];
                         if let Some(text_content) = Self::format_scalar_to(item, &mut item_buf) {
+                            if let ValueType::List(inner) = &field.val_type {
+                                Self::validate_scalar(inner, text_content, &field.name)?;
+                            }
                             if !text_content.is_empty() {
                                 writer
                                     .write_event(Event::Text(BytesText::new(text_content)))
@@ -377,6 +390,7 @@ impl XmlSerializer {
                         ValueType::Scalar(_) => {
                             let mut buf = [0u8; lexical_core::BUFFER_SIZE];
                             if let Some(text) = Self::format_scalar_to(val, &mut buf) {
+                                Self::validate_scalar(&field.val_type, text, &field.name)?;
                                 let local_child = std::str::from_utf8(&field.xml_name)?;
                                 let child_tag = if let Some(ctx) = ns_ctx {
                                     ctx.qualify_element(local_child, child_element_ns)
@@ -404,6 +418,7 @@ impl XmlSerializer {
                                             if let Some(text) =
                                                 Self::format_scalar_to(item, &mut buf)
                                             {
+                                                Self::validate_scalar(inner, text, &field.name)?;
                                                 let local_child =
                                                     std::str::from_utf8(&field.xml_name)?;
                                                 let child_tag = if let Some(ctx) = ns_ctx {

{polyxml-0.26.0 → polyxml-0.27.0}/crates/polyxml-core/tests/test_core.rs

@@ -1,10 +1,59 @@
 use std::sync::Arc;
 
 use polyxml::error::PolyXmlError;
+use polyxml::ir::PrimitiveType;
 use polyxml::schema::{FieldKind, FieldSchema, ModelSchema, ScalarType, ValueType};
 use polyxml::value::PolyValue;
 use polyxml::{deserialize, serialize};
 
+#[test]
+fn test_gregorian_partial_date_lexical_validation() {
+    use polyxml::converters::ValueConverter;
+
+    for (kind, valid, invalid) in [
+        (PrimitiveType::GDay, "---15Z", "---32"),
+        (PrimitiveType::GMonth, "--04+14:00", "--04+14:01"),
+        (PrimitiveType::GYear, "-0045", "012345"),
+        (PrimitiveType::GYearMonth, "2026-09-05:30", "2026-13"),
+        (PrimitiveType::GMonthDay, "--02-29", "--02-30"),
+    ] {
+        let scalar = ScalarType::XmlGregorian(kind);
+        assert_eq!(
+            ValueConverter::parse_scalar(&scalar, valid.as_bytes(), "date").unwrap(),
+            PolyValue::String(valid.into())
+        );
+        assert!(ValueConverter::parse_scalar(&scalar, invalid.as_bytes(), "date").is_err());
+    }
+}
+
+#[test]
+fn test_xsd_gregorian_fields_round_trip_and_reject_invalid_dates() {
+    let xsd = r#"<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
+      <xs:complexType name="Calendar"><xs:sequence>
+        <xs:element name="day" type="xs:gDay"/>
+        <xs:element name="month" type="xs:gMonth"/>
+        <xs:element name="year" type="xs:gYear"/>
+        <xs:element name="yearMonth" type="xs:gYearMonth"/>
+        <xs:element name="monthDay" type="xs:gMonthDay"/>
+      </xs:sequence></xs:complexType>
+      <xs:element name="calendar" type="Calendar"/>
+    </xs:schema>"#;
+    let ir = polyxml::schema_parser::XsdParser::new()
+        .parse_str(xsd)
+        .unwrap();
+    assert_eq!(ir.types.len(), 6);
+    let schema = ModelSchema::from_ir(&ir, Some("calendar")).unwrap();
+    let xml = br#"<calendar><day>---15Z</day><month>--04+14:00</month><year>-0045</year><yearMonth>2026-09-05:30</yearMonth><monthDay>--02-29</monthDay></calendar>"#;
+    let value = deserialize(xml, Arc::clone(&schema)).unwrap();
+    let out = serialize("calendar", &value, &schema, None).unwrap();
+    assert_eq!(deserialize(&out, Arc::clone(&schema)).unwrap(), value);
+    let invalid = br#"<calendar><day>---32</day><month>--04</month><year>2026</year><yearMonth>2026-09</yearMonth><monthDay>--02-29</monthDay></calendar>"#;
+    assert!(deserialize(invalid, Arc::clone(&schema)).is_err());
+    let mut bad_value = std::collections::HashMap::new();
+    bad_value.insert("day".into(), PolyValue::String("---32".into()));
+    assert!(serialize("calendar", &PolyValue::Object(bad_value), &schema, None).is_err());
+}
+
 #[test]
 fn test_all_scalar_types() {
     let schema = ModelSchema::builder("Sensors")

{polyxml-0.26.0 → polyxml-0.27.0}/crates/polyxml-core/tests/test_pattern_codegen.rs

@@ -26,6 +26,59 @@ const SCHEMA: &str = r#"<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
   <xs:element name="document" type="Document"/>
 </xs:schema>"#;
 
+const GREGORIAN_SCHEMA: &str = r#"<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
+  <xs:complexType name="Calendar"><xs:sequence>
+    <xs:element name="day" type="xs:gDay"/>
+    <xs:element name="month" type="xs:gMonth"/>
+    <xs:element name="year" type="xs:gYear"/>
+    <xs:element name="yearMonth" type="xs:gYearMonth"/>
+    <xs:element name="monthDay" type="xs:gMonthDay"/>
+  </xs:sequence></xs:complexType>
+</xs:schema>"#;
+
+#[test]
+fn gregorian_primitives_emit_validated_types_across_targets() {
+    let ir = XsdParser::new().parse_str(GREGORIAN_SCHEMA).unwrap();
+    assert_eq!(ir.types.len(), 6);
+    let rust = RustCodegen::new(RustOptions::default()).generate_module(&ir);
+    assert!(rust.contains("validate_GDay_patterns"));
+    assert!(rust.contains("validate_GMonthDay_patterns"));
+    let go = GoCodegen::new(GoOptions::default()).generate_module(&ir);
+    assert!(go.contains("func (s GDay) Validate() error"));
+    assert!(go.contains("func (s *GMonthDay) UnmarshalText(text []byte) error"));
+    let cpp = CppCodegen::new(CppOptions::default()).generate_header(&ir);
+    assert!(cpp.contains("validate_GDay_patterns"));
+    let java = JavaCodegen::new(JavaOptions::default()).generate_module(&ir, "Models");
+    assert!(java.contains("Pattern.compile(\"---"));
+    let python = PythonCodegen::new(PythonOptions {
+        backend: PythonBackend::Pydantic,
+        ..Default::default()
+    })
+    .generate_module(&ir);
+    assert!(python.contains("type GDay = Annotated[str, Field(pattern="));
+    let ts = TypeScriptCodegen::new(TypeScriptOptions {
+        backend: TypeScriptBackend::Zod,
+        ..Default::default()
+    })
+    .generate_module(&ir);
+    assert!(ts.contains("GDaySchema = z.string().regex("));
+    let valibot = TypeScriptCodegen::new(TypeScriptOptions {
+        backend: TypeScriptBackend::Valibot,
+        ..Default::default()
+    })
+    .generate_module(&ir);
+    assert!(valibot.contains("GDaySchema = v.pipe(v.string(), v.regex("));
+    let typebox = TypeScriptCodegen::new(TypeScriptOptions {
+        backend: TypeScriptBackend::TypeBox,
+        ..Default::default()
+    })
+    .generate_module(&ir);
+    assert!(typebox.contains("GDaySchema = Type.String({ pattern:"));
+    let csharp = CSharpCodegen::new(CSharpOptions::default()).generate_module(&ir);
+    assert!(csharp.contains("record GDay("));
+    assert!(csharp.contains("Regex.IsMatch(Value.ToString()"));
+}
+
 fn schema() -> SchemaIR {
     let dir = tempdir().unwrap();
     let path = dir.path().join("pattern.xsd");

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

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

polyxml-0.26.0/crates/polyxml-core/src/converters.rs

@@ -1,80 +0,0 @@
-use crate::error::{PolyXmlError, Result};
-use crate::schema::ScalarType;
-use crate::value::PolyValue;
-
-#[inline(always)]
-pub fn trim_bytes(mut b: &[u8]) -> &[u8] {
-    while let Some((first, rest)) = b.split_first() {
-        if first.is_ascii_whitespace() {
-            b = rest;
-        } else {
-            break;
-        }
-    }
-    while let Some((last, rest)) = b.split_last() {
-        if last.is_ascii_whitespace() {
-            b = rest;
-        } else {
-            break;
-        }
-    }
-    b
-}
-
-pub struct ValueConverter;
-
-impl ValueConverter {
-    pub fn parse_scalar(
-        scalar_type: &ScalarType,
-        bytes: &[u8],
-        field_name: &str,
-    ) -> Result<PolyValue> {
-        match scalar_type {
-            ScalarType::String => {
-                let s = std::str::from_utf8(bytes)?;
-                Ok(PolyValue::String(s.to_string()))
-            }
-            ScalarType::Int => {
-                let trimmed = trim_bytes(bytes);
-                let val: i64 =
-                    lexical_core::parse(trimmed).map_err(|_| PolyXmlError::ScalarParseError {
-                        field: field_name.to_string(),
-                        expected: "integer",
-                        value: String::from_utf8_lossy(bytes).to_string(),
-                    })?;
-                Ok(PolyValue::Int(val))
-            }
-            ScalarType::Float => {
-                let trimmed = trim_bytes(bytes);
-                let val: f64 =
-                    lexical_core::parse(trimmed).map_err(|_| PolyXmlError::ScalarParseError {
-                        field: field_name.to_string(),
-                        expected: "float",
-                        value: String::from_utf8_lossy(bytes).to_string(),
-                    })?;
-                Ok(PolyValue::Float(val))
-            }
-            ScalarType::Bool => {
-                let trimmed = trim_bytes(bytes);
-                match trimmed {
-                    b"true" | b"1" => Ok(PolyValue::Bool(true)),
-                    b"false" | b"0" => Ok(PolyValue::Bool(false)),
-                    _ => Err(PolyXmlError::ScalarParseError {
-                        field: field_name.to_string(),
-                        expected: "boolean ('true', 'false', '1', '0')",
-                        value: String::from_utf8_lossy(bytes).to_string(),
-                    }),
-                }
-            }
-            ScalarType::Decimal
-            | ScalarType::XmlDate
-            | ScalarType::XmlDateTime
-            | ScalarType::XmlTime
-            | ScalarType::XmlDuration
-            | ScalarType::Any => {
-                let s = std::str::from_utf8(trim_bytes(bytes))?;
-                Ok(PolyValue::String(s.to_string()))
-            }
-        }
-    }
-}