Revert urlencoded to plain serde_urlencoded logic temporarily

src/urlencoded.rs

@@ -1,7 +1,6 @@
 //! `x-www-form-urlencoded` meets Serde
 
 pub mod de;
-pub mod error;
 pub mod ser;
 
 #[doc(inline)]

src/urlencoded/de.rs

@@ -2,10 +2,9 @@
 
 use std::{borrow::Cow, io::Read};
 
-use serde::de::{
+use serde::{
-    self,
+    de::{self, value::MapDeserializer, Error as de_Error, IntoDeserializer},
-    value::{MapDeserializer, SeqDeserializer},
+    forward_to_deserialize_any,
-    Error as de_Error, IntoDeserializer,
 };
 use url::form_urlencoded::{parse, Parse as UrlEncodedParse};
 
@@ -70,9 +69,9 @@ where
     from_bytes(&buf)
 }
 
-/// A deserializer for the Matrix query string format.
+/// A deserializer for the `application/x-www-form-urlencoded` format.
 ///
-/// * Supported top-level outputs are structs, maps and sequences,
+/// * Supported top-level outputs are structs, maps and sequences of pairs,
 ///   with or without a given length.
 ///
 /// * Main `deserialize` methods defers to `deserialize_map`.
@@ -80,12 +79,15 @@ where
 /// * Everything else but `deserialize_seq` and `deserialize_seq_fixed_size`
 ///   defers to `deserialize`.
 pub struct Deserializer<'de> {
-    parser: UrlEncodedParse<'de>,
+    inner: MapDeserializer<'de, PartIterator<'de>, Error>,
 }
 
 impl<'de> Deserializer<'de> {
+    /// Returns a new `Deserializer`.
     pub fn new(parser: UrlEncodedParse<'de>) -> Self {
-        Self { parser }
+        Deserializer {
+            inner: MapDeserializer::new(PartIterator(parser)),
+        }
     }
 }
 
@@ -103,57 +105,25 @@ impl<'de> de::Deserializer<'de> for Deserializer<'de> {
     where
         V: de::Visitor<'de>,
     {
-        visitor.visit_map(MapDeserializer::new(PartIterator(self.parser)))
+        visitor.visit_map(self.inner)
     }
 
     fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value, Self::Error>
     where
         V: de::Visitor<'de>,
     {
-        visitor.visit_seq(MapDeserializer::new(PartIterator(self.parser)))
+        visitor.visit_seq(self.inner)
-    }
-
-    fn deserialize_struct<V>(
-        self,
-        _name: &'static str,
-        fields: &'static [&'static str],
-        visitor: V,
-    ) -> Result<V::Value, Self::Error>
-    where
-        V: de::Visitor<'de>,
-    {
-        let pairs = self.parser.collect::<Vec<_>>();
-        let mut map = std::collections::VecDeque::new();
-        for field in fields {
-            let values = pairs
-                .iter()
-                .filter(|(f, _)| f == field)
-                .map(|(_f, v)| v.clone())
-                .collect::<Vec<_>>();
-            map.push_back((*field, values));
-        }
-        let parts = fields
-            .iter()
-            .map(|f| Part(Cow::Borrowed(f), None))
-            .zip(PartIterator(self.parser).map(|(_, mut v)| {
-                if let Some((_, val)) = map.pop_front() {
-                    v.1 = Some(val);
-                }
-                v
-            }))
-            .map(|(field, value)| (field, value));
-        visitor.visit_map(MapDeserializer::new(parts))
     }
 
     fn deserialize_unit<V>(self, visitor: V) -> Result<V::Value, Self::Error>
     where
         V: de::Visitor<'de>,
     {
-        MapDeserializer::new(PartIterator(self.parser)).end()?;
+        self.inner.end()?;
         visitor.visit_unit()
     }
 
-    serde::forward_to_deserialize_any! {
+    forward_to_deserialize_any! {
         bool
         u8
         u16
@@ -174,6 +144,7 @@ impl<'de> de::Deserializer<'de> for Deserializer<'de> {
         unit_struct
         newtype_struct
         tuple_struct
+        struct
         identifier
         tuple
         enum
@@ -187,11 +158,11 @@ impl<'de> Iterator for PartIterator<'de> {
     type Item = (Part<'de>, Part<'de>);
 
     fn next(&mut self) -> Option<Self::Item> {
-        self.0.next().map(|(k, v)| (Part(k, None), Part(v, None)))
+        self.0.next().map(|(k, v)| (Part(k), Part(v)))
     }
 }
 
-struct Part<'de>(Cow<'de, str>, Option<Vec<Cow<'de, str>>>);
+struct Part<'de>(Cow<'de, str>);
 
 impl<'de> IntoDeserializer<'de> for Part<'de> {
     type Deserializer = Self;
@@ -259,40 +230,7 @@ impl<'de> de::Deserializer<'de> for Part<'de> {
         visitor.visit_newtype_struct(self)
     }
 
-    fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+    forward_to_deserialize_any! {
-    where
-        V: de::Visitor<'de>,
-    {
-        let iter = self.1.ok_or_else(|| Error::custom("expected sequence"))?;
-        visitor.visit_seq(SeqDeserializer::new(
-            iter.into_iter().map(|v| Part(v, None)),
-        ))
-    }
-
-    fn deserialize_struct<V>(
-        self,
-        name: &'static str,
-        fields: &'static [&'static str],
-        visitor: V,
-    ) -> Result<V::Value, Self::Error>
-    where
-        V: de::Visitor<'de>,
-    {
-        let pairs = self
-            .1
-            .ok_or_else(|| Error::custom("percent decoding may have failed"))?;
-
-        let raw_json = pairs
-            .get(0)
-            .ok_or_else(|| Error::custom("no value found for nested struct"))?;
-
-        let mut de =
-            serde_json::de::Deserializer::from_reader(raw_json.as_bytes());
-        de.deserialize_struct(name, fields, visitor)
-            .map_err(|e| Error::custom(e.to_string()))
-    }
-
-    serde::forward_to_deserialize_any! {
         char
         str
         string
@@ -301,9 +239,11 @@ impl<'de> de::Deserializer<'de> for Part<'de> {
         byte_buf
         unit_struct
         tuple_struct
+        struct
         identifier
         tuple
         ignored_any
+        seq
         map
     }
 

src/urlencoded/error.rs

@@ -1,69 +0,0 @@
-use std::{borrow::Cow, error, fmt, str};
-
-use serde::ser;
-
-pub type Result<T> = std::result::Result<T, Error>;
-
-/// Errors returned during serializing to `application/x-www-form-urlencoded`.
-#[derive(Clone, Debug, PartialEq, Eq)]
-pub enum Error {
-    Custom(Cow<'static, str>),
-    Utf8(str::Utf8Error),
-}
-
-impl Error {
-    pub fn done() -> Self {
-        Error::Custom("this pair has already been serialized".into())
-    }
-
-    pub fn not_done() -> Self {
-        Error::Custom("this pair has not yet been serialized".into())
-    }
-
-    pub fn unsupported_pair() -> Self {
-        Error::Custom("unsupported pair".into())
-    }
-
-    pub fn top_level() -> Self {
-        let msg = "top-level serializer supports only maps and structs";
-        Error::Custom(msg.into())
-    }
-
-    pub fn no_key() -> Self {
-        let msg = "tried to serialize a value before serializing key";
-        Error::Custom(msg.into())
-    }
-}
-
-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 {
-    /// The lower-level cause of this error, in the case of a `Utf8` error.
-    fn cause(&self) -> Option<&dyn error::Error> {
-        match *self {
-            Error::Custom(_) => None,
-            Error::Utf8(ref err) => Some(err),
-        }
-    }
-
-    /// The lower-level source of this error, in the case of a `Utf8` error.
-    fn source(&self) -> Option<&(dyn error::Error + 'static)> {
-        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())
-    }
-}

src/urlencoded/ser.rs

@@ -5,14 +5,13 @@ mod pair;
 mod part;
 mod value;
 
-use std::{borrow::Cow, str};
-
 use serde::ser;
-use url::form_urlencoded::{
+use std::borrow::Cow;
-    Serializer as UrlEncodedSerializer, Target as UrlEncodedTarget,
+use std::error;
-};
+use std::fmt;
-
+use std::str;
-use crate::urlencoded::error::{Error, Result};
+use url::form_urlencoded::Serializer as UrlEncodedSerializer;
+use url::form_urlencoded::Target as UrlEncodedTarget;
 
 /// Serializes a value into a `application/x-www-form-urlencoded` `String` buffer.
 ///
@@ -28,7 +27,7 @@ use crate::urlencoded::error::{Error, Result};
 ///     ruma_serde::urlencoded::to_string(meal),
 ///     Ok("bread=baguette&cheese=comt%C3%A9&meat=ham&fat=butter".to_owned()));
 /// ```
-pub fn to_string<T: ser::Serialize>(input: T) -> Result<String> {
+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())
@@ -58,11 +57,49 @@ impl<'input, 'output, Target: 'output + UrlEncodedTarget>
     }
 }
 
+/// Errors returned during serializing to `application/x-www-form-urlencoded`.
+#[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 {
+    /// The lower-level cause of this error, in the case of a `Utf8` error.
+    fn cause(&self) -> Option<&dyn error::Error> {
+        match *self {
+            Error::Custom(_) => None,
+            Error::Utf8(ref err) => Some(err),
+        }
+    }
+
+    /// The lower-level source of this error, in the case of a `Utf8` error.
+    fn source(&self) -> Option<&(dyn error::Error + 'static)> {
+        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<'input, 'output, Target: 'output + UrlEncodedTarget> {
     urlencoder: &'output mut UrlEncodedSerializer<'input, Target>,
-    key: Option<Cow<'input, str>>,
-    count: usize,
 }
 
 /// Tuple serializer.
@@ -133,82 +170,85 @@ where
         StructVariantSerializer<'input, 'output, Target>;
 
     /// Returns an error.
-    fn serialize_bool(self, _v: bool) -> Result<Self::Ok> {
+    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> {
+    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> {
+    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> {
+    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> {
+    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> {
+    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> {
+    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> {
+    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> {
+    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> {
+    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> {
+    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> {
+    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> {
+    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> {
+    fn serialize_bytes(self, _value: &[u8]) -> Result<Self::Ok, Error> {
         Err(Error::top_level())
     }
 
     /// Returns `Ok`.
-    fn serialize_unit(self) -> Result<Self::Ok> {
+    fn serialize_unit(self) -> Result<Self::Ok, Error> {
         Ok(self.urlencoder)
     }
 
     /// Returns `Ok`.
-    fn serialize_unit_struct(self, _name: &'static str) -> Result<Self::Ok> {
+    fn serialize_unit_struct(
+        self,
+        _name: &'static str,
+    ) -> Result<Self::Ok, Error> {
         Ok(self.urlencoder)
     }
 
@@ -218,7 +258,7 @@ where
         _name: &'static str,
         _variant_index: u32,
         _variant: &'static str,
-    ) -> Result<Self::Ok> {
+    ) -> Result<Self::Ok, Error> {
         Err(Error::top_level())
     }
 
@@ -227,7 +267,7 @@ where
         self,
         _name: &'static str,
         value: &T,
-    ) -> Result<Self::Ok> {
+    ) -> Result<Self::Ok, Error> {
         value.serialize(self)
     }
 
@@ -238,12 +278,12 @@ where
         _variant_index: u32,
         _variant: &'static str,
         _value: &T,
-    ) -> Result<Self::Ok> {
+    ) -> Result<Self::Ok, Error> {
         Err(Error::top_level())
     }
 
     /// Returns `Ok`.
-    fn serialize_none(self) -> Result<Self::Ok> {
+    fn serialize_none(self) -> Result<Self::Ok, Error> {
         Ok(self.urlencoder)
     }
 
@@ -251,21 +291,25 @@ where
     fn serialize_some<T: ?Sized + ser::Serialize>(
         self,
         value: &T,
-    ) -> Result<Self::Ok> {
+    ) -> 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> {
+    fn serialize_seq(
+        self,
+        _len: Option<usize>,
+    ) -> Result<Self::SerializeSeq, Error> {
         Ok(SeqSerializer {
             urlencoder: self.urlencoder,
-            key: None,
-            count: 0,
         })
     }
 
     /// Returns an error.
-    fn serialize_tuple(self, _len: usize) -> Result<Self::SerializeTuple> {
+    fn serialize_tuple(
+        self,
+        _len: usize,
+    ) -> Result<Self::SerializeTuple, Error> {
         Ok(TupleSerializer {
             urlencoder: self.urlencoder,
         })
@@ -276,7 +320,7 @@ where
         self,
         _name: &'static str,
         _len: usize,
-    ) -> Result<Self::SerializeTupleStruct> {
+    ) -> Result<Self::SerializeTupleStruct, Error> {
         Err(Error::top_level())
     }
 
@@ -287,12 +331,15 @@ where
         _variant_index: u32,
         _variant: &'static str,
         _len: usize,
-    ) -> Result<Self::SerializeTupleVariant> {
+    ) -> 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> {
+    fn serialize_map(
+        self,
+        _len: Option<usize>,
+    ) -> Result<Self::SerializeMap, Error> {
         Ok(MapSerializer {
             urlencoder: self.urlencoder,
             key: None,
@@ -304,7 +351,7 @@ where
         self,
         _name: &'static str,
         _len: usize,
-    ) -> Result<Self::SerializeStruct> {
+    ) -> Result<Self::SerializeStruct, Error> {
         Ok(StructSerializer {
             urlencoder: self.urlencoder,
         })
@@ -317,7 +364,7 @@ where
         _variant_index: u32,
         _variant: &'static str,
         _len: usize,
-    ) -> Result<Self::SerializeStructVariant> {
+    ) -> Result<Self::SerializeStructVariant, Error> {
         Err(Error::top_level())
     }
 }
@@ -333,15 +380,11 @@ where
     fn serialize_element<T: ?Sized + ser::Serialize>(
         &mut self,
         value: &T,
-    ) -> Result<()> {
+    ) -> Result<(), Error> {
-        value.serialize(pair::PairSerializer::new(
+        value.serialize(pair::PairSerializer::new(self.urlencoder))
-            self.urlencoder,
-            self.key.as_ref(),
-            &mut self.count,
-        ))
     }
 
-    fn end(self) -> Result<Self::Ok> {
+    fn end(self) -> Result<Self::Ok, Error> {
         Ok(self.urlencoder)
     }
 }
@@ -357,15 +400,11 @@ where
     fn serialize_element<T: ?Sized + ser::Serialize>(
         &mut self,
         value: &T,
-    ) -> Result<()> {
+    ) -> Result<(), Error> {
-        value.serialize(pair::PairSerializer::new(
+        value.serialize(pair::PairSerializer::new(self.urlencoder))
-            self.urlencoder,
-            None,
-            &mut 0,
-        ))
     }
 
-    fn end(self) -> Result<Self::Ok> {
+    fn end(self) -> Result<Self::Ok, Error> {
         Ok(self.urlencoder)
     }
 }
@@ -381,11 +420,11 @@ where
     fn serialize_field<T: ?Sized + ser::Serialize>(
         &mut self,
         value: &T,
-    ) -> Result<()> {
+    ) -> Result<(), Error> {
         self.inner.serialize_field(value)
     }
 
-    fn end(self) -> Result<Self::Ok> {
+    fn end(self) -> Result<Self::Ok, Error> {
         self.inner.end()
     }
 }
@@ -401,11 +440,11 @@ where
     fn serialize_field<T: ?Sized + ser::Serialize>(
         &mut self,
         value: &T,
-    ) -> Result<()> {
+    ) -> Result<(), Error> {
         self.inner.serialize_field(value)
     }
 
-    fn end(self) -> Result<Self::Ok> {
+    fn end(self) -> Result<Self::Ok, Error> {
         self.inner.end()
     }
 }
@@ -425,7 +464,7 @@ where
         &mut self,
         key: &K,
         value: &V,
-    ) -> Result<()> {
+    ) -> 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))?;
@@ -439,7 +478,7 @@ where
     fn serialize_key<T: ?Sized + ser::Serialize>(
         &mut self,
         key: &T,
-    ) -> Result<()> {
+    ) -> 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)?);
@@ -449,7 +488,7 @@ where
     fn serialize_value<T: ?Sized + ser::Serialize>(
         &mut self,
         value: &T,
-    ) -> Result<()> {
+    ) -> Result<(), Error> {
         {
             let key = self.key.as_ref().ok_or_else(Error::no_key)?;
             let value_sink = value::ValueSink::new(self.urlencoder, &key);
@@ -459,7 +498,7 @@ where
         Ok(())
     }
 
-    fn end(self) -> Result<Self::Ok> {
+    fn end(self) -> Result<Self::Ok, Error> {
         Ok(self.urlencoder)
     }
 }
@@ -476,16 +515,12 @@ where
         &mut self,
         key: &'static str,
         value: &T,
-    ) -> Result<()> {
+    ) -> Result<(), Error> {
-        let key = Cow::Borrowed(key);
+        let value_sink = value::ValueSink::new(self.urlencoder, key);
-        let mut count = 0;
+        value.serialize(part::PartSerializer::new(value_sink))
-        let value_sink =
-            pair::PairSerializer::new(self.urlencoder, Some(&key), &mut count);
-        value.serialize(value_sink)?;
-        Ok(())
     }
 
-    fn end(self) -> Result<Self::Ok> {
+    fn end(self) -> Result<Self::Ok, Error> {
         Ok(self.urlencoder)
     }
 }
@@ -502,11 +537,23 @@ where
         &mut self,
         key: &'static str,
         value: &T,
-    ) -> Result<()> {
+    ) -> Result<(), Error> {
         self.inner.serialize_field(key, value)
     }
 
-    fn end(self) -> Result<Self::Ok> {
+    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())
+    }
+}

src/urlencoded/ser/key.rs

@@ -1,8 +1,7 @@
-use std::{borrow::Cow, ops::Deref};
-
-use serde::Serialize;
-
 use super::{part::Sink, Error};
+use serde::Serialize;
+use std::borrow::Cow;
+use std::ops::Deref;
 
 pub enum Key<'key> {
     Static(&'static str),

src/urlencoded/ser/pair.rs

@@ -1,39 +1,16 @@
-use std::{borrow::Cow, mem};
+use super::key::KeySink;
-
+use super::part::PartSerializer;
+use super::value::ValueSink;
+use super::Error;
 use serde::ser;
-use url::form_urlencoded::{
+use std::borrow::Cow;
-    Serializer as UrlEncodedSerializer, Target as UrlEncodedTarget,
+use std::mem;
-};
+use url::form_urlencoded::Serializer as UrlEncodedSerializer;
-
+use url::form_urlencoded::Target as UrlEncodedTarget;
-use crate::urlencoded::{
-    error::{Error, Result},
-    ser::{key::KeySink, part::PartSerializer, value::ValueSink},
-};
-
-macro_rules! serialize_pair {
-    ($($ty:ty => $name:ident,)*) => {
-        $(
-            fn $name(self, value: $ty) -> Result<()> {
-                let key = if let Some(key) = self.key {
-                    key.clone()
-                } else {
-                    return Err(Error::no_key());
-                };
-                let value_sink = ValueSink::new(self.urlencoder, &key);
-                let value_serializer = PartSerializer::new(value_sink);
-                value_serializer.$name(value)
-            }
-        )*
-    };
-}
 
 pub struct PairSerializer<'input, 'target, Target: 'target + UrlEncodedTarget> {
     urlencoder: &'target mut UrlEncodedSerializer<'input, Target>,
     state: PairState,
-    key: Option<&'target Cow<'target, str>>,
-    count: &'target mut usize,
-    len: usize,
-    json_buf: String,
 }
 
 impl<'input, 'target, Target> PairSerializer<'input, 'target, Target>
@@ -42,16 +19,10 @@ where
 {
     pub fn new(
         urlencoder: &'target mut UrlEncodedSerializer<'input, Target>,
-        key: Option<&'target Cow<'target, str>>,
-        count: &'target mut usize,
     ) -> Self {
         PairSerializer {
             urlencoder,
             state: PairState::WaitingForKey,
-            key,
-            count,
-            len: 0,
-            json_buf: String::new(),
         }
     }
 }
@@ -63,39 +34,75 @@ where
 {
     type Ok = ();
     type Error = Error;
-    type SerializeSeq = Self;
+    type SerializeSeq = ser::Impossible<(), Error>;
     type SerializeTuple = Self;
     type SerializeTupleStruct = ser::Impossible<(), Error>;
     type SerializeTupleVariant = ser::Impossible<(), Error>;
     type SerializeMap = ser::Impossible<(), Error>;
-    type SerializeStruct = Self;
+    type SerializeStruct = ser::Impossible<(), Error>;
     type SerializeStructVariant = ser::Impossible<(), Error>;
 
-    serialize_pair! {
+    fn serialize_bool(self, _v: bool) -> Result<(), Error> {
-        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<()> {
         Err(Error::unsupported_pair())
     }
 
-    fn serialize_unit(self) -> Result<()> {
+    fn serialize_i8(self, _v: i8) -> Result<(), Error> {
         Err(Error::unsupported_pair())
     }
 
-    fn serialize_unit_struct(self, _name: &'static str) -> Result<()> {
+    fn serialize_i16(self, _v: i16) -> Result<(), Error> {
+        Err(Error::unsupported_pair())
+    }
+
+    fn serialize_i32(self, _v: i32) -> Result<(), Error> {
+        Err(Error::unsupported_pair())
+    }
+
+    fn serialize_i64(self, _v: i64) -> Result<(), Error> {
+        Err(Error::unsupported_pair())
+    }
+
+    fn serialize_u8(self, _v: u8) -> Result<(), Error> {
+        Err(Error::unsupported_pair())
+    }
+
+    fn serialize_u16(self, _v: u16) -> Result<(), Error> {
+        Err(Error::unsupported_pair())
+    }
+
+    fn serialize_u32(self, _v: u32) -> Result<(), Error> {
+        Err(Error::unsupported_pair())
+    }
+
+    fn serialize_u64(self, _v: u64) -> Result<(), Error> {
+        Err(Error::unsupported_pair())
+    }
+
+    fn serialize_f32(self, _v: f32) -> Result<(), Error> {
+        Err(Error::unsupported_pair())
+    }
+
+    fn serialize_f64(self, _v: f64) -> Result<(), Error> {
+        Err(Error::unsupported_pair())
+    }
+
+    fn serialize_char(self, _v: char) -> Result<(), Error> {
+        Err(Error::unsupported_pair())
+    }
+
+    fn serialize_str(self, _value: &str) -> Result<(), Error> {
+        Err(Error::unsupported_pair())
+    }
+
+    fn serialize_bytes(self, _value: &[u8]) -> Result<(), Error> {
+        Err(Error::unsupported_pair())
+    }
+
+    fn serialize_unit(self) -> Result<(), Error> {
+        Err(Error::unsupported_pair())
+    }
+
+    fn serialize_unit_struct(self, _name: &'static str) -> Result<(), Error> {
         Err(Error::unsupported_pair())
     }
 
@@ -103,25 +110,16 @@ where
         self,
         _name: &'static str,
         _variant_index: u32,
-        variant: &'static str,
+        _variant: &'static str,
-    ) -> Result<()> {
+    ) -> Result<(), Error> {
-        let key = if let Some(key) = self.key {
+        Err(Error::unsupported_pair())
-            key.clone()
-        } else {
-            let key = Cow::Owned(self.count.to_string());
-            *self.count += 1;
-            key
-        };
-        let value_sink = ValueSink::new(self.urlencoder, &key);
-        let value_serializer = PartSerializer::new(value_sink);
-        value_serializer.serialize_str(variant)
     }
 
     fn serialize_newtype_struct<T: ?Sized + ser::Serialize>(
         self,
         _name: &'static str,
         value: &T,
-    ) -> Result<()> {
+    ) -> Result<(), Error> {
         value.serialize(self)
     }
 
@@ -131,26 +129,29 @@ where
         _variant_index: u32,
         _variant: &'static str,
         _value: &T,
-    ) -> Result<()> {
+    ) -> Result<(), Error> {
         Err(Error::unsupported_pair())
     }
 
-    fn serialize_none(self) -> Result<()> {
+    fn serialize_none(self) -> Result<(), Error> {
         Ok(())
     }
 
     fn serialize_some<T: ?Sized + ser::Serialize>(
         self,
         value: &T,
-    ) -> Result<()> {
+    ) -> Result<(), Error> {
         value.serialize(self)
     }
 
-    fn serialize_seq(self, _len: Option<usize>) -> Result<Self::SerializeSeq> {
+    fn serialize_seq(
-        Ok(self)
+        self,
+        _len: Option<usize>,
+    ) -> Result<Self::SerializeSeq, Error> {
+        Err(Error::unsupported_pair())
     }
 
-    fn serialize_tuple(self, len: usize) -> Result<Self> {
+    fn serialize_tuple(self, len: usize) -> Result<Self, Error> {
         if len == 2 {
             Ok(self)
         } else {
@@ -162,7 +163,7 @@ where
         self,
         _name: &'static str,
         _len: usize,
-    ) -> Result<Self::SerializeTupleStruct> {
+    ) -> Result<Self::SerializeTupleStruct, Error> {
         Err(Error::unsupported_pair())
     }
 
@@ -172,21 +173,23 @@ where
         _variant_index: u32,
         _variant: &'static str,
         _len: usize,
-    ) -> Result<Self::SerializeTupleVariant> {
+    ) -> Result<Self::SerializeTupleVariant, Error> {
         Err(Error::unsupported_pair())
     }
 
-    fn serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap> {
+    fn serialize_map(
+        self,
+        _len: Option<usize>,
+    ) -> Result<Self::SerializeMap, Error> {
         Err(Error::unsupported_pair())
     }
 
     fn serialize_struct(
-        mut self,
+        self,
         _name: &'static str,
-        len: usize,
+        _len: usize,
-    ) -> Result<Self::SerializeStruct> {
+    ) -> Result<Self::SerializeStruct, Error> {
-        self.len = len;
+        Err(Error::unsupported_pair())
-        Ok(self)
     }
 
     fn serialize_struct_variant(
@@ -195,80 +198,11 @@ where
         _variant_index: u32,
         _variant: &'static str,
         _len: usize,
-    ) -> Result<Self::SerializeStructVariant> {
+    ) -> Result<Self::SerializeStructVariant, Error> {
         Err(Error::unsupported_pair())
     }
 }
 
-impl<'input, 'target, Target> ser::SerializeStruct
-    for PairSerializer<'input, 'target, Target>
-where
-    Target: 'target + UrlEncodedTarget,
-{
-    type Ok = ();
-    type Error = Error;
-
-    fn serialize_field<T: ?Sized>(
-        &mut self,
-        key: &'static str,
-        value: &T,
-    ) -> Result<()>
-    where
-        T: ser::Serialize,
-    {
-        *self.count += 1;
-        if self.json_buf.is_empty() {
-            self.json_buf.push_str("{");
-        }
-        let json_blob = serde_json::to_string(value)
-            .map_err(|e| Error::Custom(e.to_string().into()))?;
-
-        if *self.count == self.len {
-            self.json_buf
-                .push_str(&format!("\"{}\":{}", key, json_blob));
-        } else {
-            self.json_buf
-                .push_str(&format!("\"{}\":{},", key, json_blob));
-        }
-        Ok(())
-    }
-
-    fn end(mut self) -> Result<Self::Ok> {
-        use serde::ser::Serialize;
-
-        self.json_buf.push_str("}");
-        self.json_buf.serialize(PairSerializer::new(
-            self.urlencoder,
-            self.key,
-            &mut self.count,
-        ))
-    }
-}
-
-impl<'input, 'target, Target> ser::SerializeSeq
-    for PairSerializer<'input, 'target, Target>
-where
-    Target: 'target + UrlEncodedTarget,
-{
-    type Ok = ();
-    type Error = Error;
-
-    fn serialize_element<T: ?Sized + ser::Serialize>(
-        &mut self,
-        value: &T,
-    ) -> Result<()> {
-        value.serialize(PairSerializer::new(
-            self.urlencoder,
-            self.key,
-            &mut self.count,
-        ))
-    }
-
-    fn end(self) -> Result<Self::Ok> {
-        Ok(())
-    }
-}
-
 impl<'input, 'target, Target> ser::SerializeTuple
     for PairSerializer<'input, 'target, Target>
 where
@@ -280,7 +214,7 @@ where
     fn serialize_element<T: ?Sized + ser::Serialize>(
         &mut self,
         value: &T,
-    ) -> Result<()> {
+    ) -> Result<(), Error> {
         match mem::replace(&mut self.state, PairState::Done) {
             PairState::WaitingForKey => {
                 let key_sink = KeySink::new(|key| Ok(key.into()));
@@ -307,7 +241,7 @@ where
         }
     }
 
-    fn end(self) -> Result<()> {
+    fn end(self) -> Result<(), Error> {
         if let PairState::Done = self.state {
             Ok(())
         } else {
@@ -321,3 +255,17 @@ enum PairState {
     WaitingForValue { key: Cow<'static, str> },
     Done,
 }
+
+impl Error {
+    fn done() -> Self {
+        Error::Custom("this pair has already been serialized".into())
+    }
+
+    fn not_done() -> Self {
+        Error::Custom("this pair has not yet been serialized".into())
+    }
+
+    fn unsupported_pair() -> Self {
+        Error::Custom("unsupported pair".into())
+    }
+}

src/urlencoded/ser/part.rs

@@ -2,7 +2,7 @@ use std::str;
 
 use serde::ser;
 
-use crate::urlencoded::error::Error;
+use super::Error;
 
 pub struct PartSerializer<S> {
     sink: S,

src/urlencoded/ser/value.rs

@@ -1,13 +1,13 @@
 use std::str;
 
-use serde::Serialize;
+use serde::ser::Serialize;
 use url::form_urlencoded::{
     Serializer as UrlEncodedSerializer, Target as UrlEncodedTarget,
 };
 
-use crate::urlencoded::{
+use super::{
-    error::Error,
+    part::{PartSerializer, Sink},
-    ser::part::{PartSerializer, Sink},
+    Error,
 };
 
 pub struct ValueSink<'input, 'key, 'target, Target>

tests/url_deserialize.rs

@@ -129,6 +129,7 @@ fn deserialize_mapstruct() {
 }
 
 #[test]
+#[ignore]
 fn deserialize_newstruct() {
     let de = NewStruct {
         list: vec!["hello".into(), "world".into()],
@@ -140,6 +141,7 @@ fn deserialize_newstruct() {
 }
 
 #[test]
+#[ignore]
 fn deserialize_numlist() {
     let de = NumList {
         list: vec![1, 2, 3, 4],
@@ -151,6 +153,7 @@ fn deserialize_numlist() {
 }
 
 #[test]
+#[ignore]
 fn deserialize_vec_bool() {
     assert_eq!(
         Wrapper {
@@ -162,6 +165,7 @@ fn deserialize_vec_bool() {
 }
 
 #[test]
+#[ignore]
 fn deserialize_vec_string() {
     assert_eq!(
         Wrapper {
@@ -177,6 +181,7 @@ fn deserialize_vec_string() {
 }
 
 #[test]
+#[ignore]
 fn deserialize_struct_unit_enum() {
     let result = Wrapper {
         item: vec![X::A, X::B, X::C],
@@ -203,6 +208,7 @@ struct InnerList<T> {
 }
 
 #[test]
+#[ignore]
 fn deserialize_nested() {
     let mut encoder = Encoder::new(String::new());
 
@@ -225,6 +231,7 @@ fn deserialize_nested() {
 }
 
 #[test]
+#[ignore]
 fn deserialize_nested_list() {
     let mut encoder = Encoder::new(String::new());
 
@@ -244,6 +251,7 @@ fn deserialize_nested_list() {
 }
 
 #[test]
+#[ignore]
 fn deserialize_nested_list_option() {
     let mut encoder = Encoder::new(String::new());
 

tests/url_serialize.rs

@@ -105,6 +105,7 @@ struct ListStruct {
 }
 
 #[test]
+#[ignore]
 fn serialize_newstruct() {
     let s = NewStruct {
         list: vec!["hello".into(), "world".into()],
@@ -116,6 +117,7 @@ fn serialize_newstruct() {
 }
 
 #[test]
+#[ignore]
 fn serialize_vec_bool() {
     let params = Wrapper {
         item: vec![true, false, false],
@@ -127,6 +129,7 @@ fn serialize_vec_bool() {
 }
 
 #[test]
+#[ignore]
 fn serialize_vec_num() {
     let params = Wrapper {
         item: vec![0, 1, 2],
@@ -138,6 +141,7 @@ fn serialize_vec_num() {
 }
 
 #[test]
+#[ignore]
 fn serialize_vec_str() {
     let params = Wrapper {
         item: vec!["hello", "world", "hello"],
@@ -149,6 +153,7 @@ fn serialize_vec_str() {
 }
 
 #[test]
+#[ignore]
 fn serialize_struct_opt() {
     let s = Struct {
         list: vec![Some("hello".into()), Some("world".into())],
@@ -160,6 +165,7 @@ fn serialize_struct_opt() {
 }
 
 #[test]
+#[ignore]
 fn serialize_struct_newtype() {
     let s = ListStruct {
         list: vec![NewType(0), NewType(1)],
@@ -171,6 +177,7 @@ fn serialize_struct_newtype() {
 }
 
 #[test]
+#[ignore]
 fn serialize_struct_unit_enum() {
     let params = Wrapper {
         item: vec![X::A, X::B, X::C],
@@ -210,6 +217,7 @@ struct InnerList<T> {
 }
 
 #[test]
+#[ignore]
 fn serialize_nested() {
     let mut encoder = Encoder::new(String::new());
 
@@ -229,6 +237,7 @@ fn serialize_nested() {
 }
 
 #[test]
+#[ignore]
 fn serialize_nested_list() {
     let mut encoder = Encoder::new(String::new());
 
@@ -244,6 +253,7 @@ fn serialize_nested_list() {
 }
 
 #[test]
+#[ignore]
 fn serialize_nested_list_option() {
     let mut encoder = Encoder::new(String::new());