Merge pull request #189 from Nadrieril/serialize

3 files changed, 268 insertions, 150 deletions

diff --git a/serde_dhall/tests/de.rs b/serde_dhall/tests/de.rs
deleted file mode 100644
index 3abaad2..0000000
--- a/serde_dhall/tests/de.rs
+++ /dev/null
@@ -1,150 +0,0 @@
-use serde::Deserialize;
-use serde_dhall::{from_str, FromDhall, NumKind, SimpleValue, StaticType};
-
-#[test]
-fn test_de_typed() {
-    fn parse<T: FromDhall + StaticType>(s: &str) -> T {
-        from_str(s).static_type_annotation().parse().unwrap()
-    }
-
-    assert_eq!(parse::<bool>("True"), true);
-
-    assert_eq!(parse::<u64>("1"), 1);
-    assert_eq!(parse::<u32>("1"), 1);
-    assert_eq!(parse::<usize>("1"), 1);
-
-    assert_eq!(parse::<i64>("+1"), 1);
-    assert_eq!(parse::<i32>("+1"), 1);
-    assert_eq!(parse::<isize>("+1"), 1);
-
-    assert_eq!(parse::<f64>("1.0"), 1.0);
-    assert_eq!(parse::<f32>("1.0"), 1.0);
-
-    assert_eq!(parse::<String>(r#""foo""#), "foo".to_owned());
-    assert_eq!(parse::<Vec<u64>>("[] : List Natural"), <Vec<u64>>::new());
-    assert_eq!(parse::<Vec<u64>>("[1, 2]"), vec![1, 2]);
-    assert_eq!(parse::<Option<u64>>("None Natural"), None);
-    assert_eq!(parse::<Option<u64>>("Some 1"), Some(1));
-
-    assert_eq!(
-        parse::<(u64, String)>(r#"{ _1 = 1, _2 = "foo" }"#),
-        (1, "foo".to_owned())
-    );
-
-    #[derive(Debug, PartialEq, Eq, Deserialize, StaticType)]
-    struct Foo {
-        x: u64,
-        y: i64,
-    }
-    assert_eq!(parse::<Foo>("{ x = 1, y = -2 }"), Foo { x: 1, y: -2 });
-
-    #[derive(Debug, PartialEq, Eq, Deserialize, StaticType)]
-    enum Bar {
-        X(u64),
-        Y(i64),
-    }
-    assert_eq!(parse::<Bar>("< X: Natural | Y: Integer >.X 1"), Bar::X(1));
-
-    #[derive(Debug, PartialEq, Eq, Deserialize, StaticType)]
-    enum Baz {
-        X,
-        Y(i64),
-    }
-    assert_eq!(parse::<Baz>("< X | Y: Integer >.X"), Baz::X);
-
-    assert!(from_str("< X | Y: Integer >.Y")
-        .static_type_annotation()
-        .parse::<Baz>()
-        .is_err());
-}
-
-#[test]
-fn test_de_untyped() {
-    use std::collections::BTreeMap;
-    use std::collections::HashMap;
-
-    fn parse<T: FromDhall>(s: &str) -> T {
-        from_str(s).parse().unwrap()
-    }
-
-    // Test tuples on record of wrong type
-    assert_eq!(
-        parse::<(u64, String, i64)>(r#"{ y = "foo", x = 1, z = +42 }"#),
-        (1, "foo".to_owned(), 42)
-    );
-
-    let mut expected_map = HashMap::new();
-    expected_map.insert("x".to_string(), 1);
-    expected_map.insert("y".to_string(), 2);
-    assert_eq!(
-        parse::<HashMap<String, u64>>("{ x = 1, y = 2 }"),
-        expected_map
-    );
-    assert_eq!(
-        parse::<HashMap<String, u64>>("toMap { x = 1, y = 2 }"),
-        expected_map
-    );
-
-    let mut expected_map = HashMap::new();
-    expected_map.insert("if".to_string(), 1);
-    expected_map.insert("FOO_BAR".to_string(), 2);
-    expected_map.insert("baz-kux".to_string(), 3);
-    assert_eq!(
-        parse::<HashMap<String, u64>>("{ `if` = 1, FOO_BAR = 2, baz-kux = 3 }"),
-        expected_map
-    );
-
-    let mut expected_map = BTreeMap::new();
-    expected_map.insert("x".to_string(), 1);
-    expected_map.insert("y".to_string(), 2);
-    assert_eq!(
-        parse::<BTreeMap<String, u64>>("{ x = 1, y = 2 }"),
-        expected_map
-    );
-
-    #[derive(Debug, PartialEq, Eq, Deserialize)]
-    struct Foo {
-        x: u64,
-        y: Option<u64>,
-    }
-    // Omit optional field
-    assert_eq!(parse::<Foo>("{ x = 1 }"), Foo { x: 1, y: None });
-
-    // https://github.com/Nadrieril/dhall-rust/issues/155
-    assert!(from_str("List/length [True, 42]").parse::<bool>().is_err());
-}
-
-#[test]
-fn test_de_simplevalue() {
-    let bool_true = SimpleValue::Num(NumKind::Bool(true));
-    // https://github.com/Nadrieril/dhall-rust/issues/184
-    assert_eq!(
-        from_str("[ True ]").parse::<Vec<SimpleValue>>().unwrap(),
-        vec![bool_true.clone()]
-    );
-
-    assert_eq!(
-        from_str("< Foo >.Foo").parse::<SimpleValue>().unwrap(),
-        SimpleValue::Union("Foo".into(), None)
-    );
-    assert_eq!(
-        from_str("< Foo: Bool >.Foo True")
-            .parse::<SimpleValue>()
-            .unwrap(),
-        SimpleValue::Union("Foo".into(), Some(Box::new(bool_true.clone())))
-    );
-
-    #[derive(Debug, PartialEq, Eq, Deserialize)]
-    struct Foo {
-        foo: SimpleValue,
-    }
-    assert_eq!(
-        from_str("{ foo = True }").parse::<Foo>().unwrap(),
-        Foo {
-            foo: bool_true.clone()
-        },
-    );
-}
-
-// TODO: test various builder configurations
-// In particular test cloning and reusing builder
diff --git a/serde_dhall/tests/serde.rs b/serde_dhall/tests/serde.rs
new file mode 100644
index 0000000..4c184e7
--- /dev/null
+++ b/serde_dhall/tests/serde.rs
@@ -0,0 +1,210 @@
+mod serde {
+    use serde::{Deserialize, Serialize};
+    use serde_dhall::{from_str, serialize, FromDhall, StaticType, ToDhall};
+
+    fn assert_de<T>(s: &str, x: T)
+    where
+        T: FromDhall + StaticType + PartialEq + std::fmt::Debug,
+    {
+        assert_eq!(
+            from_str(s)
+                .static_type_annotation()
+                .parse::<T>()
+                .map_err(|e| e.to_string()),
+            Ok(x)
+        );
+    }
+    fn assert_ser<T>(s: &str, x: T)
+    where
+        T: ToDhall + StaticType + PartialEq + std::fmt::Debug,
+    {
+        assert_eq!(
+            serialize(&x)
+                .static_type_annotation()
+                .to_string()
+                .map_err(|e| e.to_string()),
+            Ok(s.to_string())
+        );
+    }
+    fn assert_serde<T>(s: &str, x: T)
+    where
+        T: ToDhall
+            + FromDhall
+            + StaticType
+            + PartialEq
+            + std::fmt::Debug
+            + Clone,
+    {
+        assert_de(s, x.clone());
+        assert_ser(s, x);
+    }
+
+    #[test]
+    fn numbers() {
+        assert_serde("True", true);
+
+        assert_serde("1", 1u64);
+        assert_serde("1", 1u32);
+        assert_serde("1", 1usize);
+
+        assert_serde("+1", 1i64);
+        assert_serde("+1", 1i32);
+        assert_serde("+1", 1isize);
+
+        assert_serde("1.0", 1.0f64);
+        assert_serde("1.0", 1.0f32);
+    }
+
+    #[test]
+    fn text() {
+        assert_serde(r#""foo""#, "foo".to_owned());
+        assert_ser(r#""foo""#, "foo");
+    }
+
+    #[test]
+    fn list() {
+        assert_serde("[] : List Natural", <Vec<u64>>::new());
+        assert_serde("[] : List Text", <Vec<String>>::new());
+        assert_serde(
+            r#"["foo", "bar"]"#,
+            vec!["foo".to_owned(), "bar".to_owned()],
+        );
+        assert_ser(r#"["foo", "bar"]"#, vec!["foo", "bar"]);
+        assert_serde::<Vec<u64>>("[1, 2]", vec![1, 2]);
+    }
+
+    #[test]
+    fn optional() {
+        assert_serde("None Natural", None::<u64>);
+        assert_serde("None Text", None::<String>);
+        assert_serde("Some 1", Some(1u64));
+        assert_eq!(
+            serialize(&None::<u64>).to_string().map_err(|e| e.to_string()),
+            Err("cannot serialize value without a type annotation: Optional(None)".to_string())
+        );
+    }
+
+    #[test]
+    fn tuple() {
+        assert_serde::<()>(r#"{=}"#, ());
+        assert_serde::<(u64, String)>(
+            r#"{ _1 = 1, _2 = "foo" }"#,
+            (1, "foo".to_owned()),
+        );
+        assert_serde::<(u64, u64, u64, u64)>(
+            r#"{ _1 = 1, _2 = 2, _3 = 3, _4 = 4 }"#,
+            (1, 2, 3, 4),
+        );
+    }
+
+    #[test]
+    fn structs() {
+        // #[derive(
+        //     Debug, Clone, PartialEq, Eq, Deserialize, Serialize, StaticType,
+        // )]
+        // struct Foo;
+        // assert_serde::<Foo>("{=}", Foo);
+
+        // #[derive(
+        //     Debug, Clone, PartialEq, Eq, Deserialize, Serialize, StaticType,
+        // )]
+        // struct Bar(u64);
+        // assert_serde::<Bar>("{ _1 = 1 }", Bar (1));
+
+        #[derive(
+            Debug, Clone, PartialEq, Eq, Deserialize, Serialize, StaticType,
+        )]
+        struct Baz {
+            x: u64,
+            y: i64,
+        }
+        assert_serde::<Baz>("{ x = 1, y = -2 }", Baz { x: 1, y: -2 });
+    }
+
+    #[test]
+    fn enums() {
+        #[derive(
+            Debug, Clone, PartialEq, Eq, Deserialize, Serialize, StaticType,
+        )]
+        enum Foo {
+            X(u64),
+            Y(i64),
+        }
+        assert_serde::<Foo>("< X: Natural | Y: Integer >.X 1", Foo::X(1));
+
+        #[derive(
+            Debug, Clone, PartialEq, Eq, Deserialize, Serialize, StaticType,
+        )]
+        enum Bar {
+            X,
+            Y(i64),
+        }
+        assert_serde::<Bar>("< X | Y: Integer >.X", Bar::X);
+
+        assert!(from_str("< X | Y: Integer >.Y")
+            .static_type_annotation()
+            .parse::<Bar>()
+            .is_err());
+    }
+
+    #[test]
+    fn test_de_untyped() {
+        use std::collections::BTreeMap;
+        use std::collections::HashMap;
+
+        fn parse<T: FromDhall>(s: &str) -> T {
+            from_str(s).parse().unwrap()
+        }
+
+        // Test tuples on record of wrong type. Fields are just taken in alphabetic order.
+        assert_eq!(
+            parse::<(u64, String, i64)>(r#"{ y = "foo", x = 1, z = +42 }"#),
+            (1, "foo".to_owned(), 42)
+        );
+
+        let mut expected_map = HashMap::new();
+        expected_map.insert("x".to_string(), 1);
+        expected_map.insert("y".to_string(), 2);
+        assert_eq!(
+            parse::<HashMap<String, u64>>("{ x = 1, y = 2 }"),
+            expected_map
+        );
+        assert_eq!(
+            parse::<HashMap<String, u64>>("toMap { x = 1, y = 2 }"),
+            expected_map
+        );
+
+        let mut expected_map = HashMap::new();
+        expected_map.insert("if".to_string(), 1);
+        expected_map.insert("FOO_BAR".to_string(), 2);
+        expected_map.insert("baz-kux".to_string(), 3);
+        assert_eq!(
+            parse::<HashMap<String, u64>>(
+                "{ `if` = 1, FOO_BAR = 2, baz-kux = 3 }"
+            ),
+            expected_map
+        );
+
+        let mut expected_map = BTreeMap::new();
+        expected_map.insert("x".to_string(), 1);
+        expected_map.insert("y".to_string(), 2);
+        assert_eq!(
+            parse::<BTreeMap<String, u64>>("{ x = 1, y = 2 }"),
+            expected_map
+        );
+
+        #[derive(Debug, PartialEq, Eq, Deserialize)]
+        struct Foo {
+            x: u64,
+            y: Option<u64>,
+        }
+        // Omit optional field
+        assert_eq!(parse::<Foo>("{ x = 1 }"), Foo { x: 1, y: None });
+
+        // https://github.com/Nadrieril/dhall-rust/issues/155
+        assert!(from_str("List/length [True, 42]").parse::<bool>().is_err());
+    }
+
+    // TODO: test various builder configurations
+    // In particular test cloning and reusing builder
+}
diff --git a/serde_dhall/tests/simple_value.rs b/serde_dhall/tests/simple_value.rs
new file mode 100644
index 0000000..3bd9d64
--- /dev/null
+++ b/serde_dhall/tests/simple_value.rs
@@ -0,0 +1,58 @@
+mod simple_value {
+    use serde::{Deserialize, Serialize};
+    use serde_dhall::{
+        from_str, serialize, FromDhall, NumKind, SimpleValue, ToDhall,
+    };
+
+    fn assert_de<T>(s: &str, x: T)
+    where
+        T: FromDhall + PartialEq + std::fmt::Debug,
+    {
+        assert_eq!(from_str(s).parse::<T>().map_err(|e| e.to_string()), Ok(x));
+    }
+    fn assert_ser<T>(s: &str, x: T)
+    where
+        T: ToDhall + PartialEq + std::fmt::Debug,
+    {
+        assert_eq!(
+            serialize(&x).to_string().map_err(|e| e.to_string()),
+            Ok(s.to_string())
+        );
+    }
+    fn assert_serde<T>(s: &str, x: T)
+    where
+        T: ToDhall + FromDhall + PartialEq + std::fmt::Debug + Clone,
+    {
+        assert_de(s, x.clone());
+        assert_ser(s, x);
+    }
+
+    #[test]
+    fn test_serde() {
+        let bool_true = SimpleValue::Num(NumKind::Bool(true));
+        // https://github.com/Nadrieril/dhall-rust/issues/184
+        assert_serde("[True]", vec![bool_true.clone()]);
+
+        assert_de("< Foo >.Foo", SimpleValue::Union("Foo".into(), None));
+        assert_de(
+            "< Foo: Bool >.Foo True",
+            SimpleValue::Union("Foo".into(), Some(Box::new(bool_true.clone()))),
+        );
+
+        assert_eq!(
+            serialize(&SimpleValue::Union("Foo".into(), None)).to_string().map_err(|e| e.to_string()),
+            Err("cannot serialize value without a type annotation: Union(\"Foo\", None)".to_string())
+        );
+
+        #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+        struct Foo {
+            foo: SimpleValue,
+        }
+        assert_serde(
+            "{ foo = True }",
+            Foo {
+                foo: bool_true.clone(),
+            },
+        );
+    }
+}