feat: (de)serialize options

Author: angrynode

src/de.rs

@@ -770,4 +770,126 @@ mod tests {
         assert_eq!(s, expected);
         Ok(())
     }
+
+    #[test]
+    fn test_deserialize_some_struct() -> Result<()> {
+        #[derive(Debug, PartialEq, Deserialize)]
+        struct S {
+            inner: i32,
+        }
+
+        let input = "d5:inneri32ee";
+        let s: Option<S> = from_slice(input.as_bytes())?;
+        let expected = Some(S { inner: 32 });
+        assert_eq!(s, expected);
+        Ok(())
+    }
+
+    #[test]
+    fn test_deserialize_none_struct() -> Result<()> {
+        #[derive(Debug, PartialEq, Deserialize)]
+        struct S {
+            inner: i32,
+        }
+
+        let input = "de";
+        // let s: Option<S> = from_slice(input.as_bytes());
+        let s: Result<Option<S>> = from_slice(input.as_bytes());
+        println!("{:?}", s);
+        let s = s.unwrap();
+        let expected = None;
+        assert_eq!(s, expected);
+        Ok(())
+    }
+
+    #[test]
+    fn test_deserialize_struct_some() -> Result<()> {
+        #[derive(Debug, PartialEq, Deserialize)]
+        struct S {
+            inner: Option<i32>,
+        }
+
+        let input = "d5:inneri32ee";
+        let s: S = from_slice(input.as_bytes())?;
+        let expected = S { inner: Some(32) };
+        assert_eq!(s, expected);
+        Ok(())
+    }
+
+    #[test]
+    fn test_deserialize_struct_none_dict() -> Result<()> {
+        #[derive(Debug, PartialEq, Deserialize)]
+        struct S {
+            inner: Option<i32>,
+        }
+
+        let input = "de";
+        let s: S = from_slice(input.as_bytes())?;
+        let expected = S { inner: None };
+        assert_eq!(s, expected);
+        Ok(())
+    }
+
+    #[test]
+    fn test_deserialize_struct_some_none() -> Result<()> {
+        #[derive(Debug, PartialEq, Deserialize)]
+        struct S {
+            inner: Option<T>,
+        }
+
+        #[derive(Debug, PartialEq, Deserialize)]
+        struct T {
+            innermost: Option<i32>,
+        }
+
+        let input = "d5:innerdee";
+        let s: S = from_slice(input.as_bytes())?;
+        let expected = S {
+            inner: Some(T { innermost: None }),
+        };
+        assert_eq!(s, expected);
+        Ok(())
+    }
+
+    #[test]
+    fn test_deserialize_struct_some_some() -> Result<()> {
+        #[derive(Debug, PartialEq, Deserialize)]
+        struct S {
+            inner: Option<T>,
+        }
+
+        #[derive(Debug, PartialEq, Deserialize)]
+        struct T {
+            innermost: Option<i32>,
+        }
+
+        let input = "d5:innerd9:innermosti32eee";
+        let s: S = from_slice(input.as_bytes())?;
+        let expected = S {
+            inner: Some(T {
+                innermost: Some(32),
+            }),
+        };
+        assert_eq!(s, expected);
+        Ok(())
+    }
+
+    #[test]
+    fn test_deserialize_inner_none() -> Result<()> {
+        #[derive(Debug, PartialEq, Deserialize)]
+        struct S {
+            inner: Option<T>,
+        }
+
+        #[derive(Debug, PartialEq, Deserialize)]
+        struct T {
+            innermost: Option<i32>,
+        }
+
+        let input = "de";
+        let s: S = from_slice(input.as_bytes())?;
+        let expected = S { inner: None };
+        assert_eq!(s, expected);
+        Ok(())
+    }
 }

src/ser.rs

@@ -181,7 +181,7 @@ where
 
     #[inline]
     fn serialize_none(self) -> Result<()> {
-        self.serialize_unit()
+        Ok(())
     }
 
     #[inline]
@@ -266,8 +266,12 @@ where
     }
 
     #[inline]
-    fn serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap> {
-        self.writer.write_all(b"d")?;
+    fn serialize_map(self, len: Option<usize>) -> Result<Self::SerializeMap> {
+        assert!(len.is_some());
+        println!("{:?}", len);
+        if len.unwrap() > 0 {
+            self.writer.write_all(b"d")?;
+        }
         Ok(SerializeMap::new(self))
     }
 
@@ -432,8 +436,10 @@ where
 
     #[inline]
     fn end(mut self) -> Result<()> {
-        self.end_map()?;
-        self.ser.writer.write_all(b"e")?;
+        if !self.entries.is_empty() {
+            self.end_map()?;
+            self.ser.writer.write_all(b"e")?;
+        }
         Ok(())
     }
 }
@@ -638,6 +644,8 @@ impl ser::Serializer for &mut MapKeySerializer {
 mod tests {
     use crate::ByteString;
 
+    use serde_derive::Serialize;
+
     use super::*;
 
     #[cfg(all(feature = "alloc", not(feature = "std")))]
@@ -785,7 +793,7 @@ mod tests {
     #[test]
     fn test_serialize_none() {
         let value: Option<i64> = None;
-        assert_is_unsupported_type!(to_vec(&value));
+        assert_eq!(to_vec(&value).unwrap(), String::from("").into_bytes());
     }
 
     #[test]
@@ -794,6 +802,42 @@ mod tests {
         assert_eq!(to_vec(&value).unwrap(), String::from("i2e").into_bytes());
     }
 
+    #[test]
+    fn test_serialize_none_struct() {
+        #[derive(Debug, PartialEq, Serialize)]
+        struct S {
+            inner: i64,
+        }
+
+        let value: Option<S> = None;
+        assert_eq!(to_vec(&value).unwrap(), String::from("").into_bytes());
+    }
+
+    #[test]
+    fn test_serialize_none_struct_none() {
+        #[derive(Debug, PartialEq, Serialize)]
+        struct S {
+            inner: Option<i64>,
+        }
+
+        let value: Option<S> = None;
+        assert_eq!(to_vec(&value).unwrap(), String::from("").into_bytes());
+    }
+
+    #[test]
+    fn test_serialize_some_struct_some() {
+        #[derive(Debug, PartialEq, Serialize)]
+        struct S {
+            inner: Option<i64>,
+        }
+
+        let value: Option<S> = Some(S { inner: Some(32) });
+        assert_eq!(
+            to_vec(&value).unwrap(),
+            String::from("d5inner:i32ee").into_bytes()
+        );
+    }
+
     #[test]
     fn test_serialize_unit_struct() {
         use serde::Serializer;