polyxml 0.34.1__tar.gz → 0.34.3__tar.gz

{polyxml-0.34.1 → polyxml-0.34.3}/Cargo.lock

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

{polyxml-0.34.1 → polyxml-0.34.3}/Cargo.toml

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

{polyxml-0.34.1 → polyxml-0.34.3}/PKG-INFO

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

{polyxml-0.34.1 → polyxml-0.34.3}/crates/polyxml-core/src/codegen/csharp/mod.rs

@@ -1099,6 +1099,53 @@ impl CSharpCodegen {
         true
     }
 
+    fn emit_optional_enum_attribute_proxy(
+        &self,
+        out: &mut String,
+        field: &FieldDef,
+        name: &str,
+        ir: &SchemaIR,
+        indent: &str,
+    ) -> bool {
+        if !self.options.emit_xml_attributes
+            || field.kind != FieldKind::Attribute
+            || !field.cardinality.is_optional()
+            || field.cardinality.is_list()
+        {
+            return false;
+        }
+        let TypeRef::Named(qname) = &field.type_ref else {
+            return false;
+        };
+        if !matches!(ir.types.get(qname), Some(TypeDef::Enum(_))) {
+            return false;
+        }
+        let ty = self.map_field_type(field, ir);
+        let base = ty.trim_end_matches('?');
+        let namespace = field
+            .namespace
+            .as_ref()
+            .map(|ns| format!(", Namespace = {ns:?}"))
+            .unwrap_or_default();
+        if self.options.emit_json_attributes {
+            writeln!(out, "{indent}    [JsonPropertyName({:?})]", field.xml_name).unwrap();
+        }
+        writeln!(
+            out,
+            "{indent}    [XmlIgnore] public {ty} {name} {{ get; set; }}"
+        )
+        .unwrap();
+        if self.options.emit_json_attributes {
+            // Keep the XML lexical proxy out of JSON, preserving the typed property.
+            writeln!(out, "{indent}    [JsonIgnore]").unwrap();
+        }
+        writeln!(out, "{indent}    [XmlAttribute({:?}{namespace})] public string? {name}Xml {{
+{indent}        get => {name}?.ToXmlValue();
+{indent}        set => {name} = value is null ? null : ({base})new XmlSerializer(typeof({base}), new XmlRootAttribute(\"value\")).Deserialize(new System.IO.StringReader(\"<value>\" + System.Security.SecurityElement.Escape(value) + \"</value>\"))!;
+{indent}    }}", field.xml_name).unwrap();
+        true
+    }
+
     fn emit_default_scalar_proxy(
         &self,
         out: &mut String,
@@ -1392,6 +1439,8 @@ impl CSharpCodegen {
         }
 
         let has_lexical_union = self.options.emit_xml_attributes && s.fields.iter().any(|f| {
+            (f.kind == FieldKind::Attribute && f.cardinality.is_optional()
+                && matches!(&f.type_ref, TypeRef::Named(q) if matches!(ir.types.get(q), Some(TypeDef::Enum(_))))) ||
             matches!(f.type_ref, TypeRef::Primitive(p) if p.is_unbounded_integer()) || matches!(f.type_ref, TypeRef::Primitive(PrimitiveType::Date | PrimitiveType::DateTime | PrimitiveType::Time | PrimitiveType::Duration)) || f.default_value.is_some() || f.fixed_value.is_some() || matches!(&f.type_ref, TypeRef::Named(q) if matches!(ir.types.get(q), Some(TypeDef::Union(u)) if u.is_lexical()))
         });
 
@@ -1404,6 +1453,7 @@ impl CSharpCodegen {
             .unwrap();
             for (f, name) in s.fields.iter().zip(&prop_names) {
                 if self.emit_default_scalar_proxy(out, f, name, ir, indent)
+                    || self.emit_optional_enum_attribute_proxy(out, f, name, ir, indent)
                     || self.emit_integer_proxy(out, f, name, ir, indent)
                     || self.emit_temporal_proxy(out, f, name, ir, indent)
                 {
@@ -1471,6 +1521,7 @@ impl CSharpCodegen {
             writeln!(out, "{}    public {}() {{ }}", indent, struct_name).unwrap();
             for (f, name) in s.fields.iter().zip(&prop_names) {
                 if self.emit_default_scalar_proxy(out, f, name, ir, indent)
+                    || self.emit_optional_enum_attribute_proxy(out, f, name, ir, indent)
                     || self.emit_integer_proxy(out, f, name, ir, indent)
                     || self.emit_temporal_proxy(out, f, name, ir, indent)
                 {

{polyxml-0.34.1 → polyxml-0.34.3}/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.1 → polyxml-0.34.3}/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.1 → polyxml-0.34.3}/crates/polyxml-core/src/schema_parser/mod.rs

@@ -350,20 +350,13 @@ impl XsdParser {
                             }
                         }
                         "attribute" => {
-                            if let (Some(name), Some(ty)) =
-                                (get_attr_value(e, "name"), get_attr_value(e, "type"))
-                            {
-                                ir.attributes
-                                    .entry(QName::new(target_namespace.as_deref(), name))
-                                    .or_insert_with(|| {
-                                        resolve_type_ref(
-                                            &ty,
-                                            target_namespace.as_deref(),
-                                            &prefixes,
-                                        )
-                                    });
-                            }
-                            skip_subtree(&mut reader)?;
+                            self.parse_global_attribute(
+                                &mut reader,
+                                e,
+                                target_namespace.as_deref(),
+                                &prefixes,
+                                &mut ir,
+                            )?;
                         }
                         "group" => {
                             // Named model group definition.
@@ -445,18 +438,19 @@ impl XsdParser {
                             }
                         }
                         "attribute" => {
-                            if let (Some(name), Some(ty)) =
-                                (get_attr_value(e, "name"), get_attr_value(e, "type"))
-                            {
-                                ir.attributes
-                                    .entry(QName::new(target_namespace.as_deref(), name))
-                                    .or_insert_with(|| {
+                            if let Some(name) = get_attr_value(e, "name") {
+                                let type_ref = get_attr_value(e, "type")
+                                    .map(|ty| {
                                         resolve_type_ref(
                                             &ty,
                                             target_namespace.as_deref(),
                                             &prefixes,
                                         )
-                                    });
+                                    })
+                                    .unwrap_or_else(TypeRef::string);
+                                ir.attributes
+                                    .entry(QName::new(target_namespace.as_deref(), name))
+                                    .or_insert(type_ref);
                             }
                         }
                         "group" => {
@@ -1225,6 +1219,7 @@ impl XsdParser {
         let mut facets = RestrictionFacets::default();
         let mut enum_values = Vec::new();
         let mut union_branches: Option<Vec<UnionBranch>> = None;
+        let mut list_requires_inline = false;
         let mut documentation = None;
         let mut buf = Vec::new();
 
@@ -1252,14 +1247,30 @@ impl XsdParser {
                                     &item, target_ns, prefixes,
                                 )));
                             } else {
-                                return Err(SchemaError::Malformed(
-                                    "xs:list requires a supported itemType".into(),
-                                ));
+                                list_requires_inline = true;
                             }
                         }
                         "union" => {
                             union_branches = Some(parse_union_members(e, target_ns, prefixes));
                         }
+                        "simpleType" if list_requires_inline => {
+                            let item_name =
+                                unique_type_name(ir, target_ns, &format!("{}Item", qname.local));
+                            if let Some(item) = self.parse_simple_type(
+                                reader,
+                                e,
+                                target_ns,
+                                prefixes,
+                                Some(item_name),
+                                ir,
+                            )? {
+                                base_type =
+                                    TypeRef::List(Box::new(TypeRef::Named(item.qname().clone())));
+                                ir.add_type(item);
+                                list_requires_inline = false;
+                            }
+                            depth -= 1;
+                        }
                         "simpleType" if union_branches.is_some() => {
                             let branch_index = union_branches.as_ref().unwrap().len() + 1;
                             let inline_name = unique_type_name(
@@ -1380,7 +1391,12 @@ impl XsdParser {
                         _ => {}
                     }
                 }
-                Event::End(_) => {
+                Event::End(ref e) => {
+                    if strip_prefix(e.name().into_inner()) == "list" && list_requires_inline {
+                        return Err(SchemaError::Malformed(
+                            "xs:list requires itemType or an inline simpleType".into(),
+                        ));
+                    }
                     depth -= 1;
                 }
                 Event::Eof => break,
@@ -1465,6 +1481,46 @@ impl XsdParser {
         }
     }
 
+    fn parse_global_attribute(
+        &self,
+        reader: &mut Reader<&[u8]>,
+        start: &BytesStart,
+        target_ns: Option<&str>,
+        prefixes: &HashMap<String, String>,
+        ir: &mut SchemaIR,
+    ) -> Result<(), SchemaError> {
+        let Some(name) = get_attr_value(start, "name") else {
+            return skip_subtree(reader);
+        };
+        let mut type_ref = get_attr_value(start, "type")
+            .map(|ty| resolve_type_ref(&ty, target_ns, prefixes))
+            .unwrap_or_else(TypeRef::string);
+        loop {
+            match reader.read_event()? {
+                Event::Start(e) if strip_prefix(e.name().into_inner()) == "simpleType" => {
+                    let anonymous_name =
+                        unique_type_name(ir, target_ns, &format!("{name}AttributeType"));
+                    if let Some(definition) = self.parse_simple_type(
+                        reader,
+                        &e,
+                        target_ns,
+                        prefixes,
+                        Some(anonymous_name),
+                        ir,
+                    )? {
+                        type_ref = TypeRef::Named(definition.qname().clone());
+                        ir.add_type(definition);
+                    }
+                }
+                Event::Start(_) => skip_subtree(reader)?,
+                Event::End(_) | Event::Eof => break,
+                _ => {}
+            }
+        }
+        ir.attributes.insert(QName::new(target_ns, name), type_ref);
+        Ok(())
+    }
+
     fn parse_global_element(
         &mut self,
         reader: &mut Reader<&[u8]>,
@@ -2554,7 +2610,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);
@@ -2722,6 +2784,7 @@ fn validate_type_references(ir: &SchemaIR, xml: &str) -> Result<(), SchemaError>
 }
 fn validate_schema_grammar(xml: &str) -> Result<(), SchemaError> {
     let mut reader = Reader::from_str(xml);
+    let mut schema_namespace = None;
     let mut stack = Vec::<(String, HashMap<String, String>)>::new();
     let mut line = 1;
     let mut line_position = 0;
@@ -2748,6 +2811,9 @@ fn validate_schema_grammar(xml: &str) -> Result<(), SchemaError> {
             }
         }
         let local = strip_prefix(element.name().into_inner());
+        if stack.is_empty() && local == "schema" {
+            schema_namespace = get_attr_value(&element, "targetNamespace");
+        }
         let position = reader.buffer_position() as usize;
         line += xml[line_position..position]
             .bytes()
@@ -2798,6 +2864,9 @@ fn validate_schema_grammar(xml: &str) -> Result<(), SchemaError> {
                             )));
                         };
                         if namespace == "http://www.w3.org/2001/XMLSchema"
+                            // The schema-for-schemas declares named types in this
+                            // namespace; the resolved IR validates their existence.
+                            && schema_namespace.as_deref() != Some(namespace.as_str())
                             && attr.key.as_ref() != "ref"
                             && PrimitiveType::from_xsd_name(local).is_none()
                         {

{polyxml-0.34.1 → polyxml-0.34.3}/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.1 → polyxml-0.34.3}/crates/polyxml-core/tests/test_qualified_attributes.rs

@@ -15,11 +15,35 @@ fn global_attribute_references_round_trip_by_namespace() {
             "/../../research/fixtures/wave6/xlink_shared_attribute/root.xsd"
         ))
         .unwrap();
+    assert_attribute_round_trip(&ir);
+}
+
+#[test]
+fn imported_inline_global_attribute_enum_round_trips() {
+    let fixture = tempdir().unwrap();
+    fs::copy(
+        concat!(
+            env!("CARGO_MANIFEST_DIR"),
+            "/../../research/fixtures/wave6/xlink_shared_attribute/root.xsd"
+        ),
+        fixture.path().join("root.xsd"),
+    )
+    .unwrap();
+    fs::write(fixture.path().join("xlink.xsd"), r#"<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" targetNamespace="http://www.w3.org/1999/xlink">
+      <xs:attribute name="type"><xs:simpleType><xs:restriction base="xs:string"><xs:enumeration value="resource"/><xs:enumeration value="arc"/></xs:restriction></xs:simpleType></xs:attribute>
+    </xs:schema>"#).unwrap();
+    let ir = XsdParser::new()
+        .parse_file(fixture.path().join("root.xsd"))
+        .unwrap();
+    assert_attribute_round_trip(&ir);
+}
+
+fn assert_attribute_round_trip(ir: &polyxml::ir::SchemaIR) {
     let temp = tempdir().unwrap();
     fs::write(temp.path().join("go.mod"), "module attrs\n\ngo 1.22\n").unwrap();
     fs::write(
         temp.path().join("models.go"),
-        GoCodegen::new(GoOptions::default()).generate_module(&ir),
+        GoCodegen::new(GoOptions::default()).generate_module(ir),
     )
     .unwrap();
     fs::write(temp.path().join("models_test.go"), r#"package models
@@ -32,6 +56,8 @@ func TestAttributes(t *testing.T) {
  for {token,err:=decoder.Token();if err==io.EOF{break};if err!=nil{t.Fatal(err)};if start,ok:=token.(xml.StartElement);ok{for _,attr:=range start.Attr{if attr.Name.Space=="http://www.w3.org/1999/xlink"&&attr.Name.Local=="type"{count++;if attr.Value!="resource"&&attr.Value!="arc"{t.Fatal(attr)}}}}}
  if count!=2{t.Fatalf("attributes lost: %s",data)}
  }
+ var absent Links; if err:=xml.Unmarshal([]byte(`<Links><Resource/><Arc/></Links>`),&absent);err!=nil{t.Fatal(err)}
+ data,err:=xml.Marshal(absent);if err!=nil{t.Fatal(err)};if strings.Contains(string(data),`type=`){t.Fatalf("absent attribute emitted: %s",data)}
 }"#).unwrap();
     let result = Command::new("go")
         .args(["test", "./..."])
@@ -54,7 +80,7 @@ func TestAttributes(t *testing.T) {
                 use_records,
                 ..Default::default()
             })
-            .generate_module(&ir),
+            .generate_module(ir),
         )
         .unwrap();
         fs::write(temp.path().join("Program.cs"), r#"using System.Xml.Serialization;using System.Xml.Linq;using Models;
@@ -62,9 +88,30 @@ var serializer=new XmlSerializer(typeof(Links));
 foreach(var document in new[]{"<Links xmlns:xl='http://www.w3.org/1999/xlink'><Resource xl:type='resource'/><Arc xl:type='arc'/></Links>","<Links><Resource xmlns:b='http://www.w3.org/1999/xlink' b:type='resource'/><Arc xmlns:c='http://www.w3.org/1999/xlink' c:type='arc'/></Links>"}){
 var root=(Links)serializer.Deserialize(new StringReader(document))!;
 var writer=new StringWriter();serializer.Serialize(writer,root);
+using(var jsonDocument=System.Text.Json.JsonSerializer.SerializeToDocument(root)){
+if(!jsonDocument.RootElement.GetProperty("Resource").TryGetProperty("type",out _))throw new Exception("JSON wire name lost");
+}
 var xml=XDocument.Parse(writer.ToString());XNamespace ns="http://www.w3.org/1999/xlink";
 if((string?)xml.Root!.Element("Resource")!.Attribute(ns+"type")!="resource"||(string?)xml.Root.Element("Arc")!.Attribute(ns+"type")!="arc")throw new Exception(writer.ToString());
-}"#).unwrap();
+}
+var absent=(Links)serializer.Deserialize(new StringReader("<Links><Resource/><Arc/></Links>"))!;
+var absentWriter=new StringWriter();serializer.Serialize(absentWriter,absent);
+if(XDocument.Parse(absentWriter.ToString()).Descendants().Attributes().Any(a=>a.Name.LocalName=="type"))throw new Exception(absentWriter.ToString());
+var json=System.Text.Json.JsonSerializer.Serialize(absent);
+if(json.Contains("TypeXml"))throw new Exception("XML proxy leaked to JSON: "+json);
+"#).unwrap();
+        if ir
+            .types
+            .values()
+            .any(|definition| matches!(definition, polyxml::ir::TypeDef::Enum(_)))
+        {
+            use std::io::Write;
+            let mut program = fs::OpenOptions::new()
+                .append(true)
+                .open(temp.path().join("Program.cs"))
+                .unwrap();
+            writeln!(program, r#"bool rejected=false;try{{serializer.Deserialize(new StringReader("<Links xmlns:x='http://www.w3.org/1999/xlink'><Resource x:type='invalid'/><Arc/></Links>"));}}catch(InvalidOperationException){{rejected=true;}}if(!rejected)throw new Exception("invalid enum accepted");"#).unwrap();
+        }
         let result = Command::new("dotnet")
             .arg("run")
             .current_dir(temp.path())

{polyxml-0.34.1 → polyxml-0.34.3}/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.1 → polyxml-0.34.3}/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.1 → polyxml-0.34.3}/crates/polyxml-core/tests/test_schema_ir.rs

@@ -652,3 +652,140 @@ fn schema_errors_preserve_forward_imports_and_annotation_payloads() {
         assert!(XsdParser::new().parse_str(schema).is_err());
     }
 }
+
+#[test]
+fn imported_inline_global_attribute_types_are_resolved() {
+    let dir = tempdir().unwrap();
+    std::fs::write(dir.path().join("attributes.xsd"), r#"<s:schema xmlns:s="http://www.w3.org/2001/XMLSchema" targetNamespace="urn:attrs">
+      <s:attribute name="code"><s:annotation><s:documentation>Inline enum</s:documentation></s:annotation><s:simpleType><s:restriction base="s:string"><s:enumeration value="arc"/><s:enumeration value="resource"/></s:restriction></s:simpleType></s:attribute>
+      <s:attribute name="number"><s:simpleType><s:restriction base="s:int"><s:minInclusive value="3"/></s:restriction></s:simpleType></s:attribute>
+      <s:attribute name="lang"><s:simpleType><s:union memberTypes="s:language"><s:simpleType><s:restriction base="s:string"><s:enumeration value=""/></s:restriction></s:simpleType></s:union></s:simpleType></s:attribute>
+      <s:attribute name="plain"/>
+      <s:attribute name="annotated"><s:annotation><s:documentation>Untyped</s:documentation></s:annotation></s:attribute>
+    </s:schema>"#).unwrap();
+    let root = dir.path().join("root.xsd");
+    std::fs::write(&root, r#"<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" xmlns:a="urn:attrs">
+      <xs:import namespace="urn:attrs" schemaLocation="attributes.xsd"/>
+      <xs:complexType name="Record"><xs:attribute ref="a:code" use="required"/><xs:attribute ref="a:number"/><xs:attribute ref="a:lang"/><xs:attribute ref="a:plain"/><xs:attribute ref="a:annotated"/></xs:complexType>
+    </xs:schema>"#).unwrap();
+    let ir = XsdParser::new().parse_file(&root).unwrap();
+    let TypeDef::Struct(record) = &ir.types[&QName::new(None::<String>, "Record")] else {
+        panic!("Record");
+    };
+    for field in &record.fields {
+        assert_eq!(field.namespace.as_deref(), Some("urn:attrs"));
+        assert_eq!(
+            field.type_ref,
+            ir.attributes[&QName::new(Some("urn:attrs"), &field.xml_name)]
+        );
+    }
+    assert_eq!(record.fields[0].cardinality, Cardinality::required_one());
+    let TypeRef::Named(enum_name) = &record.fields[0].type_ref else {
+        panic!("enum type");
+    };
+    let TypeDef::Enum(enumeration) = &ir.types[enum_name] else {
+        panic!("enum declaration");
+    };
+    assert_eq!(
+        enumeration
+            .variants
+            .iter()
+            .map(|v| v.value.as_str())
+            .collect::<Vec<_>>(),
+        ["arc", "resource"]
+    );
+    let TypeRef::Named(number_name) = &record.fields[1].type_ref else {
+        panic!("number type");
+    };
+    let TypeDef::Simple(number) = &ir.types[number_name] else {
+        panic!("restriction");
+    };
+    assert_eq!(number.base_type, TypeRef::Primitive(PrimitiveType::Int));
+    assert_eq!(number.facets.min_inclusive.as_deref(), Some("3"));
+    let TypeRef::Named(union_name) = &record.fields[2].type_ref else {
+        panic!("union type");
+    };
+    let TypeDef::Union(union) = &ir.types[union_name] else {
+        panic!("union declaration");
+    };
+    assert!(union.is_lexical());
+    assert_eq!(union.branches.len(), 2);
+    assert_eq!(record.fields[3].type_ref, TypeRef::string());
+    assert_eq!(record.fields[4].type_ref, TypeRef::string());
+    let invalid = std::fs::read_to_string(&root)
+        .unwrap()
+        .replace("a:code", "a:missing");
+    std::fs::write(&root, invalid).unwrap();
+    assert!(XsdParser::new()
+        .parse_file(&root)
+        .unwrap_err()
+        .to_string()
+        .contains("Unresolved type"));
+}
+
+#[test]
+fn schema_for_schemas_declared_types_are_not_unknown_builtins() {
+    let xsd = r#"<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" targetNamespace="http://www.w3.org/2001/XMLSchema">
+      <xs:complexType name="Derived"><xs:complexContent><xs:extension base="xs:openAttrs"><xs:attribute name="name" type="xs:string"/></xs:extension></xs:complexContent></xs:complexType>
+      <xs:complexType name="openAttrs"><xs:anyAttribute processContents="lax"/></xs:complexType>
+      <xs:element name="Root" type="xs:Derived"/>
+    </xs:schema>"#;
+    let ir = XsdParser::new().parse_str(xsd).unwrap();
+    let ns = Some("http://www.w3.org/2001/XMLSchema");
+    let TypeDef::Struct(derived) = &ir.types[&QName::new(ns, "Derived")] else {
+        panic!("Derived");
+    };
+    assert_eq!(derived.base_type, Some(QName::new(ns, "openAttrs")));
+    let missing = xsd.replace("base=\"xs:openAttrs\"", "base=\"xs:Misspelled\"");
+    assert!(XsdParser::new()
+        .parse_str(&missing)
+        .unwrap_err()
+        .to_string()
+        .contains("Misspelled"));
+    let normal = r#"<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"><xs:element name="Root" type="xs:NotAType"/></xs:schema>"#;
+    assert!(XsdParser::new()
+        .parse_str(normal)
+        .unwrap_err()
+        .to_string()
+        .contains("Unknown built-in type"));
+}
+
+#[test]
+fn inline_list_item_types_preserve_enum_and_union_declarations() {
+    for item in [
+        r#"<xs:restriction base="xs:string"><xs:enumeration value="one"/><xs:enumeration value="two"/></xs:restriction>"#,
+        r#"<xs:union memberTypes="xs:int xs:string"/>"#,
+    ] {
+        let xsd = format!(
+            r#"<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"><xs:simpleType name="Values"><xs:list><xs:annotation><xs:documentation>items</xs:documentation></xs:annotation><xs:simpleType>{item}</xs:simpleType></xs:list></xs:simpleType></xs:schema>"#
+        );
+        let ir = XsdParser::new().parse_str(&xsd).unwrap();
+        let TypeDef::Simple(values) = &ir.types[&QName::new(None::<String>, "Values")] else {
+            panic!("list");
+        };
+        let TypeRef::List(inner) = &values.base_type else {
+            panic!("list reference");
+        };
+        let TypeRef::Named(name) = inner.as_ref() else {
+            panic!("item declaration");
+        };
+        match &ir.types[name] {
+            TypeDef::Enum(e) => assert_eq!(e.variants.len(), 2),
+            TypeDef::Union(u) => {
+                assert!(u.is_lexical());
+                assert_eq!(u.branches.len(), 2);
+            }
+            other => panic!("unexpected item: {other:?}"),
+        }
+    }
+    for list in ["<xs:list/>", "<xs:list></xs:list>"] {
+        let invalid = format!(
+            r#"<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"><xs:simpleType name="Values">{list}</xs:simpleType></xs:schema>"#
+        );
+        assert!(XsdParser::new()
+            .parse_str(&invalid)
+            .unwrap_err()
+            .to_string()
+            .contains("xs:list requires"));
+    }
+}

{polyxml-0.34.1 → polyxml-0.34.3}/pyproject.toml

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