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]
@@ -638,6 +638,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 +787,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 +796,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("d5:inneri32ee").into_bytes()
+        );
+    }
+
     #[test]
     fn test_serialize_unit_struct() {
         use serde::Serializer;