Merge pull request #246 from ChristopherRabotin/feat/enum-variant-simple-type-issue-242-impl1

Author: Nadrieril

CHANGELOG.md

@@ -4,6 +4,7 @@
 
 #### [0.13.0] - unreleased
 
+- Support enum struct variants in `SimpleType`
 - BREAKING CHANGE: Change minimum supported version to 1.76.0 because of the `wasm_bindgen` dependency
 
 #### [0.12.1] - 2023-02-01

serde_dhall/src/serialize.rs

@@ -67,7 +67,7 @@ impl ser::Serializer for Serializer {
     type SerializeTupleVariant = ser::Impossible<Self::Ok, Self::Error>;
     type SerializeMap = MapSerializer;
     type SerializeStruct = StructSerializer;
-    type SerializeStructVariant = ser::Impossible<Self::Ok, Self::Error>;
+    type SerializeStructVariant = StructVariantSerializer;
 
     fn serialize_bool(self, v: bool) -> Result<Self::Ok> {
         Ok(Num(NumKind::Bool(v)))
@@ -195,13 +195,13 @@ impl ser::Serializer for Serializer {
         self,
         _name: &'static str,
         _variant_index: u32,
-        _variant: &'static str,
+        variant: &'static str,
         _len: usize,
     ) -> Result<Self::SerializeStructVariant> {
-        Err(ErrorKind::Serialize(
-            "Unsupported data for serialization: struct variant".to_owned(),
-        )
-        .into())
+        Ok(StructVariantSerializer {
+            variant,
+            value: BTreeMap::new(),
+        })
     }
 
     fn serialize_tuple(self, _len: usize) -> Result<Self::SerializeTuple> {
@@ -339,6 +339,32 @@ impl ser::SerializeStruct for StructSerializer {
     }
 }
 
+struct StructVariantSerializer {
+    variant: &'static str,
+    value: BTreeMap<String, SimpleValue>,
+}
+
+impl ser::SerializeStructVariant for StructVariantSerializer {
+    type Ok = SimpleValue;
+    type Error = Error;
+
+    fn serialize_field<T>(&mut self, key: &'static str, val: &T) -> Result<()>
+    where
+        T: ?Sized + ser::Serialize,
+    {
+        let val: SimpleValue = val.serialize(Serializer)?;
+        self.value.insert(key.into(), val);
+        Ok(())
+    }
+
+    fn end(self) -> Result<Self::Ok> {
+        Ok(SimpleValue::Union(
+            self.variant.to_string(),
+            Some(Box::new(Record(self.value))),
+        ))
+    }
+}
+
 impl serde::ser::Serialize for SimpleValue {
     fn serialize<S>(
         &self,

serde_dhall/tests/enum_tests.rs

@@ -0,0 +1,75 @@
+mod test_enum {
+    use serde::{Deserialize, Serialize};
+    use serde_dhall::StaticType;
+
+    #[derive(
+        Copy, Clone, Debug, PartialEq, Eq, Serialize, Deserialize, StaticType,
+    )]
+    pub struct ParentStruct {
+        pub id0: i32,
+        pub id1: i32,
+    }
+
+    #[derive(Clone, Serialize, Deserialize, Debug, PartialEq, StaticType)]
+    pub enum EnumVariants {
+        SimpleStruct {
+            x: f64,
+            y: f64,
+            z: f64,
+        },
+        InheritStruct {
+            field_a: ParentStruct,
+            field_b: ParentStruct,
+        },
+
+        Unitary,
+    }
+
+    #[test]
+    fn test_enum_simple_struct() {
+        let v = EnumVariants::SimpleStruct {
+            x: 1.0,
+            y: 2.0,
+            z: 3.0,
+        };
+        let v_str = serde_dhall::serialize(&v)
+            .static_type_annotation()
+            .to_string()
+            .unwrap();
+        println!("{v_str:?}");
+        let v_deser: EnumVariants =
+            serde_dhall::from_str(&v_str).parse().unwrap();
+        assert_eq!(v_deser, v);
+    }
+
+    #[test]
+    fn test_enum_inherit_struct() {
+        let v = EnumVariants::InheritStruct {
+            field_a: ParentStruct { id0: 399, id1: 0 },
+            field_b: ParentStruct { id0: 301, id1: 0 },
+        };
+
+        let v_str = serde_dhall::serialize(&v)
+            .static_type_annotation()
+            .to_string()
+            .unwrap();
+        println!("{v_str:?}");
+        let v_deser: EnumVariants =
+            serde_dhall::from_str(&v_str).parse().unwrap();
+        assert_eq!(v_deser, v);
+    }
+
+    #[test]
+    fn test_enum_unitary() {
+        let v = EnumVariants::Unitary;
+
+        let v_str = serde_dhall::serialize(&v)
+            .static_type_annotation()
+            .to_string()
+            .unwrap();
+        println!("{v_str:?}");
+        let v_deser: EnumVariants =
+            serde_dhall::from_str(&v_str).parse().unwrap();
+        assert_eq!(v_deser, v);
+    }
+}