Run cargo fmt.

9 files changed, 611 insertions, 455 deletions

diff --git a/examples/csv_vectors.rs b/examples/csv_vectors.rs
index 7824cdd..4dbc947 100644
--- a/examples/csv_vectors.rs
+++ b/examples/csv_vectors.rs
@@ -10,7 +10,7 @@ use std::default::Default;
 
 #[derive(Debug, Deserialize, Serialize)]
 struct Query {
-    #[serde(deserialize_with="from_csv")]
+    #[serde(deserialize_with = "from_csv")]
     r: Vec<u8>,
     s: u8,
 }
@@ -21,10 +21,10 @@ fn main() {
     println!("{:?}", q);
 }
 
-
 fn from_csv<'de, D, T>(deserializer: D) -> Result<Vec<T>, D::Error>
-    where D: serde::Deserializer<'de>,
-          T: DeserializeOwned
+where
+    D: serde::Deserializer<'de>,
+    T: DeserializeOwned,
 {
     deserializer.deserialize_str(CSVVecVisitor::<T>::default())
 }
@@ -41,19 +41,26 @@ impl<T: DeserializeOwned> Default for CSVVecVisitor<T> {
 impl<'de, T: DeserializeOwned> serde::de::Visitor<'de> for CSVVecVisitor<T> {
     type Value = Vec<T>;
 
-    fn expecting(&self,
-                 formatter: &mut std::fmt::Formatter)
-                 -> std::fmt::Result {
+    fn expecting(
+        &self,
+        formatter: &mut std::fmt::Formatter,
+    ) -> std::fmt::Result {
         write!(formatter, "a str")
     }
 
     fn visit_str<E>(self, s: &str) -> std::result::Result<Self::Value, E>
-        where E: serde::de::Error,
+    where
+        E: serde::de::Error,
     {
         let mut output = Vec::new();
         let mut items = csv::Reader::from_reader(s.as_bytes());
         for res in items.deserialize() {
-            let item: T = res.map_err(|e| E::custom(format!("could not deserialize sequence value: {:?}", e)))?;
+            let item: T = res.map_err(|e| {
+                E::custom(format!(
+                    "could not deserialize sequence value: {:?}",
+                    e
+                ))
+            })?;
             output.push(item);
         }
 
diff --git a/examples/introduction.rs b/examples/introduction.rs
index a1f6fc9..34cb530 100644
--- a/examples/introduction.rs
+++ b/examples/introduction.rs
@@ -24,7 +24,6 @@ struct QueryParams {
     user_ids: Vec<u8>,
 }
 
-
 fn main() {
     // Encodes as:
     // "user_ids%5B3%5D=4&user_ids%5B2%5D=3&address%5Bcity%5D=Carrot+City&\
@@ -83,7 +82,6 @@ fn main() {
     println!("`serde_qs` to_string for struct:\n\t{:?}", encoded);
     println!("");
 
-
     // One nice feature is that this gives deterministic encodings:
     let encoded2 = qs::to_string(&params).unwrap();
     assert_eq!(encoded, encoded2);
@@ -91,15 +89,17 @@ fn main() {
     // An advantage of `serde_qs` for deserializing, is that it is robust
     // against different orderings of inputs:
 
-    let mut inputs = vec!["id=42",
-                          "name=Acme",
-                          "phone=12345",
-                          "address[city]=Carrot+City",
-                          "address[postcode]=12345",
-                          "user_ids[0]=1",
-                          "user_ids[1]=2",
-                          "user_ids[2]=3",
-                          "user_ids[3]=4"];
+    let mut inputs = vec![
+        "id=42",
+        "name=Acme",
+        "phone=12345",
+        "address[city]=Carrot+City",
+        "address[postcode]=12345",
+        "user_ids[0]=1",
+        "user_ids[1]=2",
+        "user_ids[2]=3",
+        "user_ids[3]=4",
+    ];
 
     let mut rng = rand::thread_rng();
     for _ in 0..10 {
@@ -151,7 +151,9 @@ fn main() {
         e: AdjTaggedEnum,
     }
 
-    let example_params = EnumQuery { e: AdjTaggedEnum::B(false) };
+    let example_params = EnumQuery {
+        e: AdjTaggedEnum::B(false),
+    };
     // encodes as:
     //   "e[B]=false"
     let encoded = qs::to_string(&example_params).unwrap();
@@ -160,7 +162,9 @@ fn main() {
     println!("`serde_qs` from_str for enum:\n\t{:?}", params);
     println!("");
 
-    let example_params = EnumQuery { e: AdjTaggedEnum::A };
+    let example_params = EnumQuery {
+        e: AdjTaggedEnum::A,
+    };
     // encodes as:
     //   "e=A"
     let encoded = qs::to_string(&example_params).unwrap();
@@ -168,5 +172,4 @@ fn main() {
     let params: EnumQuery = qs::from_str(&encoded).unwrap();
     println!("`serde_qs` from_str for enum:\n\t{:?}", params);
     println!("");
-
 }
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())
     }
 }
diff --git a/tests/test_deserialize.rs b/tests/test_deserialize.rs
index 81dc954..512ea72 100644
--- a/tests/test_deserialize.rs
+++ b/tests/test_deserialize.rs
@@ -32,7 +32,6 @@ macro_rules! map_test {
     }
 }
 
-
 // Macro used to quickly generate a nested HashMap from a string.
 macro_rules! hash_to_map {
     // Base case: a map with no inputs, do nothing.
@@ -84,30 +83,38 @@ fn deserialize_struct() {
 
     for config in vec![qs::Config::new(5, true), qs::Config::new(5, false)] {
         // standard parameters
-        let rec_params: QueryParams = config.deserialize_str("\
-            name=Acme&id=42&phone=12345&address[postcode]=12345&\
-            address[city]=Carrot+City&user_ids[0]=1&user_ids[1]=2&\
-            user_ids[2]=3&user_ids[3]=4")
+        let rec_params: QueryParams = config
+            .deserialize_str(
+                "\
+                 name=Acme&id=42&phone=12345&address[postcode]=12345&\
+                 address[city]=Carrot+City&user_ids[0]=1&user_ids[1]=2&\
+                 user_ids[2]=3&user_ids[3]=4",
+            )
             .unwrap();
         assert_eq!(rec_params, params);
 
         // unindexed arrays
-        let rec_params: QueryParams = config.deserialize_str("\
-            name=Acme&id=42&phone=12345&address[postcode]=12345&\
-            address[city]=Carrot+City&user_ids[]=1&user_ids[]=2&\
-            user_ids[]=3&user_ids[]=4")
+        let rec_params: QueryParams = config
+            .deserialize_str(
+                "\
+                 name=Acme&id=42&phone=12345&address[postcode]=12345&\
+                 address[city]=Carrot+City&user_ids[]=1&user_ids[]=2&\
+                 user_ids[]=3&user_ids[]=4",
+            )
             .unwrap();
         assert_eq!(rec_params, params);
 
         // ordering doesn't matter
-        let rec_params: QueryParams = config.deserialize_str("\
-            address[city]=Carrot+City&user_ids[]=1&user_ids[]=2&\
-            name=Acme&id=42&phone=12345&address[postcode]=12345&\
-            user_ids[]=3&user_ids[]=4")
+        let rec_params: QueryParams = config
+            .deserialize_str(
+                "\
+                 address[city]=Carrot+City&user_ids[]=1&user_ids[]=2&\
+                 name=Acme&id=42&phone=12345&address[postcode]=12345&\
+                 user_ids[]=3&user_ids[]=4",
+            )
             .unwrap();
         assert_eq!(rec_params, params);
     }
-
 }
 
 #[test]
@@ -179,10 +186,9 @@ fn qs_test_simple() {
     // });
 }
 
-
 #[test]
 fn no_panic_on_parse_error() {
-    #[derive(Debug,Serialize,Deserialize,PartialEq)]
+    #[derive(Debug, Serialize, Deserialize, PartialEq)]
     struct Query {
         vec: Vec<u32>,
     }
@@ -206,13 +212,15 @@ fn qs_nesting() {
     //     'defaults to a depth of 5'
     // );
     // This looks like depth 6 to me? Tweaked test to make it 5.
-    map_test!("a[b][c][d][e][f][g][h]=i",
-              "a"["b"["c"["d"["e"["[f][g][h]"["i"]]]]]]);
+    map_test!(
+        "a[b][c][d][e][f][g][h]=i",
+        "a"["b"["c"["d"["e"["[f][g][h]"["i"]]]]]]
+    );
 }
 
 #[test]
 fn optional_seq() {
-    #[derive(Debug,Serialize,Deserialize,PartialEq)]
+    #[derive(Debug, Serialize, Deserialize, PartialEq)]
     struct Query {
         vec: Option<Vec<u8>>,
     }
@@ -228,14 +236,16 @@ fn optional_seq() {
     assert_eq!(rec_params, query);
 
     let params = "vec[0]=1&vec[1]=2";
-    let query = Query { vec: Some(vec![1, 2]) };
+    let query = Query {
+        vec: Some(vec![1, 2]),
+    };
     let rec_params: Query = qs::from_str(params).unwrap();
     assert_eq!(rec_params, query);
 }
 
 #[test]
 fn optional_struct() {
-    #[derive(Debug,Serialize,Deserialize,PartialEq)]
+    #[derive(Debug, Serialize, Deserialize, PartialEq)]
     struct Query {
         address: Option<Address>,
     }
@@ -277,7 +287,12 @@ fn deserialize_enum_untagged() {
 
     let params = "e=true";
     let rec_params: Query = qs::from_str(params).unwrap();
-    assert_eq!(rec_params, Query { e: E::S("true".to_string()) });
+    assert_eq!(
+        rec_params,
+        Query {
+            e: E::S("true".to_string())
+        }
+    );
 }
 
 #[test]
@@ -304,19 +319,23 @@ fn deserialize_enum_adjacently() {
 
     let params = "e[type]=B&e[val]=true&v[type]=V1&v[val][x]=12&v[val][y]=300";
     let rec_params: Query = qs::from_str(params).unwrap();
-    assert_eq!(rec_params,
-               Query {
-                   e: E::B(true),
-                   v: Some(V::V1 { x: 12, y: 300 }),
-               });
+    assert_eq!(
+        rec_params,
+        Query {
+            e: E::B(true),
+            v: Some(V::V1 { x: 12, y: 300 }),
+        }
+    );
 
     let params = "e[type]=S&e[val]=other";
     let rec_params: Query = qs::from_str(params).unwrap();
-    assert_eq!(rec_params,
-               Query {
-                   e: E::S("other".to_string()),
-                   v: None,
-               });
+    assert_eq!(
+        rec_params,
+        Query {
+            e: E::S("other".to_string()),
+            v: None,
+        }
+    );
 }
 
 #[test]
@@ -345,21 +364,25 @@ fn deserialize_enum() {
 
     let params = "e=B&v[V1][x]=12&v[V1][y]=300&u=12";
     let rec_params: Query = qs::from_str(params).unwrap();
-    assert_eq!(rec_params,
-               Query {
-                   e: E::B,
-                   v: Some(V::V1 { x: 12, y: 300 }),
-                   u: NewU8(12),
-               });
+    assert_eq!(
+        rec_params,
+        Query {
+            e: E::B,
+            v: Some(V::V1 { x: 12, y: 300 }),
+            u: NewU8(12),
+        }
+    );
 
     let params = "e[S]=other&u=1";
     let rec_params: Query = qs::from_str(params).unwrap();
-    assert_eq!(rec_params,
-               Query {
-                   e: E::S("other".to_string()),
-                   v: None,
-                   u: NewU8(1),
-               });
+    assert_eq!(
+        rec_params,
+        Query {
+            e: E::S("other".to_string()),
+            v: None,
+            u: NewU8(1),
+        }
+    );
 
     let params = "B=";
     let rec_params: E = qs::from_str(params).unwrap();
@@ -372,7 +395,6 @@ fn deserialize_enum() {
 
 #[test]
 fn seq_of_struct() {
-
     #[derive(Deserialize, Debug, PartialEq)]
     struct Test {
         a: u8,
@@ -384,7 +406,12 @@ fn seq_of_struct() {
 
     let params = "b[0][a]=1&b[1][a]=2";
     let rec_params: Query = qs::from_str(params).unwrap();
-    assert_eq!(rec_params, Query { b: vec![Test { a: 1 }, Test { a: 2 }] });
+    assert_eq!(
+        rec_params,
+        Query {
+            b: vec![Test { a: 1 }, Test { a: 2 }]
+        }
+    );
 }
 
 #[test]
@@ -396,7 +423,7 @@ fn correct_decoding() {
 
 #[test]
 fn returns_errors() {
-    #[derive(Debug,Serialize,Deserialize,PartialEq)]
+    #[derive(Debug, Serialize, Deserialize, PartialEq)]
     struct Query {
         vec: Vec<u32>,
     }
@@ -414,14 +441,13 @@ fn returns_errors() {
     println!("{}", params.unwrap_err());
 }
 
-
 #[test]
 fn strict_mode() {
-    #[derive(Deserialize,Serialize,Debug, PartialEq)]
+    #[derive(Deserialize, Serialize, Debug, PartialEq)]
     struct Test {
         a: u8,
     }
-    #[derive(Debug,Serialize,Deserialize,PartialEq)]
+    #[derive(Debug, Serialize, Deserialize, PartialEq)]
     #[serde(deny_unknown_fields)]
     struct Query {
         vec: Vec<Test>,
@@ -438,27 +464,43 @@ fn strict_mode() {
 
     let params: Result<Query, _> =
         loose_config.deserialize_str("vec%5B0%5D%5Ba%5D=1&vec[1][a]=2");
-    assert_eq!(params.unwrap(),
-               Query { vec: vec![Test { a: 1 }, Test { a: 2 }] });
+    assert_eq!(
+        params.unwrap(),
+        Query {
+            vec: vec![Test { a: 1 }, Test { a: 2 }]
+        }
+    );
 
     let params: Result<Query, _> =
         loose_config.deserialize_str("vec[%5B0%5D%5Ba%5D]=1&vec[1][a]=2");
-    assert_eq!(params.unwrap(),
-               Query { vec: vec![Test { a: 1 }, Test { a: 2 }] });
+    assert_eq!(
+        params.unwrap(),
+        Query {
+            vec: vec![Test { a: 1 }, Test { a: 2 }]
+        }
+    );
 
     let params: Result<Query, _> =
         loose_config.deserialize_str("vec[%5B0%5D%5Ba%5D=1&vec[1][a]=2");
-    assert_eq!(params.unwrap(),
-               Query { vec: vec![Test { a: 1 }, Test { a: 2 }] });
+    assert_eq!(
+        params.unwrap(),
+        Query {
+            vec: vec![Test { a: 1 }, Test { a: 2 }]
+        }
+    );
 
     let params: Result<Query, _> =
         loose_config.deserialize_str("vec%5B0%5D%5Ba%5D]=1&vec[1][a]=2");
-    assert_eq!(params.unwrap(),
-               Query { vec: vec![Test { a: 1 }, Test { a: 2 }] });
+    assert_eq!(
+        params.unwrap(),
+        Query {
+            vec: vec![Test { a: 1 }, Test { a: 2 }]
+        }
+    );
 
-    #[derive(Deserialize,Serialize,Debug, PartialEq)]
+    #[derive(Deserialize, Serialize, Debug, PartialEq)]
     struct OddTest {
-        #[serde(rename="[but&why=?]")]
+        #[serde(rename = "[but&why=?]")]
         a: u8,
     }
 
@@ -484,14 +526,14 @@ fn square_brackets_in_values() {
 #[test]
 #[ignore]
 fn deserialize_flatten() {
-    #[derive(Deserialize,Serialize,Debug, PartialEq)]
+    #[derive(Deserialize, Serialize, Debug, PartialEq)]
     struct Query {
         a: u8,
         #[serde(flatten)]
         common: CommonParams,
     }
 
-    #[derive(Deserialize,Serialize,Debug, PartialEq)]
+    #[derive(Deserialize, Serialize, Debug, PartialEq)]
     struct CommonParams {
         limit: u64,
         offset: u64,
@@ -499,32 +541,46 @@ fn deserialize_flatten() {
     }
 
     let params = "a=1&limit=100&offset=50&remaining=true";
-    let query = Query { a: 1, common: CommonParams { limit: 100, offset: 50, remaining: true } };
+    let query = Query {
+        a: 1,
+        common: CommonParams {
+            limit: 100,
+            offset: 50,
+            remaining: true,
+        },
+    };
     let rec_query: Result<Query, _> = qs::from_str(params);
     assert_eq!(rec_query.unwrap(), query);
 }
 
 #[test]
 fn deserialize_flatten_workaround() {
-    #[derive(Deserialize,Serialize,Debug, PartialEq)]
+    #[derive(Deserialize, Serialize, Debug, PartialEq)]
     struct Query {
         a: u8,
         #[serde(flatten)]
         common: CommonParams,
     }
 
-    #[derive(Deserialize,Serialize,Debug, PartialEq)]
+    #[derive(Deserialize, Serialize, Debug, PartialEq)]
     struct CommonParams {
-        #[serde(deserialize_with="from_str")]
+        #[serde(deserialize_with = "from_str")]
         limit: u64,
-        #[serde(deserialize_with="from_str")]
+        #[serde(deserialize_with = "from_str")]
         offset: u64,
-        #[serde(deserialize_with="from_str")]
+        #[serde(deserialize_with = "from_str")]
         remaining: bool,
     }
 
     let params = "a=1&limit=100&offset=50&remaining=true";
-    let query = Query { a: 1, common: CommonParams { limit: 100, offset: 50, remaining: true } };
+    let query = Query {
+        a: 1,
+        common: CommonParams {
+            limit: 100,
+            offset: 50,
+            remaining: true,
+        },
+    };
     let rec_query: Result<Query, _> = qs::from_str(params);
     assert_eq!(rec_query.unwrap(), query);
 }
@@ -532,9 +588,10 @@ fn deserialize_flatten_workaround() {
 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
+where
+    D: serde::Deserializer<'de>,
+    S: std::str::FromStr,
 {
     let s = <&str as serde::Deserialize>::deserialize(deserializer)?;
     S::from_str(&s).map_err(|_| D::Error::custom("could not parse string"))
-}
\ No newline at end of file
+}
diff --git a/tests/test_serialize.rs b/tests/test_serialize.rs
index 5a918ab..8adae57 100644
--- a/tests/test_serialize.rs
+++ b/tests/test_serialize.rs
@@ -17,7 +17,6 @@ struct QueryParams {
     user_ids: Vec<u8>,
 }
 
-
 #[test]
 fn serialize_struct() {
     let params = QueryParams {
@@ -31,16 +30,18 @@ fn serialize_struct() {
         user_ids: vec![1, 2, 3, 4],
     };
 
-    assert_eq!(qs::to_string(&params).unwrap(),
-               "\
-        id=42&name=Acme&phone=12345&address[city]=Carrot+City&\
-        address[postcode]=12345&user_ids[0]=1&user_ids[1]=2&\
-        user_ids[2]=3&user_ids[3]=4");
+    assert_eq!(
+        qs::to_string(&params).unwrap(),
+        "\
+         id=42&name=Acme&phone=12345&address[city]=Carrot+City&\
+         address[postcode]=12345&user_ids[0]=1&user_ids[1]=2&\
+         user_ids[2]=3&user_ids[3]=4"
+    );
 }
 
 #[test]
 fn serialize_option() {
-    #[derive(Debug,Serialize,Deserialize,PartialEq)]
+    #[derive(Debug, Serialize, Deserialize, PartialEq)]
     struct Query {
         vec: Option<Vec<u8>>,
     }
@@ -51,14 +52,16 @@ fn serialize_option() {
     assert_eq!(rec_params, params);
 
     let params = "vec[0]=1&vec[1]=2";
-    let query = Query { vec: Some(vec![1, 2]) };
+    let query = Query {
+        vec: Some(vec![1, 2]),
+    };
     let rec_params = qs::to_string(&query).unwrap();
     assert_eq!(rec_params, params);
 }
 
 #[test]
 fn serialize_enum() {
-    #[derive(Debug,Serialize,Deserialize,PartialEq)]
+    #[derive(Debug, Serialize, Deserialize, PartialEq)]
     #[serde(rename_all = "lowercase")]
     enum TestEnum {
         A,
@@ -67,7 +70,7 @@ fn serialize_enum() {
         D(u8, u8),
     }
 
-    #[derive(Debug,Serialize,Deserialize,PartialEq)]
+    #[derive(Debug, Serialize, Deserialize, PartialEq)]
     struct Query {
         e: TestEnum,
     }
@@ -78,38 +81,50 @@ fn serialize_enum() {
     assert_eq!(rec_params, params);
 
     let params = "e[b]=true";
-    let query = Query { e: TestEnum::B(true) };
+    let query = Query {
+        e: TestEnum::B(true),
+    };
     let rec_params = qs::to_string(&query).unwrap();
     assert_eq!(rec_params, params);
 
     let params = "e[c][x]=2&e[c][y]=3";
-    let query = Query { e: TestEnum::C { x: 2, y: 3 } };
+    let query = Query {
+        e: TestEnum::C { x: 2, y: 3 },
+    };
     let rec_params = qs::to_string(&query).unwrap();
     assert_eq!(rec_params, params);
 
     let params = "e[d][0]=128&e[d][1]=1";
-    let query = Query { e: TestEnum::D(128, 1) };
+    let query = Query {
+        e: TestEnum::D(128, 1),
+    };
     let rec_params = qs::to_string(&query).unwrap();
     assert_eq!(rec_params, params);
 }
 
 #[test]
 fn serialize_flatten() {
-    #[derive(Deserialize,Serialize,Debug, PartialEq)]
+    #[derive(Deserialize, Serialize, Debug, PartialEq)]
     struct Query {
         a: u8,
         #[serde(flatten)]
         common: CommonParams,
     }
 
-    #[derive(Deserialize,Serialize,Debug, PartialEq)]
+    #[derive(Deserialize, Serialize, Debug, PartialEq)]
     struct CommonParams {
         limit: u64,
         offset: u64,
     }
 
     let params = "a=1&limit=100&offset=50";
-    let query = Query { a: 1, common: CommonParams { limit: 100, offset: 50 } };
+    let query = Query {
+        a: 1,
+        common: CommonParams {
+            limit: 100,
+            offset: 50,
+        },
+    };
     let rec_params = qs::to_string(&query).unwrap();
     assert_eq!(rec_params, params);
 }