Run cargo fmt.

5 files changed, 418 insertions, 344 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 => {
diff --git a/src/error.rs b/src/error.rs
index 596f0a7..360d2b3 100644
--- a/src/error.rs
+++ b/src/error.rs
@@ -10,7 +10,7 @@ use std::str;
 use std::string;
 
 error_chain! {
-    errors { 
+    errors {
         Custom(msg: String) {
             description("miscellaneous failure")
             display("failed with reason: {}", msg)
@@ -34,16 +34,18 @@ error_chain! {
 impl Error {
     /// Generate error to show top-level type cannot be deserialized.
     pub fn top_level(object: &'static str) -> Self {
-        ErrorKind::Custom(format!("cannot deserialize {} at the top level.\
-                           Try deserializing into a struct.",
-                                  object))
-            .into()
-
+        ErrorKind::Custom(format!(
+            "cannot deserialize {} at the top level.\
+             Try deserializing into a struct.",
+            object
+        ))
+        .into()
     }
 
     /// Generate a parsing error message with position.
     pub fn parse_err<T>(msg: T, position: usize) -> Self
-        where T: Display,
+    where
+        T: Display,
     {
         ErrorKind::Parse(msg.to_string(), position).into()
     }
@@ -51,7 +53,8 @@ impl Error {
 
 impl de::Error for Error {
     fn custom<T>(msg: T) -> Self
-        where T: Display,
+    where
+        T: Display,
     {
         ErrorKind::Custom(msg.to_string()).into()
     }
diff --git a/src/lib.rs b/src/lib.rs
index 1c3d33e..53bfef2 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -89,7 +89,7 @@
 //! However, since some implementations will automatically encode everything
 //! in the URL, we also have a non-strict mode. This means that `serde_qs`
 //! will assume that any encoded square brackets in the string were meant to
-//! be taken as nested keys. From the example before, `a[b%5Bc%5D]=123` will 
+//! be taken as nested keys. From the example before, `a[b%5Bc%5D]=123` will
 //! now become `{"a": {"b": {"c": 123 }}}`.
 //!
 //! Non-strict mode can be useful when, as said before, some middleware
@@ -113,7 +113,7 @@
 //! extern crate serde_qs as qs;
 //!
 //! use serde::de::Error;
-//! 
+//!
 //! fn from_str<'de, D, S>(deserializer: D) -> Result<S, D::Error>
 //!     where D: serde::Deserializer<'de>,
 //!           S: std::str::FromStr
@@ -147,8 +147,7 @@
 //! }
 //! ```
 
-#![allow(
-)]
+#![allow()]
 #![deny(
     const_err,
     dead_code,
@@ -190,7 +189,7 @@
     unused_unsafe,
     unused_variables,
     variant_size_differences,
-    while_true,
+    while_true
 )]
 
 extern crate data_encoding;
@@ -204,11 +203,10 @@ mod de;
 mod error;
 mod ser;
 
-
-#[doc(inline)]
-pub use de::{from_bytes, from_str};
 #[doc(inline)]
 pub use de::Config;
+#[doc(inline)]
+pub use de::{from_bytes, from_str};
 pub use error::Error;
 #[doc(inline)]
-pub use ser::{QsSerializer, to_string, to_writer};
+pub use ser::{to_string, to_writer, QsSerializer};
diff --git a/src/ser.rs b/src/ser.rs
index 13796ce..fb765d7 100644
--- a/src/ser.rs
+++ b/src/ser.rs
@@ -1,8 +1,7 @@
-
 //! Serialization support for querystrings.
 
 use data_encoding::BASE64URL_NOPAD as BASE64;
-use percent_encoding::{EncodeSet, percent_encode};
+use percent_encoding::{percent_encode, EncodeSet};
 use serde::ser;
 
 use error::*;
@@ -19,8 +18,14 @@ struct QS_ENCODE_SET;
 impl EncodeSet for QS_ENCODE_SET {
     fn contains(&self, byte: u8) -> bool {
         match byte {
-            b' ' | b'*' | b'-' | b'.' | b'0'...b'9' | b'A'...b'Z' | b'_' |
-            b'a'...b'z' => false,
+            b' '
+            | b'*'
+            | b'-'
+            | b'.'
+            | b'0'...b'9'
+            | b'A'...b'Z'
+            | b'_'
+            | b'a'...b'z' => false,
             _ => true,
         }
     }
@@ -56,10 +61,10 @@ pub fn to_string<T: ser::Serialize>(input: &T) -> Result<String> {
     let mut buffer = Vec::new();
     let mut first = true;
     input.serialize(&mut QsSerializer {
-            writer: &mut buffer,
-            key: None,
-            first: &mut first,
-        })?;
+        writer: &mut buffer,
+        key: None,
+        first: &mut first,
+    })?;
     String::from_utf8(buffer).map_err(Error::from)
 }
 
@@ -90,13 +95,16 @@ pub fn to_string<T: ser::Serialize>(input: &T) -> Result<String> {
 ///     "name=Alice&age=24&occupation=Student");
 /// # }
 /// ```
-pub fn to_writer<T: ser::Serialize, W: Write>(input: &T, writer: &mut W) -> Result<()> {
+pub fn to_writer<T: ser::Serialize, W: Write>(
+    input: &T,
+    writer: &mut W,
+) -> Result<()> {
     let mut first = true;
     input.serialize(&mut QsSerializer {
-            writer,
-            key: None,
-            first: &mut first,
-        })
+        writer,
+        key: None,
+        first: &mut first,
+    })
 }
 
 /// A serializer for the querystring format.
@@ -124,17 +132,19 @@ fn replace_space(input: &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"),
+            )
         },
     }
 }
 
 impl<'a, W: 'a + Write> QsSerializer<'a, W> {
     fn extend_key(&mut self, newkey: &str) {
-        let newkey = percent_encode(replace_space(newkey).as_bytes(),
-                                    QS_ENCODE_SET)
-            .collect::<Cow<str>>();
+        let newkey =
+            percent_encode(replace_space(newkey).as_bytes(), QS_ENCODE_SET)
+                .collect::<Cow<str>>();
         let key = if let Some(ref key) = self.key {
             format!("{}[{}]", key, newkey).into()
         } else {
@@ -145,19 +155,21 @@ impl<'a, W: 'a + Write> QsSerializer<'a, W> {
 
     fn write_value(&mut self, value: &str) -> Result<()> {
         if let Some(ref key) = self.key {
-            write!(self.writer,
-                   "{}{}={}",
-                   if *self.first {
-                       *self.first = false;
-                       ""
-                   } else {
-                       "&"
-                   },
-                   key,
-                   percent_encode(value.as_bytes(), QS_ENCODE_SET)
-                       .map(replace_space)
-                       .collect::<String>())
-                .map_err(Error::from)
+            write!(
+                self.writer,
+                "{}{}={}",
+                if *self.first {
+                    *self.first = false;
+                    ""
+                } else {
+                    "&"
+                },
+                key,
+                percent_encode(value.as_bytes(), QS_ENCODE_SET)
+                    .map(replace_space)
+                    .collect::<String>()
+            )
+            .map_err(Error::from)
         } else {
             Err(Error::no_key())
         }
@@ -165,8 +177,9 @@ impl<'a, W: 'a + Write> QsSerializer<'a, W> {
 
     /// Creates a new `QsSerializer` with a distinct key, but `writer` and
     ///`first` referring to the original data.
-    fn new_from_ref<'b: 'a>(other: &'a mut QsSerializer<'b, W>)
-                            -> QsSerializer<'a, W> {
+    fn new_from_ref<'b: 'a>(
+        other: &'a mut QsSerializer<'b, W>,
+    ) -> QsSerializer<'a, W> {
         Self {
             key: other.key.clone(),
             writer: other.writer,
@@ -210,7 +223,7 @@ impl<'a, W: Write> ser::Serializer for &'a mut QsSerializer<'a, W> {
     type SerializeStruct = Self;
     type SerializeStructVariant = Self;
 
-    serialize_as_string!{
+    serialize_as_string! {
         Qs
         bool => serialize_bool,
         u8  => serialize_u8,
@@ -231,7 +244,6 @@ impl<'a, W: Write> ser::Serializer for &'a mut QsSerializer<'a, W> {
         self.write_value(&BASE64.encode(value))
     }
 
-
     fn serialize_unit(self) -> Result<Self::Ok> {
         self.write_value("")
     }
@@ -242,31 +254,32 @@ impl<'a, W: Write> ser::Serializer for &'a mut QsSerializer<'a, W> {
     }
 
     /// Returns an error.
-    fn serialize_unit_variant(self,
-                              _name: &'static str,
-                              _variant_index: u32,
-                              variant: &'static str)
-                              -> Result<Self::Ok> {
+    fn serialize_unit_variant(
+        self,
+        _name: &'static str,
+        _variant_index: u32,
+        variant: &'static str,
+    ) -> Result<Self::Ok> {
         self.write_value(variant)
     }
 
     /// Returns an error.
-    fn serialize_newtype_struct<T: ?Sized + ser::Serialize>
-        (self,
-         _name: &'static str,
-         value: &T)
-         -> Result<Self::Ok> {
+    fn serialize_newtype_struct<T: ?Sized + ser::Serialize>(
+        self,
+        _name: &'static str,
+        value: &T,
+    ) -> Result<Self::Ok> {
         value.serialize(self)
     }
 
     /// Returns an error.
-    fn serialize_newtype_variant<T: ?Sized + ser::Serialize>
-        (self,
-         _name: &'static str,
-         _variant_index: u32,
-         variant: &'static str,
-         value: &T)
-         -> Result<Self::Ok> {
+    fn serialize_newtype_variant<T: ?Sized + ser::Serialize>(
+        self,
+        _name: &'static str,
+        _variant_index: u32,
+        variant: &'static str,
+        value: &T,
+    ) -> Result<Self::Ok> {
         self.extend_key(variant);
         value.serialize(self)
     }
@@ -275,9 +288,10 @@ impl<'a, W: Write> ser::Serializer for &'a mut QsSerializer<'a, W> {
         Ok(())
     }
 
-    fn serialize_some<T: ?Sized + ser::Serialize>(self,
-                                                  value: &T)
-                                                  -> Result<Self::Ok> {
+    fn serialize_some<T: ?Sized + ser::Serialize>(
+        self,
+        value: &T,
+    ) -> Result<Self::Ok> {
         // Err(ErrorKind::Unsupported.into())
         value.serialize(self)
     }
@@ -287,25 +301,26 @@ impl<'a, W: Write> ser::Serializer for &'a mut QsSerializer<'a, W> {
         Ok(QsSeq(self, 0))
     }
 
-
     fn serialize_tuple(self, _len: usize) -> Result<Self::SerializeTuple> {
         Ok(QsSeq(self, 0))
     }
 
     /// Returns an error.
-    fn serialize_tuple_struct(self,
-                              _name: &'static str,
-                              _len: usize)
-                              -> Result<Self::SerializeTupleStruct> {
+    fn serialize_tuple_struct(
+        self,
+        _name: &'static str,
+        _len: usize,
+    ) -> Result<Self::SerializeTupleStruct> {
         Ok(QsSeq(self, 0))
     }
 
-    fn serialize_tuple_variant(self,
-                               _name: &'static str,
-                               _variant_index: u32,
-                               variant: &'static str,
-                               _len: usize)
-                               -> Result<Self::SerializeTupleVariant> {
+    fn serialize_tuple_variant(
+        self,
+        _name: &'static str,
+        _variant_index: u32,
+        variant: &'static str,
+        _len: usize,
+    ) -> Result<Self::SerializeTupleVariant> {
         // self.write(variant)?;
         self.extend_key(variant);
         Ok(QsSeq(self, 0))
@@ -315,43 +330,47 @@ impl<'a, W: Write> ser::Serializer for &'a mut QsSerializer<'a, W> {
         Ok(QsMap(self, None))
     }
 
-    fn serialize_struct(self,
-                        _name: &'static str,
-                        _len: usize)
-                        -> Result<Self::SerializeStruct> {
+    fn serialize_struct(
+        self,
+        _name: &'static str,
+        _len: usize,
+    ) -> Result<Self::SerializeStruct> {
         Ok(self)
     }
 
-    fn serialize_struct_variant(self,
-                                _name: &'static str,
-                                _variant_index: u32,
-                                variant: &'static str,
-                                _len: usize)
-                                -> Result<Self::SerializeStructVariant> {
+    fn serialize_struct_variant(
+        self,
+        _name: &'static str,
+        _variant_index: u32,
+        variant: &'static str,
+        _len: usize,
+    ) -> Result<Self::SerializeStructVariant> {
         self.extend_key(variant);
         Ok(self)
     }
 }
 
-
 impl ser::Error for Error {
     fn custom<T>(msg: T) -> Self
-        where T: Display,
+    where
+        T: Display,
     {
         ErrorKind::Custom(msg.to_string()).into()
     }
 }
 
 pub struct QsSeq<'a, W: 'a + Write>(&'a mut QsSerializer<'a, W>, usize);
-pub struct QsMap<'a, W: 'a + Write>(&'a mut QsSerializer<'a, W>,
-                                    Option<Cow<'a, str>>);
-
+pub struct QsMap<'a, W: 'a + Write>(
+    &'a mut QsSerializer<'a, W>,
+    Option<Cow<'a, str>>,
+);
 
 impl<'a, W: Write> ser::SerializeTuple for QsSeq<'a, W> {
     type Ok = ();
     type Error = Error;
     fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<()>
-        where T: ser::Serialize,
+    where
+        T: ser::Serialize,
     {
         let mut serializer = QsSerializer::new_from_ref(self.0);
         serializer.extend_key(&self.1.to_string());
@@ -361,7 +380,6 @@ impl<'a, W: Write> ser::SerializeTuple for QsSeq<'a, W> {
 
     fn end(self) -> Result<Self::Ok> {
         Ok(())
-
     }
 }
 
@@ -369,7 +387,8 @@ impl<'a, W: Write> ser::SerializeSeq for QsSeq<'a, W> {
     type Ok = ();
     type Error = Error;
     fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<()>
-        where T: ser::Serialize,
+    where
+        T: ser::Serialize,
     {
         let mut serializer = QsSerializer::new_from_ref(self.0);
         serializer.extend_key(&self.1.to_string());
@@ -378,18 +397,19 @@ impl<'a, W: Write> ser::SerializeSeq for QsSeq<'a, W> {
     }
     fn end(self) -> Result<Self::Ok> {
         Ok(())
-
     }
 }
 
 impl<'a, W: Write> ser::SerializeStruct for &'a mut QsSerializer<'a, W> {
     type Ok = ();
     type Error = Error;
-    fn serialize_field<T: ?Sized>(&mut self,
-                                  key: &'static str,
-                                  value: &T)
-                                  -> Result<()>
-        where T: ser::Serialize,
+    fn serialize_field<T: ?Sized>(
+        &mut self,
+        key: &'static str,
+        value: &T,
+    ) -> Result<()>
+    where
+        T: ser::Serialize,
     {
         let mut serializer = QsSerializer::new_from_ref(self);
         serializer.extend_key(key);
@@ -404,11 +424,13 @@ impl<'a, W: Write> ser::SerializeStructVariant for &'a mut QsSerializer<'a, W> {
     type Ok = ();
     type Error = Error;
 
-    fn serialize_field<T: ?Sized>(&mut self,
-                                  key: &'static str,
-                                  value: &T)
-                                  -> Result<()>
-        where T: ser::Serialize,
+    fn serialize_field<T: ?Sized>(
+        &mut self,
+        key: &'static str,
+        value: &T,
+    ) -> Result<()>
+    where
+        T: ser::Serialize,
     {
         let mut serializer = QsSerializer::new_from_ref(self);
         serializer.extend_key(key);
@@ -425,7 +447,8 @@ impl<'a, W: Write> ser::SerializeTupleVariant for QsSeq<'a, W> {
     type Error = Error;
 
     fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<()>
-        where T: ser::Serialize,
+    where
+        T: ser::Serialize,
     {
         let mut serializer = QsSerializer::new_from_ref(self.0);
         serializer.extend_key(&self.1.to_string());
@@ -443,7 +466,8 @@ impl<'a, W: Write> ser::SerializeTupleStruct for QsSeq<'a, W> {
     type Error = Error;
 
     fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<()>
-        where T: ser::Serialize,
+    where
+        T: ser::Serialize,
     {
         let mut serializer = QsSerializer::new_from_ref(self.0);
         serializer.extend_key(&self.1.to_string());
@@ -461,14 +485,16 @@ impl<'a, W: Write> ser::SerializeMap for QsMap<'a, W> {
     type Error = Error;
 
     fn serialize_key<T: ?Sized>(&mut self, key: &T) -> Result<()>
-        where T: ser::Serialize,
+    where
+        T: ser::Serialize,
     {
         self.1 = Some(Cow::from(key.serialize(StringSerializer)?));
         Ok(())
     }
 
     fn serialize_value<T: ?Sized>(&mut self, value: &T) -> Result<()>
-        where T: ser::Serialize,
+    where
+        T: ser::Serialize,
     {
         let mut serializer = QsSerializer::new_from_ref(self.0);
         if let Some(ref key) = self.1 {
@@ -484,12 +510,14 @@ impl<'a, W: Write> ser::SerializeMap for QsMap<'a, W> {
         Ok(())
     }
 
-    fn serialize_entry<K: ?Sized, V: ?Sized>(&mut self,
-                                             key: &K,
-                                             value: &V)
-                                             -> Result<()>
-        where K: ser::Serialize,
-              V: ser::Serialize,
+    fn serialize_entry<K: ?Sized, V: ?Sized>(
+        &mut self,
+        key: &K,
+        value: &V,
+    ) -> Result<()>
+    where
+        K: ser::Serialize,
+        V: ser::Serialize,
     {
         let mut serializer = QsSerializer::new_from_ref(self.0);
         serializer.extend_key(&key.serialize(StringSerializer)?);
@@ -510,7 +538,7 @@ impl ser::Serializer for StringSerializer {
     type SerializeStruct = ser::Impossible<String, Error>;
     type SerializeStructVariant = ser::Impossible<String, Error>;
 
-    serialize_as_string!{
+    serialize_as_string! {
         bool => serialize_bool,
         u8  => serialize_u8,
         u16 => serialize_u16,
@@ -526,7 +554,6 @@ impl ser::Serializer for StringSerializer {
         &str => serialize_str,
     }
 
-
     fn serialize_bytes(self, value: &[u8]) -> Result<Self::Ok> {
         Ok(BASE64.encode(value))
     }
@@ -542,31 +569,32 @@ impl ser::Serializer for StringSerializer {
     }
 
     /// Returns an error.
-    fn serialize_unit_variant(self,
-                              _name: &'static str,
-                              _variant_index: u32,
-                              _variant: &'static str)
-                              -> Result<Self::Ok> {
+    fn serialize_unit_variant(
+        self,
+        _name: &'static str,
+        _variant_index: u32,
+        _variant: &'static str,
+    ) -> Result<Self::Ok> {
         Err(ErrorKind::Unsupported.into())
     }
 
     /// Returns an error.
-    fn serialize_newtype_struct<T: ?Sized + ser::Serialize>
-        (self,
-         _name: &'static str,
-         _value: &T)
-         -> Result<Self::Ok> {
+    fn serialize_newtype_struct<T: ?Sized + ser::Serialize>(
+        self,
+        _name: &'static str,
+        _value: &T,
+    ) -> Result<Self::Ok> {
         Err(ErrorKind::Unsupported.into())
     }
 
     /// Returns an error.
-    fn serialize_newtype_variant<T: ?Sized + ser::Serialize>
-        (self,
-         _name: &'static str,
-         _variant_index: u32,
-         _variant: &'static str,
-         _value: &T)
-         -> Result<Self::Ok> {
+    fn serialize_newtype_variant<T: ?Sized + ser::Serialize>(
+        self,
+        _name: &'static str,
+        _variant_index: u32,
+        _variant: &'static str,
+        _value: &T,
+    ) -> Result<Self::Ok> {
         Err(ErrorKind::Unsupported.into())
     }
 
@@ -576,9 +604,10 @@ impl ser::Serializer for StringSerializer {
     }
 
     /// Returns an error.
-    fn serialize_some<T: ?Sized + ser::Serialize>(self,
-                                                  _value: &T)
-                                                  -> Result<Self::Ok> {
+    fn serialize_some<T: ?Sized + ser::Serialize>(
+        self,
+        _value: &T,
+    ) -> Result<Self::Ok> {
         Err(ErrorKind::Unsupported.into())
     }
 
@@ -587,46 +616,48 @@ impl ser::Serializer for StringSerializer {
         Err(ErrorKind::Unsupported.into())
     }
 
-
     fn serialize_tuple(self, _len: usize) -> Result<Self::SerializeTuple> {
         Err(ErrorKind::Unsupported.into())
     }
 
     /// Returns an error.
-    fn serialize_tuple_struct(self,
-                              _name: &'static str,
-                              _len: usize)
-                              -> Result<Self::SerializeTupleStruct> {
+    fn serialize_tuple_struct(
+        self,
+        _name: &'static str,
+        _len: usize,
+    ) -> Result<Self::SerializeTupleStruct> {
         Err(ErrorKind::Unsupported.into())
     }
 
-    fn serialize_tuple_variant(self,
-                               _name: &'static str,
-                               _variant_index: u32,
-                               _variant: &'static str,
-                               _len: usize)
-                               -> Result<Self::SerializeTupleVariant> {
+    fn serialize_tuple_variant(
+        self,
+        _name: &'static str,
+        _variant_index: u32,
+        _variant: &'static str,
+        _len: usize,
+    ) -> Result<Self::SerializeTupleVariant> {
         Err(ErrorKind::Unsupported.into())
     }
 
     fn serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap> {
         Err(ErrorKind::Unsupported.into())
-
     }
 
-    fn serialize_struct(self,
-                        _name: &'static str,
-                        _len: usize)
-                        -> Result<Self::SerializeStruct> {
+    fn serialize_struct(
+        self,
+        _name: &'static str,
+        _len: usize,
+    ) -> Result<Self::SerializeStruct> {
         Err(ErrorKind::Unsupported.into())
     }
 
-    fn serialize_struct_variant(self,
-                                _name: &'static str,
-                                _variant_index: u32,
-                                _variant: &'static str,
-                                _len: usize)
-                                -> Result<Self::SerializeStructVariant> {
+    fn serialize_struct_variant(
+        self,
+        _name: &'static str,
+        _variant_index: u32,
+        _variant: &'static str,
+        _len: usize,
+    ) -> Result<Self::SerializeStructVariant> {
         Err(ErrorKind::Unsupported.into())
     }
 }