Run cargo fmt.

2 files changed, 220 insertions, 178 deletions

diff --git a/src/de/mod.rs b/src/de/mod.rs
index c44ae19..a82a37b 100644
--- a/src/de/mod.rs
+++ b/src/de/mod.rs
@@ -36,8 +36,6 @@
 //! `Level` is a flat value it will attempt to deserialize it to a primitive via
 //! `ParsableStringDeserializer`.
 
-
-
 mod parse;
 
 use error::*;
@@ -48,7 +46,6 @@ use serde::de::IntoDeserializer;
 use std::borrow::Cow;
 use std::collections::btree_map::{BTreeMap, Entry, IntoIter};
 
-
 /// To override the default serialization parameters, first construct a new
 /// Config.
 ///
@@ -100,10 +97,7 @@ impl Default for Config {
 impl Config {
     /// Create a new `Config` with the specified `max_depth` and `strict` mode.
     pub fn new(max_depth: usize, strict: bool) -> Self {
-        Self {
-            max_depth,
-            strict,
-        }
+        Self { max_depth, strict }
     }
 
     /// Get maximum depth parameter.
@@ -114,9 +108,10 @@ impl Config {
 
 impl Config {
     /// Deserializes a querystring from a `&[u8]` using this `Config`.
-    pub fn deserialize_bytes<'de, T: de::Deserialize<'de>>(&self,
-                                                           input: &'de [u8])
-                                                           -> Result<T> {
+    pub fn deserialize_bytes<'de, T: de::Deserialize<'de>>(
+        &self,
+        input: &'de [u8],
+    ) -> Result<T> {
         T::deserialize(QsDeserializer::with_config(self, input)?)
     }
 
@@ -130,9 +125,10 @@ impl Config {
     // }
 
     /// Deserializes a querystring from a `&str` using this `Config`.
-    pub fn deserialize_str<'de, T: de::Deserialize<'de>>(&self,
-                                                         input: &'de str)
-                                                         -> Result<T> {
+    pub fn deserialize_str<'de, T: de::Deserialize<'de>>(
+        &self,
+        input: &'de str,
+    ) -> Result<T> {
         self.deserialize_bytes(input.as_bytes())
     }
 }
@@ -233,23 +229,27 @@ impl<'de> de::Deserializer<'de> for QsDeserializer<'de> {
     type Error = Error;
 
     fn deserialize_any<V>(self, _visitor: V) -> Result<V::Value>
-        where V: de::Visitor<'de>,
+    where
+        V: de::Visitor<'de>,
     {
         Err(Error::top_level("primitive"))
     }
 
     fn deserialize_map<V>(self, visitor: V) -> Result<V::Value>
-        where V: de::Visitor<'de>,
+    where
+        V: de::Visitor<'de>,
     {
         visitor.visit_map(self)
     }
 
-    fn deserialize_struct<V>(self,
-                             _name: &'static str,
-                             _fields: &'static [&'static str],
-                             visitor: V)
-                             -> Result<V::Value>
-        where V: de::Visitor<'de>,
+    fn deserialize_struct<V>(
+        self,
+        _name: &'static str,
+        _fields: &'static [&'static str],
+        visitor: V,
+    ) -> Result<V::Value>
+    where
+        V: de::Visitor<'de>,
     {
         self.deserialize_map(visitor)
     }
@@ -258,16 +258,19 @@ impl<'de> de::Deserializer<'de> for QsDeserializer<'de> {
     ///
     /// Sequences are not supported at the top level.
     fn deserialize_seq<V>(self, _visitor: V) -> Result<V::Value>
-        where V: de::Visitor<'de>,
+    where
+        V: de::Visitor<'de>,
     {
         Err(Error::top_level("sequence"))
     }
 
-    fn deserialize_newtype_struct<V>(self,
-                                     _name: &'static str,
-                                     visitor: V)
-                                     -> Result<V::Value>
-        where V: de::Visitor<'de>,
+    fn deserialize_newtype_struct<V>(
+        self,
+        _name: &'static str,
+        visitor: V,
+    ) -> Result<V::Value>
+    where
+        V: de::Visitor<'de>,
     {
         self.deserialize_map(visitor)
     }
@@ -276,31 +279,35 @@ impl<'de> de::Deserializer<'de> for QsDeserializer<'de> {
     ///
     /// Tuples are not supported at the top level.
     fn deserialize_tuple<V>(self, _len: usize, _visitor: V) -> Result<V::Value>
-        where V: de::Visitor<'de>,
+    where
+        V: de::Visitor<'de>,
     {
         Err(Error::top_level("tuple"))
-
     }
 
     /// Throws an error.
     ///
     /// TupleStructs are not supported at the top level.
-    fn deserialize_tuple_struct<V>(self,
-                                   _name: &'static str,
-                                   _len: usize,
-                                   _visitor: V)
-                                   -> Result<V::Value>
-        where V: de::Visitor<'de>,
+    fn deserialize_tuple_struct<V>(
+        self,
+        _name: &'static str,
+        _len: usize,
+        _visitor: V,
+    ) -> Result<V::Value>
+    where
+        V: de::Visitor<'de>,
     {
         Err(Error::top_level("tuple struct"))
     }
 
-    fn deserialize_enum<V>(self,
-                           _name: &'static str,
-                           _variants: &'static [&'static str],
-                           visitor: V)
-                           -> Result<V::Value>
-        where V: de::Visitor<'de>,
+    fn deserialize_enum<V>(
+        self,
+        _name: &'static str,
+        _variants: &'static [&'static str],
+        visitor: V,
+    ) -> Result<V::Value>
+    where
+        V: de::Visitor<'de>,
     {
         visitor.visit_enum(self)
     }
@@ -334,7 +341,8 @@ impl<'de> de::MapAccess<'de> for QsDeserializer<'de> {
     type Error = Error;
 
     fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>>
-        where K: de::DeserializeSeed<'de>,
+    where
+        K: de::DeserializeSeed<'de>,
     {
         if let Some((key, value)) = self.iter.next() {
             self.value = Some(value);
@@ -344,13 +352,16 @@ impl<'de> de::MapAccess<'de> for QsDeserializer<'de> {
     }
 
     fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value>
-        where V: de::DeserializeSeed<'de>,
+    where
+        V: de::DeserializeSeed<'de>,
     {
         if let Some(v) = self.value.take() {
             seed.deserialize(LevelDeserializer(v))
         } else {
-            Err(de::Error::custom("Somehow the list was empty after a \
-                                   non-empty key was returned"))
+            Err(de::Error::custom(
+                "Somehow the list was empty after a \
+                 non-empty key was returned",
+            ))
         }
     }
 }
@@ -360,7 +371,8 @@ impl<'de> de::EnumAccess<'de> for QsDeserializer<'de> {
     type Variant = Self;
 
     fn variant_seed<V>(mut self, seed: V) -> Result<(V::Value, Self::Variant)>
-        where V: de::DeserializeSeed<'de>,
+    where
+        V: de::DeserializeSeed<'de>,
     {
         if let Some((key, value)) = self.iter.next() {
             self.value = Some(value);
@@ -378,17 +390,18 @@ impl<'de> de::VariantAccess<'de> for QsDeserializer<'de> {
     }
 
     fn newtype_variant_seed<T>(self, seed: T) -> Result<T::Value>
-        where T: de::DeserializeSeed<'de>,
+    where
+        T: de::DeserializeSeed<'de>,
     {
         if let Some(value) = self.value {
             seed.deserialize(LevelDeserializer(value))
         } else {
             Err(de::Error::custom("no value to deserialize"))
         }
-
     }
     fn tuple_variant<V>(self, _len: usize, visitor: V) -> Result<V::Value>
-        where V: de::Visitor<'de>,
+    where
+        V: de::Visitor<'de>,
     {
         if let Some(value) = self.value {
             de::Deserializer::deserialize_seq(LevelDeserializer(value), visitor)
@@ -396,11 +409,13 @@ impl<'de> de::VariantAccess<'de> for QsDeserializer<'de> {
             Err(de::Error::custom("no value to deserialize"))
         }
     }
-    fn struct_variant<V>(self,
-                         _fields: &'static [&'static str],
-                         visitor: V)
-                         -> Result<V::Value>
-        where V: de::Visitor<'de>,
+    fn struct_variant<V>(
+        self,
+        _fields: &'static [&'static str],
+        visitor: V,
+    ) -> Result<V::Value>
+    where
+        V: de::Visitor<'de>,
     {
         if let Some(value) = self.value {
             de::Deserializer::deserialize_map(LevelDeserializer(value), visitor)
@@ -415,19 +430,22 @@ impl<'de> de::EnumAccess<'de> for LevelDeserializer<'de> {
     type Variant = Self;
 
     fn variant_seed<V>(self, seed: V) -> Result<(V::Value, Self::Variant)>
-        where V: de::DeserializeSeed<'de>,
+    where
+        V: de::DeserializeSeed<'de>,
     {
         match self.0 {
-            Level::Flat(x) => {
-                Ok((seed.deserialize(ParsableStringDeserializer(x))?,
-                    LevelDeserializer(Level::Invalid("this value can only \
-                                                      deserialize to a \
-                                                      UnitVariant"))))
-            },
-            _ => {
-                Err(de::Error::custom("this value can only deserialize to a \
-                                       UnitVariant"))
-            },
+            Level::Flat(x) => Ok((
+                seed.deserialize(ParsableStringDeserializer(x))?,
+                LevelDeserializer(Level::Invalid(
+                    "this value can only \
+                     deserialize to a \
+                     UnitVariant",
+                )),
+            )),
+            _ => Err(de::Error::custom(
+                "this value can only deserialize to a \
+                 UnitVariant",
+            )),
         }
     }
 }
@@ -439,22 +457,24 @@ impl<'de> de::VariantAccess<'de> for LevelDeserializer<'de> {
     }
 
     fn newtype_variant_seed<T>(self, seed: T) -> Result<T::Value>
-        where T: de::DeserializeSeed<'de>,
+    where
+        T: de::DeserializeSeed<'de>,
     {
         seed.deserialize(self)
-
     }
     fn tuple_variant<V>(self, _len: usize, visitor: V) -> Result<V::Value>
-        where V: de::Visitor<'de>,
+    where
+        V: de::Visitor<'de>,
     {
         de::Deserializer::deserialize_seq(self, visitor)
-
     }
-    fn struct_variant<V>(self,
-                         _fields: &'static [&'static str],
-                         visitor: V)
-                         -> Result<V::Value>
-        where V: de::Visitor<'de>,
+    fn struct_variant<V>(
+        self,
+        _fields: &'static [&'static str],
+        visitor: V,
+    ) -> Result<V::Value>
+    where
+        V: de::Visitor<'de>,
     {
         de::Deserializer::deserialize_map(self, visitor)
     }
@@ -463,11 +483,12 @@ impl<'de> de::VariantAccess<'de> for LevelDeserializer<'de> {
 struct LevelSeq<'a, I: Iterator<Item = Level<'a>>>(I);
 
 impl<'de, I: Iterator<Item = Level<'de>>> de::SeqAccess<'de>
-    for
-    LevelSeq<'de, I> {
+    for LevelSeq<'de, I>
+{
     type Error = Error;
     fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>>
-        where T: de::DeserializeSeed<'de>,
+    where
+        T: de::DeserializeSeed<'de>,
     {
         if let Some(v) = self.0.next() {
             seed.deserialize(LevelDeserializer(v)).map(Some)
@@ -477,8 +498,6 @@ impl<'de, I: Iterator<Item = Level<'de>>> de::SeqAccess<'de>
     }
 }
 
-
-
 struct LevelDeserializer<'a>(Level<'a>);
 
 macro_rules! deserialize_primitive {
@@ -518,11 +537,11 @@ impl<'a> LevelDeserializer<'a> {
         match self.0 {
             Level::Nested(map) => Ok(QsDeserializer::with_map(map)),
             Level::Invalid(e) => Err(de::Error::custom(e)),
-            l => {
-                Err(de::Error::custom(format!("could not convert {:?} to \
-                                               QsDeserializer<'a>",
-                                              l)))
-            },
+            l => Err(de::Error::custom(format!(
+                "could not convert {:?} to \
+                 QsDeserializer<'a>",
+                l
+            ))),
         }
     }
 }
@@ -531,7 +550,8 @@ impl<'de> de::Deserializer<'de> for LevelDeserializer<'de> {
     type Error = Error;
 
     fn deserialize_any<V>(self, visitor: V) -> Result<V::Value>
-        where V: de::Visitor<'de>,
+    where
+        V: de::Visitor<'de>,
     {
         match self.0 {
             Level::Nested(_) => {
@@ -543,22 +563,21 @@ impl<'de> de::Deserializer<'de> for LevelDeserializer<'de> {
             Level::Sequence(seq) => {
                 visitor.visit_seq(LevelSeq(seq.into_iter()))
             },
-            Level::Flat(x) => {
-                match x {
-                    Cow::Owned(s) => visitor.visit_string(s),
-                    Cow::Borrowed(s) => visitor.visit_borrowed_str(s),
-                }
+            Level::Flat(x) => match x {
+                Cow::Owned(s) => visitor.visit_string(s),
+                Cow::Borrowed(s) => visitor.visit_borrowed_str(s),
             },
             Level::Invalid(e) => Err(de::Error::custom(e)),
-            Level::Uninitialised => {
-                Err(de::Error::custom("attempted to deserialize unitialised \
-                                       value"))
-            },
+            Level::Uninitialised => Err(de::Error::custom(
+                "attempted to deserialize unitialised \
+                 value",
+            )),
         }
     }
 
     fn deserialize_option<V>(self, visitor: V) -> Result<V::Value>
-        where V: de::Visitor<'de>,
+    where
+        V: de::Visitor<'de>,
     {
         match self.0 {
             Level::Flat(ref x) if x == "" => visitor.visit_none(),
@@ -566,32 +585,34 @@ impl<'de> de::Deserializer<'de> for LevelDeserializer<'de> {
         }
     }
 
-    fn deserialize_enum<V>(self,
-                           name: &'static str,
-                           variants: &'static [&'static str],
-                           visitor: V)
-                           -> Result<V::Value>
-        where V: de::Visitor<'de>,
+    fn deserialize_enum<V>(
+        self,
+        name: &'static str,
+        variants: &'static [&'static str],
+        visitor: V,
+    ) -> Result<V::Value>
+    where
+        V: de::Visitor<'de>,
     {
         match self.0 {
-            Level::Nested(map) => {
-                QsDeserializer::with_map(map)
-                    .deserialize_enum(name, variants, visitor)
-            },
+            Level::Nested(map) => QsDeserializer::with_map(map)
+                .deserialize_enum(name, variants, visitor),
             Level::Flat(_) => visitor.visit_enum(self),
-            x => {
-                Err(de::Error::custom(format!("{:?} does not appear to be \
-                                               an enum",
-                                              x)))
-            },
+            x => Err(de::Error::custom(format!(
+                "{:?} does not appear to be \
+                 an enum",
+                x
+            ))),
         }
     }
 
-    fn deserialize_newtype_struct<V>(self,
-                                     _name: &'static str,
-                                     visitor: V)
-                                     -> Result<V::Value>
-        where V: de::Visitor<'de>,
+    fn deserialize_newtype_struct<V>(
+        self,
+        _name: &'static str,
+        visitor: V,
+    ) -> Result<V::Value>
+    where
+        V: de::Visitor<'de>,
     {
         match self.0 {
             Level::Nested(_) => {
@@ -609,14 +630,13 @@ impl<'de> de::Deserializer<'de> for LevelDeserializer<'de> {
                 visitor.visit_seq(LevelSeq(vec![self.0].into_iter()))
             },
             Level::Invalid(e) => Err(de::Error::custom(e)),
-            Level::Uninitialised => {
-                Err(de::Error::custom("attempted to deserialize unitialised \
-                                       value"))
-            },
+            Level::Uninitialised => Err(de::Error::custom(
+                "attempted to deserialize unitialised \
+                 value",
+            )),
         }
     }
 
-
     deserialize_primitive!(bool, deserialize_bool, visit_bool);
     deserialize_primitive!(i8, deserialize_i8, visit_i8);
     deserialize_primitive!(i16, deserialize_i16, visit_i16);
@@ -629,7 +649,6 @@ impl<'de> de::Deserializer<'de> for LevelDeserializer<'de> {
     deserialize_primitive!(f32, deserialize_f32, visit_f32);
     deserialize_primitive!(f64, deserialize_f64, visit_f64);
 
-
     forward_to_deserialize_any! {
         char
         str
@@ -649,7 +668,6 @@ impl<'de> de::Deserializer<'de> for LevelDeserializer<'de> {
     }
 }
 
-
 macro_rules! forward_parsable_to_deserialize_any {
     ($($ty:ident => $meth:ident,)*) => {
         $(
@@ -663,19 +681,18 @@ macro_rules! forward_parsable_to_deserialize_any {
     }
 }
 
-
 struct ParsableStringDeserializer<'a>(Cow<'a, str>);
 
 impl<'de> de::Deserializer<'de> for ParsableStringDeserializer<'de> {
     type Error = Error;
 
     fn deserialize_any<V>(self, visitor: V) -> Result<V::Value>
-        where V: de::Visitor<'de>,
+    where
+        V: de::Visitor<'de>,
     {
         self.0.into_deserializer().deserialize_any(visitor)
     }
 
-
     forward_to_deserialize_any! {
         map
         struct
diff --git a/src/de/parse.rs b/src/de/parse.rs
index 09552fe..5d84512 100644
--- a/src/de/parse.rs
+++ b/src/de/parse.rs
@@ -8,15 +8,17 @@ use std::iter::Iterator;
 use std::slice::Iter;
 use std::str;
 
-
 macro_rules! tu {
-    ($x:expr) => (
+    ($x:expr) => {
         match $x {
             Some(x) => *x,
-            None => return Err(
-                de::Error::custom("query string ended before expected"))
+            None => {
+                return Err(de::Error::custom(
+                    "query string ended before expected",
+                ))
+            },
         }
-    )
+    };
 }
 
 impl<'a> Level<'a> {
@@ -42,8 +44,10 @@ impl<'a> Level<'a> {
             let _ = map.insert(key, Level::Flat(value));
             *self = Level::Nested(map);
         } else {
-            *self = Level::Invalid("Attempted to insert map value into \
-                                    non-map structure");
+            *self = Level::Invalid(
+                "Attempted to insert map value into \
+                 non-map structure",
+            );
         }
     }
 
@@ -67,8 +71,10 @@ impl<'a> Level<'a> {
             let _ = map.insert(key, Level::Flat(value));
             *self = Level::OrderedSeq(map);
         } else {
-            *self = Level::Invalid("Attempted to insert seq value into \
-                                    non-seq structure");
+            *self = Level::Invalid(
+                "Attempted to insert seq value into \
+                 non-seq structure",
+            );
         }
     }
 
@@ -85,13 +91,14 @@ impl<'a> Level<'a> {
             seq.push(Level::Flat(value));
             *self = Level::Sequence(seq);
         } else {
-            *self = Level::Invalid("Attempted to insert seq value into \
-                                    non-seq structure");
+            *self = Level::Invalid(
+                "Attempted to insert seq value into \
+                 non-seq structure",
+            );
         }
     }
 }
 
-
 /// The `Parser` struct is a stateful querystring parser.
 /// It iterates over a slice of bytes, with a range to track the current
 /// start/end points of a value.
@@ -197,8 +204,10 @@ fn replace_plus(input: Cow<str>) -> Cow<str> {
                     *byte = b' ';
                 }
             }
-            Cow::Owned(String::from_utf8(replaced)
-                .expect("replacing '+' with ' ' cannot panic"))
+            Cow::Owned(
+                String::from_utf8(replaced)
+                    .expect("replacing '+' with ' ' cannot panic"),
+            )
         },
     }
 }
@@ -227,9 +236,10 @@ impl<'a> Parser<'a> {
     /// Avoids allocations when neither percent encoded, nor `'+'` values are
     /// present.
     fn collect_str(&mut self) -> Result<Cow<'a, str>> {
-        let res: Cow<'a, str> =
-            percent_encoding::percent_decode(&self.inner[self.acc.0..
-                                              self.acc.1 - 1]).decode_utf8()?;
+        let res: Cow<'a, str> = percent_encoding::percent_decode(
+            &self.inner[self.acc.0..self.acc.1 - 1],
+        )
+        .decode_utf8()?;
         let res: Result<Cow<'a, str>> = Ok(replace_plus(res));
         self.clear_acc();
         res.map_err(Error::from)
@@ -247,10 +257,7 @@ impl<'a> Parser<'a> {
             Level::Nested(map) => map.into_iter(),
             _ => BTreeMap::default().into_iter(),
         };
-        Ok(QsDeserializer {
-            iter,
-            value: None,
-        })
+        Ok(QsDeserializer { iter, value: None })
     }
 
     /// This is the top level parsing function. It checks the first character to
@@ -294,20 +301,29 @@ 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 = usize::from_str_radix(&key, 10)
+                                        .map_err(Error::from)?;
                                     self.parse_ord_seq_value(key, node)?;
                                     return Ok(true);
                                 },
                                 // Key is "[a..." so parse up to the closing "]"
-                                0x20...0x2f | 0x3a...0x5a | 0x5c |
-                                0x5e...0x7e => {
+                                0x20...0x2f
+                                | 0x3a...0x5a
+                                | 0x5c
+                                | 0x5e...0x7e => {
                                     let key = self.parse_key(b']', true)?;
                                     self.parse_map_value(key, node)?;
                                     return Ok(true);
                                 },
                                 c => {
                                     if self.strict {
-                                        return Err(super::Error::parse_err(&format!("unexpected character: {}", String::from_utf8_lossy(&[c])), self.index));
+                                        return Err(super::Error::parse_err(
+                                            &format!(
+                                                "unexpected character: {}",
+                                                String::from_utf8_lossy(&[c])
+                                            ),
+                                            self.index,
+                                        ));
                                     } else {
                                         let _ = self.next();
                                     }
@@ -320,9 +336,7 @@ impl<'a> Parser<'a> {
                     // We do actually allow integer keys here since they cannot
                     // be confused with sequences
                     _ => {
-                        let key = {
-                            self.parse_key(b'[', false)?
-                        };
+                        let key = { self.parse_key(b'[', false)? };
                         // Root keys are _always_ map values
                         self.parse_map_value(key, node)?;
                         Ok(true)
@@ -334,7 +348,6 @@ impl<'a> Parser<'a> {
         }
     }
 
-
     /// The iterator is currently pointing at a key, so parse up until the
     /// `end_on` value. This will either be `'['` when the key is the root key,
     /// or `']'` when the key is a nested key. In the former case, `'='` will
@@ -387,10 +400,11 @@ impl<'a> Parser<'a> {
 
     /// The `(key,value)` pair is determined to be corresponding to a map entry,
     /// so parse it as such. The first part of the `key` has been parsed.
-    fn parse_map_value(&mut self,
-                       key: Cow<'a, str>,
-                       node: &mut Level<'a>)
-                       -> Result<()> {
+    fn parse_map_value(
+        &mut self,
+        key: Cow<'a, str>,
+        node: &mut Level<'a>,
+    ) -> Result<()> {
         self.state = ParsingState::Key;
         let res = loop {
             if let Some(x) = self.peek() {
@@ -421,15 +435,20 @@ impl<'a> Parser<'a> {
                             // Either take the existing entry, or add a new
                             // unitialised level
                             // Use this new node to keep parsing
-                            let _ = self.parse(map.entry(key)
-                                    .or_insert(Level::Uninitialised))?;
+                            let _ = self.parse(
+                                map.entry(key).or_insert(Level::Uninitialised),
+                            )?;
                             break Ok(());
                         } else {
                             // We expected to parse into a map here.
-                            break Err(super::Error::parse_err(&format!("tried to insert a \
-                                                           new key into {:?}",
-                                                                       node),
-                                                              self.index));
+                            break Err(super::Error::parse_err(
+                                &format!(
+                                    "tried to insert a \
+                                     new key into {:?}",
+                                    node
+                                ),
+                                self.index,
+                            ));
                         }
                     },
                     c => {
@@ -457,10 +476,11 @@ impl<'a> Parser<'a> {
     /// ordered sequence.
     /// Basically the same as the above, but we insert into `OrderedSeq`
     /// Can potentially be merged?
-    fn parse_ord_seq_value(&mut self,
-                           key: usize,
-                           node: &mut Level<'a>)
-                           -> Result<()> {
+    fn parse_ord_seq_value(
+        &mut self,
+        key: usize,
+        node: &mut Level<'a>,
+    ) -> Result<()> {
         self.state = ParsingState::Key;
         let res = loop {
             if let Some(x) = self.peek() {
@@ -493,14 +513,19 @@ impl<'a> Parser<'a> {
                                 // Either take the existing entry, or add a new
                                 // unitialised level
                                 // Use this new node to keep parsing
-                                map.entry(key).or_insert(Level::Uninitialised))?;
+                                map.entry(key).or_insert(Level::Uninitialised),
+                            )?;
                             break Ok(());
                         } else {
                             // We expected to parse into a seq here.
-                            break Err(super::Error::parse_err(&format!("tried to insert a \
-                                                           new key into {:?}",
-                                                                       node),
-                                                              self.index));
+                            break Err(super::Error::parse_err(
+                                &format!(
+                                    "tried to insert a \
+                                     new key into {:?}",
+                                    node
+                                ),
+                                self.index,
+                            ));
                         }
                     },
                     c => {
@@ -548,11 +573,11 @@ impl<'a> Parser<'a> {
                         node.insert_seq_value(Cow::Borrowed(""));
                         Ok(())
                     },
-                    _ => {
-                        Err(super::Error::parse_err("non-indexed sequence of \
-                                                     structs not supported",
-                                                    self.index))
-                    },
+                    _ => Err(super::Error::parse_err(
+                        "non-indexed sequence of \
+                         structs not supported",
+                        self.index,
+                    )),
                 }
             },
             None => {