Revert to rustfmt defaults.

4 files changed, 113 insertions, 208 deletions

diff --git a/src/actix.rs b/src/actix.rs
index 70dc6e1..3c0b0ca 100644
--- a/src/actix.rs
+++ b/src/actix.rs
@@ -6,9 +6,7 @@ use crate::de::Config as QsConfig;
 use crate::error::Error as QsError;
 
 use actix_web::dev::Payload;
-use actix_web::{
-    Error as ActixError, FromRequest, HttpRequest, HttpResponse, ResponseError,
-};
+use actix_web::{Error as ActixError, FromRequest, HttpRequest, HttpResponse, ResponseError};
 use futures::future::{ready, Ready};
 use serde::de;
 use std::fmt;
@@ -97,8 +95,7 @@ where
     fn from_request(req: &HttpRequest, _: &mut Payload) -> Self::Future {
         let query_config = req.app_data::<QsQueryConfig>();
 
-        let error_handler =
-            query_config.map(|c| c.ehandler.clone()).unwrap_or(None);
+        let error_handler = query_config.map(|c| c.ehandler.clone()).unwrap_or(None);
 
         let default_qsconfig = QsConfig::default();
         let qsconfig = query_config
@@ -157,8 +154,7 @@ where
 /// ```
 
 pub struct QsQueryConfig {
-    ehandler:
-        Option<Arc<dyn Fn(QsError, &HttpRequest) -> ActixError + Send + Sync>>,
+    ehandler: Option<Arc<dyn Fn(QsError, &HttpRequest) -> ActixError + Send + Sync>>,
     qs_config: QsConfig,
 }
 
diff --git a/src/de/mod.rs b/src/de/mod.rs
index 923c4b9..3d8b508 100644
--- a/src/de/mod.rs
+++ b/src/de/mod.rs
@@ -108,10 +108,7 @@ 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)?)
     }
 
@@ -125,10 +122,7 @@ 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())
     }
 }
@@ -220,8 +214,7 @@ impl<'a> QsDeserializer<'a> {
 
     /// Returns a new `QsDeserializer<'a>`.
     fn with_config(config: &Config, input: &'a [u8]) -> Result<Self> {
-        parse::Parser::new(input, config.max_depth(), config.strict)
-            .as_deserializer()
+        parse::Parser::new(input, config.max_depth(), config.strict).as_deserializer()
     }
 }
 
@@ -264,11 +257,7 @@ impl<'de> de::Deserializer<'de> for QsDeserializer<'de> {
         Err(Error::top_level("sequence"))
     }
 
-    fn deserialize_newtype_struct<V>(
-        self,
-        _name: &'static str,
-        visitor: V,
-    ) -> Result<V::Value>
+    fn deserialize_newtype_struct<V>(self, _name: &'static str, visitor: V) -> Result<V::Value>
     where
         V: de::Visitor<'de>,
     {
@@ -409,11 +398,7 @@ 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>
+    fn struct_variant<V>(self, _fields: &'static [&'static str], visitor: V) -> Result<V::Value>
     where
         V: de::Visitor<'de>,
     {
@@ -468,11 +453,7 @@ impl<'de> de::VariantAccess<'de> for LevelDeserializer<'de> {
     {
         de::Deserializer::deserialize_seq(self, visitor)
     }
-    fn struct_variant<V>(
-        self,
-        _fields: &'static [&'static str],
-        visitor: V,
-    ) -> Result<V::Value>
+    fn struct_variant<V>(self, _fields: &'static [&'static str], visitor: V) -> Result<V::Value>
     where
         V: de::Visitor<'de>,
     {
@@ -482,9 +463,7 @@ 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>
-{
+impl<'de, I: Iterator<Item = Level<'de>>> de::SeqAccess<'de> for LevelSeq<'de, I> {
     type Error = Error;
     fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>>
     where
@@ -501,35 +480,32 @@ impl<'de, I: Iterator<Item = Level<'de>>> de::SeqAccess<'de>
 struct LevelDeserializer<'a>(Level<'a>);
 
 macro_rules! deserialize_primitive {
-    ($ty:ident, $method:ident, $visit_method:ident) => (
+    ($ty:ident, $method:ident, $visit_method:ident) => {
         fn $method<V>(self, visitor: V) -> Result<V::Value>
-            where V: de::Visitor<'de>,
+        where
+            V: de::Visitor<'de>,
         {
             match self.0 {
-                Level::Nested(_) => {
-                    Err(de::Error::custom(format!("Expected: {:?}, got a Map",
-                                                  stringify!($ty))))
-                },
-                Level::OrderedSeq(_) => {
-                    Err(de::Error::custom(format!("Expected: {:?}, got an OrderedSequence",
-                                                  stringify!($ty))))
-                },
-                Level::Sequence(_) => {
-                    Err(de::Error::custom(format!("Expected: {:?}, got a Sequence",
-                                                  stringify!($ty))))
-                },
-                Level::Flat(x) => {
-                    ParsableStringDeserializer(x).$method(visitor)
-                },
-                Level::Invalid(e) => {
-                    Err(de::Error::custom(e))
-                },
-                Level::Uninitialised => {
-                    Err(de::Error::custom("attempted to deserialize unitialised value"))
-                },
+                Level::Nested(_) => Err(de::Error::custom(format!(
+                    "Expected: {:?}, got a Map",
+                    stringify!($ty)
+                ))),
+                Level::OrderedSeq(_) => Err(de::Error::custom(format!(
+                    "Expected: {:?}, got an OrderedSequence",
+                    stringify!($ty)
+                ))),
+                Level::Sequence(_) => Err(de::Error::custom(format!(
+                    "Expected: {:?}, got a Sequence",
+                    stringify!($ty)
+                ))),
+                Level::Flat(x) => ParsableStringDeserializer(x).$method(visitor),
+                Level::Invalid(e) => Err(de::Error::custom(e)),
+                Level::Uninitialised => Err(de::Error::custom(
+                    "attempted to deserialize unitialised value",
+                )),
             }
         }
-    )
+    };
 }
 
 impl<'a> LevelDeserializer<'a> {
@@ -554,15 +530,9 @@ impl<'de> de::Deserializer<'de> for LevelDeserializer<'de> {
         V: de::Visitor<'de>,
     {
         match self.0 {
-            Level::Nested(_) => {
-                self.into_deserializer()?.deserialize_map(visitor)
-            },
-            Level::OrderedSeq(map) => {
-                visitor.visit_seq(LevelSeq(map.into_iter().map(|(_k, v)| v)))
-            },
-            Level::Sequence(seq) => {
-                visitor.visit_seq(LevelSeq(seq.into_iter()))
-            },
+            Level::Nested(_) => self.into_deserializer()?.deserialize_map(visitor),
+            Level::OrderedSeq(map) => visitor.visit_seq(LevelSeq(map.into_iter().map(|(_k, v)| v))),
+            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),
@@ -595,8 +565,9 @@ impl<'de> de::Deserializer<'de> for LevelDeserializer<'de> {
         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 \
@@ -606,29 +577,19 @@ impl<'de> de::Deserializer<'de> for LevelDeserializer<'de> {
         }
     }
 
-    fn deserialize_newtype_struct<V>(
-        self,
-        _name: &'static str,
-        visitor: V,
-    ) -> Result<V::Value>
+    fn deserialize_newtype_struct<V>(self, _name: &'static str, visitor: V) -> Result<V::Value>
     where
         V: de::Visitor<'de>,
     {
         match self.0 {
-            Level::Nested(_) => {
-                self.into_deserializer()?.deserialize_map(visitor)
-            },
-            Level::OrderedSeq(map) => {
-                visitor.visit_seq(LevelSeq(map.into_iter().map(|(_k, v)| v)))
-            },
-            Level::Sequence(seq) => {
-                visitor.visit_seq(LevelSeq(seq.into_iter()))
-            },
+            Level::Nested(_) => self.into_deserializer()?.deserialize_map(visitor),
+            Level::OrderedSeq(map) => visitor.visit_seq(LevelSeq(map.into_iter().map(|(_k, v)| v))),
+            Level::Sequence(seq) => visitor.visit_seq(LevelSeq(seq.into_iter())),
             Level::Flat(_) => {
                 // For a newtype_struct, attempt to deserialize a flat value as a
                 // single element sequence.
                 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 \
diff --git a/src/de/parse.rs b/src/de/parse.rs
index c23aa7e..ffd1a3f 100644
--- a/src/de/parse.rs
+++ b/src/de/parse.rs
@@ -11,11 +11,7 @@ macro_rules! tu {
     ($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")),
         }
     };
 }
@@ -30,13 +26,12 @@ impl<'a> Level<'a> {
             match map.entry(key) {
                 Entry::Occupied(mut o) => {
                     // Throw away old result; map is now invalid anyway.
-                    let _ =
-                        o.insert(Level::Invalid("Multiple values for one key"));
-                },
+                    let _ = o.insert(Level::Invalid("Multiple values for one key"));
+                }
                 Entry::Vacant(vm) => {
                     // Map is empty, result is None
                     let _ = vm.insert(Level::Flat(value));
-                },
+                }
             }
         } else if let Level::Uninitialised = *self {
             let mut map = BTreeMap::default();
@@ -56,13 +51,12 @@ impl<'a> Level<'a> {
             match map.entry(key) {
                 Entry::Occupied(mut o) => {
                     // Throw away old result; map is now invalid anyway.
-                    let _ =
-                        o.insert(Level::Invalid("Multiple values for one key"));
-                },
+                    let _ = o.insert(Level::Invalid("Multiple values for one key"));
+                }
                 Entry::Vacant(vm) => {
                     // Map is empty, result is None
                     let _ = vm.insert(Level::Flat(value));
-                },
+                }
             }
         } else if let Level::Uninitialised = *self {
             // To reach here, self is either an OrderedSeq or nothing.
@@ -147,21 +141,21 @@ impl<'a> Iterator for Parser<'a> {
                                     let _ = self.iter.next();
                                     self.index += 2;
                                     Some(&b'[')
-                                },
+                                }
                                 b"5D" => {
                                     // skip the next two characters
                                     let _ = self.iter.next();
                                     let _ = self.iter.next();
                                     self.index += 2;
                                     Some(&b']')
-                                },
+                                }
                                 _ => Some(v),
                             }
-                        },
+                        }
                         Some(v) => Some(v),
                         None => None,
                     }
-                },
+                }
             }
         } else {
             match self.peeked.take() {
@@ -170,7 +164,7 @@ impl<'a> Iterator for Parser<'a> {
                     self.index += 1;
                     self.acc.1 += 1;
                     self.iter.next()
-                },
+                }
             }
         }
     }
@@ -205,7 +199,7 @@ fn replace_plus(input: &[u8]) -> Cow<[u8]> {
             }
 
             Cow::Owned(replaced)
-        },
+        }
     }
 }
 
@@ -241,17 +235,15 @@ impl<'a> Parser<'a> {
                         Cow::Borrowed(_) => {
                             // In this case, neither method made replacements, so we
                             // reuse the original bytes
-                            let res = str::from_utf8(
-                                &self.inner[self.acc.0..self.acc.1 - 1],
-                            )?;
+                            let res = str::from_utf8(&self.inner[self.acc.0..self.acc.1 - 1])?;
                             Ok(Cow::Borrowed(res))
-                        },
+                        }
                         Cow::Owned(owned) => {
                             let res = String::from_utf8(owned)?;
                             Ok(Cow::Owned(res))
-                        },
+                        }
                     }
-                },
+                }
                 Cow::Owned(owned) => Ok(Cow::Owned(owned)),
             };
         self.clear_acc();
@@ -302,7 +294,7 @@ impl<'a> Parser<'a> {
                                     } else {
                                         let _ = self.next();
                                     }
-                                },
+                                }
                                 // key is simply "[]", so treat as a seq.
                                 b']' => {
                                     // throw away the bracket
@@ -310,24 +302,21 @@ impl<'a> Parser<'a> {
                                     self.clear_acc();
                                     self.parse_seq_value(node)?;
                                     return Ok(true);
-                                },
+                                }
                                 // 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(
@@ -340,10 +329,10 @@ impl<'a> Parser<'a> {
                                     } else {
                                         let _ = self.next();
                                     }
-                                },
+                                }
                             }
                         }
-                    },
+                    }
                     // This means the key should be a root key
                     // of the form "abc" or "abc[..=]"
                     // We do actually allow integer keys here since they cannot
@@ -353,9 +342,9 @@ impl<'a> Parser<'a> {
                         // Root keys are _always_ map values
                         self.parse_map_value(key, node)?;
                         Ok(true)
-                    },
+                    }
                 }
-            },
+            }
             // Ran out of characters to parse
             None => Ok(false),
         }
@@ -381,7 +370,7 @@ impl<'a> Parser<'a> {
                             self.peeked = Some(x);
                         }
                         return self.collect_str();
-                    },
+                    }
                     b'=' => {
                         // Allow the '=' byte only when parsing keys within []
                         if end_on != b']' {
@@ -392,17 +381,17 @@ impl<'a> Parser<'a> {
                         }
 
                         // otherwise do nothing, so '=' is accumulated
-                    },
+                    }
                     b'&' => {
                         // important to keep the `&` character so we know the
                         // key-value is of the form `key&..=` (i.e. no value)
                         self.peeked = Some(&b'&');
                         return self.collect_str();
-                    },
+                    }
                     _ => {
                         // for any other character
                         // do nothing, keep adding to key
-                    },
+                    }
                 }
             } else {
                 // no more string to parse
@@ -413,11 +402,7 @@ 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() {
@@ -430,12 +415,12 @@ impl<'a> Parser<'a> {
                         let value: Cow<'a, str> = self.collect_str()?;
                         node.insert_map_value(key, value);
                         break Ok(());
-                    },
+                    }
                     b'&' => {
                         // No value
                         node.insert_map_value(key, Cow::Borrowed(""));
                         break Ok(());
-                    },
+                    }
                     b'[' => {
                         // The key continues to another level of nested.
                         // Add a new unitialised level for this node and continue.
@@ -448,9 +433,7 @@ 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.
@@ -463,16 +446,22 @@ impl<'a> Parser<'a> {
                                 self.index,
                             ));
                         }
-                    },
+                    }
                     c => {
                         // Anything else is unexpected since we just finished
                         // parsing a key.
                         if self.strict {
-                            break Err(super::Error::parse_err(format!("Unexpected character: '{}' found when parsing", String::from_utf8_lossy(&[c])), self.index));
+                            break Err(super::Error::parse_err(
+                                format!(
+                                    "Unexpected character: '{}' found when parsing",
+                                    String::from_utf8_lossy(&[c])
+                                ),
+                                self.index,
+                            ));
                         } else {
                             let _ = self.next();
                         }
-                    },
+                    }
                 }
             } else {
                 // The string has ended, so the value is empty.
@@ -489,11 +478,7 @@ 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() {
@@ -507,12 +492,12 @@ impl<'a> Parser<'a> {
                         // Reached the end of the key string
                         node.insert_ord_seq_value(key, value);
                         break Ok(());
-                    },
+                    }
                     b'&' => {
                         // No value
                         node.insert_ord_seq_value(key, Cow::Borrowed(""));
                         break Ok(());
-                    },
+                    }
                     b'[' => {
                         // The key continues to another level of nested.
                         // Add a new unitialised level for this node and continue.
@@ -540,18 +525,19 @@ impl<'a> Parser<'a> {
                                 self.index,
                             ));
                         }
-                    },
+                    }
                     c => {
                         // Anything else is unexpected since we just finished
                         // parsing a key.
                         if self.strict {
-                            break Err(super::Error::parse_err(format!("Unexpected character: {:?} found when parsing",
-                                                                      c),
-                                                              self.index));
+                            break Err(super::Error::parse_err(
+                                format!("Unexpected character: {:?} found when parsing", c),
+                                self.index,
+                            ));
                         } else {
                             let _ = self.next();
                         }
-                    },
+                    }
                 }
             } else {
                 // The string has ended, so the value is empty.
@@ -580,24 +566,24 @@ impl<'a> Parser<'a> {
                         let value = self.collect_str()?;
                         node.insert_seq_value(value);
                         Ok(())
-                    },
+                    }
                     b'&' => {
                         // key value is empty
                         node.insert_seq_value(Cow::Borrowed(""));
                         Ok(())
-                    },
+                    }
                     _ => Err(super::Error::parse_err(
                         "non-indexed sequence of \
                          structs not supported",
                         self.index,
                     )),
                 }
-            },
+            }
             None => {
                 // The string has ended, so the value is empty.
                 node.insert_seq_value(Cow::Borrowed(""));
                 Ok(())
-            },
+            }
         };
         // We have finished parsing this level, so go back up a level.
         self.depth += 1;
diff --git a/src/ser.rs b/src/ser.rs
index 618b148..c34343d 100644
--- a/src/ser.rs
+++ b/src/ser.rs
@@ -82,10 +82,7 @@ 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,
@@ -119,19 +116,15 @@ 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>>();
+            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 {
@@ -164,9 +157,7 @@ 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,
@@ -275,10 +266,7 @@ 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)
     }
@@ -317,11 +305,7 @@ 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)
     }
 
@@ -347,10 +331,7 @@ impl ser::Error for Error {
 }
 
 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 = ();
@@ -390,11 +371,7 @@ impl<'a, W: Write> ser::SerializeSeq for QsSeq<'a, W> {
 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<()>
+    fn serialize_field<T: ?Sized>(&mut self, key: &'static str, value: &T) -> Result<()>
     where
         T: ser::Serialize,
     {
@@ -411,11 +388,7 @@ 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<()>
+    fn serialize_field<T: ?Sized>(&mut self, key: &'static str, value: &T) -> Result<()>
     where
         T: ser::Serialize,
     {
@@ -497,11 +470,7 @@ 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<()>
+    fn serialize_entry<K: ?Sized, V: ?Sized>(&mut self, key: &K, value: &V) -> Result<()>
     where
         K: ser::Serialize,
         V: ser::Serialize,
@@ -591,10 +560,7 @@ 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())
     }
 
@@ -630,11 +596,7 @@ impl ser::Serializer for StringSerializer {
         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())
     }