Fix serializing json enums

serde2/src/json/ser.rs

@@ -47,12 +47,6 @@ impl<'a, W: io::Write> ser::Visitor for Visitor<'a, W> {
     type Value = ();
     type Error = io::Error;
 
-    #[inline]
-    fn visit_unit(&mut self) -> io::Result<()> {
-        try!(self.writer.write(b"null"));
-        Ok(())
-    }
-
     #[inline]
     fn visit_bool(&mut self, value: bool) -> io::Result<()> {
         if value {
@@ -145,6 +139,20 @@ impl<'a, W: io::Write> ser::Visitor for Visitor<'a, W> {
         value.visit(self)
     }
 
+    #[inline]
+    fn visit_unit(&mut self) -> io::Result<()> {
+        try!(self.writer.write(b"null"));
+        Ok(())
+    }
+
+    #[inline]
+    fn visit_enum_unit(&mut self, _name: &str, variant: &str) -> io::Result<()> {
+        try!(self.writer.write(b"{"));
+        try!(self.visit_str(variant));
+        try!(self.writer.write(b":[]}"));
+        Ok(())
+    }
+
     #[inline]
     fn visit_seq<V>(&mut self, mut visitor: V) -> io::Result<()>
         where V: ser::SeqVisitor,
@@ -157,6 +165,19 @@ impl<'a, W: io::Write> ser::Visitor for Visitor<'a, W> {
         Ok(())
     }
 
+    #[inline]
+    fn visit_enum_seq<V>(&mut self, _name: &str, variant: &str, visitor: V) -> io::Result<()>
+        where V: ser::SeqVisitor,
+    {
+        try!(self.writer.write(b"{"));
+        try!(self.visit_str(variant));
+        try!(self.writer.write(b":"));
+        try!(self.visit_seq(visitor));
+        try!(self.writer.write(b"}"));
+
+        Ok(())
+    }
+
     #[inline]
     fn visit_seq_elt<T>(&mut self, first: bool, value: T) -> io::Result<()>
         where T: ser::Serialize,
@@ -181,6 +202,19 @@ impl<'a, W: io::Write> ser::Visitor for Visitor<'a, W> {
         Ok(())
     }
 
+    #[inline]
+    fn visit_enum_map<V>(&mut self, _name: &str, variant: &str, visitor: V) -> io::Result<()>
+        where V: ser::MapVisitor,
+    {
+        try!(self.writer.write(b"{"));
+        try!(self.visit_str(variant));
+        try!(self.writer.write(b":"));
+        try!(self.visit_map(visitor));
+        try!(self.writer.write(b"}"));
+
+        Ok(())
+    }
+
     #[inline]
     fn visit_map_elt<K, V>(&mut self, first: bool, key: K, value: V) -> io::Result<()>
         where K: ser::Serialize,

serde2/src/json/value.rs

@@ -193,6 +193,26 @@ impl ser::Visitor for Serializer {
         Ok(())
     }
 
+    #[inline]
+    fn visit_enum_seq<V>(&mut self, _name: &str, variant: &str, visitor: V) -> Result<(), ()>
+        where V: ser::SeqVisitor,
+    {
+        try!(self.visit_seq(visitor));
+
+        let value = match self.state.pop().unwrap() {
+            State::Value(value) => value,
+            _ => panic!(),
+        };
+
+        let mut object = BTreeMap::new();
+
+        object.insert(variant.to_string(), value);
+
+        self.state.push(State::Value(Value::Object(object)));
+
+        Ok(())
+    }
+
     #[inline]
     fn visit_seq_elt<T>(&mut self, _first: bool, value: T) -> Result<(), ()>
         where T: ser::Serialize,
@@ -232,6 +252,26 @@ impl ser::Visitor for Serializer {
         Ok(())
     }
 
+    #[inline]
+    fn visit_enum_map<V>(&mut self, _name: &str, variant: &str, visitor: V) -> Result<(), ()>
+        where V: ser::MapVisitor,
+    {
+        try!(self.visit_map(visitor));
+
+        let value = match self.state.pop().unwrap() {
+            State::Value(value) => value,
+            _ => panic!(),
+        };
+
+        let mut object = BTreeMap::new();
+
+        object.insert(variant.to_string(), value);
+
+        self.state.push(State::Value(Value::Object(object)));
+
+        Ok(())
+    }
+
     #[inline]
     fn visit_map_elt<K, V>(&mut self, _first: bool, key: K, value: V) -> Result<(), ()>
         where K: ser::Serialize,

serde2/tests/test_json.rs

@@ -54,7 +54,9 @@ macro_rules! treemap {
 #[derive_deserialize]
 enum Animal {
     Dog,
-    Frog(String, Vec<isize>)
+    Frog(String, Vec<isize>),
+    Cat { age: usize, name: String },
+
 }
 
 #[derive(PartialEq, Debug)]
@@ -349,10 +351,26 @@ fn test_write_tuple() {
 #[test]
 fn test_write_enum() {
     test_encode_ok(&[
-        (Animal::Dog, "{\"Dog\":[]}"),
+        (
-        (Animal::Frog("Henry".to_string(), vec!()), "{\"Frog\":[\"Henry\",[]]}"),
+            Animal::Dog,
-        (Animal::Frog("Henry".to_string(), vec!(349)), "{\"Frog\":[\"Henry\",[349]]}"),
+            "{\"Dog\":[]}",
-        (Animal::Frog("Henry".to_string(), vec!(349, 102)), "{\"Frog\":[\"Henry\",[349,102]]}"),
+        ),
+        (
+            Animal::Frog("Henry".to_string(), vec!()),
+            "{\"Frog\":[\"Henry\",[]]}",
+        ),
+        (
+            Animal::Frog("Henry".to_string(), vec!(349)),
+            "{\"Frog\":[\"Henry\",[349]]}",
+        ),
+        (
+            Animal::Frog("Henry".to_string(), vec!(349, 102)),
+            "{\"Frog\":[\"Henry\",[349,102]]}",
+        ),
+        (
+            Animal::Cat { age: 5, name: "Kate".to_string() },
+            "{\"Cat\":{\"age\":5,\"name\":\"Kate\"}}"
+        ),
     ]);
 
     /*