avrotize 2.21.1__py3-none-any.whl

avrotize/structuretorust/dataclass_enum.rs.jinja

@@ -0,0 +1,63 @@
+{%- if serde_annotation %}
+use serde::{self, Serialize, Deserialize};
+{%- endif %}
+
+{% if doc %}
+/// {{ doc }}
+{%- endif %}
+#[derive(Debug{%- if serde_annotation %}, Serialize, Deserialize{%- endif %}, PartialEq, Clone, Default)]
+{%- if serde_annotation %}
+#[serde(rename_all = "snake_case")]
+{%- endif %}
+pub enum {{ enum_name }} {
+    #[default]
+{%- for symbol in symbols %}
+    {%- if serde_annotation and symbol.name != symbol.value %}
+    #[serde(rename = "{{ symbol.value }}")]
+    {%- endif %}
+    {{ symbol.name }},
+{%- endfor %}
+}
+
+{%- if serde_annotation %}
+impl {{ enum_name }} {
+    pub fn is_json_match(node: &serde_json::Value) -> bool {
+        return node.is_string();
+    }
+
+    /// Returns the struct instance itself
+    pub fn to_object(&self) -> &Self {
+        return self;
+    }
+}
+{%- endif %}
+
+#[cfg(test)]
+impl {{ enum_name }} {
+    pub fn generate_random_instance() -> {{ enum_name }} {
+        let mut rng = rand::thread_rng();
+        match rand::Rng::gen_range(&mut rng, 0..{{ symbols | length }}) {
+            {%- for symbol in symbols %}
+            {{ loop.index0 }} => {{ enum_name }}::{{ symbol.name }},
+            {%- endfor %}
+            _ => panic!("Invalid random index generated"),
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use rand::Rng;
+
+    #[test]
+    fn test_enum_values_{{ enum_name.lower() }}() {
+        {%- for symbol in symbols %}
+        let instance = {{ enum_name }}::{{ symbol.name }};
+        {%- if serde_annotation %}
+        let json = serde_json::to_string(&instance).unwrap();
+        assert!(json.contains("{{ symbol.value }}"));
+        {%- endif %}
+        {%- endfor %}
+    }
+}

avrotize/structuretorust/dataclass_struct.rs.jinja

@@ -0,0 +1,121 @@
+{%- if serde_annotation %}
+use serde::{Serialize, Deserialize};
+{%- endif %}
+use std::io::Write;
+use flate2::write::GzEncoder;
+use flate2::read::GzDecoder;
+
+{% if doc %}
+/// {{ doc }}
+{%- endif %}
+#[derive(Debug{%- if serde_annotation %}, Serialize, Deserialize{%- endif %}, PartialEq, Clone, Default)]
+pub struct {{ struct_name }} {
+{%- for field in fields %}
+    {%- if field.serde_rename and serde_annotation %}
+    #[serde(rename = "{{ field.original_name }}")]
+    {%- endif %}
+    pub {{ field.name }}: {{ field.type }},
+{%- endfor %}
+}
+
+impl {{ struct_name }} {
+   /// Serializes the struct to a byte array based on the provided content type
+    pub fn to_byte_array(&self, content_type: &str) -> Result<Vec<u8>, Box<dyn std::error::Error>> {
+        let result: Vec<u8>;
+        let media_type = content_type.split(';').next().unwrap_or("");
+        {%- if serde_annotation %}
+        if media_type.starts_with("application/json") {
+            result = serde_json::to_vec(self)?;
+        }
+        else {% endif -%}
+        {
+            return Err(format!("unsupported media type: {}", media_type).into())
+        }
+        if media_type.ends_with("+gzip") {
+            let mut encoder = GzEncoder::new(Vec::new(), flate2::Compression::default());
+            encoder.write_all(&result)?;
+            let gzipresult = encoder.finish()?;
+            return Ok(gzipresult)
+        } else {
+            return Ok(result)
+        }
+    }
+
+    /// Deserializes the struct from a byte array based on the provided content type
+    pub fn from_data(data: impl AsRef<[u8]>, content_type: &str) -> Result<Self, Box<dyn std::error::Error>> {
+        let media_type = content_type.split(';').next().unwrap_or("");
+        let data = if media_type.ends_with("+gzip") {
+            let mut decoder = GzDecoder::new(data.as_ref());
+            let mut decompressed_data = Vec::new();
+            std::io::copy(&mut decoder, &mut decompressed_data)?;
+            decompressed_data
+        } else {
+            data.as_ref().to_vec()
+        };
+        {%- if serde_annotation %}
+        if media_type.starts_with("application/json") {
+            let result = serde_json::from_slice(&data)?;
+            return Ok(result)
+        }
+        {%- endif %}
+        Err(format!("unsupported media type: {}", media_type).into())
+    }
+
+    /// Returns the struct instance itself
+    pub fn to_object(&self) -> &Self {
+        self
+    }
+}
+
+#[cfg(test)]
+impl {{ struct_name }} {
+    pub fn generate_random_instance() -> {{ struct_name }} {
+        let mut rng = rand::thread_rng();
+        {{ struct_name }} {
+            {%- for field in fields %}
+            {%- if field.type.startswith("Option<") %}
+            {{ field.name }}: Some({{ field.random_value }}),
+            {%- else %}
+            {{ field.name }}: {{ field.random_value }},
+            {%- endif %}
+            {%- endfor %}
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+ 
+    #[test]
+    fn test_create_{{ struct_name.lower() }}() {
+        let instance = {{struct_name}}::generate_random_instance();
+        {%- for field in fields %}
+        {%- if field.type.startswith("Option<") %}
+        assert!(instance.{{ field.name }}.is_some()); // Check that {{ field.name }} is not None
+        {%- elif field.type.startswith("Vec<") %}
+        {%- set field_type = 'Vec::<'+field.type[4:] %}
+        assert!(instance.{{ field.name }} != {{ field_type }}::default()); // Check that {{ field.name }} is not default
+        {%- elif field.type.startswith("std::collections::HashMap<")%}
+        assert!(instance.{{ field.name }}.len() >= 0); // Check that {{ field.name }} is not empty
+        {%- elif field.type != "bool" %}
+        assert!(instance.{{ field.name }} != {{ field.type }}::default()); // Check that {{ field.name }} is not default
+        {%- endif %}
+        {%- endfor %}
+    }
+
+    {%- if serde_annotation %}
+    #[test]
+    fn test_serialize_deserialize_{{ struct_name.lower() }}() {
+        let instance = {{struct_name}}::generate_random_instance();
+        // Test JSON serialization and deserialization
+        let json_bytes = instance.to_byte_array("application/json").unwrap();
+        let deserialized_instance: {{ struct_name }} = {{ struct_name }}::from_data(&json_bytes, "application/json").unwrap();
+        assert_eq!(instance, deserialized_instance);
+        // Test JSON serialization and deserialization with compression
+        let json_gzip_bytes = instance.to_byte_array("application/json+gzip").unwrap();
+        let deserialized_gzip_instance: {{ struct_name }} = {{ struct_name }}::from_data(&json_gzip_bytes, "application/json+gzip").unwrap();
+        assert_eq!(instance, deserialized_gzip_instance);
+    }
+    {%- endif %}
+}

avrotize/structuretorust/dataclass_union.rs.jinja

@@ -0,0 +1,81 @@
+{%- if serde_annotation %}
+use serde::{self, Serialize, Deserialize};
+{%- endif %}
+
+{% if doc %}
+/// {{ doc }}
+{%- endif %}
+#[derive(Debug, PartialEq, Clone)]
+{%- if serde_annotation %}
+#[serde(untagged)]
+{%- endif %}
+pub enum {{ union_enum_name }} {
+{%- for variant in variants %}
+    {{ variant.variant_name }}({{ variant.type -}})
+    {%- if not loop.last %},{% endif %}
+{%- endfor %}
+}
+
+impl Default for {{ union_enum_name }} {
+    fn default() -> Self {
+        return {{ union_enum_name }}::{{ variants[0].variant_name }}(Default::default())
+    }
+}
+
+{%- if serde_annotation %}
+impl Serialize for {{ union_enum_name }} {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::ser::Serializer
+    {
+        match self {
+            {%- for variant in variants %}
+            {{ union_enum_name }}::{{ variant.variant_name}}(value) => value.serialize(serializer),
+            {%- endfor %}
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for {{ union_enum_name }} {
+    fn deserialize<D>(deserializer: D) -> Result<{{ union_enum_name }}, D::Error>
+    where
+        D: serde::de::Deserializer<'de>
+    {
+        let node = serde_json::Value::deserialize(deserializer)?;
+        {%- for variant in variants %}
+        {
+            if let Ok(value) = serde_json::from_value::<{{ variant.type }}>(node.clone()) {
+                return Ok({{ union_enum_name }}::{{ variant.variant_name }}(value));
+            }
+        }
+        {%- endfor %}
+        Err(serde::de::Error::custom("No valid variant found"))
+    }
+}
+{%- endif %}
+
+#[cfg(test)]
+impl {{ union_enum_name }} {
+    pub fn generate_random_instance() -> {{ union_enum_name }} {
+        let mut rng = rand::thread_rng();
+        match rand::Rng::gen_range(&mut rng, 0..{{ variants | length }}) {
+            {%- for variant in variants %}
+            {{ loop.index0 }} => {{ union_enum_name }}::{{ variant.variant_name }}(Default::default()),
+            {%- endfor %}
+            _ => panic!("Invalid random index generated"),
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_union_variants_{{ union_enum_name.lower() }}() {
+        {%- for variant in variants %}
+        let instance = {{ union_enum_name }}::{{ variant.variant_name }}(Default::default());
+        assert!(matches!(instance, {{ union_enum_name }}::{{ variant.variant_name }}(_)));
+        {%- endfor %}
+    }
+}