polyxml 0.30.7__tar.gz → 0.32.0__tar.gz

{polyxml-0.30.7 → polyxml-0.32.0}/Cargo.lock

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

{polyxml-0.30.7 → polyxml-0.32.0}/Cargo.toml

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

{polyxml-0.30.7 → polyxml-0.32.0}/PKG-INFO

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

{polyxml-0.30.7 → polyxml-0.32.0}/crates/polyxml-core/src/codegen/python/aot.rs

@@ -147,6 +147,8 @@ restored_json = {module_name}.<ModelName>.from_json(json_data)
             pyo3: true,
             pyo3_module_name: Some(module_name.clone()),
             custom_header: self.options.custom_header.clone(),
+            split_units: None,
+            chunk_size: None,
         };
         let rust_codegen = RustCodegen::new(rust_opts);
         let lib_rs = rust_codegen.generate_module(ir);

{polyxml-0.30.7 → polyxml-0.32.0}/crates/polyxml-core/src/codegen/rust/mod.rs

@@ -42,6 +42,12 @@ pub struct RustOptions {
     pub pyo3_module_name: Option<String>,
     /// Custom header text to prepend to generated files (default: None).
     pub custom_header: Option<String>,
+    /// Split oversized modules into bounded topological chunks (default: None, auto-split if > 400 types).
+    #[serde(default)]
+    pub split_units: Option<bool>,
+    /// Target maximum types per compilation unit chunk (default: 250).
+    #[serde(default)]
+    pub chunk_size: Option<usize>,
 }
 
 impl Default for RustOptions {
@@ -58,6 +64,8 @@ impl Default for RustOptions {
             pyo3: false,
             pyo3_module_name: None,
             custom_header: None,
+            split_units: None,
+            chunk_size: None,
         }
     }
 }
@@ -263,12 +271,7 @@ impl RustCodegen {
                 continue;
             }
             out.push('\n');
-            match type_def {
-                TypeDef::Simple(s) => self.emit_simple_type(&mut out, s, &types_with_lifetime),
-                TypeDef::Enum(e) => self.emit_enum(&mut out, e),
-                TypeDef::Union(u) => self.emit_union(&mut out, u, &types_with_lifetime, ir),
-                TypeDef::Struct(s) => self.emit_struct(&mut out, s, &types_with_lifetime, ir),
-            }
+            self.emit_single_type(&mut out, type_def, &types_with_lifetime, ir);
         }
 
         if self.options.emit_root_aliases {
@@ -285,6 +288,147 @@ impl RustCodegen {
         out.replace("var_r#", "var_")
     }
 
+    fn emit_single_type(
+        &self,
+        out: &mut String,
+        type_def: &TypeDef,
+        types_with_lifetime: &HashSet<QName>,
+        ir: &SchemaIR,
+    ) {
+        match type_def {
+            TypeDef::Simple(s) => self.emit_simple_type(out, s, types_with_lifetime),
+            TypeDef::Enum(e) => self.emit_enum(out, e),
+            TypeDef::Union(u) => self.emit_union(out, u, types_with_lifetime, ir),
+            TypeDef::Struct(s) => self.emit_struct(out, s, types_with_lifetime, ir),
+        }
+    }
+
+    /// Generate a multi-file or single-file module representation.
+    /// When `split_units` is requested or the type count exceeds the threshold,
+    /// emits topologically sorted, bounded chunk modules (`chunk_00.rs`, `chunk_01.rs`, ...)
+    /// and a parent `mod.rs` that re-exports all chunks.
+    pub fn generate_files(&self, ir: &SchemaIR, base_name: &str) -> Vec<(String, String)> {
+        set_type_name_map(build_type_name_map(ir, |local| {
+            AsPascalCase(local).to_string()
+        }));
+
+        let emitted_count = ir.types.keys().filter(|q| !ir.is_external_type(q)).count();
+        let should_split = self.options.split_units.unwrap_or(emitted_count > 400);
+        let chunk_size = self.options.chunk_size.unwrap_or(250);
+
+        if !should_split {
+            let code = self.generate_module(ir);
+            if base_name == "mod" {
+                return vec![("mod.rs".to_string(), code)];
+            }
+            return vec![
+                (format!("{}.rs", base_name), code),
+                (
+                    "mod.rs".to_string(),
+                    format!("pub mod {base_name};\npub use {base_name}::*;\n"),
+                ),
+            ];
+        }
+
+        let plan = ir.partition_topological_chunks(chunk_size);
+        if plan.chunks.len() <= 1 {
+            let code = self.generate_module(ir);
+            if base_name == "mod" {
+                return vec![("mod.rs".to_string(), code)];
+            }
+            return vec![
+                (format!("{}.rs", base_name), code),
+                (
+                    "mod.rs".to_string(),
+                    format!("pub mod {base_name};\npub use {base_name}::*;\n"),
+                ),
+            ];
+        }
+
+        let types_with_lifetime = if self.options.zero_copy {
+            self.compute_types_with_lifetime(ir)
+        } else {
+            HashSet::new()
+        };
+
+        let mut files = Vec::new();
+
+        // 1. Chunks
+        for chunk in &plan.chunks {
+            let mut out = String::new();
+            if let Some(ref header) = self.options.custom_header {
+                let trimmed = header.trim();
+                if !trimmed.is_empty() {
+                    out.push_str(trimmed);
+                    out.push_str("\n\n");
+                }
+            }
+            out.push_str(
+                "// @generated by PolyXML Compiler (https://github.com/polyxml/PolyXML)\n",
+            );
+            out.push_str(
+                "#![allow(dead_code, unused_imports, unused_mut, unused_variables, unused_assignments, non_camel_case_types, non_snake_case)]\n\n",
+            );
+
+            self.emit_imports(&mut out, !types_with_lifetime.is_empty());
+            out.push_str("\nuse super::*;\n");
+
+            for qname in &chunk.types {
+                if let Some(type_def) = ir.types.get(qname) {
+                    out.push('\n');
+                    self.emit_single_type(&mut out, type_def, &types_with_lifetime, ir);
+                }
+            }
+
+            let code = out.replace("var_r#", "var_");
+            files.push((format!("{}.rs", chunk.name), code));
+        }
+
+        // 2. mod.rs
+        let mut mod_out = String::new();
+        if let Some(ref header) = self.options.custom_header {
+            let trimmed = header.trim();
+            if !trimmed.is_empty() {
+                mod_out.push_str(trimmed);
+                mod_out.push_str("\n\n");
+            }
+        }
+        mod_out
+            .push_str("// @generated by PolyXML Compiler (https://github.com/polyxml/PolyXML)\n");
+        mod_out.push_str(
+            "#![allow(dead_code, unused_imports, unused_mut, unused_variables, unused_assignments, non_camel_case_types, non_snake_case)]\n\n",
+        );
+
+        self.emit_imports(&mut mod_out, !types_with_lifetime.is_empty());
+        mod_out.push('\n');
+
+        for chunk in &plan.chunks {
+            let _ = writeln!(mod_out, "pub mod {};", chunk.name);
+        }
+        mod_out.push('\n');
+        for chunk in &plan.chunks {
+            let _ = writeln!(mod_out, "pub use {}::*;", chunk.name);
+        }
+
+        if self.options.emit_codecs {
+            self.emit_codec_helpers(&mut mod_out);
+        }
+
+        if self.options.emit_root_aliases {
+            self.emit_root_aliases(&mut mod_out, ir, &types_with_lifetime);
+        }
+
+        if self.options.pyo3 {
+            let sorted_types = self.order_types(ir);
+            self.emit_pymodule(&mut mod_out, ir, &sorted_types);
+        }
+
+        let mod_code = mod_out.replace("var_r#", "var_");
+        files.push(("mod.rs".to_string(), mod_code));
+
+        files
+    }
+
     /// Fixed-point analysis determining which types in SchemaIR require a lifetime parameter `<'a>`.
     fn compute_types_with_lifetime(&self, ir: &SchemaIR) -> HashSet<QName> {
         let mut requires_lifetime = HashSet::new();
@@ -896,7 +1040,9 @@ impl RustCodegen {
 
     fn emit_codec_helpers(&self, out: &mut String) {
         out.push_str("\n#[allow(dead_code)]\n");
-        out.push_str("fn skip_xml_element(reader: &mut Reader<&[u8]>) -> Result<()> {\n");
+        out.push_str(
+            "pub(crate) fn skip_xml_element(reader: &mut Reader<&[u8]>) -> Result<()> {\n",
+        );
         out.push_str("    let mut depth = 1;\n");
         out.push_str("    loop {\n");
         out.push_str("        match reader.read_event()? {\n");
@@ -916,7 +1062,7 @@ impl RustCodegen {
 
         if self.options.zero_copy {
             out.push_str("#[allow(dead_code)]\n");
-            out.push_str("fn read_element_text<'a>(reader: &mut Reader<&'a [u8]>, tag_name: &str) -> Result<Cow<'a, str>> {\n");
+            out.push_str("pub(crate) fn read_element_text<'a>(reader: &mut Reader<&'a [u8]>, tag_name: &str) -> Result<Cow<'a, str>> {\n");
             out.push_str("    let mut text = Cow::Borrowed(\"\");\n");
             out.push_str("    loop {\n");
             out.push_str("        match reader.read_event()? {\n");
@@ -963,7 +1109,7 @@ impl RustCodegen {
             out.push_str("}\n");
         } else {
             out.push_str("#[allow(dead_code)]\n");
-            out.push_str("fn read_element_text(reader: &mut Reader<&[u8]>, tag_name: &str) -> Result<String> {\n");
+            out.push_str("pub(crate) fn read_element_text(reader: &mut Reader<&[u8]>, tag_name: &str) -> Result<String> {\n");
             out.push_str("    let mut text = String::new();\n");
             out.push_str("    loop {\n");
             out.push_str("        match reader.read_event()? {\n");