feat: add enum variants

Author: ChristopherRabotin

Cargo.lock

@@ -1,7 +1,7 @@
 [package]
 name = "serde_dhall"
 # remember to update html_root_url, README and changelog
-version = "0.12.1"
+version = "0.12.2"
 authors = ["Nadrieril <[email protected]>"]
 license = "BSD-2-Clause"
 description = "Dhall support for serde"

serde_dhall/Cargo.toml

@@ -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/src/serialize.rs

@@ -0,0 +1,92 @@
+mod test_enum {
+    use serde::{Deserialize, Serialize};
+    use serde_dhall::{SimpleType, 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,
+    }
+
+    fn build_type() -> SimpleType {
+        let ty: SimpleType = serde_dhall::from_str(
+            r#"
+let ParentStruct = {id0: Integer, id1: Integer }
+
+let EnumVariant =
+        < SimpleStruct : { x : Double, y : Double, z : Double }
+        | InheritStruct: { field_a: ParentStruct, field_b: ParentStruct }
+        | Unitary
+        >       
+in EnumVariant"#,
+        )
+        .parse()
+        .unwrap();
+        ty
+    }
+
+    #[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)
+            .type_annotation(&build_type())
+            .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)
+            .type_annotation(&build_type())
+            .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)
+            .type_annotation(&build_type())
+            .to_string()
+            .unwrap();
+        println!("{v_str:?}");
+        let v_deser: EnumVariants =
+            serde_dhall::from_str(&v_str).parse().unwrap();
+        assert_eq!(v_deser, v);
+    }
+}