polyxml 0.34.6__tar.gz → 0.34.8__tar.gz

{polyxml-0.34.6 → polyxml-0.34.8}/Cargo.lock

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

{polyxml-0.34.6 → polyxml-0.34.8}/Cargo.toml

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

{polyxml-0.34.6 → polyxml-0.34.8}/PKG-INFO

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

{polyxml-0.34.6 → polyxml-0.34.8}/crates/polyxml-core/src/codegen/cpp/mod.rs

@@ -553,7 +553,14 @@ endif()
                         } else {
                             ""
                         };
-                        writeln!(out, "        {:?}, T::{}{}", v.value, var_name, comma).unwrap();
+                        writeln!(
+                            out,
+                            "        {}, T::{}{}",
+                            super::cpp_string_literal(&v.value),
+                            var_name,
+                            comma
+                        )
+                        .unwrap();
                     }
                     writeln!(out, "    );").unwrap();
                 }
@@ -790,8 +797,10 @@ inline int polyxml_integer_compare(std::string_view a,std::string_view b) noexce
             for (variant, var_name) in enum_def.variants.iter().zip(&variant_names) {
                 writeln!(
                     out,
-                    "        case {}::{}: return \"{}\";",
-                    enum_name, var_name, variant.value
+                    "        case {}::{}: return {};",
+                    enum_name,
+                    var_name,
+                    super::cpp_string_literal(&variant.value)
                 )
                 .unwrap();
             }
@@ -818,8 +827,10 @@ inline int polyxml_integer_compare(std::string_view a,std::string_view b) noexce
             for (variant, var_name) in enum_def.variants.iter().zip(&variant_names) {
                 writeln!(
                     out,
-                    "    if (s == \"{}\") return {}::{};",
-                    variant.value, enum_name, var_name
+                    "    if (s == {}) return {}::{};",
+                    super::cpp_string_literal(&variant.value),
+                    enum_name,
+                    var_name
                 )
                 .unwrap();
             }
@@ -998,7 +1009,9 @@ inline int polyxml_integer_compare(std::string_view a,std::string_view b) noexce
             // Value field
             let init = match &f.default_value {
                 Some(v) => match f.type_ref {
-                    TypeRef::Primitive(p) if p.is_unbounded_integer() => format!(" = {v:?}"),
+                    TypeRef::Primitive(p) if p.is_unbounded_integer() => {
+                        format!(" = {}", super::cpp_string_literal(v))
+                    }
                     TypeRef::Primitive(PrimitiveType::Boolean) => {
                         format!(" = {}", v.to_lowercase())
                     }
@@ -1008,7 +1021,7 @@ inline int polyxml_integer_compare(std::string_view a,std::string_view b) noexce
                     TypeRef::Primitive(PrimitiveType::String)
                     | TypeRef::Primitive(PrimitiveType::Token)
                     | TypeRef::Primitive(PrimitiveType::NormalizedString) => {
-                        format!(" = \"{}\"", v.replace('\\', "\\\\").replace('"', "\\\""))
+                        format!(" = {}", super::cpp_string_literal(v))
                     }
                     TypeRef::Primitive(_) => format!(" = {}", v),
                     TypeRef::Named(_) => format!(" = {}", v),

{polyxml-0.34.6 → polyxml-0.34.8}/crates/polyxml-core/src/codegen/csharp/mod.rs

@@ -618,7 +618,13 @@ impl CSharpCodegen {
                 self.emit_docstring(out, doc, &format!("{}    ", indent));
             }
             if self.options.emit_xml_attributes {
-                writeln!(out, "{}    [XmlEnum(\"{}\")]", indent, variant.value).unwrap();
+                writeln!(
+                    out,
+                    "{}    [XmlEnum({})]",
+                    indent,
+                    super::string_literal(&variant.value)
+                )
+                .unwrap();
             }
             writeln!(out, "{}    {},", indent, variant_name).unwrap();
         }
@@ -659,8 +665,11 @@ impl CSharpCodegen {
         for (variant, variant_name) in e.variants.iter().zip(&variant_names) {
             writeln!(
                 out,
-                "{}        {}.{} => \"{}\",",
-                indent, enum_name, variant_name, variant.value
+                "{}        {}.{} => {},",
+                indent,
+                enum_name,
+                variant_name,
+                super::string_literal(&variant.value)
             )
             .unwrap();
         }
@@ -1295,10 +1304,10 @@ impl CSharpCodegen {
             if let Some(kind) = integer_kind {
                 return format!("PolyxmlIntegerLexical.Validate({text},{kind})");
             }
-            format!("({base})new XmlSerializer(typeof({base}), new XmlRootAttribute(\"value\")).Deserialize(new System.IO.StringReader(\"<value>\" + System.Security.SecurityElement.Escape({text}) + \"</value>\"))!")
+            format!("({base})new XmlSerializer(typeof({base}), new XmlRootAttribute(\"value\")).Deserialize(new System.IO.StringReader(\"<value>\" + System.Security.SecurityElement.Escape({text}).Replace(\"\\r\", \"&#13;\") + \"</value>\"))!")
         };
         if let Some(fixed) = &field.fixed_value {
-            let expected = parse(&format!("{fixed:?}"));
+            let expected = parse(&super::string_literal(fixed));
             let initial = if field.cardinality.is_optional() && field.kind == FieldKind::Element {
                 "default!".to_string()
             } else {
@@ -1318,7 +1327,7 @@ impl CSharpCodegen {
 {indent}    [XmlIgnore] public {ty} {name} {{ get => _{name}; set {{ if ({present}!({equal})) 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:?}"))
+                parse(&super::string_literal(default))
             } else {
                 "default!".to_string()
             };
@@ -1352,7 +1361,10 @@ impl CSharpCodegen {
         let text = if field.kind == FieldKind::Attribute {
             "value".into()
         } else {
-            format!("value.Length == 0 ? {default:?} : value")
+            format!(
+                "value.Length == 0 ? {} : value",
+                super::string_literal(default)
+            )
         };
         let parsed = parse("text");
         writeln!(out, "{indent}        set {{ if (value is null) {{ {name} = default!; return; }} var text = {text}; {name} = {parsed}; }}

{polyxml-0.34.6 → polyxml-0.34.8}/crates/polyxml-core/src/codegen/go/mod.rs

@@ -577,7 +577,7 @@ func (v {type_name}) MarshalText() ([]byte,error) {{ tokens:=make([]string,0,len
                         let variants = enumeration
                             .variants
                             .iter()
-                            .map(|v| format!("{:?}", v.value))
+                            .map(|v| super::string_literal(&v.value))
                             .collect::<Vec<_>>()
                             .join(",");
                         writeln!(out,"switch string(value) {{case {variants}: default:return fmt.Errorf(\"invalid enum list item\")}}").unwrap();
@@ -670,8 +670,10 @@ func (v {type_name}) MarshalText() ([]byte,error) {{ tokens:=make([]string,0,len
             }
             writeln!(
                 out,
-                "    {} {} = \"{}\"",
-                const_name, enum_name, variant.value
+                "    {} {} = {}",
+                const_name,
+                enum_name,
+                super::string_literal(&variant.value)
             )
             .unwrap();
         }
@@ -925,7 +927,7 @@ func (v {type_name}) MarshalText() ([]byte,error) {{ tokens:=make([]string,0,len
                     let comparisons = def
                         .variants
                         .iter()
-                        .map(|v| format!("value == {:?}", v.value))
+                        .map(|v| format!("value == {}", super::string_literal(&v.value)))
                         .collect::<Vec<_>>()
                         .join(" || ");
                     let _ = writeln!(

{polyxml-0.34.6 → polyxml-0.34.8}/crates/polyxml-core/src/codegen/java/mod.rs

@@ -597,8 +597,11 @@ impl JavaCodegen {
             let semi_or_comma = if i + 1 == e.variants.len() { ";" } else { "," };
             let _ = writeln!(
                 out,
-                "{}    {}({:?}){}",
-                indent, const_name, v.value, semi_or_comma
+                "{}    {}({}){}",
+                indent,
+                const_name,
+                super::string_literal(&v.value),
+                semi_or_comma
             );
         }
 

{polyxml-0.34.6 → polyxml-0.34.8}/crates/polyxml-core/src/codegen/mod.rs

@@ -24,6 +24,40 @@ pub use python::{
 pub use rust::{RustCodegen, RustOptions};
 pub use typescript::{TypeScriptBackend, TypeScriptCodegen, TypeScriptOptions};
 
+/// JSON string escapes are also valid in Python, Go, Java, C# and TypeScript
+/// string literals. Rust and C++ need their own escapes for control characters.
+pub(crate) fn string_literal(value: &str) -> String {
+    serde_json::to_string(value)
+        .expect("serializing a string cannot fail")
+        // C# treats these Unicode characters as source line terminators even
+        // inside quoted strings; JSON permits their literal forms.
+        .replace('\u{85}', "\\u0085")
+        .replace('\u{2028}', "\\u2028")
+        .replace('\u{2029}', "\\u2029")
+}
+
+pub(crate) fn cpp_string_literal(value: &str) -> String {
+    use std::fmt::Write;
+    let mut literal = String::from("\"");
+    for character in value.chars() {
+        match character {
+            '\\' => literal.push_str("\\\\"),
+            '"' => literal.push_str("\\\""),
+            '\n' => literal.push_str("\\n"),
+            '\r' => literal.push_str("\\r"),
+            '\t' => literal.push_str("\\t"),
+            c if c.is_ascii_control() => {
+                // Three octal digits prevent a following digit from extending
+                // the escape; universal character names cannot encode these.
+                write!(literal, "\\{:03o}", c as u32).unwrap();
+            }
+            c => literal.push(c),
+        }
+    }
+    literal.push('"');
+    literal
+}
+
 /// Prefix every physical XSD documentation line so embedded newlines cannot
 /// escape a generated source comment.
 pub(crate) fn write_documentation_lines(out: &mut String, prefix: &str, doc: &str) {

{polyxml-0.34.6 → polyxml-0.34.8}/crates/polyxml-core/src/codegen/python/mod.rs

@@ -521,9 +521,9 @@ impl PythonCodegen {
 
             let _ = writeln!(
                 out,
-                "    {} = \"{}\"",
+                "    {} = {}",
                 var_id,
-                variant.value.replace('"', "\\\"")
+                super::string_literal(&variant.value)
             );
         }
     }
@@ -1012,10 +1012,10 @@ impl PythonCodegen {
         }
 
         if let Some(ref fixed) = field.fixed_value {
-            parts.push(format!("\"fixed\": {fixed:?}"));
+            parts.push(format!("\"fixed\": {}", super::string_literal(fixed)));
         }
         if let Some(ref default) = field.default_value {
-            parts.push(format!("\"default\": {default:?}"));
+            parts.push(format!("\"default\": {}", super::string_literal(default)));
         }
         if matches!(super::primitive_base(&field.type_ref, ir), TypeRef::List(_)) {
             parts.push("\"tokens\": True".into());
@@ -1045,7 +1045,7 @@ impl PythonCodegen {
     fn format_default_value(&self, val: &str, type_ref: &TypeRef, ir: &SchemaIR) -> String {
         if matches!(super::primitive_base(type_ref, ir), TypeRef::Primitive(p) if p.is_unbounded_integer())
         {
-            return format!("int({val:?})");
+            return format!("int({})", super::string_literal(val));
         }
 
         let base = super::primitive_base(type_ref, ir);
@@ -1073,20 +1073,20 @@ impl PythonCodegen {
                 if val.trim().parse::<i64>().is_ok() {
                     val.trim().to_string()
                 } else {
-                    format!("\"{}\"", val.replace('"', "\\\""))
+                    super::string_literal(val)
                 }
             }
             TypeRef::Primitive(PrimitiveType::Float | PrimitiveType::Double) => {
                 if val.trim().parse::<f64>().is_ok() {
                     val.trim().to_string()
                 } else {
-                    format!("\"{}\"", val.replace('"', "\\\""))
+                    super::string_literal(val)
                 }
             }
             TypeRef::Primitive(PrimitiveType::Decimal) => {
-                format!("Decimal(\"{}\")", val.replace('"', "\\\""))
+                format!("Decimal({})", super::string_literal(val))
             }
-            _ => format!("\"{}\"", val.replace('"', "\\\"")),
+            _ => super::string_literal(val),
         }
     }
 

{polyxml-0.34.6 → polyxml-0.34.8}/crates/polyxml-core/src/codegen/rust/mod.rs

@@ -724,7 +724,7 @@ impl RustCodegen {
                 write_documentation_lines(out, "    /// ", doc);
             }
             if self.options.derive_serde {
-                let _ = writeln!(out, "    #[serde(rename = \"{}\")]", variant.value);
+                let _ = writeln!(out, "    #[serde(rename = {:?})]", variant.value);
             }
             if self.options.derive_default && idx == 0 {
                 let _ = writeln!(out, "    #[default]");
@@ -740,7 +740,7 @@ impl RustCodegen {
         out.push_str("    pub fn as_str(&self) -> &'static str {\n");
         out.push_str("        match self {\n");
         for (var_id, val) in &variant_map {
-            let _ = writeln!(out, "            Self::{} => \"{}\",", var_id, val);
+            let _ = writeln!(out, "            Self::{} => {:?},", var_id, val);
         }
         if variant_map.is_empty() {
             out.push_str("            _ => \"\",\n");
@@ -755,7 +755,7 @@ impl RustCodegen {
         out.push_str("    fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {\n");
         out.push_str("        match s {\n");
         for (var_id, val) in &variant_map {
-            let _ = writeln!(out, "            \"{}\" => Ok(Self::{}),", val, var_id);
+            let _ = writeln!(out, "            {:?} => Ok(Self::{}),", val, var_id);
         }
         let _ = writeln!(
             out,
@@ -844,7 +844,7 @@ impl RustCodegen {
                 write_documentation_lines(out, "    /// ", doc);
             }
             if self.options.derive_serde && !u.is_lexical() {
-                let _ = writeln!(out, "    #[serde(rename = \"{}\")]", branch.xml_name);
+                let _ = writeln!(out, "    #[serde(rename = {:?})]", branch.xml_name);
             }
             if self.options.emit_polyxml_attrs && !u.is_lexical() {
                 let _ = writeln!(out, "    #[polyxml(element = \"{}\")]", branch.xml_name);
@@ -2218,8 +2218,8 @@ impl RustCodegen {
     /// Decode the simpleContent value field from the element's own text
     /// content. Emitted only when the struct has no child elements (the
     /// element loop already consumes through `End(start)`), and only for
-    /// scalar-backed text: a simpleContent chain whose value is typed as its
-    /// base struct has no scalar form here and keeps its previous behavior.
+    /// scalar-backed text. The schema post-pass resolves inherited simpleContent
+    /// to its terminal scalar while retaining named simple-type constraints.
     fn emit_text_content_parse(
         &self,
         out: &mut String,

{polyxml-0.34.6 → polyxml-0.34.8}/crates/polyxml-core/src/codegen/typescript/mod.rs

@@ -422,7 +422,12 @@ impl TypeScriptCodegen {
         let mut seen = HashSet::new();
         for v in &e.variants {
             let variant_key = self.unique_variant_name(&v.name, &mut seen);
-            let _ = writeln!(out, "  {}: {:?},", variant_key, v.value);
+            let _ = writeln!(
+                out,
+                "  {}: {},",
+                variant_key,
+                super::string_literal(&v.value)
+            );
         }
         out.push_str("} as const;\n\n");
 
@@ -437,7 +442,7 @@ impl TypeScriptCodegen {
         let literals = e
             .variants
             .iter()
-            .map(|v| format!("{:?}", v.value))
+            .map(|v| super::string_literal(&v.value))
             .collect::<Vec<_>>()
             .join(", ");
 
@@ -461,7 +466,7 @@ impl TypeScriptCodegen {
                 let tb_literals = e
                     .variants
                     .iter()
-                    .map(|v| format!("Type.Literal({:?})", v.value))
+                    .map(|v| format!("Type.Literal({})", super::string_literal(&v.value)))
                     .collect::<Vec<_>>()
                     .join(", ");
                 let _ = writeln!(
@@ -605,7 +610,12 @@ impl TypeScriptCodegen {
             self.emit_docstring(out, doc, "");
         }
 
-        let base_name = s.base_type.as_ref().map(type_ident);
+        // Scalar simpleContent bases are text types, not object inheritance.
+        let base_name = s
+            .base_type
+            .as_ref()
+            .filter(|name| matches!(ir.types.get(*name), Some(TypeDef::Struct(_))))
+            .map(type_ident);
         let mut inherited_fields = HashSet::new();
         let mut current_base = s.base_type.as_ref();
         let mut visited_bases = HashSet::new();

{polyxml-0.34.6 → polyxml-0.34.8}/crates/polyxml-core/src/converters.rs

@@ -42,9 +42,7 @@ impl ValueConverter {
                     && facets.min_length.is_none_or(|n| length >= n)
                     && facets.max_length.is_none_or(|n| length <= n);
                 for pattern in &facets.patterns {
-                    valid &= regex::Regex::new(&format!("\\A(?:{pattern})\\z"))
-                        .map(|r| r.is_match(text))
-                        .unwrap_or(false);
+                    valid &= crate::pattern::matches(pattern, text);
                 }
                 for (bound, inclusive, minimum) in [
                     (&facets.min_inclusive, true, true),
@@ -120,11 +118,7 @@ impl ValueConverter {
             ScalarType::Pattern(base, patterns) => {
                 let value = std::str::from_utf8(trim_bytes(bytes))?;
                 for pattern in patterns {
-                    let anchored = format!(r"\A(?:{pattern})\z");
-                    if !regex::Regex::new(&anchored)
-                        .map(|compiled| compiled.is_match(value))
-                        .unwrap_or(false)
-                    {
+                    if !crate::pattern::matches(pattern, value) {
                         return Err(PolyXmlError::ScalarParseError {
                             field: field_name.to_string(),
                             expected: "pattern",

{polyxml-0.34.6 → polyxml-0.34.8}/crates/polyxml-core/src/lib.rs

@@ -5,6 +5,7 @@ pub mod integer;
 pub mod ir;
 pub mod json;
 pub mod parser;
+mod pattern;
 pub mod schema;
 pub mod schema_parser;
 pub mod serializer;