Reformat

rustfmt.toml

@@ -1,7 +1,5 @@
 match_block_trailing_comma = true
 max_width = 80
 newline_style = "Unix"
-reorder_imported_names = true
 reorder_imports = true
 use_try_shorthand = true
-where_trailing_comma = true

src/de.rs

@@ -1,12 +1,12 @@
 //! Deserialization support for the `application/x-www-form-urlencoded` format.
 
-use serde::de::{self, IntoDeserializer};
-use serde::de::Error as de_Error;
 use serde::de::value::MapDeserializer;
+use serde::de::Error as de_Error;
+use serde::de::{self, IntoDeserializer};
 use std::borrow::Cow;
 use std::io::Read;
-use url::form_urlencoded::Parse as UrlEncodedParse;
 use url::form_urlencoded::parse;
+use url::form_urlencoded::Parse as UrlEncodedParse;
 
 #[doc(inline)]
 pub use serde::de::value::Error;
@@ -27,7 +27,8 @@ pub use serde::de::value::Error;
 ///     Ok(meal));
 /// ```
 pub fn from_bytes<'de, T>(input: &'de [u8]) -> Result<T, Error>
-    where T: de::Deserialize<'de>,
+where
+    T: de::Deserialize<'de>,
 {
     T::deserialize(Deserializer::new(parse(input)))
 }
@@ -48,7 +49,8 @@ pub fn from_bytes<'de, T>(input: &'de [u8]) -> Result<T, Error>
 ///     Ok(meal));
 /// ```
 pub fn from_str<'de, T>(input: &'de str) -> Result<T, Error>
-    where T: de::Deserialize<'de>,
+where
+    T: de::Deserialize<'de>,
 {
     from_bytes(input.as_bytes())
 }
@@ -56,14 +58,14 @@ pub fn from_str<'de, T>(input: &'de str) -> Result<T, Error>
 /// Convenience function that reads all bytes from `reader` and deserializes
 /// them with `from_bytes`.
 pub fn from_reader<T, R>(mut reader: R) -> Result<T, Error>
-    where T: de::DeserializeOwned,
+where
-          R: Read,
+    T: de::DeserializeOwned,
+    R: Read,
 {
     let mut buf = vec![];
-    reader.read_to_end(&mut buf)
+    reader.read_to_end(&mut buf).map_err(|e| {
-        .map_err(|e| {
+        de::Error::custom(format_args!("could not read input: {}", e))
-            de::Error::custom(format_args!("could not read input: {}", e))
+    })?;
-        })?;
     from_bytes(&buf)
 }
 
@@ -93,25 +95,29 @@ impl<'de> de::Deserializer<'de> for Deserializer<'de> {
     type Error = Error;
 
     fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
-        where V: de::Visitor<'de>,
+    where
+        V: de::Visitor<'de>,
     {
         self.deserialize_map(visitor)
     }
 
     fn deserialize_map<V>(self, visitor: V) -> Result<V::Value, Self::Error>
-        where V: de::Visitor<'de>,
+    where
+        V: de::Visitor<'de>,
     {
         visitor.visit_map(self.inner)
     }
 
     fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value, Self::Error>
-        where V: de::Visitor<'de>,
+    where
+        V: de::Visitor<'de>,
     {
         visitor.visit_seq(self.inner)
     }
 
     fn deserialize_unit<V>(self, visitor: V) -> Result<V::Value, Self::Error>
-        where V:  de::Visitor<'de>,
+    where
+        V: de::Visitor<'de>,
     {
         self.inner.end()?;
         visitor.visit_unit()
@@ -158,8 +164,7 @@ impl<'de> Iterator for PartIterator<'de> {
 
 struct Part<'de>(Cow<'de, str>);
 
-impl<'de> IntoDeserializer<'de> for Part<'de>
+impl<'de> IntoDeserializer<'de> for Part<'de> {
-{
     type Deserializer = Self;
 
     fn into_deserializer(self) -> Self::Deserializer {
@@ -186,13 +191,15 @@ impl<'de> de::Deserializer<'de> for Part<'de> {
     type Error = Error;
 
     fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
-        where V: de::Visitor<'de>,
+    where
+        V: de::Visitor<'de>,
     {
         self.0.into_deserializer().deserialize_any(visitor)
     }
 
     fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Self::Error>
-        where V: de::Visitor<'de>,
+    where
+        V: de::Visitor<'de>,
     {
         visitor.visit_some(self)
     }
@@ -203,7 +210,8 @@ impl<'de> de::Deserializer<'de> for Part<'de> {
         _variants: &'static [&'static str],
         visitor: V,
     ) -> Result<V::Value, Self::Error>
-        where V: de::Visitor<'de>,
+    where
+        V: de::Visitor<'de>,
     {
         visitor.visit_enum(ValueEnumAccess(self.0))
     }
@@ -213,7 +221,8 @@ impl<'de> de::Deserializer<'de> for Part<'de> {
         _name: &'static str,
         visitor: V,
     ) -> Result<V::Value, Self::Error>
-        where V: de::Visitor<'de>,
+    where
+        V: de::Visitor<'de>,
     {
         visitor.visit_newtype_struct(self)
     }
@@ -260,7 +269,8 @@ impl<'de> de::EnumAccess<'de> for ValueEnumAccess<'de> {
         self,
         seed: V,
     ) -> Result<(V::Value, Self::Variant), Self::Error>
-        where V: de::DeserializeSeed<'de>,
+    where
+        V: de::DeserializeSeed<'de>,
     {
         let variant = seed.deserialize(self.0.into_deserializer())?;
         Ok((variant, UnitOnlyVariantAccess))
@@ -277,7 +287,8 @@ impl<'de> de::VariantAccess<'de> for UnitOnlyVariantAccess {
     }
 
     fn newtype_variant_seed<T>(self, _seed: T) -> Result<T::Value, Self::Error>
-        where T: de::DeserializeSeed<'de>,
+    where
+        T: de::DeserializeSeed<'de>,
     {
         Err(Error::custom("expected unit variant"))
     }
@@ -287,7 +298,8 @@ impl<'de> de::VariantAccess<'de> for UnitOnlyVariantAccess {
         _len: usize,
         _visitor: V,
     ) -> Result<V::Value, Self::Error>
-        where V: de::Visitor<'de>,
+    where
+        V: de::Visitor<'de>,
     {
         Err(Error::custom("expected unit variant"))
     }
@@ -297,7 +309,8 @@ impl<'de> de::VariantAccess<'de> for UnitOnlyVariantAccess {
         _fields: &'static [&'static str],
         _visitor: V,
     ) -> Result<V::Value, Self::Error>
-        where V: de::Visitor<'de>,
+    where
+        V: de::Visitor<'de>,
     {
         Err(Error::custom("expected unit variant"))
     }

src/lib.rs

@@ -2,8 +2,8 @@
 
 #![warn(unused_extern_crates)]
 
-extern crate itoa;
 extern crate dtoa;
+extern crate itoa;
 #[macro_use]
 extern crate serde;
 extern crate url;
@@ -12,6 +12,6 @@ pub mod de;
 pub mod ser;
 
 #[doc(inline)]
-pub use de::{Deserializer, from_bytes, from_reader, from_str};
+pub use de::{from_bytes, from_reader, from_str, Deserializer};
 #[doc(inline)]
-pub use ser::{Serializer, to_string};
+pub use ser::{to_string, Serializer};

src/ser/key.rs

@@ -1,5 +1,5 @@
-use ser::Error;
 use ser::part::Sink;
+use ser::Error;
 use serde::Serialize;
 use std::borrow::Cow;
 use std::ops::Deref;
@@ -34,7 +34,8 @@ pub struct KeySink<End> {
 }
 
 impl<End, Ok> KeySink<End>
-    where End: for<'key> FnOnce(Key<'key>) -> Result<Ok, Error>
+where
+    End: for<'key> FnOnce(Key<'key>) -> Result<Ok, Error>,
 {
     pub fn new(end: End) -> Self {
         KeySink { end: end }
@@ -42,13 +43,12 @@ impl<End, Ok> KeySink<End>
 }
 
 impl<End, Ok> Sink for KeySink<End>
-    where End: for<'key> FnOnce(Key<'key>) -> Result<Ok, Error>
+where
+    End: for<'key> FnOnce(Key<'key>) -> Result<Ok, Error>,
 {
     type Ok = Ok;
 
-    fn serialize_static_str(self,
+    fn serialize_static_str(self, value: &'static str) -> Result<Ok, Error> {
-                            value: &'static str)
-                            -> Result<Ok, Error> {
         (self.end)(Key::Static(value))
     }
 
@@ -64,9 +64,10 @@ impl<End, Ok> Sink for KeySink<End>
         Err(self.unsupported())
     }
 
-    fn serialize_some<T: ?Sized + Serialize>(self,
+    fn serialize_some<T: ?Sized + Serialize>(
-                                             _value: &T)
+        self,
-                                             -> Result<Ok, Error> {
+        _value: &T,
+    ) -> Result<Ok, Error> {
         Err(self.unsupported())
     }
 

src/ser/mod.rs

@@ -49,7 +49,9 @@ pub struct Serializer<'output, Target: 'output + UrlEncodedTarget> {
 impl<'output, Target: 'output + UrlEncodedTarget> Serializer<'output, Target> {
     /// Returns a new `Serializer`.
     pub fn new(urlencoder: &'output mut UrlEncodedSerializer<Target>) -> Self {
-        Serializer { urlencoder: urlencoder }
+        Serializer {
+            urlencoder: urlencoder,
+        }
     }
 }
 
@@ -137,7 +139,8 @@ pub struct StructVariantSerializer<'output, T: 'output + UrlEncodedTarget> {
 }
 
 impl<'output, Target> ser::Serializer for Serializer<'output, Target>
-    where Target: 'output + UrlEncodedTarget,
+where
+    Target: 'output + UrlEncodedTarget,
 {
     type Ok = &'output mut UrlEncodedSerializer<Target>;
     type Error = Error;
@@ -225,38 +228,40 @@ impl<'output, Target> ser::Serializer for Serializer<'output, Target>
     }
 
     /// Returns an error.
-    fn serialize_unit_struct(self,
+    fn serialize_unit_struct(
-                             _name: &'static str)
+        self,
-                             -> Result<Self::Ok, Error> {
+        _name: &'static str,
+    ) -> Result<Self::Ok, Error> {
         Err(Error::top_level())
     }
 
     /// Returns an error.
-    fn serialize_unit_variant(self,
+    fn serialize_unit_variant(
-                              _name: &'static str,
+        self,
-                              _variant_index: u32,
+        _name: &'static str,
-                              _variant: &'static str)
+        _variant_index: u32,
-                              -> Result<Self::Ok, Error> {
+        _variant: &'static str,
+    ) -> Result<Self::Ok, Error> {
         Err(Error::top_level())
     }
 
     /// Serializes the inner value, ignoring the newtype name.
-    fn serialize_newtype_struct<T: ?Sized + ser::Serialize>
+    fn serialize_newtype_struct<T: ?Sized + ser::Serialize>(
-        (self,
+        self,
-         _name: &'static str,
+        _name: &'static str,
-         value: &T)
+        value: &T,
-         -> Result<Self::Ok, Error> {
+    ) -> Result<Self::Ok, Error> {
         value.serialize(self)
     }
 
     /// Returns an error.
-    fn serialize_newtype_variant<T: ?Sized + ser::Serialize>
+    fn serialize_newtype_variant<T: ?Sized + ser::Serialize>(
-        (self,
+        self,
-         _name: &'static str,
+        _name: &'static str,
-         _variant_index: u32,
+        _variant_index: u32,
-         _variant: &'static str,
+        _variant: &'static str,
-         _value: &T)
+        _value: &T,
-         -> Result<Self::Ok, Error> {
+    ) -> Result<Self::Ok, Error> {
         Err(Error::top_level())
     }
 
@@ -266,50 +271,58 @@ impl<'output, Target> ser::Serializer for Serializer<'output, Target>
     }
 
     /// Serializes the given value.
-    fn serialize_some<T: ?Sized + ser::Serialize>
+    fn serialize_some<T: ?Sized + ser::Serialize>(
-        (self,
+        self,
-         value: &T)
+        value: &T,
-         -> Result<Self::Ok, Error> {
+    ) -> Result<Self::Ok, Error> {
         value.serialize(self)
     }
 
     /// Serialize a sequence, given length (if any) is ignored.
-    fn serialize_seq(self,
+    fn serialize_seq(
-                     _len: Option<usize>)
+        self,
-                     -> Result<Self::SerializeSeq, Error> {
+        _len: Option<usize>,
-        Ok(SeqSerializer { urlencoder: self.urlencoder })
+    ) -> Result<Self::SerializeSeq, Error> {
+        Ok(SeqSerializer {
+            urlencoder: self.urlencoder,
+        })
     }
 
     /// Returns an error.
-    fn serialize_tuple(self,
+    fn serialize_tuple(
-                       _len: usize)
+        self,
-                       -> Result<Self::SerializeTuple, Error> {
+        _len: usize,
-        Ok(TupleSerializer { urlencoder: self.urlencoder })
+    ) -> Result<Self::SerializeTuple, Error> {
+        Ok(TupleSerializer {
+            urlencoder: self.urlencoder,
+        })
     }
 
     /// Returns an error.
-    fn serialize_tuple_struct(self,
+    fn serialize_tuple_struct(
-                              _name: &'static str,
+        self,
-                              _len: usize)
+        _name: &'static str,
-                              -> Result<Self::SerializeTupleStruct, Error> {
+        _len: usize,
+    ) -> Result<Self::SerializeTupleStruct, Error> {
         Err(Error::top_level())
     }
 
     /// Returns an error.
-    fn serialize_tuple_variant
+    fn serialize_tuple_variant(
-        (self,
+        self,
-         _name: &'static str,
+        _name: &'static str,
-         _variant_index: u32,
+        _variant_index: u32,
-         _variant: &'static str,
+        _variant: &'static str,
-         _len: usize)
+        _len: usize,
-         -> Result<Self::SerializeTupleVariant, Error> {
+    ) -> Result<Self::SerializeTupleVariant, Error> {
         Err(Error::top_level())
     }
 
     /// Serializes a map, given length is ignored.
-    fn serialize_map(self,
+    fn serialize_map(
-                     _len: Option<usize>)
+        self,
-                     -> Result<Self::SerializeMap, Error> {
+        _len: Option<usize>,
+    ) -> Result<Self::SerializeMap, Error> {
         Ok(MapSerializer {
             urlencoder: self.urlencoder,
             key: None,
@@ -317,34 +330,39 @@ impl<'output, Target> ser::Serializer for Serializer<'output, Target>
     }
 
     /// Serializes a struct, given length is ignored.
-    fn serialize_struct(self,
+    fn serialize_struct(
-                        _name: &'static str,
+        self,
-                        _len: usize)
+        _name: &'static str,
-                        -> Result<Self::SerializeStruct, Error> {
+        _len: usize,
-        Ok(StructSerializer { urlencoder: self.urlencoder })
+    ) -> Result<Self::SerializeStruct, Error> {
+        Ok(StructSerializer {
+            urlencoder: self.urlencoder,
+        })
     }
 
     /// Returns an error.
-    fn serialize_struct_variant
+    fn serialize_struct_variant(
-        (self,
+        self,
-         _name: &'static str,
+        _name: &'static str,
-         _variant_index: u32,
+        _variant_index: u32,
-         _variant: &'static str,
+        _variant: &'static str,
-         _len: usize)
+        _len: usize,
-         -> Result<Self::SerializeStructVariant, Error> {
+    ) -> Result<Self::SerializeStructVariant, Error> {
         Err(Error::top_level())
     }
 }
 
 impl<'output, Target> ser::SerializeSeq for SeqSerializer<'output, Target>
-    where Target: 'output + UrlEncodedTarget,
+where
+    Target: 'output + UrlEncodedTarget,
 {
     type Ok = &'output mut UrlEncodedSerializer<Target>;
     type Error = Error;
 
-    fn serialize_element<T: ?Sized + ser::Serialize>(&mut self,
+    fn serialize_element<T: ?Sized + ser::Serialize>(
-                                                     value: &T)
+        &mut self,
-                                                     -> Result<(), Error> {
+        value: &T,
+    ) -> Result<(), Error> {
         value.serialize(pair::PairSerializer::new(self.urlencoder))
     }
 
@@ -354,14 +372,16 @@ impl<'output, Target> ser::SerializeSeq for SeqSerializer<'output, Target>
 }
 
 impl<'output, Target> ser::SerializeTuple for TupleSerializer<'output, Target>
-    where Target: 'output + UrlEncodedTarget,
+where
+    Target: 'output + UrlEncodedTarget,
 {
     type Ok = &'output mut UrlEncodedSerializer<Target>;
     type Error = Error;
 
-    fn serialize_element<T: ?Sized + ser::Serialize>(&mut self,
+    fn serialize_element<T: ?Sized + ser::Serialize>(
-                                                     value: &T)
+        &mut self,
-                                                     -> Result<(), Error> {
+        value: &T,
+    ) -> Result<(), Error> {
         value.serialize(pair::PairSerializer::new(self.urlencoder))
     }
 
@@ -371,16 +391,17 @@ impl<'output, Target> ser::SerializeTuple for TupleSerializer<'output, Target>
 }
 
 impl<'output, Target> ser::SerializeTupleStruct
-    for
+    for TupleStructSerializer<'output, Target>
-    TupleStructSerializer<'output, Target>
+where
-    where Target: 'output + UrlEncodedTarget,
+    Target: 'output + UrlEncodedTarget,
 {
     type Ok = &'output mut UrlEncodedSerializer<Target>;
     type Error = Error;
 
-    fn serialize_field<T: ?Sized + ser::Serialize>(&mut self,
+    fn serialize_field<T: ?Sized + ser::Serialize>(
-                                                   value: &T)
+        &mut self,
-                                                   -> Result<(), Error> {
+        value: &T,
+    ) -> Result<(), Error> {
         self.inner.serialize_field(value)
     }
 
@@ -390,16 +411,17 @@ impl<'output, Target> ser::SerializeTupleStruct
 }
 
 impl<'output, Target> ser::SerializeTupleVariant
-    for
+    for TupleVariantSerializer<'output, Target>
-    TupleVariantSerializer<'output, Target>
+where
-    where Target: 'output + UrlEncodedTarget,
+    Target: 'output + UrlEncodedTarget,
 {
     type Ok = &'output mut UrlEncodedSerializer<Target>;
     type Error = Error;
 
-    fn serialize_field<T: ?Sized + ser::Serialize>(&mut self,
+    fn serialize_field<T: ?Sized + ser::Serialize>(
-                                                   value: &T)
+        &mut self,
-                                                   -> Result<(), Error> {
+        value: &T,
+    ) -> Result<(), Error> {
         self.inner.serialize_field(value)
     }
 
@@ -409,16 +431,20 @@ impl<'output, Target> ser::SerializeTupleVariant
 }
 
 impl<'output, Target> ser::SerializeMap for MapSerializer<'output, Target>
-    where Target: 'output + UrlEncodedTarget,
+where
+    Target: 'output + UrlEncodedTarget,
 {
     type Ok = &'output mut UrlEncodedSerializer<Target>;
     type Error = Error;
 
-    fn serialize_entry<K: ?Sized + ser::Serialize, V: ?Sized + ser::Serialize>
+    fn serialize_entry<
-        (&mut self,
+        K: ?Sized + ser::Serialize,
-         key: &K,
+        V: ?Sized + ser::Serialize,
-         value: &V)
+    >(
-         -> Result<(), Error> {
+        &mut self,
+        key: &K,
+        value: &V,
+    ) -> Result<(), Error> {
         let key_sink = key::KeySink::new(|key| {
             let value_sink = value::ValueSink::new(self.urlencoder, &key);
             value.serialize(part::PartSerializer::new(value_sink))?;
@@ -429,18 +455,20 @@ impl<'output, Target> ser::SerializeMap for MapSerializer<'output, Target>
         key.serialize(entry_serializer)
     }
 
-    fn serialize_key<T: ?Sized + ser::Serialize>(&mut self,
+    fn serialize_key<T: ?Sized + ser::Serialize>(
-                                                 key: &T)
+        &mut self,
-                                                 -> Result<(), Error> {
+        key: &T,
+    ) -> Result<(), Error> {
         let key_sink = key::KeySink::new(|key| Ok(key.into()));
         let key_serializer = part::PartSerializer::new(key_sink);
         self.key = Some(key.serialize(key_serializer)?);
         Ok(())
     }
 
-    fn serialize_value<T: ?Sized + ser::Serialize>(&mut self,
+    fn serialize_value<T: ?Sized + ser::Serialize>(
-                                                   value: &T)
+        &mut self,
-                                                   -> Result<(), Error> {
+        value: &T,
+    ) -> Result<(), Error> {
         {
             let key = self.key.as_ref().ok_or_else(|| Error::no_key())?;
             let value_sink = value::ValueSink::new(self.urlencoder, &key);
@@ -456,15 +484,17 @@ impl<'output, Target> ser::SerializeMap for MapSerializer<'output, Target>
 }
 
 impl<'output, Target> ser::SerializeStruct for StructSerializer<'output, Target>
-    where Target: 'output + UrlEncodedTarget,
+where
+    Target: 'output + UrlEncodedTarget,
 {
     type Ok = &'output mut UrlEncodedSerializer<Target>;
     type Error = Error;
 
-    fn serialize_field<T: ?Sized + ser::Serialize>(&mut self,
+    fn serialize_field<T: ?Sized + ser::Serialize>(
-                                                   key: &'static str,
+        &mut self,
-                                                   value: &T)
+        key: &'static str,
-                                                   -> Result<(), Error> {
+        value: &T,
+    ) -> Result<(), Error> {
         let value_sink = value::ValueSink::new(self.urlencoder, key);
         value.serialize(part::PartSerializer::new(value_sink))
     }
@@ -475,17 +505,18 @@ impl<'output, Target> ser::SerializeStruct for StructSerializer<'output, Target>
 }
 
 impl<'output, Target> ser::SerializeStructVariant
-    for
+    for StructVariantSerializer<'output, Target>
-    StructVariantSerializer<'output, Target>
+where
-    where Target: 'output + UrlEncodedTarget,
+    Target: 'output + UrlEncodedTarget,
 {
     type Ok = &'output mut UrlEncodedSerializer<Target>;
     type Error = Error;
 
-    fn serialize_field<T: ?Sized + ser::Serialize>(&mut self,
+    fn serialize_field<T: ?Sized + ser::Serialize>(
-                                                   key: &'static str,
+        &mut self,
-                                                   value: &T)
+        key: &'static str,
-                                                   -> Result<(), Error> {
+        value: &T,
+    ) -> Result<(), Error> {
         self.inner.serialize_field(key, value)
     }
 

src/ser/pair.rs

@@ -1,7 +1,7 @@
-use ser::Error;
 use ser::key::KeySink;
 use ser::part::PartSerializer;
 use ser::value::ValueSink;
+use ser::Error;
 use serde::ser;
 use std::borrow::Cow;
 use std::mem;
@@ -14,7 +14,8 @@ pub struct PairSerializer<'target, Target: 'target + UrlEncodedTarget> {
 }
 
 impl<'target, Target> PairSerializer<'target, Target>
-    where Target: 'target + UrlEncodedTarget,
+where
+    Target: 'target + UrlEncodedTarget,
 {
     pub fn new(urlencoder: &'target mut UrlEncodedSerializer<Target>) -> Self {
         PairSerializer {
@@ -25,7 +26,8 @@ impl<'target, Target> PairSerializer<'target, Target>
 }
 
 impl<'target, Target> ser::Serializer for PairSerializer<'target, Target>
-    where Target: 'target + UrlEncodedTarget,
+where
+    Target: 'target + UrlEncodedTarget,
 {
     type Ok = ();
     type Error = Error;
@@ -101,29 +103,30 @@ impl<'target, Target> ser::Serializer for PairSerializer<'target, Target>
         Err(Error::unsupported_pair())
     }
 
-    fn serialize_unit_variant(self,
+    fn serialize_unit_variant(
-                              _name: &'static str,
+        self,
-                              _variant_index: u32,
+        _name: &'static str,
-                              _variant: &'static str)
+        _variant_index: u32,
-                              -> Result<(), Error> {
+        _variant: &'static str,
+    ) -> Result<(), Error> {
         Err(Error::unsupported_pair())
     }
 
-    fn serialize_newtype_struct<T: ?Sized + ser::Serialize>
+    fn serialize_newtype_struct<T: ?Sized + ser::Serialize>(
-        (self,
+        self,
-         _name: &'static str,
+        _name: &'static str,
-         value: &T)
+        value: &T,
-         -> Result<(), Error> {
+    ) -> Result<(), Error> {
         value.serialize(self)
     }
 
-    fn serialize_newtype_variant<T: ?Sized + ser::Serialize>
+    fn serialize_newtype_variant<T: ?Sized + ser::Serialize>(
-        (self,
+        self,
-         _name: &'static str,
+        _name: &'static str,
-         _variant_index: u32,
+        _variant_index: u32,
-         _variant: &'static str,
+        _variant: &'static str,
-         _value: &T)
+        _value: &T,
-         -> Result<(), Error> {
+    ) -> Result<(), Error> {
         Err(Error::unsupported_pair())
     }
 
@@ -131,15 +134,17 @@ impl<'target, Target> ser::Serializer for PairSerializer<'target, Target>
         Ok(())
     }
 
-    fn serialize_some<T: ?Sized + ser::Serialize>(self,
+    fn serialize_some<T: ?Sized + ser::Serialize>(
-                                                  value: &T)
+        self,
-                                                  -> Result<(), Error> {
+        value: &T,
+    ) -> Result<(), Error> {
         value.serialize(self)
     }
 
-    fn serialize_seq(self,
+    fn serialize_seq(
-                     _len: Option<usize>)
+        self,
-                     -> Result<Self::SerializeSeq, Error> {
+        _len: Option<usize>,
+    ) -> Result<Self::SerializeSeq, Error> {
         Err(Error::unsupported_pair())
     }
 
@@ -151,56 +156,61 @@ impl<'target, Target> ser::Serializer for PairSerializer<'target, Target>
         }
     }
 
-    fn serialize_tuple_struct(self,
+    fn serialize_tuple_struct(
-                              _name: &'static str,
+        self,
-                              _len: usize)
+        _name: &'static str,
-                              -> Result<Self::SerializeTupleStruct, Error> {
+        _len: usize,
+    ) -> Result<Self::SerializeTupleStruct, Error> {
         Err(Error::unsupported_pair())
     }
 
-    fn serialize_tuple_variant
+    fn serialize_tuple_variant(
-        (self,
+        self,
-         _name: &'static str,
+        _name: &'static str,
-         _variant_index: u32,
+        _variant_index: u32,
-         _variant: &'static str,
+        _variant: &'static str,
-         _len: usize)
+        _len: usize,
-         -> Result<Self::SerializeTupleVariant, Error> {
+    ) -> Result<Self::SerializeTupleVariant, Error> {
         Err(Error::unsupported_pair())
     }
 
-    fn serialize_map(self,
+    fn serialize_map(
-                     _len: Option<usize>)
+        self,
-                     -> Result<Self::SerializeMap, Error> {
+        _len: Option<usize>,
+    ) -> Result<Self::SerializeMap, Error> {
         Err(Error::unsupported_pair())
     }
 
-    fn serialize_struct(self,
+    fn serialize_struct(
-                        _name: &'static str,
+        self,
-                        _len: usize)
+        _name: &'static str,
-                        -> Result<Self::SerializeStruct, Error> {
+        _len: usize,
+    ) -> Result<Self::SerializeStruct, Error> {
         Err(Error::unsupported_pair())
     }
 
-    fn serialize_struct_variant
+    fn serialize_struct_variant(
-        (self,
+        self,
-         _name: &'static str,
+        _name: &'static str,
-         _variant_index: u32,
+        _variant_index: u32,
-         _variant: &'static str,
+        _variant: &'static str,
-         _len: usize)
+        _len: usize,
-         -> Result<Self::SerializeStructVariant, Error> {
+    ) -> Result<Self::SerializeStructVariant, Error> {
         Err(Error::unsupported_pair())
     }
 }
 
 impl<'target, Target> ser::SerializeTuple for PairSerializer<'target, Target>
-    where Target: 'target + UrlEncodedTarget,
+where
+    Target: 'target + UrlEncodedTarget,
 {
     type Ok = ();
     type Error = Error;
 
-    fn serialize_element<T: ?Sized + ser::Serialize>(&mut self,
+    fn serialize_element<T: ?Sized + ser::Serialize>(
-                                                     value: &T)
+        &mut self,
-                                                     -> Result<(), Error> {
+        value: &T,
+    ) -> Result<(), Error> {
         match mem::replace(&mut self.state, PairState::Done) {
             PairState::WaitingForKey => {
                 let key_sink = KeySink::new(|key| Ok(key.into()));

src/ser/part.rs

@@ -17,18 +17,19 @@ impl<S: Sink> PartSerializer<S> {
 pub trait Sink: Sized {
     type Ok;
 
-    fn serialize_static_str(self,
+    fn serialize_static_str(
-                            value: &'static str)
+        self,
-                            -> Result<Self::Ok, Error>;
+        value: &'static str,
+    ) -> Result<Self::Ok, Error>;
 
     fn serialize_str(self, value: &str) -> Result<Self::Ok, Error>;
     fn serialize_string(self, value: String) -> Result<Self::Ok, Error>;
     fn serialize_none(self) -> Result<Self::Ok, Error>;
 
-    fn serialize_some<T: ?Sized + ser::Serialize>
+    fn serialize_some<T: ?Sized + ser::Serialize>(
-        (self,
+        self,
-         value: &T)
+        value: &T,
-         -> Result<Self::Ok, Error>;
+    ) -> Result<Self::Ok, Error>;
 
     fn unsupported(self) -> Error;
 }
@@ -45,7 +46,8 @@ impl<S: Sink> ser::Serializer for PartSerializer<S> {
     type SerializeStructVariant = ser::Impossible<S::Ok, Error>;
 
     fn serialize_bool(self, v: bool) -> Result<S::Ok, Error> {
-        self.sink.serialize_static_str(if v { "true" } else { "false" })
+        self.sink
+            .serialize_static_str(if v { "true" } else { "false" })
     }
 
     fn serialize_i8(self, v: i8) -> Result<S::Ok, Error> {
@@ -111,29 +113,30 @@ impl<S: Sink> ser::Serializer for PartSerializer<S> {
         self.sink.serialize_static_str(name.into())
     }
 
-    fn serialize_unit_variant(self,
+    fn serialize_unit_variant(
-                              _name: &'static str,
+        self,
-                              _variant_index: u32,
+        _name: &'static str,
-                              variant: &'static str)
+        _variant_index: u32,
-                              -> Result<S::Ok, Error> {
+        variant: &'static str,
+    ) -> Result<S::Ok, Error> {
         self.sink.serialize_static_str(variant.into())
     }
 
-    fn serialize_newtype_struct<T: ?Sized + ser::Serialize>
+    fn serialize_newtype_struct<T: ?Sized + ser::Serialize>(
-        (self,
+        self,
-         _name: &'static str,
+        _name: &'static str,
-         value: &T)
+        value: &T,
-         -> Result<S::Ok, Error> {
+    ) -> Result<S::Ok, Error> {
         value.serialize(self)
     }
 
-    fn serialize_newtype_variant<T: ?Sized + ser::Serialize>
+    fn serialize_newtype_variant<T: ?Sized + ser::Serialize>(
-        (self,
+        self,
-         _name: &'static str,
+        _name: &'static str,
-         _variant_index: u32,
+        _variant_index: u32,
-         _variant: &'static str,
+        _variant: &'static str,
-         _value: &T)
+        _value: &T,
-         -> Result<S::Ok, Error> {
+    ) -> Result<S::Ok, Error> {
         Err(self.sink.unsupported())
     }
 
@@ -141,68 +144,75 @@ impl<S: Sink> ser::Serializer for PartSerializer<S> {
         self.sink.serialize_none()
     }
 
-    fn serialize_some<T: ?Sized + ser::Serialize>(self,
+    fn serialize_some<T: ?Sized + ser::Serialize>(
-                                                  value: &T)
+        self,
-                                                  -> Result<S::Ok, Error> {
+        value: &T,
+    ) -> Result<S::Ok, Error> {
         self.sink.serialize_some(value)
     }
 
-    fn serialize_seq(self,
+    fn serialize_seq(
-                     _len: Option<usize>)
+        self,
-                     -> Result<Self::SerializeSeq, Error> {
+        _len: Option<usize>,
+    ) -> Result<Self::SerializeSeq, Error> {
         Err(self.sink.unsupported())
     }
 
-    fn serialize_tuple(self,
+    fn serialize_tuple(
-                       _len: usize)
+        self,
-                       -> Result<Self::SerializeTuple, Error> {
+        _len: usize,
+    ) -> Result<Self::SerializeTuple, Error> {
         Err(self.sink.unsupported())
     }
 
-    fn serialize_tuple_struct(self,
+    fn serialize_tuple_struct(
-                              _name: &'static str,
+        self,
-                              _len: usize)
+        _name: &'static str,
-                              -> Result<Self::SerializeTuple, Error> {
+        _len: usize,
+    ) -> Result<Self::SerializeTuple, Error> {
         Err(self.sink.unsupported())
     }
 
-    fn serialize_tuple_variant
+    fn serialize_tuple_variant(
-        (self,
+        self,
-         _name: &'static str,
+        _name: &'static str,
-         _variant_index: u32,
+        _variant_index: u32,
-         _variant: &'static str,
+        _variant: &'static str,
-         _len: usize)
+        _len: usize,
-         -> Result<Self::SerializeTupleVariant, Error> {
+    ) -> Result<Self::SerializeTupleVariant, Error> {
         Err(self.sink.unsupported())
     }
 
-    fn serialize_map(self,
+    fn serialize_map(
-                     _len: Option<usize>)
+        self,
-                     -> Result<Self::SerializeMap, Error> {
+        _len: Option<usize>,
+    ) -> Result<Self::SerializeMap, Error> {
         Err(self.sink.unsupported())
     }
 
-    fn serialize_struct(self,
+    fn serialize_struct(
-                        _name: &'static str,
+        self,
-                        _len: usize)
+        _name: &'static str,
-                        -> Result<Self::SerializeStruct, Error> {
+        _len: usize,
+    ) -> Result<Self::SerializeStruct, Error> {
         Err(self.sink.unsupported())
     }
 
-    fn serialize_struct_variant
+    fn serialize_struct_variant(
-        (self,
+        self,
-         _name: &'static str,
+        _name: &'static str,
-         _variant_index: u32,
+        _variant_index: u32,
-         _variant: &'static str,
+        _variant: &'static str,
-         _len: usize)
+        _len: usize,
-         -> Result<Self::SerializeStructVariant, Error> {
+    ) -> Result<Self::SerializeStructVariant, Error> {
         Err(self.sink.unsupported())
     }
 }
 
 impl<S: Sink> PartSerializer<S> {
     fn serialize_integer<I>(self, value: I) -> Result<S::Ok, Error>
-        where I: itoa::Integer,
+    where
+        I: itoa::Integer,
     {
         let mut buf = [b'\0'; 20];
         let len = itoa::write(&mut buf[..], value).unwrap();
@@ -211,7 +221,8 @@ impl<S: Sink> PartSerializer<S> {
     }
 
     fn serialize_floating<F>(self, value: F) -> Result<S::Ok, Error>
-        where F: dtoa::Floating,
+    where
+        F: dtoa::Floating,
     {
         let mut buf = [b'\0'; 24];
         let len = dtoa::write(&mut buf[..], value).unwrap();

src/ser/value.rs

@@ -1,23 +1,26 @@
-use ser::Error;
 use ser::part::{PartSerializer, Sink};
+use ser::Error;
 use serde::ser::Serialize;
 use std::str;
 use url::form_urlencoded::Serializer as UrlEncodedSerializer;
 use url::form_urlencoded::Target as UrlEncodedTarget;
 
 pub struct ValueSink<'key, 'target, Target>
-    where Target: 'target + UrlEncodedTarget,
+where
+    Target: 'target + UrlEncodedTarget,
 {
     urlencoder: &'target mut UrlEncodedSerializer<Target>,
     key: &'key str,
 }
 
 impl<'key, 'target, Target> ValueSink<'key, 'target, Target>
-    where Target: 'target + UrlEncodedTarget,
+where
+    Target: 'target + UrlEncodedTarget,
 {
-    pub fn new(urlencoder: &'target mut UrlEncodedSerializer<Target>,
+    pub fn new(
-               key: &'key str)
+        urlencoder: &'target mut UrlEncodedSerializer<Target>,
-               -> Self {
+        key: &'key str,
+    ) -> Self {
         ValueSink {
             urlencoder: urlencoder,
             key: key,
@@ -26,7 +29,8 @@ impl<'key, 'target, Target> ValueSink<'key, 'target, Target>
 }
 
 impl<'key, 'target, Target> Sink for ValueSink<'key, 'target, Target>
-    where Target: 'target + UrlEncodedTarget,
+where
+    Target: 'target + UrlEncodedTarget,
 {
     type Ok = ();
 
@@ -47,9 +51,10 @@ impl<'key, 'target, Target> Sink for ValueSink<'key, 'target, Target>
         Ok(())
     }
 
-    fn serialize_some<T: ?Sized + Serialize>(self,
+    fn serialize_some<T: ?Sized + Serialize>(
-                                             value: &T)
+        self,
-                                             -> Result<Self::Ok, Error> {
+        value: &T,
+    ) -> Result<Self::Ok, Error> {
         value.serialize(PartSerializer::new(self))
     }
 

tests/test_deserialize.rs

@@ -9,32 +9,34 @@ struct NewType<T>(T);
 fn deserialize_newtype_i32() {
     let result = vec![("field".to_owned(), NewType(11))];
 
-    assert_eq!(serde_urlencoded::from_str("field=11"),
+    assert_eq!(serde_urlencoded::from_str("field=11"), Ok(result));
-               Ok(result));
 }
 
 #[test]
 fn deserialize_bytes() {
     let result = vec![("first".to_owned(), 23), ("last".to_owned(), 42)];
 
-    assert_eq!(serde_urlencoded::from_bytes(b"first=23&last=42"),
+    assert_eq!(
-               Ok(result));
+        serde_urlencoded::from_bytes(b"first=23&last=42"),
+        Ok(result)
+    );
 }
 
 #[test]
 fn deserialize_str() {
     let result = vec![("first".to_owned(), 23), ("last".to_owned(), 42)];
 
-    assert_eq!(serde_urlencoded::from_str("first=23&last=42"),
+    assert_eq!(serde_urlencoded::from_str("first=23&last=42"), Ok(result));
-               Ok(result));
 }
 
 #[test]
 fn deserialize_reader() {
     let result = vec![("first".to_owned(), 23), ("last".to_owned(), 42)];
 
-    assert_eq!(serde_urlencoded::from_reader(b"first=23&last=42" as &[_]),
+    assert_eq!(
-               Ok(result));
+        serde_urlencoded::from_reader(b"first=23&last=42" as &[_]),
+        Ok(result)
+    );
 }
 
 #[test]
@@ -66,8 +68,11 @@ fn deserialize_unit_enum() {
     let result = vec![
         ("one".to_owned(), X::A),
         ("two".to_owned(), X::B),
-        ("three".to_owned(), X::C)
+        ("three".to_owned(), X::C),
     ];
 
-    assert_eq!(serde_urlencoded::from_str("one=A&two=B&three=C"), Ok(result));
+    assert_eq!(
+        serde_urlencoded::from_str("one=A&two=B&three=C"),
+        Ok(result)
+    );
 }

tests/test_serialize.rs

@@ -7,7 +7,7 @@ struct NewType<T>(T);
 
 #[test]
 fn serialize_newtype_i32() {
-    let params = &[("field", Some(NewType(11))),];
+    let params = &[("field", Some(NewType(11)))];
     assert_eq!(
         serde_urlencoded::to_string(params),
         Ok("field=11".to_owned())
@@ -18,33 +18,44 @@ fn serialize_newtype_i32() {
 fn serialize_option_map_int() {
     let params = &[("first", Some(23)), ("middle", None), ("last", Some(42))];
 
-    assert_eq!(serde_urlencoded::to_string(params),
+    assert_eq!(
-               Ok("first=23&last=42".to_owned()));
+        serde_urlencoded::to_string(params),
+        Ok("first=23&last=42".to_owned())
+    );
 }
 
 #[test]
 fn serialize_option_map_string() {
-    let params =
+    let params = &[
-        &[("first", Some("hello")), ("middle", None), ("last", Some("world"))];
+        ("first", Some("hello")),
+        ("middle", None),
+        ("last", Some("world")),
+    ];
 
-    assert_eq!(serde_urlencoded::to_string(params),
+    assert_eq!(
-               Ok("first=hello&last=world".to_owned()));
+        serde_urlencoded::to_string(params),
+        Ok("first=hello&last=world".to_owned())
+    );
 }
 
 #[test]
 fn serialize_option_map_bool() {
     let params = &[("one", Some(true)), ("two", Some(false))];
 
-    assert_eq!(serde_urlencoded::to_string(params),
+    assert_eq!(
-               Ok("one=true&two=false".to_owned()));
+        serde_urlencoded::to_string(params),
+        Ok("one=true&two=false".to_owned())
+    );
 }
 
 #[test]
 fn serialize_map_bool() {
     let params = &[("one", true), ("two", false)];
 
-    assert_eq!(serde_urlencoded::to_string(params),
+    assert_eq!(
-               Ok("one=true&two=false".to_owned()));
+        serde_urlencoded::to_string(params),
+        Ok("one=true&two=false".to_owned())
+    );
 }
 
 #[derive(Serialize)]
@@ -57,6 +68,8 @@ enum X {
 #[test]
 fn serialize_unit_enum() {
     let params = &[("one", X::A), ("two", X::B), ("three", X::C)];
-    assert_eq!(serde_urlencoded::to_string(params),
+    assert_eq!(
-               Ok("one=A&two=B&three=C".to_owned()));
+        serde_urlencoded::to_string(params),
+        Ok("one=A&two=B&three=C".to_owned())
+    );
 }