Rewrite of most components.

Simplify `ser` logic, and expand `de` functionality.

7 files changed, 813 insertions, 1009 deletions

diff --git a/src/de.rs b/src/de.rs
index def50ec..0306d21 100644
--- a/src/de.rs
+++ b/src/de.rs
@@ -1,14 +1,16 @@
 //! Deserialization support for querystrings.
 
+use data_encoding::base64;
+
 use serde::de;
 #[doc(inline)]
 pub use serde::de::value::Error;
 use serde::de::value::MapDeserializer;
+use url::percent_encoding;
 
 use std::collections::btree_map::{BTreeMap, Entry, IntoIter};
 use std::io::Read;
-use url::percent_encoding;
-
+use std::vec;
 /// To override the default serialization parameters, first construct a new
 /// Config.
 ///
@@ -390,8 +392,6 @@ impl<I: Iterator<Item = u8>> Parser<I> {
                             // key is simply "[]", so treat as a seq.
                             b']' => {
                                 self.acc.clear();
-                                // println!("Empty key => vector");
-                                // println!("{:?}", node);
                                 self.parse_seq_value(node)?;
                                 self.depth += 1;
                                 Ok(true)
@@ -400,8 +400,6 @@ impl<I: Iterator<Item = u8>> Parser<I> {
                             // Key is "[a..." so parse up to the closing "]"
                             0x20...0x7e => {
                                 let key = self.parse_key(b']', true)?;
-                                // key.into()
-                                // println!("key: {:?}", key);
                                 self.parse_map_value(key.into(), node)?;
                                 self.depth += 1;
                                 Ok(true)
@@ -498,6 +496,49 @@ impl<'de> de::Deserializer<'de> for Deserializer {
     {
         visitor.visit_seq(MapDeserializer::new(self.iter))
     }
+
+    fn deserialize_newtype_struct<V>(
+        self, 
+        _name: &'static str, 
+        visitor: V
+    ) -> Result<V::Value, Self::Error>
+        where V: de::Visitor<'de>
+    {
+        self.deserialize_map(visitor)
+    }
+
+    fn deserialize_tuple<V>(
+        self, 
+        _len: usize, 
+        visitor: V
+    ) -> Result<V::Value, Self::Error>
+        where V: de::Visitor<'de>
+    {
+        visitor.visit_seq(MapDeserializer::new(self.iter))
+
+    }
+    fn deserialize_tuple_struct<V>(
+        self, 
+        _name: &'static str, 
+        _len: usize, 
+        visitor: V
+    ) -> Result<V::Value, Self::Error>
+        where V: de::Visitor<'de>
+    {
+        visitor.visit_seq(MapDeserializer::new(self.iter))
+    }
+
+    fn deserialize_enum<V>(
+        self, 
+        _name: &'static str, 
+        _variants: &'static [&'static str], 
+        visitor: V
+    ) -> Result<V::Value, Self::Error>
+        where V: de::Visitor<'de>
+    {
+        visitor.visit_enum(self)
+    }
+
     forward_to_deserialize_any! {
         bool
         u8
@@ -520,13 +561,13 @@ impl<'de> de::Deserializer<'de> for Deserializer {
         unit_struct
         // seq
         // seq_fixed_size
-        newtype_struct
-        tuple_struct
+        // newtype_struct
+        // tuple_struct
         // struct
         identifier
         // struct_field
-        tuple
-        enum
+        // tuple
+        // enum
         ignored_any
     }
 }
@@ -546,7 +587,6 @@ impl<'de> de::MapAccess<'de> for Deserializer {
             return seed.deserialize(ParsableStringDeserializer(key)).map(Some);
         };
         Ok(None)
-
     }
 
     fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value, Error>
@@ -561,7 +601,99 @@ impl<'de> de::MapAccess<'de> for Deserializer {
     }
 }
 
-struct LevelDeserializer(Level);
+impl<'de> de::EnumAccess<'de> for Deserializer {
+    type Error =  Error;
+    type Variant = LevelDeserializer;
+
+    fn variant_seed<V>(mut self, seed: V) -> Result<(V::Value, Self::Variant), Self::Error>
+        where V: de::DeserializeSeed<'de>
+    {
+        if let Some((key, value)) = self.iter.next() {
+            Ok((seed.deserialize(ParsableStringDeserializer(key))?, LevelDeserializer(value)))
+        } else {
+            Err(de::Error::custom("No more values"))
+        }
+    }
+}
+
+impl<'de> de::EnumAccess<'de> for LevelDeserializer {
+    type Error =  Error;
+    type Variant = Self;
+
+    fn variant_seed<V>(self, seed: V) -> Result<(V::Value, Self::Variant), Self::Error>
+        where V: de::DeserializeSeed<'de>
+    {
+        match self.0 {
+            // Level::Nested(map) => {
+            //     Deserializer::with_map(map).variant_seed(seed)
+            // },
+            // Level::Sequence(_) => {
+            //     Err(de::Error::custom(format!("Expected Enum (map or a flat value), got a Sequence")))
+            // },
+            Level::Flat(x) => {
+                Ok((seed.deserialize(ParsableStringDeserializer(x))?, LevelDeserializer(Level::Invalid(""))))
+            },
+            _ => {
+                Err(de::Error::custom("should not be here..."))
+            }
+        }
+    }
+}
+
+impl<'de> de::VariantAccess<'de> for LevelDeserializer {
+    type Error = Error;
+    fn unit_variant(self) -> Result<(), Self::Error> {
+        Ok(())
+    }
+
+    fn newtype_variant_seed<T>(self, seed: T) -> Result<T::Value, Self::Error>
+    where
+        T: de::DeserializeSeed<'de>
+    {
+        seed.deserialize(self)
+
+    }
+    fn tuple_variant<V>(
+        self, 
+        _len: usize, 
+        visitor: V
+    ) -> Result<V::Value, Self::Error>
+    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, Self::Error>
+    where
+        V: de::Visitor<'de>
+    {
+        de::Deserializer::deserialize_map(self, visitor)
+    }
+}
+
+struct LevelSeq<I: Iterator<Item=Level>>(I);
+
+impl<'de, I: Iterator<Item=Level>> de::SeqAccess<'de> for LevelSeq<I> {
+    type Error = Error;
+    fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Error>
+        where T: de::DeserializeSeed<'de>
+    {
+        if let Some(v) = self.0.next() {
+            seed.deserialize(v.into_deserializer()).map(Some)
+        } else {
+            Ok(None)
+        }
+    }
+}
+
+
+
+pub struct LevelDeserializer(Level);
 
 macro_rules! deserialize_primitive {
     ($ty:ident, $method:ident, $visit_method:ident) => (
@@ -588,6 +720,22 @@ macro_rules! deserialize_primitive {
     )
 }
 
+impl LevelDeserializer {
+    fn to_deserializer(self) -> Result<Deserializer, Error> {
+        match self.0 {
+            Level::Nested(map) => {
+                Ok(Deserializer::with_map(map))
+            },
+            Level::Invalid(e) => {
+                Err(de::Error::custom(e))
+            }
+            l => {
+                Err(de::Error::custom(format!("could not convert {:?} to Deserializer", l)))
+            },
+        }
+    }
+}
+
 impl<'de> de::Deserializer<'de> for LevelDeserializer {
     type Error = Error;
 
@@ -610,45 +758,25 @@ impl<'de> de::Deserializer<'de> for LevelDeserializer {
         }
     }
 
-    fn deserialize_map<V>(self, visitor: V) -> Result<V::Value, Self::Error>
-        where V: de::Visitor<'de>,
-    {
-        if let Level::Nested(x) = self.0 {
-            Deserializer::with_map(x).deserialize_map(visitor)
-        } else {
-            Err(de::Error::custom(format!("value: {:?} does not appear to \
-                                           be a map",
-                                          self.0)))
-        }
-    }
-
-    fn deserialize_struct<V>(self,
-                             _name: &'static str,
-                             _fields: &'static [&'static str],
-                             visitor: V)
-                             -> Result<V::Value, Self::Error>
-        where V: de::Visitor<'de>,
-    {
-
-        self.deserialize_map(visitor)
-    }
-
     fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value, Self::Error>
         where V: de::Visitor<'de>,
     {
         match self.0 {
             Level::Nested(map) => {
-                SeqDeserializer::new(map.into_iter().map(|(_k, v)| v))
-                    .deserialize_any(visitor)
+                visitor.visit_seq(LevelSeq(map.into_iter().map(|(_k, v)| v)))
+
+                // SeqDeserializer::new()
+                    // .deserialize_any(visitor)
             },
             Level::Sequence(x) => {
-                SeqDeserializer::new(x.into_iter()).deserialize_any(visitor)
+                // SeqDeserializer::new(x.into_iter()).deserialize_any(visitor)
+                visitor.visit_seq(LevelSeq(x.into_iter()))
             },
-            Level::Flat(x) => {
-                SeqDeserializer::new(vec![x].into_iter()).deserialize_any(visitor)
+            Level::Invalid(e) => {
+                Err(de::Error::custom(e))
             },
-            _ => {
-                Err(de::Error::custom("value does not appear to be a sequence"))
+            x => {
+                visitor.visit_seq(LevelSeq(vec![x].into_iter()))
             },
         }
     }
@@ -666,6 +794,76 @@ impl<'de> de::Deserializer<'de> for LevelDeserializer {
         }
     }
 
+    fn deserialize_enum<V>(
+        self, 
+        name: &'static str, 
+        variants: &'static [&'static str], 
+        visitor: V
+    ) -> Result<V::Value, Self::Error>
+        where V: de::Visitor<'de>
+    {
+        match self.0 {
+            Level::Nested(map) => {
+                 Deserializer::with_map(map).deserialize_enum(name, variants, visitor)
+            },
+            Level::Flat(_) => {
+                visitor.visit_enum(self)
+            },
+            _ => {
+                Err(de::Error::custom("value does not appear to be a sequence"))
+            },
+        }
+    }
+
+    fn deserialize_map<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+        where V: de::Visitor<'de>,
+    {
+        self.to_deserializer()?.deserialize_map(visitor)
+
+    }
+
+    fn deserialize_struct<V>(self,
+                             name: &'static str,
+                             fields: &'static [&'static str],
+                             visitor: V)
+                             -> Result<V::Value, Self::Error>
+        where V: de::Visitor<'de>,
+    {
+        self.to_deserializer()?.deserialize_struct(name, fields, visitor)
+    }
+
+    fn deserialize_newtype_struct<V>(
+        self, 
+        _name: &'static str, 
+        visitor: V
+    ) -> Result<V::Value, Self::Error>
+        where V: de::Visitor<'de>
+    {
+        self.deserialize_seq(visitor)
+    }
+
+    fn deserialize_tuple<V>(
+        self, 
+        _len: usize, 
+        visitor: V
+    ) -> Result<V::Value, Self::Error>
+        where V: de::Visitor<'de>
+    {
+        // self.to_deserializer()?.deserialize_tuple(len, visitor)
+        self.deserialize_seq(visitor)
+
+    }
+    fn deserialize_tuple_struct<V>(
+        self, 
+        _name: &'static str, 
+        _len: usize, 
+        visitor: V
+    ) -> Result<V::Value, Self::Error>
+        where V: de::Visitor<'de>
+    {
+        self.deserialize_seq(visitor)
+    }
+
     deserialize_primitive!(bool, deserialize_bool, visit_bool);
     deserialize_primitive!(i8,  deserialize_i8, visit_i8);
     deserialize_primitive!(i16, deserialize_i16, visit_i16);
@@ -687,11 +885,11 @@ impl<'de> de::Deserializer<'de> for LevelDeserializer {
         bytes
         byte_buf
         unit_struct
-        newtype_struct
-        tuple_struct
+        // newtype_struct
+        // tuple_struct
         identifier
-        tuple
-        enum
+        // tuple
+        // enum
         ignored_any
     }
 }
@@ -728,6 +926,7 @@ impl<'de> de::Deserializer<'de> for ParsableStringDeserializer {
         self.0.into_deserializer().deserialize_any(visitor)
     }
 
+
     forward_to_deserialize_any! {
         // bool
         // u8
diff --git a/src/lib.rs b/src/lib.rs
index d11e49f..7269046 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -59,7 +59,9 @@
 //! assert_eq!(rec_params, params);
 //!
 //! # }
-
+extern crate data_encoding;
+#[macro_use]
+extern crate error_chain;
 extern crate itoa;
 extern crate dtoa;
 #[macro_use]
@@ -72,4 +74,4 @@ pub mod ser;
 #[doc(inline)]
 pub use de::{Deserializer, from_bytes, from_reader, from_str};
 #[doc(inline)]
-pub use ser::{Serializer, to_string};
+pub use ser::{QsSerializer, to_string};
diff --git a/src/ser.rs b/src/ser.rs
new file mode 100644
index 0000000..fa49fda
--- /dev/null
+++ b/src/ser.rs
@@ -0,0 +1,564 @@
+
+//! Serialization support for querystrings.
+
+use serde::ser;
+use url::form_urlencoded::Serializer as UrlEncodedSerializer;
+use url::form_urlencoded::Target as UrlEncodedTarget;
+
+use std::fmt::Display;
+use std::borrow::Cow;
+use std::str;
+
+/// Serializes a value into a querystring.
+///
+/// ```
+/// # #[macro_use]
+/// # extern crate serde_derive;
+/// # extern crate serde_qs;
+/// #[derive(Deserialize, Serialize)]
+/// struct Query {
+///     name: String,
+///     age: u8,
+///     occupation: String,
+/// }
+///
+/// # fn main(){
+/// let q =  Query {
+///     name: "Alice".to_owned(),
+///     age: 24,
+///     occupation: "Student".to_owned(),
+/// };
+///
+///
+/// assert_eq!(
+///     serde_qs::to_string(&q).unwrap(),
+///     "name=Alice&age=24&occupation=Student");
+/// # }
+/// ```
+pub fn to_string<T: ser::Serialize>(input: &T) -> Result<String> {
+    let mut urlencoder = UrlEncodedSerializer::new("".to_owned());
+    input.serialize(&mut QsSerializer { key: None, urlencoder: &mut urlencoder })?;
+    Ok(urlencoder.finish())
+}
+
+/// A serializer for the querystring format.
+///
+/// * Supported top-level inputs are structs and maps.
+///
+/// * Supported values are currently most primitive types, structs, maps and
+///   sequences. Sequences are serialized with an incrementing key index.
+///
+/// * Newtype structs defer to their inner values.
+pub struct QsSerializer<'a, Target: 'a + UrlEncodedTarget> {
+    key: Option<Cow<'static, str>>,
+    urlencoder: &'a mut UrlEncodedSerializer<Target>,
+}
+
+impl<'a, Target: 'a + UrlEncodedTarget> QsSerializer<'a, Target> {
+    fn extend_key(&mut self, newkey: &str) {
+        let key = if let Some(ref key) = self.key {
+            format!("{}[{}]", key, newkey).into()
+        } else {
+            newkey.to_owned().into()
+        };
+        self.key = Some(key)
+    }
+
+    fn write_value(&mut self, value: &str) -> Result<()> {
+        if let Some(ref key) = self.key {
+            self.urlencoder.append_pair(&key, value);
+            Ok(())
+        } else {
+            Err(Error::no_key())
+        }
+    }
+}
+
+error_chain!{
+    errors { 
+        Custom(msg: String)
+        Unsupported
+    }
+}
+
+impl Error {
+    fn top_level() -> Self {
+        let msg = "top-level serializer supports only maps and structs";
+        msg.into()
+    }
+
+    fn no_key() -> Self {
+        let msg = "tried to serialize a value before serializing key";
+        msg.into()
+    }
+}
+
+macro_rules! serialize_as_string {
+    (Qs $($ty:ty => $meth:ident,)*) => {
+        $(
+            fn $meth(self, v: $ty) -> Result<Self::Ok> {
+                self.write_value(&v.to_string())
+            }
+        )*
+    };
+    ($($ty:ty => $meth:ident,)*) => {
+        $(
+            fn $meth(self, v: $ty) -> Result<Self::Ok> {
+                Ok(v.to_string())
+            }
+        )*
+    };
+}
+
+impl<'a, Target: 'a + UrlEncodedTarget> ser::Serializer for &'a mut QsSerializer<'a, Target> {
+    type Ok = ();
+    type Error = Error;
+    type SerializeSeq = QsSeq<'a, Target>;
+    type SerializeTuple = QsSeq<'a, Target>;
+    type SerializeTupleStruct = QsSeq<'a, Target>;
+    type SerializeTupleVariant = QsSeq<'a, Target>;
+    type SerializeMap = QsMap<'a, Target>;
+    type SerializeStruct = Self;
+    type SerializeStructVariant = Self;
+
+    serialize_as_string!{
+        Qs
+        bool => serialize_bool,
+        u8  => serialize_u8,
+        u16 => serialize_u16,
+        u32 => serialize_u32,
+        u64 => serialize_u64,
+        i8  => serialize_i8,
+        i16 => serialize_i16,
+        i32 => serialize_i32,
+        i64 => serialize_i64,
+        f32 => serialize_f32,
+        f64 => serialize_f64,
+        char => serialize_char,
+        &str => serialize_str,
+        // &[u8] => serialize_bytes,
+    }
+
+    fn serialize_bytes(self, _value: &[u8]) -> Result<Self::Ok> {
+        Err(Error::top_level())
+    }
+
+
+    fn serialize_unit(self) -> Result<Self::Ok> {
+        self.write_value("")
+    }
+
+    /// Returns an error.
+    fn serialize_unit_struct(self,
+                             name: &'static str)
+                             -> Result<Self::Ok> {
+        self.write_value(name)
+    }
+
+    /// Returns an error.
+    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> {
+        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> {
+        self.extend_key(variant);
+        value.serialize(self)
+    }
+
+    fn serialize_none(self) -> Result<Self::Ok> {
+        Ok(())
+    }
+
+    fn serialize_some<T: ?Sized + ser::Serialize>
+        (self,
+         value: &T)
+         -> Result<Self::Ok> {
+        // Err(ErrorKind::Unsupported.into())
+        value.serialize(self)
+    }
+
+    /// Returns an error.
+    fn serialize_seq(self,
+                     _len: Option<usize>)
+                     -> Result<Self::SerializeSeq> {
+        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> {
+        Ok(QsSeq(self, 0))
+    }
+
+    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))
+    }
+
+    fn serialize_map(self,
+                     _len: Option<usize>)
+                     -> Result<Self::SerializeMap> {
+        Ok(QsMap(self, None))
+    }
+
+    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> 
+    {
+        self.extend_key(variant);
+        Ok(self)
+    }
+}
+
+
+impl ser::Error for Error {
+    fn custom<T>(msg: T) -> Self 
+        where T: Display {
+            ErrorKind::Custom(msg.to_string()).into()
+    }
+}
+
+pub struct QsSeq<'a, Target: 'a + UrlEncodedTarget>(&'a mut QsSerializer<'a, Target>, usize);
+pub struct QsMap<'a, Target: 'a + UrlEncodedTarget>(&'a mut QsSerializer<'a, Target>, Option<Cow<'a, str>>);
+
+
+impl<'a, Target: 'a + UrlEncodedTarget> ser::SerializeTuple for QsSeq<'a, Target> {
+    type Ok = ();
+    type Error = Error;
+    fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<()>
+        where T: ser::Serialize
+    {
+        let mut serializer = QsSerializer { key: self.0.key.clone(), urlencoder: self.0.urlencoder };
+        serializer.extend_key(&self.1.to_string());
+        self.1 += 1;
+        value.serialize(&mut serializer)
+    }
+
+    fn end(self) -> Result<Self::Ok> {
+        Ok(())
+
+    }
+}
+
+impl<'a, Target: 'a + UrlEncodedTarget> ser::SerializeSeq for QsSeq<'a, Target> {
+    type Ok = ();
+    type Error = Error;
+    fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<()>
+        where T: ser::Serialize
+    {
+        let mut serializer = QsSerializer { key: self.0.key.clone(), urlencoder: self.0.urlencoder };
+        serializer.extend_key(&self.1.to_string());
+        self.1 += 1;
+        value.serialize(&mut serializer)
+    }
+    fn end(self) -> Result<Self::Ok> {
+        Ok(())
+
+    }
+}
+
+impl<'a, Target: 'a + UrlEncodedTarget> ser::SerializeStruct for &'a mut QsSerializer<'a, Target>  {
+    type Ok = ();
+    type Error = Error;
+    fn serialize_field<T: ?Sized>(&mut self, key: &'static str, value: &T) -> Result<()>
+        where T: ser::Serialize
+    {
+        let mut serializer = QsSerializer { key: self.key.clone(), urlencoder: self.urlencoder };
+        serializer.extend_key(key);
+        value.serialize(&mut serializer)
+    }
+    fn end(self) -> Result<Self::Ok> {
+        Ok(())
+    }
+}
+
+impl<'a, Target: 'a + UrlEncodedTarget> ser::SerializeStructVariant for &'a mut QsSerializer<'a, Target> {
+    type Ok = ();
+    type Error = Error;
+
+    fn serialize_field<T: ?Sized>(&mut self, key: &'static str, value: &T) -> Result<()>
+        where T: ser::Serialize
+    {
+        let mut serializer = QsSerializer { key: self.key.clone(), urlencoder: self.urlencoder };
+        serializer.extend_key(key);
+        value.serialize(&mut serializer)
+    }
+
+    fn end(self) -> Result<Self::Ok> {
+        Ok(())
+    }
+
+}
+
+impl<'a, Target: 'a + UrlEncodedTarget> ser::SerializeTupleVariant for QsSeq<'a, Target> {
+    type Ok = ();
+    type Error = Error;
+
+    fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<()>
+        where T: ser::Serialize
+    {
+        let mut serializer = QsSerializer { key: self.0.key.clone(), urlencoder: self.0.urlencoder };
+        serializer.extend_key(&self.1.to_string());
+        self.1 += 1;
+        value.serialize(&mut serializer)
+    }
+
+    fn end(self) -> Result<Self::Ok> {
+        Ok(())
+    }
+
+}
+
+impl<'a, Target: 'a + UrlEncodedTarget> ser::SerializeTupleStruct for QsSeq<'a, Target> {
+    type Ok = ();
+    type Error = Error;
+
+    fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<()>
+        where T: ser::Serialize
+    {
+        let mut serializer = QsSerializer { key: self.0.key.clone(), urlencoder: self.0.urlencoder };
+        serializer.extend_key(&self.1.to_string());
+        self.1 += 1;
+        value.serialize(&mut serializer)
+    }
+
+    fn end(self) -> Result<Self::Ok> {
+        Ok(())
+    }
+
+}
+
+impl<'a, Target: 'a + UrlEncodedTarget> ser::SerializeMap for QsMap<'a, Target> {
+    type Ok = ();
+    type Error = Error;
+
+    fn serialize_key<T: ?Sized>(&mut self, key: &T) -> Result<()>
+        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
+    {
+        let mut serializer = QsSerializer { key: self.0.key.clone(), urlencoder: self.0.urlencoder };
+        if let Some(ref key) = self.1 {
+            serializer.extend_key(key);
+        } else {
+            return Err(Error::no_key());
+        }
+        self.1 = None;
+        value.serialize(&mut serializer)
+    }
+
+    fn end(self) -> Result<Self::Ok> {
+        Ok(())
+    }
+
+    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 { key: self.0.key.clone(), urlencoder: self.0.urlencoder };
+        serializer.extend_key(&key.serialize(StringSerializer)?);
+        value.serialize(&mut serializer)
+    }
+
+}
+
+struct StringSerializer;
+
+impl ser::Serializer for StringSerializer {
+    type Ok = String;
+    type Error = Error;
+    type SerializeSeq = ser::Impossible<String, Error>;
+    type SerializeTuple = ser::Impossible<String, Error>;
+    type SerializeTupleStruct = ser::Impossible<String, Error>;
+    type SerializeTupleVariant = ser::Impossible<String, Error>;
+    type SerializeMap = ser::Impossible<String, Error>;
+    type SerializeStruct = ser::Impossible<String, Error>;
+    type SerializeStructVariant = ser::Impossible<String, Error>;
+
+    serialize_as_string!{
+        bool => serialize_bool,
+        u8  => serialize_u8,
+        u16 => serialize_u16,
+        u32 => serialize_u32,
+        u64 => serialize_u64,
+        i8  => serialize_i8,
+        i16 => serialize_i16,
+        i32 => serialize_i32,
+        i64 => serialize_i64,
+        f32 => serialize_f32,
+        f64 => serialize_f64,
+        char => serialize_char,
+        &str => serialize_str,
+    }
+
+
+    fn serialize_bytes(self, value: &[u8]) -> Result<Self::Ok> {
+        Err(ErrorKind::Unsupported.into())
+    }
+
+    /// Returns an error.
+    fn serialize_unit(self) -> Result<Self::Ok> {
+        Err(ErrorKind::Unsupported.into())
+    }
+
+    /// Returns an error.
+    fn serialize_unit_struct(self,
+                             _name: &'static str)
+                             -> Result<Self::Ok> {
+        Err(ErrorKind::Unsupported.into())
+    }
+
+    /// Returns an error.
+    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> {
+        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> {
+        Err(ErrorKind::Unsupported.into())
+    }
+
+    /// Returns an error.
+    fn serialize_none(self) -> Result<Self::Ok> {
+        Err(ErrorKind::Unsupported.into())
+    }
+
+    /// Returns an error.
+    fn serialize_some<T: ?Sized + ser::Serialize>
+        (self,
+         _value: &T)
+         -> Result<Self::Ok> {
+        Err(ErrorKind::Unsupported.into())
+    }
+
+    /// Returns an error.
+    fn serialize_seq(self,
+                     _len: Option<usize>)
+                     -> Result<Self::SerializeSeq> {
+        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> {
+        Err(ErrorKind::Unsupported.into())
+    }
+
+    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> {
+        Err(ErrorKind::Unsupported.into())
+    }
+
+    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/src/ser/key.rs b/src/ser/key.rs
deleted file mode 100644
index 10f1fff..0000000
--- a/src/ser/key.rs
+++ /dev/null
@@ -1,108 +0,0 @@
-use ser::Error;
-use ser::part::Sink;
-use serde::Serialize;
-use serde::ser::{SerializeSeq, SerializeStruct};
-use std::borrow::Cow;
-use std::ops::Deref;
-
-pub enum Key<'key> {
-    Static(&'static str),
-    Dynamic(Cow<'key, str>),
-}
-
-impl<'key> Deref for Key<'key> {
-    type Target = str;
-
-    fn deref(&self) -> &str {
-        match *self {
-            Key::Static(key) => key,
-            Key::Dynamic(ref key) => key,
-        }
-    }
-}
-
-impl<'key> From<Key<'key>> for Cow<'static, str> {
-    fn from(key: Key<'key>) -> Self {
-        match key {
-            Key::Static(key) => key.into(),
-            Key::Dynamic(key) => key.into_owned().into(),
-        }
-    }
-}
-
-pub struct KeySink<End> {
-    end: End,
-}
-
-impl<End, Ok> KeySink<End>
-    where End: for<'key> FnOnce(Key<'key>) -> Result<Ok, Error>,
-{
-    pub fn new(end: End) -> Self {
-        KeySink { end: end }
-    }
-}
-
-impl<End, Ok> Sink<Ok, Error> for KeySink<End>
-    where End: for<'key> FnOnce(Key<'key>) -> Result<Ok, Error>,
-{
-    fn serialize_static_str(self, value: &'static str) -> Result<Ok, Error> {
-        (self.end)(Key::Static(value))
-    }
-
-    fn serialize_str(self, value: &str) -> Result<Ok, Error> {
-        (self.end)(Key::Dynamic(value.into()))
-    }
-
-    fn serialize_string(self, value: String) -> Result<Ok, Error> {
-        (self.end)(Key::Dynamic(value.into()))
-    }
-
-    fn serialize_none(self) -> Result<Ok, Error> {
-        Err(self.unsupported())
-    }
-
-    fn serialize_some<T: ?Sized + Serialize>(self,
-                                             _value: &T)
-                                             -> Result<Ok, Error> {
-        Err(self.unsupported())
-    }
-
-    fn unsupported(&self) -> Error {
-        Error::Custom("unsupported key".into())
-    }
-}
-
-impl<End, Ok> SerializeStruct for KeySink<End>
-    where End: for<'key> FnOnce(Key<'key>) -> Result<Ok, Error>,
-{
-    type Ok = Ok;
-    type Error = Error;
-
-    fn serialize_field<T: ?Sized + Serialize>(&mut self,
-                                              _key: &'static str,
-                                              _value: &T)
-                                              -> Result<(), Error> {
-        Err(self.unsupported())
-    }
-
-    fn end(self) -> Result<Self::Ok, Error> {
-        Err(self.unsupported())
-    }
-}
-
-impl<End, Ok> SerializeSeq for KeySink<End>
-    where End: for<'key> FnOnce(Key<'key>) -> Result<Ok, Error>,
-{
-    type Ok = Ok;
-    type Error = Error;
-
-    fn serialize_element<T: ?Sized + Serialize>(&mut self,
-                                                _value: &T)
-                                                -> Result<(), Error> {
-        Err(self.unsupported())
-    }
-
-    fn end(self) -> Result<Self::Ok, Error> {
-        Err(self.unsupported())
-    }
-}
diff --git a/src/ser/mod.rs b/src/ser/mod.rs
deleted file mode 100644
index df35995..0000000
--- a/src/ser/mod.rs
+++ /dev/null
@@ -1,519 +0,0 @@
-//! Serialization support for querystrings.
-
-mod key;
-mod part;
-mod value;
-
-use serde::ser;
-use std::borrow::Cow;
-use std::error;
-use std::fmt;
-use std::str;
-use url::form_urlencoded::Serializer as UrlEncodedSerializer;
-use url::form_urlencoded::Target as UrlEncodedTarget;
-
-/// Serializes a value into a querystring.
-///
-/// ```
-/// # #[macro_use]
-/// # extern crate serde_derive;
-/// # extern crate serde_qs;
-/// #[derive(Deserialize, Serialize)]
-/// struct Query {
-///     name: String,
-///     age: u8,
-///     occupation: String,
-/// }
-///
-/// # fn main(){
-/// let q =  Query {
-///     name: "Alice".to_owned(),
-///     age: 24,
-///     occupation: "Student".to_owned(),
-/// };
-///
-///
-/// assert_eq!(
-///     serde_qs::to_string(&q),
-///     Ok("name=Alice&age=24&occupation=Student".to_owned()));
-/// # }
-/// ```
-pub fn to_string<T: ser::Serialize>(input: &T) -> Result<String, Error> {
-    let mut urlencoder = UrlEncodedSerializer::new("".to_owned());
-    input.serialize(Serializer::new(&mut urlencoder))?;
-    Ok(urlencoder.finish())
-}
-
-/// A serializer for the querystring format.
-///
-/// * Supported top-level inputs are structs and maps.
-///
-/// * Supported values are currently most primitive types, structs, maps and
-///   sequences. Sequences are serialized with an incrementing key index.
-///
-/// * Newtype structs defer to their inner values.
-pub struct Serializer<'output, Target: 'output + UrlEncodedTarget> {
-    urlencoder: &'output mut UrlEncodedSerializer<Target>,
-}
-
-impl<'output, Target: 'output + UrlEncodedTarget> Serializer<'output, Target> {
-    /// Returns a new `Serializer`.
-    pub fn new(urlencoder: &'output mut UrlEncodedSerializer<Target>) -> Self {
-        Serializer { urlencoder: urlencoder }
-    }
-}
-
-/// Errors returned during serializing to querystring.
-#[derive(Clone, Debug, PartialEq, Eq)]
-pub enum Error {
-    Custom(Cow<'static, str>),
-    Utf8(str::Utf8Error),
-}
-
-impl fmt::Display for Error {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        match *self {
-            Error::Custom(ref msg) => msg.fmt(f),
-            Error::Utf8(ref err) => write!(f, "invalid UTF-8: {}", err),
-        }
-    }
-}
-
-impl error::Error for Error {
-    fn description(&self) -> &str {
-        match *self {
-            Error::Custom(ref msg) => msg,
-            Error::Utf8(ref err) => error::Error::description(err),
-        }
-    }
-
-    /// The lower-level cause of this error, in the case of a `Utf8` error.
-    fn cause(&self) -> Option<&error::Error> {
-        match *self {
-            Error::Custom(_) => None,
-            Error::Utf8(ref err) => Some(err),
-        }
-    }
-}
-
-impl ser::Error for Error {
-    fn custom<T: fmt::Display>(msg: T) -> Self {
-        Error::Custom(format!("{}", msg).into())
-    }
-}
-
-/// Sequence serializer.
-pub struct SeqSerializer<'output, T: 'output + UrlEncodedTarget> {
-    inner: ser::Impossible<&'output mut UrlEncodedSerializer<T>, Error>,
-}
-
-/// Tuple serializer.
-///
-/// Never instantiated, tuples are not supported at top-level.
-pub struct TupleSerializer<'output, T: 'output + UrlEncodedTarget> {
-    inner: ser::Impossible<&'output mut UrlEncodedSerializer<T>, Error>,
-}
-
-/// Tuple struct serializer.
-///
-/// Never instantiated, tuple structs are not supported.
-pub struct TupleStructSerializer<'output, T: 'output + UrlEncodedTarget> {
-    inner: ser::Impossible<&'output mut UrlEncodedSerializer<T>, Error>,
-}
-
-/// Tuple variant serializer.
-///
-/// Never instantiated, tuple variants are not supported.
-pub struct TupleVariantSerializer<'output, T: 'output + UrlEncodedTarget> {
-    inner: ser::Impossible<&'output mut UrlEncodedSerializer<T>, Error>,
-}
-
-/// Map serializer.
-pub struct MapSerializer<'output, Target: 'output + UrlEncodedTarget> {
-    urlencoder: &'output mut UrlEncodedSerializer<Target>,
-    key: Option<Cow<'static, str>>,
-}
-
-/// Struct serializer.
-pub struct StructSerializer<'output, Target: 'output + UrlEncodedTarget> {
-    urlencoder: &'output mut UrlEncodedSerializer<Target>,
-}
-
-/// Struct variant serializer.
-///
-/// Never instantiated, struct variants are not supported.
-pub struct StructVariantSerializer<'output, T: 'output + UrlEncodedTarget> {
-    inner: ser::Impossible<&'output mut UrlEncodedSerializer<T>, Error>,
-}
-
-impl<'output, Target> ser::Serializer for Serializer<'output, Target>
-    where Target: 'output + UrlEncodedTarget,
-{
-    type Ok = &'output mut UrlEncodedSerializer<Target>;
-    type Error = Error;
-    type SerializeSeq = SeqSerializer<'output, Target>;
-    type SerializeTuple = TupleSerializer<'output, Target>;
-    type SerializeTupleStruct = TupleStructSerializer<'output, Target>;
-    type SerializeTupleVariant = TupleVariantSerializer<'output, Target>;
-    type SerializeMap = MapSerializer<'output, Target>;
-    type SerializeStruct = StructSerializer<'output, Target>;
-    type SerializeStructVariant = StructVariantSerializer<'output, Target>;
-
-    /// Returns an error.
-    fn serialize_bool(self, _v: bool) -> Result<Self::Ok, Error> {
-        Err(Error::top_level())
-    }
-
-    /// Returns an error.
-    fn serialize_i8(self, _v: i8) -> Result<Self::Ok, Error> {
-        Err(Error::top_level())
-    }
-
-    /// Returns an error.
-    fn serialize_i16(self, _v: i16) -> Result<Self::Ok, Error> {
-        Err(Error::top_level())
-    }
-
-    /// Returns an error.
-    fn serialize_i32(self, _v: i32) -> Result<Self::Ok, Error> {
-        Err(Error::top_level())
-    }
-
-    /// Returns an error.
-    fn serialize_i64(self, _v: i64) -> Result<Self::Ok, Error> {
-        Err(Error::top_level())
-    }
-
-    /// Returns an error.
-    fn serialize_u8(self, _v: u8) -> Result<Self::Ok, Error> {
-        Err(Error::top_level())
-    }
-
-    /// Returns an error.
-    fn serialize_u16(self, _v: u16) -> Result<Self::Ok, Error> {
-        Err(Error::top_level())
-    }
-
-    /// Returns an error.
-    fn serialize_u32(self, _v: u32) -> Result<Self::Ok, Error> {
-        Err(Error::top_level())
-    }
-
-    /// Returns an error.
-    fn serialize_u64(self, _v: u64) -> Result<Self::Ok, Error> {
-        Err(Error::top_level())
-    }
-
-    /// Returns an error.
-    fn serialize_f32(self, _v: f32) -> Result<Self::Ok, Error> {
-        Err(Error::top_level())
-    }
-
-    /// Returns an error.
-    fn serialize_f64(self, _v: f64) -> Result<Self::Ok, Error> {
-        Err(Error::top_level())
-    }
-
-    /// Returns an error.
-    fn serialize_char(self, _v: char) -> Result<Self::Ok, Error> {
-        Err(Error::top_level())
-    }
-
-    /// Returns an error.
-    fn serialize_str(self, _value: &str) -> Result<Self::Ok, Error> {
-        Err(Error::top_level())
-    }
-
-    /// Returns an error.
-    fn serialize_bytes(self, _value: &[u8]) -> Result<Self::Ok, Error> {
-        Err(Error::top_level())
-    }
-
-    /// Returns an error.
-    fn serialize_unit(self) -> Result<Self::Ok, Error> {
-        Err(Error::top_level())
-    }
-
-    /// Returns an error.
-    fn serialize_unit_struct(self,
-                             _name: &'static str)
-                             -> Result<Self::Ok, Error> {
-        Err(Error::top_level())
-    }
-
-    /// Returns an error.
-    fn serialize_unit_variant(self,
-                              _name: &'static str,
-                              _variant_index: u32,
-                              _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>
-        (self,
-         _name: &'static str,
-         value: &T)
-         -> Result<Self::Ok, Error> {
-        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, Error> {
-        Err(Error::top_level())
-    }
-
-    /// Returns `Ok`.
-    fn serialize_none(self) -> Result<Self::Ok, Error> {
-        Ok(self.urlencoder)
-    }
-
-    /// Serializes the given value.
-    fn serialize_some<T: ?Sized + ser::Serialize>
-        (self,
-         value: &T)
-         -> Result<Self::Ok, Error> {
-        value.serialize(self)
-    }
-
-    /// Serialize a sequence, given length (if any) is ignored.
-    fn serialize_seq(self,
-                     _len: Option<usize>)
-                     -> Result<Self::SerializeSeq, Error> {
-        Err(Error::top_level())
-    }
-
-
-    /// Returns an error.
-    fn serialize_tuple(self,
-                       _len: usize)
-                       -> Result<Self::SerializeTuple, Error> {
-        Err(Error::top_level())
-    }
-
-    /// Returns an error.
-    fn serialize_tuple_struct(self,
-                              _name: &'static str,
-                              _len: usize)
-                              -> Result<Self::SerializeTupleStruct, Error> {
-        Err(Error::top_level())
-    }
-
-    /// Returns an error.
-    fn serialize_tuple_variant
-        (self,
-         _name: &'static str,
-         _variant_index: u32,
-         _variant: &'static str,
-         _len: usize)
-         -> Result<Self::SerializeTupleVariant, Error> {
-        Err(Error::top_level())
-    }
-
-    /// Serializes a map, given length is ignored.
-    fn serialize_map(self,
-                     _len: Option<usize>)
-                     -> Result<Self::SerializeMap, Error> {
-        Ok(MapSerializer {
-            urlencoder: self.urlencoder,
-            key: None,
-        })
-    }
-
-    /// Serializes a struct, given length is ignored.
-    fn serialize_struct(self,
-                        _name: &'static str,
-                        _len: usize)
-                        -> Result<Self::SerializeStruct, Error> {
-        Ok(StructSerializer { urlencoder: self.urlencoder })
-    }
-
-    /// Returns an error.
-    fn serialize_struct_variant
-        (self,
-         _name: &'static str,
-         _variant_index: u32,
-         _variant: &'static str,
-         _len: usize)
-         -> Result<Self::SerializeStructVariant, Error> {
-        Err(Error::top_level())
-    }
-}
-
-impl<'output, Target> ser::SerializeSeq for SeqSerializer<'output, Target>
-    where Target: 'output + UrlEncodedTarget,
-{
-    type Ok = &'output mut UrlEncodedSerializer<Target>;
-    type Error = Error;
-
-    fn serialize_element<T: ?Sized + ser::Serialize>(&mut self,
-                                                     value: &T)
-                                                     -> Result<(), Error> {
-        self.inner.serialize_element(value)
-    }
-
-    fn end(self) -> Result<Self::Ok, Error> {
-        self.inner.end()
-    }
-}
-
-
-impl<'output, Target> ser::SerializeTuple for TupleSerializer<'output, Target>
-    where Target: 'output + UrlEncodedTarget,
-{
-    type Ok = &'output mut UrlEncodedSerializer<Target>;
-    type Error = Error;
-
-    fn serialize_element<T: ?Sized + ser::Serialize>(&mut self,
-                                                     value: &T)
-                                                     -> Result<(), Error> {
-        self.inner.serialize_element(value)
-    }
-
-    fn end(self) -> Result<Self::Ok, Error> {
-        self.inner.end()
-    }
-}
-
-impl<'output, Target> ser::SerializeTupleStruct
-    for
-    TupleStructSerializer<'output, Target>
-    where Target: 'output + UrlEncodedTarget,
-{
-    type Ok = &'output mut UrlEncodedSerializer<Target>;
-    type Error = Error;
-
-    fn serialize_field<T: ?Sized + ser::Serialize>(&mut self,
-                                                   value: &T)
-                                                   -> Result<(), Error> {
-        self.inner.serialize_field(value)
-    }
-
-    fn end(self) -> Result<Self::Ok, Error> {
-        self.inner.end()
-    }
-}
-
-impl<'output, Target> ser::SerializeTupleVariant
-    for
-    TupleVariantSerializer<'output, Target>
-    where Target: 'output + UrlEncodedTarget,
-{
-    type Ok = &'output mut UrlEncodedSerializer<Target>;
-    type Error = Error;
-
-    fn serialize_field<T: ?Sized + ser::Serialize>(&mut self,
-                                                   value: &T)
-                                                   -> Result<(), Error> {
-        self.inner.serialize_field(value)
-    }
-
-    fn end(self) -> Result<Self::Ok, Error> {
-        self.inner.end()
-    }
-}
-
-impl<'output, Target> ser::SerializeMap for MapSerializer<'output, Target>
-    where Target: 'output + UrlEncodedTarget,
-{
-    type Ok = &'output mut UrlEncodedSerializer<Target>;
-    type Error = Error;
-
-    fn serialize_entry<K: ?Sized + ser::Serialize, V: ?Sized + ser::Serialize>
-        (&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))?;
-            self.key = None;
-            Ok(())
-        });
-        let entry_serializer = part::PartSerializer::new(key_sink);
-        key.serialize(entry_serializer)
-    }
-
-    fn serialize_key<T: ?Sized + ser::Serialize>(&mut self,
-                                                 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,
-                                                   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);
-            value.serialize(part::PartSerializer::new(value_sink))?;
-        }
-        self.key = None;
-        Ok(())
-    }
-
-    fn end(self) -> Result<Self::Ok, Error> {
-        Ok(self.urlencoder)
-    }
-}
-
-impl<'output, Target> ser::SerializeStruct for StructSerializer<'output, Target>
-    where Target: 'output + UrlEncodedTarget,
-{
-    type Ok = &'output mut UrlEncodedSerializer<Target>;
-    type Error = Error;
-
-    fn serialize_field<T: ?Sized + ser::Serialize>(&mut self,
-                                                   key: &'static str,
-                                                   value: &T)
-                                                   -> Result<(), Error> {
-        let value_sink = value::ValueSink::new(self.urlencoder, key);
-        value.serialize(part::PartSerializer::new(value_sink))
-    }
-
-    fn end(self) -> Result<Self::Ok, Error> {
-        Ok(self.urlencoder)
-    }
-}
-
-impl<'output, Target> ser::SerializeStructVariant
-    for
-    StructVariantSerializer<'output, Target>
-    where Target: 'output + UrlEncodedTarget,
-{
-    type Ok = &'output mut UrlEncodedSerializer<Target>;
-    type Error = Error;
-
-    fn serialize_field<T: ?Sized + ser::Serialize>(&mut self,
-                                                   key: &'static str,
-                                                   value: &T)
-                                                   -> Result<(), Error> {
-        self.inner.serialize_field(key, value)
-    }
-
-    fn end(self) -> Result<Self::Ok, Error> {
-        self.inner.end()
-    }
-}
-
-impl Error {
-    fn top_level() -> Self {
-        let msg = "top-level serializer supports only maps and structs";
-        Error::Custom(msg.into())
-    }
-
-    fn no_key() -> Self {
-        let msg = "tried to serialize a value before serializing key";
-        Error::Custom(msg.into())
-    }
-}
diff --git a/src/ser/part.rs b/src/ser/part.rs
deleted file mode 100644
index ad2d9dd..0000000
--- a/src/ser/part.rs
+++ /dev/null
@@ -1,232 +0,0 @@
-use dtoa;
-use itoa;
-use ser::Error;
-use serde;
-use serde::ser;
-use std::marker::PhantomData;
-use std::str;
-
-pub struct PartSerializer<SO, S: Sink<SO, Error>> {
-    sink: S,
-    marker: PhantomData<SO>,
-}
-
-impl<SO, S: Sink<SO, Error>> PartSerializer<SO, S> {
-    pub fn new(sink: S) -> Self {
-        PartSerializer {
-            sink: sink,
-            marker: PhantomData,
-        }
-    }
-}
-
-pub trait Sink<S, E>: Sized + ser::SerializeStruct<Ok=S, Error=E>
-                            + ser::SerializeSeq<Ok=S, Error=E>
-  where E: serde::ser::Error
-{
-// type Ok;
-// type Error;
-    fn serialize_static_str(self,
-                            value: &'static str)
-                            -> Result<S, Error>;
-
-    fn serialize_str(self, value: &str) -> Result<S, Error>;
-    fn serialize_string(self, value: String) -> Result<S, Error>;
-    fn serialize_none(self) -> Result<S, Error>;
-
-    fn serialize_some<T: ?Sized + ser::Serialize>
-        (self,
-         value: &T)
-         -> Result<S, Error>;
-
-    fn unsupported(&self) -> Error;
-}
-
-impl<SO, S: Sink<SO, Error>> ser::Serializer for PartSerializer<SO, S> {
-    type Ok = SO;
-    type Error = Error;
-    type SerializeSeq = S;
-    type SerializeTuple = ser::Impossible<SO, Error>;
-    type SerializeTupleStruct = ser::Impossible<SO, Error>;
-    type SerializeTupleVariant = ser::Impossible<SO, Error>;
-    type SerializeMap = ser::Impossible<SO, Error>;
-    type SerializeStruct = S;
-    type SerializeStructVariant = ser::Impossible<SO, Error>;
-
-    fn serialize_bool(self, v: bool) -> Result<SO, Error> {
-        self.sink.serialize_static_str(if v { "true" } else { "false" })
-    }
-
-    fn serialize_i8(self, v: i8) -> Result<SO, Error> {
-        self.serialize_integer(v)
-    }
-
-    fn serialize_i16(self, v: i16) -> Result<SO, Error> {
-        self.serialize_integer(v)
-    }
-
-    fn serialize_i32(self, v: i32) -> Result<SO, Error> {
-        self.serialize_integer(v)
-    }
-
-    fn serialize_i64(self, v: i64) -> Result<SO, Error> {
-        self.serialize_integer(v)
-    }
-
-    fn serialize_u8(self, v: u8) -> Result<SO, Error> {
-        self.serialize_integer(v)
-    }
-
-    fn serialize_u16(self, v: u16) -> Result<SO, Error> {
-        self.serialize_integer(v)
-    }
-
-    fn serialize_u32(self, v: u32) -> Result<SO, Error> {
-        self.serialize_integer(v)
-    }
-
-    fn serialize_u64(self, v: u64) -> Result<SO, Error> {
-        self.serialize_integer(v)
-    }
-
-    fn serialize_f32(self, v: f32) -> Result<SO, Error> {
-        self.serialize_floating(v)
-    }
-
-    fn serialize_f64(self, v: f64) -> Result<SO, Error> {
-        self.serialize_floating(v)
-    }
-
-    fn serialize_char(self, v: char) -> Result<SO, Error> {
-        self.sink.serialize_string(v.to_string())
-    }
-
-    fn serialize_str(self, value: &str) -> Result<SO, Error> {
-        self.sink.serialize_str(value)
-    }
-
-    fn serialize_bytes(self, value: &[u8]) -> Result<SO, Error> {
-        match str::from_utf8(value) {
-            Ok(value) => self.sink.serialize_str(value),
-            Err(err) => Err(Error::Utf8(err)),
-        }
-    }
-
-    fn serialize_unit(self) -> Result<SO, Error> {
-        Err(self.sink.unsupported())
-    }
-
-    fn serialize_unit_struct(self, name: &'static str) -> Result<SO, Error> {
-        self.sink.serialize_static_str(name.into())
-    }
-
-    fn serialize_unit_variant(self,
-                              _name: &'static str,
-                              _variant_index: u32,
-                              variant: &'static str)
-                              -> Result<SO, Error> {
-        self.sink.serialize_static_str(variant.into())
-    }
-
-    fn serialize_newtype_struct<T: ?Sized + ser::Serialize>
-        (self,
-         _name: &'static str,
-         value: &T)
-         -> Result<SO, Error> {
-        value.serialize(self)
-    }
-
-    fn serialize_newtype_variant<T: ?Sized + ser::Serialize>
-        (self,
-         _name: &'static str,
-         _variant_index: u32,
-         _variant: &'static str,
-         _value: &T)
-         -> Result<SO, Error> {
-        Err(self.sink.unsupported())
-    }
-
-    fn serialize_none(self) -> Result<SO, Error> {
-        self.sink.serialize_none()
-    }
-
-    fn serialize_some<T: ?Sized + ser::Serialize>(self,
-                                                  value: &T)
-                                                  -> Result<SO, Error> {
-        self.sink.serialize_some(value)
-    }
-
-    fn serialize_seq(self,
-                     _len: Option<usize>)
-                     -> Result<Self::SerializeSeq, Error> {
-        Ok(self.sink)
-    }
-
-    fn serialize_tuple(self,
-                       _len: usize)
-                       -> Result<Self::SerializeTuple, Error> {
-        Err(self.sink.unsupported())
-    }
-
-    fn serialize_tuple_struct(self,
-                              _name: &'static str,
-                              _len: usize)
-                              -> Result<Self::SerializeTuple, Error> {
-        Err(self.sink.unsupported())
-    }
-
-    fn serialize_tuple_variant
-        (self,
-         _name: &'static str,
-         _variant_index: u32,
-         _variant: &'static str,
-         _len: usize)
-         -> Result<Self::SerializeTupleVariant, Error> {
-        Err(self.sink.unsupported())
-    }
-
-    fn serialize_map(self,
-                     _len: Option<usize>)
-                     -> Result<Self::SerializeMap, Error> {
-        Err(self.sink.unsupported())
-    }
-
-    fn serialize_struct(self,
-                        _name: &'static str,
-                        _len: usize)
-                        -> Result<Self::SerializeStruct, Error> {
-        // Err(self.sink.unsupported())
-        Ok(self.sink)
-
-    }
-
-    fn serialize_struct_variant
-        (self,
-         _name: &'static str,
-         _variant_index: u32,
-         _variant: &'static str,
-         _len: usize)
-         -> Result<Self::SerializeStructVariant, Error> {
-        Err(self.sink.unsupported())
-    }
-}
-
-impl<SO, S: Sink<SO, Error>> PartSerializer<SO, S> {
-    fn serialize_integer<I>(self, value: I) -> Result<SO, Error>
-        where I: itoa::Integer,
-    {
-        let mut buf = [b'\0'; 20];
-        let len = itoa::write(&mut buf[..], value).unwrap();
-        let part = unsafe { str::from_utf8_unchecked(&buf[0..len]) };
-        ser::Serializer::serialize_str(self, part)
-    }
-
-    fn serialize_floating<F>(self, value: F) -> Result<SO, Error>
-        where F: dtoa::Floating,
-    {
-        let mut buf = [b'\0'; 24];
-        let len = dtoa::write(&mut buf[..], value).unwrap();
-        let part = unsafe { str::from_utf8_unchecked(&buf[0..len]) };
-        ser::Serializer::serialize_str(self, part)
-    }
-}
diff --git a/src/ser/value.rs b/src/ser/value.rs
deleted file mode 100644
index f2fc617..0000000
--- a/src/ser/value.rs
+++ /dev/null
@@ -1,102 +0,0 @@
-use ser::Error;
-use ser::part::{PartSerializer, Sink};
-use serde::ser::{Serialize, SerializeSeq, SerializeStruct};
-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,
-{
-    urlencoder: &'target mut UrlEncodedSerializer<Target>,
-    key: &'key str,
-    idx: usize,
-}
-
-impl<'key, 'target, Target> ValueSink<'key, 'target, Target>
-    where Target: 'target + UrlEncodedTarget,
-{
-    pub fn new(urlencoder: &'target mut UrlEncodedSerializer<Target>,
-               key: &'key str)
-               -> Self {
-        ValueSink {
-            urlencoder: urlencoder,
-            key: key,
-            idx: 0,
-        }
-    }
-}
-
-impl<'key, 'target, Target> Sink<(), Error> for ValueSink<'key, 'target, Target>
-    where Target: 'target + UrlEncodedTarget,
-{
-    // type Ok = ();
-
-    fn serialize_str(self, value: &str) -> Result<(), Error> {
-        self.urlencoder.append_pair(self.key, value);
-        Ok(())
-    }
-
-    fn serialize_static_str(self, value: &'static str) -> Result<(), Error> {
-        self.serialize_str(value)
-    }
-
-    fn serialize_string(self, value: String) -> Result<(), Error> {
-        self.serialize_str(&value)
-    }
-
-    fn serialize_none(self) -> Result<(), Error> {
-        Ok(())
-    }
-
-    fn serialize_some<T: ?Sized + Serialize>(self,
-                                             value: &T)
-                                             -> Result<(), Error> {
-        value.serialize(PartSerializer::new(self))
-    }
-
-    fn unsupported(&self) -> Error {
-        Error::Custom("unsupported value".into())
-    }
-}
-
-
-impl<'key, 'target, Target> SerializeStruct for ValueSink<'key, 'target, Target>
-    where Target: 'target + UrlEncodedTarget,
-{
-    type Ok = ();
-    type Error = Error;
-
-    fn serialize_field<T: ?Sized + Serialize>(&mut self,
-                                              key: &'static str,
-                                              value: &T)
-                                              -> Result<(), Error> {
-        let newk = format!("{}[{}]", self.key, key);
-        let value_sink = ValueSink::new(self.urlencoder, &newk);
-        value.serialize(super::part::PartSerializer::new(value_sink))
-    }
-
-    fn end(self) -> Result<Self::Ok, Error> {
-        Ok(())
-    }
-}
-
-impl<'key, 'target, Target> SerializeSeq for ValueSink<'key, 'target, Target>
-    where Target: 'target + UrlEncodedTarget,
-{
-    type Ok = ();
-    type Error = Error;
-
-    fn serialize_element<T: ?Sized + Serialize>(&mut self,
-                                                value: &T)
-                                                -> Result<(), Error> {
-        let newk = format!("{}[{}]", self.key, self.idx);
-        self.idx += 1;
-        let value_sink = ValueSink::new(self.urlencoder, &newk);
-        value.serialize(super::part::PartSerializer::new(value_sink))
-    }
-
-    fn end(self) -> Result<Self::Ok, Error> {
-        Ok(())
-    }
-}