Add serialization support for sequences

Sequences of values for one key are serialized as `key=value1&key=value2`

src/urlencoded/ser/key.rs

@@ -1,6 +1,6 @@
 use std::{borrow::Cow, ops::Deref};
 
-use serde::Serialize;
+use serde::ser;
 
 use super::{part::Sink, Error};
 
@@ -47,6 +47,7 @@ where
     End: for<'key> FnOnce(Key<'key>) -> Result<Ok, Error>,
 {
     type Ok = Ok;
+    type SerializeSeq = ser::Impossible<Self::Ok, Error>;
 
     fn serialize_static_str(self, value: &'static str) -> Result<Ok, Error> {
         (self.end)(Key::Static(value))
@@ -64,13 +65,17 @@ where
         Err(self.unsupported())
     }
 
-    fn serialize_some<T: ?Sized + Serialize>(
+    fn serialize_some<T: ?Sized + ser::Serialize>(
         self,
         _value: &T,
     ) -> Result<Ok, Error> {
         Err(self.unsupported())
     }
 
+    fn serialize_seq(self) -> Result<Self::SerializeSeq, Error> {
+        Err(self.unsupported())
+    }
+
     fn unsupported(self) -> Error {
         Error::Custom("unsupported key".into())
     }

src/urlencoded/ser/part.rs

@@ -16,6 +16,7 @@ impl<S: Sink> PartSerializer<S> {
 
 pub trait Sink: Sized {
     type Ok;
+    type SerializeSeq: ser::SerializeSeq<Ok = Self::Ok, Error = Error>;
 
     fn serialize_static_str(
         self,
@@ -31,13 +32,15 @@ pub trait Sink: Sized {
         value: &T,
     ) -> Result<Self::Ok, Error>;
 
+    fn serialize_seq(self) -> Result<Self::SerializeSeq, Error>;
+
     fn unsupported(self) -> Error;
 }
 
 impl<S: Sink> ser::Serializer for PartSerializer<S> {
     type Ok = S::Ok;
     type Error = Error;
-    type SerializeSeq = ser::Impossible<S::Ok, Error>;
+    type SerializeSeq = S::SerializeSeq;
     type SerializeTuple = ser::Impossible<S::Ok, Error>;
     type SerializeTupleStruct = ser::Impossible<S::Ok, Error>;
     type SerializeTupleVariant = ser::Impossible<S::Ok, Error>;
@@ -155,7 +158,7 @@ impl<S: Sink> ser::Serializer for PartSerializer<S> {
         self,
         _len: Option<usize>,
     ) -> Result<Self::SerializeSeq, Error> {
-        Err(self.sink.unsupported())
+        self.sink.serialize_seq()
     }
 
     fn serialize_tuple(

src/urlencoded/ser/value.rs

@@ -1,6 +1,6 @@
 use std::str;
 
-use serde::ser::Serialize;
+use serde::ser;
 use url::form_urlencoded::{
     Serializer as UrlEncodedSerializer, Target as UrlEncodedTarget,
 };
@@ -36,6 +36,7 @@ where
     Target: 'target + UrlEncodedTarget,
 {
     type Ok = ();
+    type SerializeSeq = Self;
 
     fn serialize_str(self, value: &str) -> Result<(), Error> {
         self.urlencoder.append_pair(self.key, value);
@@ -54,14 +55,41 @@ where
         Ok(())
     }
 
-    fn serialize_some<T: ?Sized + Serialize>(
+    fn serialize_some<T: ?Sized + ser::Serialize>(
         self,
         value: &T,
     ) -> Result<Self::Ok, Error> {
         value.serialize(PartSerializer::new(self))
     }
 
+    fn serialize_seq(self) -> Result<Self, Error> {
+        Ok(self)
+    }
+
     fn unsupported(self) -> Error {
         Error::Custom("unsupported value".into())
     }
 }
+
+impl<'a, 'input, 'key, 'target, Target> ser::SerializeSeq
+    for &'a mut ValueSink<'input, 'key, 'target, Target>
+where
+    Target: 'target + UrlEncodedTarget,
+{
+    type Ok = ();
+    type Error = Error;
+
+    fn serialize_element<T: ?Sized>(
+        &mut self,
+        value: &T,
+    ) -> Result<(), Self::Error>
+    where
+        T: ser::Serialize,
+    {
+        value.serialize(PartSerializer::new(&mut **self))
+    }
+
+    fn end(self) -> Result<Self::Ok, Self::Error> {
+        Ok(())
+    }
+}

tests/url_serialize.rs

@@ -105,7 +105,6 @@ struct ListStruct {
 }
 
 #[test]
-#[ignore]
 fn serialize_newstruct() {
     let s = NewStruct {
         list: vec!["hello".into(), "world".into()],
@@ -117,7 +116,6 @@ fn serialize_newstruct() {
 }
 
 #[test]
-#[ignore]
 fn serialize_vec_bool() {
     let params = Wrapper {
         item: vec![true, false, false],
@@ -129,7 +127,6 @@ fn serialize_vec_bool() {
 }
 
 #[test]
-#[ignore]
 fn serialize_vec_num() {
     let params = Wrapper {
         item: vec![0, 1, 2],
@@ -141,7 +138,6 @@ fn serialize_vec_num() {
 }
 
 #[test]
-#[ignore]
 fn serialize_vec_str() {
     let params = Wrapper {
         item: vec!["hello", "world", "hello"],
@@ -153,7 +149,6 @@ fn serialize_vec_str() {
 }
 
 #[test]
-#[ignore]
 fn serialize_struct_opt() {
     let s = Struct {
         list: vec![Some("hello".into()), Some("world".into())],
@@ -165,7 +160,6 @@ fn serialize_struct_opt() {
 }
 
 #[test]
-#[ignore]
 fn serialize_struct_newtype() {
     let s = ListStruct {
         list: vec![NewType(0), NewType(1)],
@@ -177,7 +171,6 @@ fn serialize_struct_newtype() {
 }
 
 #[test]
-#[ignore]
 fn serialize_struct_unit_enum() {
     let params = Wrapper {
         item: vec![X::A, X::B, X::C],