polyxml 0.30.1__tar.gz → 0.30.2__tar.gz

{polyxml-0.30.1 → polyxml-0.30.2}/Cargo.lock

@@ -608,7 +608,7 @@ dependencies = [
 
 [[package]]
 name = "polyxml"
-version = "0.30.1"
+version = "0.30.2"
 dependencies = [
  "criterion",
  "heck",
@@ -629,14 +629,14 @@ dependencies = [
 
 [[package]]
 name = "polyxml-c"
-version = "0.30.1"
+version = "0.30.2"
 dependencies = [
  "polyxml",
 ]
 
 [[package]]
 name = "polyxml-cli"
-version = "0.30.1"
+version = "0.30.2"
 dependencies = [
  "clap",
  "glob",
@@ -650,7 +650,7 @@ dependencies = [
 
 [[package]]
 name = "polyxml-js"
-version = "0.30.1"
+version = "0.30.2"
 dependencies = [
  "napi",
  "napi-build",
@@ -660,7 +660,7 @@ dependencies = [
 
 [[package]]
 name = "polyxml-python"
-version = "0.30.1"
+version = "0.30.2"
 dependencies = [
  "lexical-core",
  "polyxml",
@@ -670,7 +670,7 @@ dependencies = [
 
 [[package]]
 name = "polyxml-wasm"
-version = "0.30.1"
+version = "0.30.2"
 dependencies = [
  "polyxml",
  "quick-xml",

{polyxml-0.30.1 → polyxml-0.30.2}/Cargo.toml

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

{polyxml-0.30.1 → polyxml-0.30.2}/PKG-INFO

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

{polyxml-0.30.1 → polyxml-0.30.2}/crates/polyxml-core/src/codegen/rust/mod.rs

@@ -5,8 +5,8 @@ use heck::{AsPascalCase, AsSnakeCase};
 use serde::{Deserialize, Serialize};
 
 use crate::codegen::{
-    build_type_name_map, flatten_fields, lookup_type_name, sanitize_keyword, set_type_name_map,
-    LanguageContext,
+    build_type_name_map, flatten_fields, lookup_type_name, primitive_base, sanitize_keyword,
+    set_type_name_map, LanguageContext,
 };
 use crate::ir::{
     EnumDef, FieldDef, FieldKind, PrimitiveType, QName, SchemaIR, SimpleTypeDef, StructDef,
@@ -998,8 +998,17 @@ impl RustCodegen {
         }
     }
 
+    fn unwrap_type_ref(mut ty: &TypeRef) -> &TypeRef {
+        while let TypeRef::Boxed(inner) | TypeRef::List(inner) = ty {
+            ty = inner;
+        }
+        ty
+    }
+
     fn field_is_string(&self, type_ref: &TypeRef, ir: &SchemaIR) -> bool {
-        match type_ref {
+        let ty = Self::unwrap_type_ref(type_ref);
+        let base = primitive_base(ty, ir);
+        match base {
             TypeRef::Primitive(prim) => matches!(
                 prim,
                 PrimitiveType::String
@@ -1030,19 +1039,14 @@ impl RustCodegen {
                     | PrimitiveType::HexBinary
                     | PrimitiveType::AnySimpleType
             ),
-            TypeRef::Named(qname) => {
-                if let Some(TypeDef::Simple(s)) = ir.types.get(qname) {
-                    self.field_is_string(&s.base_type, ir)
-                } else {
-                    false
-                }
-            }
-            TypeRef::Boxed(inner) | TypeRef::List(inner) => self.field_is_string(inner, ir),
+            _ => false,
         }
     }
 
     fn field_numeric_type(&self, type_ref: &TypeRef, ir: &SchemaIR) -> Option<&'static str> {
-        match type_ref {
+        let ty = Self::unwrap_type_ref(type_ref);
+        let base = primitive_base(ty, ir);
+        match base {
             TypeRef::Primitive(prim) => match prim {
                 PrimitiveType::Int => Some("i32"),
                 PrimitiveType::Integer
@@ -1061,30 +1065,14 @@ impl RustCodegen {
                 PrimitiveType::Float => Some("f32"),
                 _ => None,
             },
-            TypeRef::Named(qname) => {
-                if let Some(TypeDef::Simple(s)) = ir.types.get(qname) {
-                    self.field_numeric_type(&s.base_type, ir)
-                } else {
-                    None
-                }
-            }
-            TypeRef::Boxed(inner) | TypeRef::List(inner) => self.field_numeric_type(inner, ir),
+            _ => None,
         }
     }
 
     fn field_is_bool(&self, type_ref: &TypeRef, ir: &SchemaIR) -> bool {
-        match type_ref {
-            TypeRef::Primitive(PrimitiveType::Boolean) => true,
-            TypeRef::Named(qname) => {
-                if let Some(TypeDef::Simple(s)) = ir.types.get(qname) {
-                    self.field_is_bool(&s.base_type, ir)
-                } else {
-                    false
-                }
-            }
-            TypeRef::Boxed(inner) | TypeRef::List(inner) => self.field_is_bool(inner, ir),
-            _ => false,
-        }
+        let ty = Self::unwrap_type_ref(type_ref);
+        let base = primitive_base(ty, ir);
+        matches!(base, TypeRef::Primitive(PrimitiveType::Boolean))
     }
 
     fn field_is_enum(&self, type_ref: &TypeRef, ir: &SchemaIR) -> Option<String> {

{polyxml-0.30.1 → polyxml-0.30.2}/crates/polyxml-core/tests/test_rust_codegen.rs

@@ -3,7 +3,7 @@ use polyxml::codegen::rust::{
 };
 use polyxml::ir::{
     Cardinality, EnumDef, EnumValue, FieldDef, FieldKind, PrimitiveType, QName, SchemaIR,
-    StructDef, TypeDef, TypeRef, UnionBranch, UnionDef,
+    SimpleTypeDef, StructDef, TypeDef, TypeRef, UnionBranch, UnionDef,
 };
 use polyxml::schema_parser::XsdParser;
 
@@ -1147,3 +1147,44 @@ fn test_rust_phf_dispatch_uniquifies_like_field_metas() {
         "bare-string arm leaked into the Option match:\n{code}"
     );
 }
+
+#[test]
+fn test_rust_simple_type_cycle_resilience() {
+    let mut ir = SchemaIR::default();
+    let q_a = QName::new(Some("urn:cycle"), "TypeA");
+    let q_b = QName::new(Some("urn:cycle"), "TypeB");
+
+    // Mutual cycle between TypeA and TypeB
+    ir.add_type(TypeDef::Simple(Box::new(SimpleTypeDef {
+        qname: q_a.clone(),
+        base_type: TypeRef::Named(q_b.clone()),
+        facets: Default::default(),
+        documentation: None,
+    })));
+    ir.add_type(TypeDef::Simple(Box::new(SimpleTypeDef {
+        qname: q_b.clone(),
+        base_type: TypeRef::Named(q_a.clone()),
+        facets: Default::default(),
+        documentation: None,
+    })));
+
+    let struct_fields = vec![FieldDef::new(
+        "cyclic_field",
+        "cyclic_field",
+        FieldKind::Element,
+        TypeRef::Named(q_a),
+    )];
+
+    ir.add_type(TypeDef::Struct(StructDef {
+        qname: QName::new(Some("urn:cycle"), "CyclicStruct"),
+        fields: struct_fields,
+        base_type: None,
+        is_abstract: false,
+        is_mixed: false,
+        documentation: None,
+    }));
+
+    let codegen = RustCodegen::new(RustOptions::default());
+    let code = codegen.generate_module(&ir);
+    assert!(code.contains("pub struct CyclicStruct"));
+}

{polyxml-0.30.1 → polyxml-0.30.2}/pyproject.toml

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