Support deserializing sequences to a hashmap with keys. (#51)

3 files changed, 23 insertions, 7 deletions

diff --git a/src/de/mod.rs b/src/de/mod.rs
index 62da6a5..c3f9e40 100644
--- a/src/de/mod.rs
+++ b/src/de/mod.rs
@@ -512,6 +512,11 @@ impl<'a> LevelDeserializer<'a> {
     fn into_deserializer(self) -> Result<QsDeserializer<'a>> {
         match self.0 {
             Level::Nested(map) => Ok(QsDeserializer::with_map(map)),
+            Level::OrderedSeq(map) => Ok(QsDeserializer::with_map(
+                map.into_iter()
+                    .map(|(k, v)| (Cow::Owned(k.to_string()), v))
+                    .collect(),
+            )),
             Level::Invalid(e) => Err(de::Error::custom(e)),
             l => Err(de::Error::custom(format!(
                 "could not convert {:?} to \
@@ -598,6 +603,19 @@ impl<'de> de::Deserializer<'de> for LevelDeserializer<'de> {
         }
     }
 
+    /// given the hint that this is a map, will first
+    /// attempt to deserialize ordered sequences into a map
+    /// otherwise, follows the any code path
+    fn deserialize_map<V>(self, visitor: V) -> Result<V::Value>
+    where
+        V: de::Visitor<'de>,
+    {
+        match self.0 {
+            Level::OrderedSeq(_) => self.into_deserializer()?.deserialize_map(visitor),
+            _ => self.deserialize_any(visitor),
+        }
+    }
+
     deserialize_primitive!(bool, deserialize_bool, visit_bool);
     deserialize_primitive!(i8, deserialize_i8, visit_i8);
     deserialize_primitive!(i16, deserialize_i16, visit_i16);
@@ -625,7 +643,7 @@ impl<'de> de::Deserializer<'de> for LevelDeserializer<'de> {
         tuple
         ignored_any
         seq
-        map
+        // map
     }
 }
 
diff --git a/src/de/parse.rs b/src/de/parse.rs
index 75ae134..a466e5a 100644
--- a/src/de/parse.rs
+++ b/src/de/parse.rs
@@ -80,8 +80,7 @@ impl<'a> Level<'a> {
         if let Level::Sequence(ref mut seq) = *self {
             seq.push(Level::Flat(value));
         } else if let Level::Uninitialised = *self {
-            let mut seq = Vec::new();
-            seq.push(Level::Flat(value));
+            let seq = vec![Level::Flat(value)];
             *self = Level::Sequence(seq);
         } else {
             *self = Level::Invalid(
@@ -306,8 +305,7 @@ impl<'a> Parser<'a> {
                                 // First character is an integer, attempt to parse it as an integer key
                                 b'0'..=b'9' => {
                                     let key = self.parse_key(b']', true)?;
-                                    let key =
-                                        usize::from_str_radix(&key, 10).map_err(Error::from)?;
+                                    let key = key.parse().map_err(Error::from)?;
                                     self.parse_ord_seq_value(key, node)?;
                                     return Ok(true);
                                 }
diff --git a/src/ser.rs b/src/ser.rs
index 654c889..c281614 100644
--- a/src/ser.rs
+++ b/src/ser.rs
@@ -126,9 +126,9 @@ impl<'a, W: 'a + Write> QsSerializer<'a, W> {
             .map(replace_space)
             .collect::<String>();
         let key = if let Some(ref key) = self.key {
-            format!("{}[{}]", key, newkey).into()
+            format!("{}[{}]", key, newkey)
         } else {
-            newkey.to_owned()
+            newkey
         };
         self.key = Some(Cow::Owned(key))
     }