polyxml 0.12.0__tar.gz → 0.13.0__tar.gz

{polyxml-0.12.0 → polyxml-0.13.0}/Cargo.lock

@@ -549,7 +549,7 @@ dependencies = [
 
 [[package]]
 name = "polyxml"
-version = "0.12.0"
+version = "0.13.0"
 dependencies = [
  "criterion",
  "heck",
@@ -559,6 +559,7 @@ dependencies = [
  "pretty_assertions",
  "quick-xml",
  "serde",
+ "serde_json",
  "smallvec",
  "tempfile",
  "thiserror",
@@ -566,14 +567,14 @@ dependencies = [
 
 [[package]]
 name = "polyxml-c"
-version = "0.12.0"
+version = "0.13.0"
 dependencies = [
  "polyxml",
 ]
 
 [[package]]
 name = "polyxml-cli"
-version = "0.12.0"
+version = "0.13.0"
 dependencies = [
  "clap",
  "glob",
@@ -587,7 +588,7 @@ dependencies = [
 
 [[package]]
 name = "polyxml-js"
-version = "0.12.0"
+version = "0.13.0"
 dependencies = [
  "napi",
  "napi-build",
@@ -597,7 +598,7 @@ dependencies = [
 
 [[package]]
 name = "polyxml-python"
-version = "0.12.0"
+version = "0.13.0"
 dependencies = [
  "lexical-core",
  "polyxml",

{polyxml-0.12.0 → polyxml-0.13.0}/Cargo.toml

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

{polyxml-0.12.0 → polyxml-0.13.0}/PKG-INFO

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

{polyxml-0.12.0 → polyxml-0.13.0}/crates/polyxml-core/Cargo.toml

@@ -17,6 +17,7 @@ memchr = "2.8"
 thiserror = "2.0"
 smallvec = "1.16"
 serde = { version = "1.0", features = ["derive"] }
+serde_json = "1.0"
 minijinja = { version = "2.8", features = ["builtins"] }
 heck = "0.5"
 

{polyxml-0.12.0 → polyxml-0.13.0}/crates/polyxml-core/src/codegen/python/mod.rs

@@ -529,7 +529,23 @@ impl PythonCodegen {
             out.push_str("    ) -> bytes:\n");
             out.push_str("        \"\"\"Serialize this model instance into XML bytes.\"\"\"\n");
             out.push_str("        import polyxml\n");
-            out.push_str("        return polyxml.serialize(self, indent=indent, namespaces=namespaces, ns_map=ns_map)\n");
+            out.push_str("        return polyxml.serialize(self, indent=indent, namespaces=namespaces, ns_map=ns_map)\n\n");
+            out.push_str("    @classmethod\n");
+            out.push_str("    def from_json(cls, data: bytes | str) -> Self:\n");
+            out.push_str("        \"\"\"Deserialize JSON bytes or string into this model.\"\"\"\n");
+            out.push_str("        import polyxml\n");
+            out.push_str("        return polyxml.deserialize_json(data, cls)\n\n");
+            out.push_str("    def to_json(\n");
+            out.push_str("        self,\n");
+            out.push_str("        *,\n");
+            out.push_str("        indent: int | None = None,\n");
+            out.push_str("        by_alias: bool = True,\n");
+            out.push_str("    ) -> bytes:\n");
+            out.push_str("        \"\"\"Serialize this model instance into JSON bytes.\"\"\"\n");
+            out.push_str("        import polyxml\n");
+            out.push_str(
+                "        return polyxml.serialize_json(self, indent=indent, by_alias=by_alias)\n",
+            );
             has_body = true;
         }
 

{polyxml-0.12.0 → polyxml-0.13.0}/crates/polyxml-core/src/error.rs

@@ -49,6 +49,9 @@ pub enum PolyXmlError {
 
     #[error("I/O error: {0}")]
     IoError(#[from] std::io::Error),
+
+    #[error("JSON error: {0}")]
+    JsonError(#[from] serde_json::Error),
 }
 
 pub type Result<T> = std::result::Result<T, PolyXmlError>;

polyxml-0.13.0/crates/polyxml-core/src/json.rs

@@ -0,0 +1,356 @@
+use std::collections::HashMap;
+use std::sync::Arc;
+
+use serde::Serialize;
+use serde_json::Value as JsonValue;
+
+use crate::error::Result;
+use crate::schema::{ModelSchema, ScalarType, ValueType};
+use crate::value::PolyValue;
+
+/// Convert a `PolyValue` into a `serde_json::Value` dynamically without a schema.
+impl From<&PolyValue> for JsonValue {
+    fn from(val: &PolyValue) -> Self {
+        match val {
+            PolyValue::Null => JsonValue::Null,
+            PolyValue::Bool(b) => JsonValue::Bool(*b),
+            PolyValue::Int(i) => JsonValue::Number((*i).into()),
+            PolyValue::Float(f) => serde_json::Number::from_f64(*f)
+                .map(JsonValue::Number)
+                .unwrap_or(JsonValue::Null),
+            PolyValue::String(s) => JsonValue::String(s.clone()),
+            PolyValue::List(l) => JsonValue::Array(l.iter().map(JsonValue::from).collect()),
+            PolyValue::Object(m) => {
+                let mut map = serde_json::Map::with_capacity(m.len());
+                for (k, v) in m {
+                    map.insert(k.clone(), JsonValue::from(v));
+                }
+                JsonValue::Object(map)
+            }
+        }
+    }
+}
+
+/// Convert a `serde_json::Value` into a `PolyValue` dynamically without a schema.
+impl From<JsonValue> for PolyValue {
+    fn from(val: JsonValue) -> Self {
+        match val {
+            JsonValue::Null => PolyValue::Null,
+            JsonValue::Bool(b) => PolyValue::Bool(b),
+            JsonValue::Number(n) => {
+                if let Some(i) = n.as_i64() {
+                    PolyValue::Int(i)
+                } else if let Some(u) = n.as_u64() {
+                    PolyValue::Int(u as i64)
+                } else if let Some(f) = n.as_f64() {
+                    PolyValue::Float(f)
+                } else {
+                    PolyValue::String(n.to_string())
+                }
+            }
+            JsonValue::String(s) => PolyValue::String(s),
+            JsonValue::Array(a) => PolyValue::List(a.into_iter().map(PolyValue::from).collect()),
+            JsonValue::Object(o) => {
+                let mut map = HashMap::with_capacity(o.len());
+                for (k, v) in o {
+                    map.insert(k, PolyValue::from(v));
+                }
+                PolyValue::Object(map)
+            }
+        }
+    }
+}
+
+/// Convert a `PolyValue` to `serde_json::Value` guided by a `ModelSchema`.
+pub fn poly_value_to_json_value(
+    val: &PolyValue,
+    schema: &ModelSchema,
+    by_alias: bool,
+) -> JsonValue {
+    match val {
+        PolyValue::Object(map) => {
+            let mut json_map = serde_json::Map::with_capacity(schema.fields.len());
+            for field in &schema.fields {
+                let key = if by_alias {
+                    std::str::from_utf8(&field.xml_name).unwrap_or(field.name.as_str())
+                } else {
+                    field.name.as_str()
+                };
+
+                if let Some(field_val) = map.get(&field.name) {
+                    let converted = match &field.val_type {
+                        ValueType::Nested(nested_schema) => {
+                            if field_val.is_null() {
+                                JsonValue::Null
+                            } else {
+                                poly_value_to_json_value(field_val, nested_schema, by_alias)
+                            }
+                        }
+                        ValueType::List(inner) => {
+                            if let PolyValue::List(items) = field_val {
+                                if let ValueType::Nested(nested_schema) = inner.as_ref() {
+                                    JsonValue::Array(
+                                        items
+                                            .iter()
+                                            .map(|item| {
+                                                poly_value_to_json_value(
+                                                    item,
+                                                    nested_schema,
+                                                    by_alias,
+                                                )
+                                            })
+                                            .collect(),
+                                    )
+                                } else {
+                                    JsonValue::Array(items.iter().map(JsonValue::from).collect())
+                                }
+                            } else if field_val.is_null() {
+                                JsonValue::Null
+                            } else {
+                                JsonValue::Array(vec![JsonValue::from(field_val)])
+                            }
+                        }
+                        ValueType::Scalar(_) => JsonValue::from(field_val),
+                    };
+                    json_map.insert(key.to_string(), converted);
+                }
+            }
+            JsonValue::Object(json_map)
+        }
+        other => JsonValue::from(other),
+    }
+}
+
+/// Coerce a JSON value into a `PolyValue` scalar matching `ScalarType`.
+fn coerce_scalar(val: &JsonValue, st: &ScalarType) -> PolyValue {
+    match val {
+        JsonValue::Null => PolyValue::Null,
+        JsonValue::Bool(b) => PolyValue::Bool(*b),
+        JsonValue::Number(n) => match st {
+            ScalarType::Int => {
+                if let Some(i) = n.as_i64() {
+                    PolyValue::Int(i)
+                } else {
+                    PolyValue::Int(n.as_f64().unwrap_or(0.0) as i64)
+                }
+            }
+            ScalarType::Float => PolyValue::Float(n.as_f64().unwrap_or(0.0)),
+            ScalarType::Decimal | ScalarType::String => PolyValue::String(n.to_string()),
+            _ => {
+                if let Some(i) = n.as_i64() {
+                    PolyValue::Int(i)
+                } else {
+                    PolyValue::Float(n.as_f64().unwrap_or(0.0))
+                }
+            }
+        },
+        JsonValue::String(s) => match st {
+            ScalarType::Int => {
+                if let Ok(i) = s.trim().parse::<i64>() {
+                    PolyValue::Int(i)
+                } else {
+                    PolyValue::String(s.clone())
+                }
+            }
+            ScalarType::Float => {
+                if let Ok(f) = s.trim().parse::<f64>() {
+                    PolyValue::Float(f)
+                } else {
+                    PolyValue::String(s.clone())
+                }
+            }
+            ScalarType::Bool => {
+                let trimmed = s.trim().to_ascii_lowercase();
+                if trimmed == "true" || trimmed == "1" {
+                    PolyValue::Bool(true)
+                } else if trimmed == "false" || trimmed == "0" {
+                    PolyValue::Bool(false)
+                } else {
+                    PolyValue::String(s.clone())
+                }
+            }
+            _ => PolyValue::String(s.clone()),
+        },
+        other => PolyValue::from(other.clone()),
+    }
+}
+
+/// Convert a `serde_json::Value` into a `PolyValue` matching a `ModelSchema`.
+pub fn json_value_to_poly_value(val: &JsonValue, schema: &ModelSchema) -> Result<PolyValue> {
+    match val {
+        JsonValue::Object(map) => {
+            let mut obj = HashMap::with_capacity(schema.fields.len());
+            for field in &schema.fields {
+                let xml_name_str = std::str::from_utf8(&field.xml_name).ok();
+                // Priority: match schema alias (xml_name) first, fallback to python field.name
+                let found_val = xml_name_str
+                    .and_then(|alias| map.get(alias))
+                    .or_else(|| map.get(&field.name));
+
+                if let Some(json_field_val) = found_val {
+                    if json_field_val.is_null() {
+                        obj.insert(field.name.clone(), PolyValue::Null);
+                        continue;
+                    }
+
+                    match &field.val_type {
+                        ValueType::Scalar(st) => {
+                            obj.insert(field.name.clone(), coerce_scalar(json_field_val, st));
+                        }
+                        ValueType::List(inner) => {
+                            if let JsonValue::Array(items) = json_field_val {
+                                let mut poly_list = Vec::with_capacity(items.len());
+                                for item in items {
+                                    if let ValueType::Nested(nested_schema) = inner.as_ref() {
+                                        poly_list
+                                            .push(json_value_to_poly_value(item, nested_schema)?);
+                                    } else if let ValueType::Scalar(st) = inner.as_ref() {
+                                        poly_list.push(coerce_scalar(item, st));
+                                    } else {
+                                        poly_list.push(PolyValue::from(item.clone()));
+                                    }
+                                }
+                                obj.insert(field.name.clone(), PolyValue::List(poly_list));
+                            } else {
+                                // Single item into list
+                                let single = match inner.as_ref() {
+                                    ValueType::Nested(nested_schema) => {
+                                        json_value_to_poly_value(json_field_val, nested_schema)?
+                                    }
+                                    ValueType::Scalar(st) => coerce_scalar(json_field_val, st),
+                                    _ => PolyValue::from(json_field_val.clone()),
+                                };
+                                obj.insert(field.name.clone(), PolyValue::List(vec![single]));
+                            }
+                        }
+                        ValueType::Nested(nested_schema) => {
+                            obj.insert(
+                                field.name.clone(),
+                                json_value_to_poly_value(json_field_val, nested_schema)?,
+                            );
+                        }
+                    }
+                }
+            }
+            Ok(PolyValue::Object(obj))
+        }
+        other => Ok(PolyValue::from(other.clone())),
+    }
+}
+
+/// Serialize a `PolyValue` into JSON bytes using a `ModelSchema`.
+pub fn serialize_json(
+    value: &PolyValue,
+    schema: &ModelSchema,
+    indent: Option<usize>,
+    by_alias: bool,
+) -> Result<Vec<u8>> {
+    let json_val = poly_value_to_json_value(value, schema, by_alias);
+    match indent {
+        Some(spaces) if spaces > 0 => {
+            let indent_str = " ".repeat(spaces);
+            let formatter = serde_json::ser::PrettyFormatter::with_indent(indent_str.as_bytes());
+            let mut buf = Vec::new();
+            let mut ser = serde_json::Serializer::with_formatter(&mut buf, formatter);
+            json_val.serialize(&mut ser)?;
+            Ok(buf)
+        }
+        _ => Ok(serde_json::to_vec(&json_val)?),
+    }
+}
+
+/// Deserialize JSON bytes into a `PolyValue` using a `ModelSchema`.
+pub fn deserialize_json(json_bytes: &[u8], schema: Arc<ModelSchema>) -> Result<PolyValue> {
+    let json_val: JsonValue = serde_json::from_slice(json_bytes)?;
+    json_value_to_poly_value(&json_val, &schema)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::schema::{FieldKind, FieldSchema};
+
+    #[test]
+    fn test_json_roundtrip_primitives() {
+        let schema = ModelSchema::builder("User")
+            .field(FieldSchema::new(
+                "user_id",
+                b"userId",
+                FieldKind::Attribute,
+                ValueType::Scalar(ScalarType::Int),
+            ))
+            .field(FieldSchema::new(
+                "full_name",
+                b"fullName",
+                FieldKind::Element,
+                ValueType::Scalar(ScalarType::String),
+            ))
+            .field(FieldSchema::new(
+                "score",
+                b"score",
+                FieldKind::Element,
+                ValueType::Scalar(ScalarType::Float),
+            ))
+            .field(FieldSchema::new(
+                "is_admin",
+                b"isAdmin",
+                FieldKind::Element,
+                ValueType::Scalar(ScalarType::Bool),
+            ))
+            .build();
+
+        let mut map = HashMap::new();
+        map.insert("user_id".to_string(), PolyValue::Int(42));
+        map.insert(
+            "full_name".to_string(),
+            PolyValue::String("Ada Lovelace".to_string()),
+        );
+        map.insert("score".to_string(), PolyValue::Float(99.5));
+        map.insert("is_admin".to_string(), PolyValue::Bool(true));
+        let poly_val = PolyValue::Object(map);
+
+        // Serialize with by_alias = true
+        let json_bytes = serialize_json(&poly_val, &schema, None, true).unwrap();
+        let json_str = std::str::from_utf8(&json_bytes).unwrap();
+        assert!(json_str.contains("\"userId\":42"));
+        assert!(json_str.contains("\"fullName\":\"Ada Lovelace\""));
+        assert!(json_str.contains("\"score\":99.5"));
+        assert!(json_str.contains("\"isAdmin\":true"));
+
+        // Deserialize back
+        let parsed = deserialize_json(&json_bytes, schema).unwrap();
+        assert_eq!(parsed.get("user_id"), Some(&PolyValue::Int(42)));
+        assert_eq!(
+            parsed.get("full_name"),
+            Some(&PolyValue::String("Ada Lovelace".to_string()))
+        );
+        assert_eq!(parsed.get("score"), Some(&PolyValue::Float(99.5)));
+        assert_eq!(parsed.get("is_admin"), Some(&PolyValue::Bool(true)));
+    }
+
+    #[test]
+    fn test_json_deserialization_accepts_python_field_names() {
+        let schema = ModelSchema::builder("User")
+            .field(FieldSchema::new(
+                "user_id",
+                b"userId",
+                FieldKind::Attribute,
+                ValueType::Scalar(ScalarType::Int),
+            ))
+            .field(FieldSchema::new(
+                "full_name",
+                b"fullName",
+                FieldKind::Element,
+                ValueType::Scalar(ScalarType::String),
+            ))
+            .build();
+
+        let json = br#"{"user_id": 100, "full_name": "Grace Hopper"}"#;
+        let parsed = deserialize_json(json, schema).unwrap();
+        assert_eq!(parsed.get("user_id"), Some(&PolyValue::Int(100)));
+        assert_eq!(
+            parsed.get("full_name"),
+            Some(&PolyValue::String("Grace Hopper".to_string()))
+        );
+    }
+}

{polyxml-0.12.0 → polyxml-0.13.0}/crates/polyxml-core/src/lib.rs

@@ -2,6 +2,7 @@ pub mod codegen;
 pub mod converters;
 pub mod error;
 pub mod ir;
+pub mod json;
 pub mod parser;
 pub mod schema;
 pub mod schema_parser;
@@ -9,6 +10,7 @@ pub mod serializer;
 pub mod value;
 
 pub use error::{PolyXmlError, Result};
+pub use json::{deserialize_json, serialize_json};
 pub use parser::{XmlDeserializer, XmlItemStream};
 pub use schema::{FieldKind, FieldSchema, ModelSchema, ScalarType, ValueType};
 pub use serializer::XmlSerializer;

{polyxml-0.12.0 → polyxml-0.13.0}/crates/polyxml-core/src/value.rs

@@ -64,4 +64,27 @@ impl PolyValue {
             _ => None,
         }
     }
+
+    /// Serialize this PolyValue into raw JSON bytes.
+    pub fn to_json(&self, indent: Option<usize>) -> crate::error::Result<Vec<u8>> {
+        let json_val = serde_json::Value::from(self);
+        match indent {
+            Some(spaces) if spaces > 0 => {
+                let indent_str = " ".repeat(spaces);
+                let formatter =
+                    serde_json::ser::PrettyFormatter::with_indent(indent_str.as_bytes());
+                let mut buf = Vec::new();
+                let mut ser = serde_json::Serializer::with_formatter(&mut buf, formatter);
+                serde::Serialize::serialize(&json_val, &mut ser)?;
+                Ok(buf)
+            }
+            _ => Ok(serde_json::to_vec(&json_val)?),
+        }
+    }
+
+    /// Deserialize raw JSON bytes into a dynamic PolyValue without a schema.
+    pub fn from_json(json_bytes: &[u8]) -> crate::error::Result<Self> {
+        let json_val: serde_json::Value = serde_json::from_slice(json_bytes)?;
+        Ok(PolyValue::from(json_val))
+    }
 }