Map serde support

CHANGELOG.md

@@ -5,6 +5,9 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](http://keepachangelog.com/) and this
 project adheres to [Semantic Versioning](http://semver.org/).
 
+### Unreleased
+- Add support for map (de)serialization.
+
 ## [0.4.1] - 2022-05-05
 
 ### Changed

src/de/map.rs

@@ -163,11 +163,11 @@ impl<'de, 'a> de::Deserializer<'de> for MapKey<'a, 'de> {
         self.de.deserialize_str(visitor)
     }
 
-    fn deserialize_string<V>(self, _visitor: V) -> Result<V::Value, Self::Error>
+    fn deserialize_string<V>(self, visitor: V) -> Result<V::Value, Self::Error>
     where
         V: Visitor<'de>,
     {
-        unreachable!()
+        self.de.deserialize_string(visitor)
     }
 
     fn deserialize_bytes<V>(self, _visitor: V) -> Result<V::Value, Self::Error>

src/de/mod.rs

@@ -576,22 +576,7 @@ impl<'a, 'de> de::Deserializer<'de> for &'a mut Deserializer<'de> {
         self.deserialize_seq(visitor)
     }
 
-    /// Unsupported. Can’t make an arbitrary-sized map in no-std. Use a struct with a
-    /// known format, or implement a custom map deserializer / visitor:
-    /// https://serde.rs/deserialize-map.html
-    fn deserialize_map<V>(self, _visitor: V) -> Result<V::Value>
-    where
-        V: Visitor<'de>,
-    {
-        unreachable!()
-    }
-
-    fn deserialize_struct<V>(
-        self,
-        _name: &'static str,
-        _fields: &'static [&'static str],
-        visitor: V,
-    ) -> Result<V::Value>
+    fn deserialize_map<V>(self, visitor: V) -> Result<V::Value>
     where
         V: Visitor<'de>,
     {
@@ -610,6 +595,18 @@ impl<'a, 'de> de::Deserializer<'de> for &'a mut Deserializer<'de> {
         }
     }
 
+    fn deserialize_struct<V>(
+        self,
+        _name: &'static str,
+        _fields: &'static [&'static str],
+        visitor: V,
+    ) -> Result<V::Value>
+    where
+        V: Visitor<'de>,
+    {
+        self.deserialize_map(visitor)
+    }
+
     fn deserialize_enum<V>(
         self,
         _name: &'static str,

src/lib.rs

@@ -65,6 +65,8 @@ pub use self::ser::{to_string, to_vec};
 
 #[cfg(test)]
 mod test {
+    use std::collections::BTreeMap;
+
     use super::*;
     use serde_derive::{Deserialize, Serialize};
 
@@ -95,6 +97,7 @@ mod test {
         published: bool,
         comments: Vec<CommentId>,
         stats: Stats,
+        balances: BTreeMap<String, u16>,
     }
 
     #[test]
@@ -107,7 +110,10 @@ mod test {
             published: false,
             comments: vec![],
             stats: Stats { views: 0, score: 0 },
+            balances: BTreeMap::new(),
         };
+        let mut balances: BTreeMap<String, u16> = BTreeMap::new();
+        balances.insert("chareen".into(), 347);
         let max = Item {
             model: Model::Post {
                 category: "fun".to_string(),
@@ -122,6 +128,7 @@ mod test {
                 views: std::u64::MAX,
                 score: std::i64::MIN,
             },
+            balances,
         };
 
         // binary
@@ -172,6 +179,9 @@ mod test {
             author: Address("[email protected]".to_owned()),
         });
 
+        let mut balances: BTreeMap<String, u16> = BTreeMap::new();
+        balances.insert("chareen".into(), 347);
+
         let item = ModelOrItem::Item(Item {
             model: Model::Comment,
             title: "Title".to_owned(),
@@ -183,6 +193,7 @@ mod test {
                 views: 110,
                 score: 12,
             },
+            balances,
         });
 
         assert_eq!(

src/ser/map.rs

@@ -0,0 +1,45 @@
+use serde::ser;
+
+use crate::ser::{Error, Result, Serializer};
+
+pub struct SerializeMap<'a> {
+    ser: &'a mut Serializer,
+    first: bool,
+}
+
+impl<'a> SerializeMap<'a> {
+    pub(crate) fn new(ser: &'a mut Serializer) -> Self {
+        SerializeMap { ser, first: true }
+    }
+}
+
+impl<'a> ser::SerializeMap for SerializeMap<'a> {
+    type Ok = ();
+    type Error = Error;
+
+    fn end(self) -> Result<Self::Ok> {
+        self.ser.buf.push(b'}');
+        Ok(())
+    }
+
+    fn serialize_key<T: ?Sized>(&mut self, key: &T) -> Result<()>
+    where
+        T: ser::Serialize,
+    {
+        if !self.first {
+            self.ser.buf.push(b',');
+        }
+        self.first = false;
+        key.serialize(&mut *self.ser)?;
+        self.ser.buf.extend_from_slice(b":");
+        Ok(())
+    }
+
+    fn serialize_value<T: ?Sized>(&mut self, value: &T) -> Result<()>
+    where
+        T: ser::Serialize,
+    {
+        value.serialize(&mut *self.ser)?;
+        Ok(())
+    }
+}

src/ser/mod.rs

@@ -6,9 +6,11 @@ use serde::ser;
 
 use std::vec::Vec;
 
+use self::map::SerializeMap;
 use self::seq::SerializeSeq;
 use self::struct_::SerializeStruct;
 
+mod map;
 mod seq;
 mod struct_;
 
@@ -153,7 +155,7 @@ impl<'a> ser::Serializer for &'a mut Serializer {
     type SerializeTuple = SerializeSeq<'a>;
     type SerializeTupleStruct = Unreachable;
     type SerializeTupleVariant = SerializeSeq<'a>;
-    type SerializeMap = Unreachable;
+    type SerializeMap = SerializeMap<'a>;
     type SerializeStruct = SerializeStruct<'a>;
     type SerializeStructVariant = SerializeStruct<'a>;
 
@@ -400,7 +402,8 @@ impl<'a> ser::Serializer for &'a mut Serializer {
     }
 
     fn serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap> {
-        unreachable!()
+        self.buf.push(b'{');
+        Ok(SerializeMap::new(self))
     }
 
     fn serialize_struct(self, _name: &'static str, _len: usize) -> Result<Self::SerializeStruct> {
@@ -530,6 +533,7 @@ impl ser::SerializeStructVariant for Unreachable {
 
 #[cfg(test)]
 mod tests {
+
     use super::to_string;
     use serde_derive::Serialize;
 
@@ -979,6 +983,30 @@ mod tests {
         );
     }
 
+    #[test]
+    fn btree_map() {
+        use std::collections::BTreeMap;
+        // empty map
+        assert_eq!(to_string(&BTreeMap::<(), ()>::new()).unwrap(), r#"{}"#);
+
+        let mut two_values = BTreeMap::new();
+        two_values.insert("my_name", "joseph");
+        two_values.insert("her_name", "aline");
+        assert_eq!(
+            to_string(&two_values).unwrap(),
+            r#"{"her_name":"aline","my_name":"joseph"}"#
+        );
+
+        let mut nested_map = BTreeMap::new();
+        nested_map.insert("two_entries", two_values.clone());
+
+        two_values.remove("my_name");
+        nested_map.insert("one_entry", two_values);
+        assert_eq!(
+            to_string(&nested_map).unwrap(),
+            r#"{"one_entry":{"her_name":"aline"},"two_entries":{"her_name":"aline","my_name":"joseph"}}"#
+        );
+    }
     use serde_derive::Deserialize;
 
     #[test]

src/ser/struct_.rs

@@ -3,13 +3,13 @@ use serde::ser;
 use crate::ser::{Error, Result, Serializer};
 
 pub struct SerializeStruct<'a> {
-    de: &'a mut Serializer,
+    ser: &'a mut Serializer,
     first: bool,
 }
 
 impl<'a> SerializeStruct<'a> {
-    pub(crate) fn new(de: &'a mut Serializer) -> Self {
-        SerializeStruct { de, first: true }
+    pub(crate) fn new(ser: &'a mut Serializer) -> Self {
+        SerializeStruct { ser, first: true }
     }
 }
 
@@ -23,21 +23,21 @@ impl<'a> ser::SerializeStruct for SerializeStruct<'a> {
     {
         // XXX if `value` is `None` we not produce any output for this field
         if !self.first {
-            self.de.buf.push(b',');
+            self.ser.buf.push(b',');
         }
         self.first = false;
 
-        self.de.buf.push(b'"');
-        self.de.buf.extend_from_slice(key.as_bytes());
-        self.de.buf.extend_from_slice(b"\":");
+        self.ser.buf.push(b'"');
+        self.ser.buf.extend_from_slice(key.as_bytes());
+        self.ser.buf.extend_from_slice(b"\":");
 
-        value.serialize(&mut *self.de)?;
+        value.serialize(&mut *self.ser)?;
 
         Ok(())
     }
 
     fn end(self) -> Result<Self::Ok> {
-        self.de.buf.push(b'}');
+        self.ser.buf.push(b'}');
         Ok(())
     }
 }
@@ -52,24 +52,24 @@ impl<'a> ser::SerializeStructVariant for SerializeStruct<'a> {
     {
         // XXX if `value` is `None` we not produce any output for this field
         if !self.first {
-            self.de.buf.push(b',');
+            self.ser.buf.push(b',');
         }
         self.first = false;
 
-        self.de.buf.push(b'"');
-        self.de.buf.extend_from_slice(key.as_bytes());
-        self.de.buf.extend_from_slice(b"\":");
+        self.ser.buf.push(b'"');
+        self.ser.buf.extend_from_slice(key.as_bytes());
+        self.ser.buf.extend_from_slice(b"\":");
 
-        value.serialize(&mut *self.de)?;
+        value.serialize(&mut *self.ser)?;
 
         Ok(())
     }
 
     fn end(self) -> Result<Self::Ok> {
         // close struct
-        self.de.buf.push(b'}');
+        self.ser.buf.push(b'}');
         // close surrounding enum
-        self.de.buf.push(b'}');
+        self.ser.buf.push(b'}');
         Ok(())
     }
 }