extends/improve enum variants formats

Author: kali

serde-tests/test.rs.in

@@ -188,6 +188,7 @@ fn inner_structs_with_options() {
     assert_eq!(encode!(v),
                bdoc! {
                    "a" => {
+                       "a" => (Bson::Null),
                        "b" => {
                            "a" => "foo",
                            "b" => (4.5)
@@ -201,6 +202,43 @@ fn inner_structs_with_options() {
     assert_eq!(v, decode!(encode!(v)));
 }
 
+#[test]
+fn inner_structs_with_skippable_options() {
+    #[derive(Serialize, Deserialize, PartialEq, Debug)]
+    struct Foo {
+        #[serde(skip_serializing_if="Option::is_none")]
+        a: Option<Box<Foo>>,
+        b: Bar,
+    }
+    #[derive(Serialize, Deserialize, PartialEq, Debug)]
+    struct Bar {
+        a: String,
+        b: f64,
+    }
+
+    let v = Foo {
+        a: Some(Box::new(Foo {
+            a: None,
+            b: Bar { a: "foo".to_string(), b: 4.5 },
+        })),
+        b: Bar { a: "bar".to_string(), b: 1.0 },
+    };
+    assert_eq!(encode!(v),
+               bdoc! {
+                   "a" => {
+                   "b" => {
+                           "a" => "foo",
+                           "b" => (4.5)
+                       }
+                   },
+                   "b" => {
+                       "a" => "bar",
+                       "b" => (1.0)
+                   }
+               });
+    assert_eq!(v, decode!(encode!(v)));
+}
+
 #[test]
 fn hashmap() {
     #[derive(Serialize, Deserialize, PartialEq, Debug)]
@@ -295,7 +333,7 @@ fn missing_errors() {
 
     let mut d = Decoder::new(bdoc! {});
     let a: Result<Foo, DecoderError> = Deserialize::deserialize(&mut d);
-    
+
     assert!(a.is_err());
 }
 
@@ -305,18 +343,28 @@ fn parse_enum() {
     struct Foo { a: E }
     #[derive(Serialize, Deserialize, PartialEq, Debug)]
     enum E {
+        Empty,
         Bar(i32),
         Baz(f64),
+        Pair(i32, i32),
         Last(Foo2),
+        Vector(Vec<i32>),
+        Named { a: i32 },
+        MultiNamed { a: i32, b: i32 },
     }
     #[derive(Serialize, Deserialize, PartialEq, Debug)]
     struct Foo2 {
         test: String,
     }
 
+    let v = Foo { a: E::Empty };
+    assert_eq!(
+        encode!(v),
+        bdoc! { "a" => "Empty" }
+    );
+    assert_eq!(v, decode!(encode!(v)));
+
     let v = Foo { a: E::Bar(10) };
-    // technically serde is correct here. a single element tuple still is a
-    // tuple and therefor a sequence
     assert_eq!(
         encode!(v),
         bdoc! { "a" => { "Bar" => 10 } }
@@ -326,7 +374,14 @@ fn parse_enum() {
     let v = Foo { a: E::Baz(10.2) };
     assert_eq!(
         encode!(v),
-        bdoc! { "a" => { "Baz" => (10.2) } }
+        bdoc! { "a" => { "Baz" => 10.2 } }
+    );
+    assert_eq!(v, decode!(encode!(v)));
+
+    let v = Foo { a: E::Pair(12,42) };
+    assert_eq!(
+        encode!(v),
+        bdoc! { "a" => { "Pair" => [ 12, 42] } }
     );
     assert_eq!(v, decode!(encode!(v)));
 
@@ -336,6 +391,26 @@ fn parse_enum() {
         bdoc! { "a" => { "Last" => { "test" => "test" } } }
     );
     assert_eq!(v, decode!(encode!(v)));
+
+    let v = Foo { a: E::Vector(vec!(12,42)) };
+    assert_eq!(
+        encode!(v),
+        bdoc! { "a" => { "Vector" => [ 12, 42 ] } }
+    );
+    assert_eq!(v, decode!(encode!(v)));
+
+    let v = Foo { a: E::Named { a: 12 } };
+    assert_eq!(
+        encode!(v),
+        bdoc! { "a" => { "Named" => { "a" => 12 } } }
+    );
+    assert_eq!(v, decode!(encode!(v)));
+    let v = Foo { a: E::MultiNamed { a: 12, b: 42 } };
+    assert_eq!(
+        encode!(v),
+        bdoc! { "a" => { "MultiNamed" => { "a" => 12, "b" => 42 } } }
+    );
+    assert_eq!(v, decode!(encode!(v)));
 }
 
 #[test]

src/decoder/serde.rs

@@ -256,6 +256,13 @@ impl Deserializer for Decoder {
     {
         let value = match self.value.take() {
             Some(Bson::Document(value)) => value,
+            Some(Bson::String(variant)) => {
+                return visitor.visit(VariantDecoder {
+                    de: self,
+                    val: None,
+                    variant: Some(Bson::String(variant)),
+                })
+            }
             Some(_) => {
                 return Err(de::Error::invalid_value("expected an enum"));
             }
@@ -343,9 +350,13 @@ impl<'a> VariantVisitor for VariantDecoder<'a> {
     }
 
     fn visit_unit(&mut self) -> DecoderResult<()> {
-        Deserialize::deserialize(&mut Decoder::new(try!(self.val
-            .take()
-            .ok_or(DecoderError::EndOfStream))))
+        match self.val.take() {
+            None => Ok(()),
+            Some(val) => {
+                try!(Deserialize::deserialize(&mut Decoder::new(val)));
+                Ok(())
+            }
+        }
     }
 
     fn visit_newtype<T>(&mut self) -> DecoderResult<T>

src/encoder/serde.rs

@@ -216,10 +216,7 @@ impl Serializer for Encoder {
                               _variant_index: usize,
                               variant: &'static str)
                               -> EncoderResult<()> {
-        let mut unit_variant = Document::new();
-        unit_variant.insert(variant.to_string(), Bson::Array(vec![]));
-
-        self.value = Bson::Document(unit_variant);
+        self.value = Bson::String(variant.to_string());
         Ok(())
     }
 
@@ -330,7 +327,11 @@ impl Serializer for Encoder {
     #[inline]
     fn serialize_tuple_variant_end(&mut self, state: TupleVariantState) -> EncoderResult<()> {
         let mut tuple_variant = Document::new();
-        tuple_variant.insert(state.name.to_string(), Bson::Array(state.array));
+        if state.array.len() == 1 {
+            tuple_variant.insert(state.name.to_string(), state.array.into_iter().next().unwrap());
+        } else {
+            tuple_variant.insert(state.name.to_string(), Bson::Array(state.array));
+        }
 
         self.value = Bson::Document(tuple_variant);
         Ok(())