polyxml 0.34.0__tar.gz → 0.34.2__tar.gz

{polyxml-0.34.0 → polyxml-0.34.2}/Cargo.lock

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

{polyxml-0.34.0 → polyxml-0.34.2}/Cargo.toml

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

{polyxml-0.34.0 → polyxml-0.34.2}/PKG-INFO

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

{polyxml-0.34.0 → polyxml-0.34.2}/crates/polyxml-core/src/codegen/csharp/mod.rs

@@ -114,6 +114,12 @@ pub fn to_csharp_property_name(raw: &str, enclosing_type: Option<&str>) -> Strin
     };
 
     let sanitized = sanitize_keyword(&safe, "csharp");
+    // Positional record members cannot shadow the synthesized equality methods.
+    let sanitized = if matches!(sanitized.as_str(), "Equals" | "GetHashCode" | "ToString") {
+        format!("{sanitized}Value")
+    } else {
+        sanitized
+    };
     if let Some(enclosing) = enclosing_type {
         if sanitized == enclosing || sanitized.trim_start_matches('@') == enclosing {
             return format!("{}Value", sanitized);

{polyxml-0.34.0 → polyxml-0.34.2}/crates/polyxml-core/src/codegen/python/mod.rs

@@ -36,7 +36,7 @@ fn write_python_docstring(out: &mut String, indent: &str, doc: &str) {
     let escaped = doc
         .trim()
         .replace('\\', "\\\\")
-        .replace("\"\"\"", "\\\"\\\"\\\"")
+        .replace('"', "\\\"")
         .replace('\r', "");
     let _ = writeln!(out, "{indent}\"\"\"{escaped}\"\"\"");
 }

{polyxml-0.34.0 → polyxml-0.34.2}/crates/polyxml-core/src/codegen/rust/mod.rs

@@ -16,7 +16,7 @@ use crate::ir::{
 /// Options configuring Rust 2021/2024 code generation.
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct RustOptions {
-    /// Use zero-copy Cow<'a, str> and Cow<'a, [u8]> (default: true).
+    /// Use zero-copy Cow<'a, str> for XML lexical values (default: true).
     pub zero_copy: bool,
     /// Derive serde::{Serialize, Deserialize} (default: true).
     pub derive_serde: bool,
@@ -147,11 +147,13 @@ impl LanguageContext for RustLanguageContext {
             PrimitiveType::UnsignedShort => "u16",
             PrimitiveType::UnsignedByte => "u8",
 
+            // XML carries hex/base64 lexical text, just as the runtime schema does.
+            // Preserve that spelling; callers can explicitly decode binary payloads.
             PrimitiveType::HexBinary | PrimitiveType::Base64Binary => {
                 if self.zero_copy {
-                    "Cow<'a, [u8]>"
+                    "Cow<'a, str>"
                 } else {
-                    "Vec<u8>"
+                    "String"
                 }
             }
         }

{polyxml-0.34.0 → polyxml-0.34.2}/crates/polyxml-core/src/schema_parser/mod.rs

@@ -2554,7 +2554,13 @@ fn collect_chain_patterns(ir: &SchemaIR, q: &QName, visited: &mut HashSet<QName>
 }
 
 fn merge_ir(dest: &mut SchemaIR, src: SchemaIR) {
-    dest.upa_documents.extend(src.upa_documents);
+    // Diamond include graphs can replay the same transitive document many times.
+    // Validate each identical source model once; chameleon copies differ by namespace.
+    for document in src.upa_documents {
+        if !dest.upa_documents.contains(&document) {
+            dest.upa_documents.push(document);
+        }
+    }
     dest.abstract_elements.extend(src.abstract_elements);
     dest.ordered_types.extend(src.ordered_types);
     dest.content_models.extend(src.content_models);

{polyxml-0.34.0 → polyxml-0.34.2}/crates/polyxml-core/tests/test_csharp_codegen.rs

@@ -79,6 +79,7 @@ static DOTNET_LOCK: Mutex<()> = Mutex::new(());
 #[test]
 fn particle_wire_structure_round_trips() {
     for (schema, root, documents) in [
+        (r#"<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"><xs:element name="Query"><xs:complexType><xs:sequence><xs:element name="Equals" type="xs:string"/><xs:element name="EqualsValue" type="xs:string"/><xs:element name="GetHashCode" type="xs:string"/><xs:element name="ToString" type="xs:string"/></xs:sequence></xs:complexType></xs:element></xs:schema>"#, "Query", vec!["<Query><Equals>a</Equals><EqualsValue>b</EqualsValue><GetHashCode>c</GetHashCode><ToString>d</ToString></Query>"]),
         (include_str!("../../../research/fixtures/nested_sequence_choice.xsd"), "Root", vec!["<Root><First>A</First><Second>B</Second></Root>", "<Root><Alternative>C</Alternative></Root>"]),
         (include_str!("../../../research/fixtures/repeated_sequence.xsd"), "Root", vec!["<Root><First>A1</First><Second>B1</Second><First>A2</First><Second>B2</Second></Root>"]),
         (include_str!("../../../research/fixtures/substitution_group.xsd"), "Portfolio", vec!["<Portfolio xmlns='urn:audit:substitution'><Bond>A1</Bond><Equity>B1</Equity><Bond>A2</Bond></Portfolio>"]),

{polyxml-0.34.0 → polyxml-0.34.2}/crates/polyxml-core/tests/test_python_codegen.rs

@@ -793,3 +793,32 @@ fn test_python_sequence_nested_inside_choice_codegen() {
     assert!(code.contains("first: str | None = field("));
     assert!(code.contains("second: str | None = field("));
 }
+
+#[test]
+fn quoted_docstrings_preserve_text_and_remain_valid_python() {
+    let ir = XsdParser::new().parse_str(r#"<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"><xs:simpleType name="Direction"><xs:annotation><xs:documentation>Default is "Outbound"</xs:documentation></xs:annotation><xs:restriction base="xs:string"><xs:enumeration value="Outbound"/></xs:restriction></xs:simpleType><xs:complexType name="Record"><xs:annotation><xs:documentation>Literal \path, "quotes" and """triples"""</xs:documentation></xs:annotation><xs:sequence><xs:element name="direction" type="Direction"/></xs:sequence></xs:complexType></xs:schema>"#).unwrap();
+    for backend in [PythonBackend::Dataclass, PythonBackend::Pydantic] {
+        let dir = tempfile::tempdir().unwrap();
+        let path = dir.path().join("models.py");
+        std::fs::write(
+            &path,
+            PythonCodegen::new(PythonOptions {
+                backend,
+                ..Default::default()
+            })
+            .generate_module(&ir),
+        )
+        .unwrap();
+        let expected = serde_json::to_string(&vec![
+            "Default is \"Outbound\"",
+            r#"Literal \path, "quotes" and """triples""""#,
+        ])
+        .unwrap();
+        let output = std::process::Command::new("python3").arg("-c").arg("import ast,json,sys; tree=ast.parse(open(sys.argv[1]).read()); docs=[ast.get_docstring(n) for n in tree.body if isinstance(n,ast.ClassDef) and ast.get_docstring(n) is not None]; assert docs==json.loads(sys.argv[2]),docs").arg(path).arg(expected).output().unwrap();
+        assert!(
+            output.status.success(),
+            "{}",
+            String::from_utf8_lossy(&output.stderr)
+        );
+    }
+}

{polyxml-0.34.0 → polyxml-0.34.2}/crates/polyxml-core/tests/test_rust_codegen.rs

@@ -1310,3 +1310,57 @@ fn test_rust_digit_prefixed_module_sanitization() {
     assert!(mod_file.1.contains("pub mod _17_report;"));
     assert!(mod_file.1.contains("pub use _17_report::*;"));
 }
+
+#[test]
+fn binary_lexical_values_compile_and_round_trip_in_owned_and_borrowed_modes() {
+    let schema = r#"<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
+      <xs:complexType name="BinaryText"><xs:simpleContent><xs:extension base="xs:hexBinary"/></xs:simpleContent></xs:complexType>
+      <xs:complexType name="Payload"><xs:sequence>
+        <xs:element name="required" type="xs:hexBinary"/>
+        <xs:element name="optional" type="xs:base64Binary" minOccurs="0"/>
+        <xs:element name="repeated" type="xs:hexBinary" maxOccurs="unbounded"/>
+      </xs:sequence><xs:attribute name="encoded" type="xs:base64Binary"/></xs:complexType>
+      <xs:complexType name="Alternative"><xs:choice><xs:element name="hex" type="xs:hexBinary"/><xs:element name="base64" type="xs:base64Binary"/></xs:choice></xs:complexType>
+    </xs:schema>"#;
+    let ir = XsdParser::new().parse_str(schema).unwrap();
+    let core = std::path::Path::new(env!("CARGO_MANIFEST_DIR"));
+    for zero_copy in [true, false] {
+        let dir = tempfile::tempdir().unwrap();
+        std::fs::create_dir(dir.path().join("src")).unwrap();
+        std::fs::write(dir.path().join("Cargo.toml"), format!("[package]\nname=\"binary-lexical-test\"\nversion=\"0.0.0\"\nedition=\"2021\"\n[dependencies]\npolyxml={{path={core:?}}}\nquick-xml={{version=\"0.42\",features=[\"serialize\"]}}\nserde={{version=\"1\",features=[\"derive\"]}}\nserde_json=\"1\"\nregex=\"1\"\n")).unwrap();
+        let code = RustCodegen::new(RustOptions {
+            zero_copy,
+            ..Default::default()
+        })
+        .generate_module(&ir);
+        std::fs::write(dir.path().join("src/models.rs"), code).unwrap();
+        std::fs::write(dir.path().join("src/main.rs"), r#"mod models;
+use models::*;
+fn main() {
+ let xml="<Payload encoded=\"YWI=\"><required>0aFF</required><optional>YWI=</optional><repeated>00</repeated><repeated>FE</repeated></Payload>";
+ let value=Payload::from_xml(xml).unwrap();
+ assert_eq!(&*value.required,"0aFF"); assert_eq!(&*value.optional.as_ref().unwrap(),"YWI=");
+ assert_eq!(&*value.repeated[1],"FE"); assert_eq!(&*value.encoded.as_ref().unwrap(),"YWI=");
+ assert_eq!(value.to_xml_string().unwrap(),xml);
+ let text=BinaryText::from_xml("<BinaryText>0AFF</BinaryText>").unwrap();
+ assert_eq!(text.to_xml_string().unwrap(),"<BinaryText>0AFF</BinaryText>");
+ for xml in ["<hex>0AFF</hex>","<base64>YWI=</base64>"] { let value=Alternative::from_xml(xml).unwrap(); assert_eq!(value.to_xml_string().unwrap(),xml); }
+}
+"#).unwrap();
+        let output = std::process::Command::new("cargo")
+            .args(["run", "--quiet", "--offline"])
+            .env(
+                "CARGO_TARGET_DIR",
+                core.join("../../target/binary-lexical-tests"),
+            )
+            .current_dir(dir.path())
+            .output()
+            .unwrap();
+        assert!(
+            output.status.success(),
+            "zero_copy={zero_copy}: {}\n{}",
+            String::from_utf8_lossy(&output.stdout),
+            String::from_utf8_lossy(&output.stderr)
+        );
+    }
+}

{polyxml-0.34.0 → polyxml-0.34.2}/crates/polyxml-core/tests/test_schema_audit.rs

@@ -576,3 +576,30 @@ fn restricted_simple_types_emit_named_aliases() {
     let csharp = CSharpCodegen::new(CSharpOptions::default()).generate_module(&ir);
     assert!(csharp.contains("BicCode"), "csharp type missing:\n{csharp}");
 }
+
+#[test]
+fn diamond_includes_do_not_duplicate_upa_source_documents() {
+    let dir = tempdir().unwrap();
+    for index in 0usize..16 {
+        let includes = (index.saturating_sub(2)..index)
+            .map(|previous| format!("<xs:include schemaLocation=\"{previous}.xsd\"/>"))
+            .collect::<String>();
+        fs::write(dir.path().join(format!("{index}.xsd")), format!("<xs:schema xmlns:xs=\"http://www.w3.org/2001/XMLSchema\">{includes}<xs:complexType name=\"T{index}\"><xs:sequence><xs:element name=\"item{index}\" type=\"xs:string\"/></xs:sequence></xs:complexType></xs:schema>")).unwrap();
+    }
+    let mut parser = XsdParser::new();
+    let ir = parser.parse_file(dir.path().join("15.xsd")).unwrap();
+    assert_eq!(ir.types.len(), 16);
+    assert_eq!(
+        ir.upa_documents.len(),
+        16,
+        "each unique source document is retained once"
+    );
+    assert_eq!(
+        parser
+            .parse_file(dir.path().join("15.xsd"))
+            .unwrap()
+            .upa_documents
+            .len(),
+        16
+    );
+}

{polyxml-0.34.0 → polyxml-0.34.2}/pyproject.toml

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