polyxml 0.33.7__tar.gz → 0.33.9__tar.gz

{polyxml-0.33.7 → polyxml-0.33.9}/Cargo.lock

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

{polyxml-0.33.7 → polyxml-0.33.9}/Cargo.toml

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

{polyxml-0.33.7 → polyxml-0.33.9}/PKG-INFO

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

{polyxml-0.33.7 → polyxml-0.33.9}/crates/polyxml-core/src/codegen/csharp/mod.rs

@@ -877,11 +877,11 @@ impl CSharpCodegen {
         ir: &SchemaIR,
         indent: &str,
     ) -> bool {
-        let Some(default) = field.default_value.as_ref() else {
+        let Some(default) = field.default_value.as_ref().or(field.fixed_value.as_ref()) else {
             return false;
         };
         if !self.options.emit_xml_attributes
-            || field.kind != FieldKind::Element
+            || !matches!(field.kind, FieldKind::Element | FieldKind::Attribute)
             || field.cardinality.is_list()
             || matches!(field.type_ref, TypeRef::Named(ref q) if matches!(ir.types.get(q), Some(TypeDef::Struct(_) | TypeDef::Union(_))))
         {
@@ -894,19 +894,49 @@ impl CSharpCodegen {
             .as_ref()
             .map(|ns| format!(", Namespace = {ns:?}"))
             .unwrap_or_default();
+        let parse = |text: &str| {
+            format!("({base})new XmlSerializer(typeof({base}), new XmlRootAttribute(\"value\")).Deserialize(new System.IO.StringReader(\"<value>\" + System.Security.SecurityElement.Escape({text}) + \"</value>\"))!")
+        };
+        if let Some(fixed) = &field.fixed_value {
+            let expected = parse(&format!("{fixed:?}"));
+            let initial = if field.cardinality.is_optional() && field.kind == FieldKind::Element {
+                "default!".to_string()
+            } else {
+                expected.clone()
+            };
+            writeln!(out, "{indent}    private {ty} _{name} = {initial};
+{indent}    [XmlIgnore] public {ty} {name} {{ get => _{name}; set {{ if (value is not null && !object.Equals(value, {expected})) throw new System.ComponentModel.DataAnnotations.ValidationException(\"Fixed value constraint violated for {name}\"); _{name} = value; }} }}").unwrap();
+        } else {
+            let initial = if field.kind == FieldKind::Attribute {
+                parse(&format!("{default:?}"))
+            } else {
+                "default!".to_string()
+            };
+            writeln!(
+                out,
+                "{indent}    [XmlIgnore] public {ty} {name} {{ get; set; }} = {initial};"
+            )
+            .unwrap();
+        }
+        let kind = if field.kind == FieldKind::Attribute {
+            "XmlAttribute"
+        } else {
+            "XmlElement"
+        };
         writeln!(
             out,
-            "{indent}    [XmlIgnore] public {ty} {name} {{ get; set; }} = default!;"
-        )
-        .unwrap();
-        writeln!(
-            out,
-            "{indent}    [XmlElement({:?}{namespace})] public string? {name}Xml {{",
+            "{indent}    [{kind}({:?}{namespace})] public string? {name}Xml {{",
             field.xml_name
         )
         .unwrap();
         writeln!(out, "{indent}        get {{ if ({name} is null) return null; var writer = new System.IO.StringWriter(System.Globalization.CultureInfo.InvariantCulture); new XmlSerializer(typeof({base}), new XmlRootAttribute(\"value\")).Serialize(writer, {name}); return System.Xml.Linq.XDocument.Parse(writer.ToString()).Root!.Value; }}").unwrap();
-        writeln!(out, "{indent}        set {{ if (value is null) {{ {name} = default!; return; }} var text = value.Length == 0 ? {default:?} : value; {name} = ({base})new XmlSerializer(typeof({base}), new XmlRootAttribute(\"value\")).Deserialize(new System.IO.StringReader(\"<value>\" + System.Security.SecurityElement.Escape(text) + \"</value>\"))!; }}
+        let text = if field.kind == FieldKind::Attribute {
+            "value".into()
+        } else {
+            format!("value.Length == 0 ? {default:?} : value")
+        };
+        let parsed = parse("text");
+        writeln!(out, "{indent}        set {{ if (value is null) {{ {name} = default!; return; }} var text = {text}; {name} = {parsed}; }}
 {indent}    }}").unwrap();
         if field.cardinality.is_optional() || field.nillable {
             writeln!(
@@ -1079,7 +1109,7 @@ impl CSharpCodegen {
         }
 
         let has_lexical_union = self.options.emit_xml_attributes && s.fields.iter().any(|f| {
-            f.default_value.is_some() || matches!(&f.type_ref, TypeRef::Named(q) if matches!(ir.types.get(q), Some(TypeDef::Union(u)) if u.is_lexical()))
+            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()))
         });
 
         if self.options.use_records && has_lexical_union {

{polyxml-0.33.7 → polyxml-0.33.9}/crates/polyxml-core/src/codegen/go/mod.rs

@@ -371,6 +371,10 @@ impl GoCodegen {
         }
         self.emit_root_aliases(&mut body, ir);
 
+        if self.options.emit_xml_tags && !ir.content_models.is_empty() {
+            self.emit_content_helpers(&mut body);
+        }
+
         // Assemble final output with package and imports
         let mut out = String::new();
         if let Some(ref header) = self.options.custom_header {
@@ -399,20 +403,21 @@ impl GoCodegen {
             imports.push("\"encoding/xml\"");
         }
         if self.options.emit_xml_tags
-            && ir
-                .types
-                .values()
-                .any(|def| matches!(def, TypeDef::Struct(s) if ir.has_ordered_content(s)))
+            && (!ir.content_models.is_empty()
+                || ir
+                    .types
+                    .values()
+                    .any(|def| matches!(def, TypeDef::Struct(s) if ir.has_ordered_content(s))))
         {
             imports.push("\"bytes\"");
         }
         if has_fmt || body.contains("fmt.") {
             imports.push("\"fmt\"");
         }
-        if has_io {
+        if has_io || body.contains("io.") {
             imports.push("\"io\"");
         }
-        if has_patterns {
+        if has_patterns || body.contains("regexp.") {
             imports.push("\"regexp\"");
         }
         if ir
@@ -1108,11 +1113,50 @@ impl GoCodegen {
             self.emit_mixed_struct_xml(out, s, ir, &field_names);
         }
 
+        if self.options.emit_xml_tags && !ir.has_ordered_content(s) && !s.is_abstract {
+            if let Some(model) = ir.content_models.get(&s.qname) {
+                self.emit_content_codec(out, s, &format!("^(?:{})$", model.pattern()));
+            }
+        }
         if self.options.validate_facets {
             self.emit_struct_validator(out, s, ir, &field_names);
         }
     }
 
+    fn emit_content_helpers(&self, out: &mut String) {
+        out.push_str(r#"
+func polyxmlReadElement(d *xml.Decoder, start xml.StartElement) ([]byte,error) {
+ var buffer bytes.Buffer; encoder:=xml.NewEncoder(&buffer);depth:=1
+ token:=xml.Token(start)
+ for {
+  if element,ok:=token.(xml.StartElement);ok { attrs:=element.Attr[:0];for _,a:=range element.Attr {if a.Name.Space!="xmlns"&&a.Name.Local!="xmlns" {attrs=append(attrs,a)}};element.Attr=attrs;token=element }
+  if err:=encoder.EncodeToken(token);err!=nil{return nil,err}
+  if depth==0{break}
+  next,err:=d.Token();if err!=nil{return nil,err};token=next
+  switch token.(type){case xml.StartElement:depth++;case xml.EndElement:depth--}
+ }
+ if err:=encoder.Flush();err!=nil{return nil,err};return buffer.Bytes(),nil
+}
+func polyxmlValidateContent(data []byte,pattern string) error {
+ decoder:=xml.NewDecoder(bytes.NewReader(data));depth:=0;tokens:=""
+ for {token,err:=decoder.Token();if err==io.EOF{break};if err!=nil{return err};switch v:=token.(type){case xml.StartElement:depth++;if depth==2{if v.Name.Space!=""{tokens+="{"+v.Name.Space+"}"};tokens+=v.Name.Local+";"};case xml.EndElement:depth--}}
+ matched,err:=regexp.MatchString(pattern,tokens);if err!=nil{return err};if !matched{return fmt.Errorf("content model constraint violated")};return nil
+}
+"#);
+    }
+    fn emit_content_codec(&self, out: &mut String, structure: &StructDef, pattern: &str) {
+        let name = type_ident(&structure.qname);
+        writeln!(out,"func (v *{name}) UnmarshalXML(d *xml.Decoder,start xml.StartElement) error {{
+ data,err:=polyxmlReadElement(d,start);if err!=nil{{return err}};if err:=polyxmlValidateContent(data,{pattern:?});err!=nil{{return err}}
+ type Alias {name};return xml.Unmarshal(data,(*Alias)(v))
+}}
+func (v {name}) MarshalXML(e *xml.Encoder,start xml.StartElement) error {{
+ type Alias {name};var buffer bytes.Buffer;encoder:=xml.NewEncoder(&buffer);if err:=encoder.EncodeElement(Alias(v),start);err!=nil{{return err}};if err:=polyxmlValidateContent(buffer.Bytes(),{pattern:?});err!=nil{{return err}}
+ decoder:=xml.NewDecoder(&buffer);for {{token,err:=decoder.Token();if err==io.EOF{{return nil}};if err!=nil{{return err}};if err:=e.EncodeToken(token);err!=nil{{return err}}}}
+}}
+").unwrap();
+    }
+
     fn emit_mixed_struct_xml(
         &self,
         out: &mut String,

{polyxml-0.33.7 → polyxml-0.33.9}/crates/polyxml-core/src/codegen/python/mod.rs

@@ -645,6 +645,14 @@ impl PythonCodegen {
             }
             let _ = writeln!(out, "        name = \"{}\"", s.qname.local);
             out.push_str("        strict_root = False\n");
+            if let Some(model) = ir.content_models.get(&s.qname) {
+                writeln!(
+                    out,
+                    "        content_pattern = {:?}",
+                    format!("^(?:{})$", model.pattern())
+                )
+                .unwrap();
+            }
             if let Some(ref ns) = s.qname.namespace {
                 let _ = writeln!(out, "        namespace = \"{}\"", ns);
             }
@@ -993,6 +1001,9 @@ impl PythonCodegen {
             parts.push(format!("\"namespace\": \"{}\"", ns));
         }
 
+        if let Some(ref fixed) = field.fixed_value {
+            parts.push(format!("\"fixed\": {fixed:?}"));
+        }
         if let Some(ref default) = field.default_value {
             parts.push(format!("\"default\": {default:?}"));
         }

{polyxml-0.33.7 → polyxml-0.33.9}/crates/polyxml-core/src/ir/mod.rs

@@ -1,4 +1,6 @@
 pub mod chunker;
+pub mod particle;
+pub use particle::Particle;
 pub mod tarjan;
 
 pub use chunker::{partition_topological_chunks, ChunkPlan, TypeChunk};
@@ -467,6 +469,8 @@ pub struct SchemaIR {
     /// repeated particle or substitution-member order during serialization.
     #[serde(default)]
     pub ordered_types: std::collections::BTreeSet<QName>,
+    #[serde(default)]
+    pub content_models: BTreeMap<QName, Particle>,
     /// Type owners outside the module currently being emitted. Definitions
     /// remain in `types` so generators can resolve their field semantics.
     #[serde(default)]

polyxml-0.33.9/crates/polyxml-core/src/ir/particle.rs

@@ -0,0 +1,60 @@
+use super::QName;
+use serde::{Deserialize, Serialize};
+
+/// Source particle boundaries and occurrence constraints, independent of field layout.
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+pub enum Particle {
+    Element(QName),
+    Sequence(Vec<Particle>),
+    Choice(Vec<Particle>),
+    Repeat {
+        particle: Box<Particle>,
+        min: usize,
+        max: Option<usize>,
+    },
+}
+impl Particle {
+    pub fn has_choice(&self) -> bool {
+        match self {
+            Self::Choice(_) => true,
+            Self::Sequence(items) => items.iter().any(Self::has_choice),
+            Self::Repeat { particle, .. } => particle.has_choice(),
+            _ => false,
+        }
+    }
+    pub fn adopt_namespace(&mut self, namespace: &str) {
+        match self {
+            Self::Element(name) => {
+                if name.namespace.is_none() {
+                    name.namespace = Some(namespace.into());
+                }
+            }
+            Self::Sequence(items) | Self::Choice(items) => {
+                for item in items {
+                    item.adopt_namespace(namespace);
+                }
+            }
+            Self::Repeat { particle, .. } => particle.adopt_namespace(namespace),
+        }
+    }
+    pub fn pattern(&self) -> String {
+        match self {
+            Self::Element(name) => regex::escape(&format!("{};", name)),
+            Self::Sequence(items) => items.iter().map(Self::pattern).collect(),
+            Self::Choice(items) => format!(
+                "(?:{})",
+                items
+                    .iter()
+                    .map(Self::pattern)
+                    .collect::<Vec<_>>()
+                    .join("|")
+            ),
+            Self::Repeat { particle, min, max } => format!(
+                "(?:{}){{{},{}}}",
+                particle.pattern(),
+                min,
+                max.map(|v| v.to_string()).unwrap_or_default()
+            ),
+        }
+    }
+}

{polyxml-0.33.7 → polyxml-0.33.9}/crates/polyxml-core/src/parser.rs

@@ -18,6 +18,7 @@ pub(crate) struct StackFrame {
     list_values: SmallVec<[Option<Vec<PolyValue>>; 4]>,
     frame_text_buf: Option<Vec<u8>>,
     mixed_parent_kind: Option<String>,
+    content_tokens: String,
 }
 
 impl StackFrame {
@@ -34,6 +35,7 @@ impl StackFrame {
             list_values: SmallVec::new(),
             frame_text_buf,
             mixed_parent_kind: None,
+            content_tokens: String::new(),
         }
     }
 
@@ -71,11 +73,13 @@ impl StackFrame {
     }
 
     fn finish(mut self) -> Result<PolyValue> {
+        crate::schema::validate_content(&self.schema, &self.content_tokens)?;
         for (index, field) in self.schema.fields.iter().enumerate() {
             if field.kind == FieldKind::Attribute && self.values[index].is_none() {
-                if let (Some(default), ValueType::Scalar(scalar)) =
-                    (&field.default_value, &field.val_type)
-                {
+                if let (Some(default), ValueType::Scalar(scalar)) = (
+                    &field.default_value.as_ref().or(field.fixed_value.as_ref()),
+                    &field.val_type,
+                ) {
                     self.values[index] = Some(ValueConverter::parse_scalar(
                         scalar,
                         default.as_bytes(),
@@ -113,6 +117,11 @@ impl StackFrame {
             }
         }
 
+        for (index, field) in self.schema.fields.iter().enumerate() {
+            if let Some(value) = self.values[index].as_ref() {
+                crate::schema::validate_fixed(field, value)?;
+            }
+        }
         Ok(PolyValue::Record {
             schema: self.schema,
             values: self.values.into_vec().into_boxed_slice(),
@@ -129,6 +138,7 @@ fn parse_field_scalar(
         field
             .default_value
             .as_ref()
+            .or(field.fixed_value.as_ref())
             .map_or(text, |value| value.as_bytes())
     } else {
         text
@@ -422,6 +432,13 @@ impl XmlDeserializer {
                         unknown_depth += 1;
                         continue;
                     }
+                    if active_scalar_field.is_none()
+                        && active_mixed_scalar.is_none()
+                        && any_stack.is_empty()
+                    {
+                        let scope = namespace_stack.last().unwrap();
+                        record_content_token(stack.last_mut().unwrap(), e, scope);
+                    }
                     if active_scalar_field.is_some() || active_mixed_scalar.is_some() {
                         unknown_depth = 1;
                         continue;
@@ -598,6 +615,10 @@ impl XmlDeserializer {
                     {
                         continue;
                     }
+                    if any_stack.is_empty() {
+                        let scope = namespace_scope(namespace_stack.last().unwrap(), e);
+                        record_content_token(stack.last_mut().unwrap(), e, &scope);
+                    }
                     if !any_stack.is_empty() {
                         let scope = namespace_scope(namespace_stack.last().unwrap(), e);
                         let (ns, local) = resolve_element_qname(e, &scope);
@@ -1068,3 +1089,18 @@ impl<R: std::io::BufRead> XmlItemStream<R> {
         }
     }
 }
+
+fn record_content_token(
+    frame: &mut StackFrame,
+    element: &BytesStart,
+    scope: &HashMap<String, String>,
+) {
+    if frame.schema.content_pattern.is_some() {
+        let (ns, local) = resolve_element_qname(element, scope);
+        if let Some(ns) = ns {
+            frame.content_tokens.push_str(&format!("{{{ns}}}"));
+        }
+        frame.content_tokens.push_str(&local);
+        frame.content_tokens.push(';');
+    }
+}

{polyxml-0.33.7 → polyxml-0.33.9}/crates/polyxml-core/src/schema.rs

@@ -66,6 +66,7 @@ pub struct FieldSchema {
     pub val_type: ValueType,
     pub required: bool,
     pub default_value: Option<String>,
+    pub fixed_value: Option<String>,
 }
 
 impl FieldSchema {
@@ -83,6 +84,7 @@ impl FieldSchema {
             val_type,
             required: false,
             default_value: None,
+            fixed_value: None,
         }
     }
 
@@ -117,6 +119,7 @@ pub struct ModelSchema {
     pub is_abstract: bool,
     /// Require the document element to match this schema's expanded QName.
     pub strict_root: bool,
+    pub content_pattern: Option<regex::Regex>,
     /// Concrete derivations eligible for `xsi:type` dispatch. Python may
     /// refresh this registry when subclasses are defined after first use.
     variants: Arc<RwLock<Vec<Arc<ModelSchema>>>>,
@@ -354,6 +357,7 @@ impl ModelSchema {
 
             let mut field_schema = FieldSchema::new(&f.name, f.xml_name.as_bytes(), kind, val_type);
             field_schema.default_value = f.default_value.clone();
+            field_schema.fixed_value = f.fixed_value.clone();
             if let Some(ref ns) = f.namespace {
                 field_schema = field_schema.namespace(ns);
             }
@@ -396,6 +400,12 @@ impl ModelSchema {
                 builder = builder.namespace(ns);
             }
             builder = builder.is_abstract(s.is_abstract);
+            if let Some(model) = ir.content_models.get(&s.qname) {
+                builder = builder.content_pattern(
+                    regex::Regex::new(&format!("^(?:{})$", model.pattern()))
+                        .expect("validated content pattern"),
+                );
+            }
 
             // Flatten the xs:extension content model: base-chain fields
             // precede the struct's own fields (mirrors the Java codegen).
@@ -534,6 +544,7 @@ pub struct ModelSchemaBuilder {
     fields: Vec<FieldSchema>,
     is_abstract: bool,
     strict_root: bool,
+    content_pattern: Option<regex::Regex>,
 }
 
 impl ModelSchemaBuilder {
@@ -545,6 +556,7 @@ impl ModelSchemaBuilder {
             fields: Vec::new(),
             is_abstract: false,
             strict_root: false,
+            content_pattern: None,
         }
     }
 
@@ -559,6 +571,11 @@ impl ModelSchemaBuilder {
         self
     }
 
+    pub fn content_pattern(mut self, pattern: regex::Regex) -> Self {
+        self.content_pattern = Some(pattern);
+        self
+    }
+
     pub fn strict_root(mut self, strict_root: bool) -> Self {
         self.strict_root = strict_root;
         self
@@ -629,7 +646,67 @@ impl ModelSchemaBuilder {
             mixed_content: None,
             is_abstract: self.is_abstract,
             strict_root: self.strict_root,
+            content_pattern: self.content_pattern,
             variants: Arc::new(RwLock::new(Vec::new())),
         })
     }
 }
+
+/// Validate fixed constraints in value space rather than comparing lexical spellings.
+pub(crate) fn validate_fixed(
+    field: &FieldSchema,
+    value: &crate::value::PolyValue,
+) -> crate::error::Result<()> {
+    use crate::value::PolyValue;
+    let Some(fixed) = &field.fixed_value else {
+        return Ok(());
+    };
+    fn check(
+        ty: &ValueType,
+        value: &PolyValue,
+        fixed: &str,
+        name: &str,
+    ) -> crate::error::Result<()> {
+        if matches!(value, PolyValue::Null) {
+            return Ok(());
+        }
+        match (ty, value) {
+            (ValueType::Scalar(scalar), value) => {
+                let expected = crate::converters::ValueConverter::parse_scalar(
+                    scalar,
+                    fixed.as_bytes(),
+                    name,
+                )?;
+                if *value != expected {
+                    return Err(crate::error::PolyXmlError::SchemaError(format!(
+                        "Fixed value constraint violated for {name}"
+                    )));
+                }
+            }
+            (ValueType::List(inner), PolyValue::List(items)) => {
+                for item in items {
+                    check(inner, item, fixed, name)?;
+                }
+            }
+            _ => {}
+        }
+        Ok(())
+    }
+    check(&field.val_type, value, fixed, &field.name)
+}
+
+pub(crate) fn validate_content(schema: &ModelSchema, tokens: &str) -> crate::error::Result<()> {
+    if let Some(pattern) = &schema.content_pattern {
+        if !pattern.is_match(tokens) {
+            return Err(crate::error::PolyXmlError::SchemaError(format!(
+                "Content model constraint violated for {}",
+                schema.name
+            )));
+        }
+    }
+    Ok(())
+}
+
+pub fn compile_content_pattern(pattern: &str) -> std::result::Result<regex::Regex, regex::Error> {
+    regex::Regex::new(pattern)
+}