From 01562cb7acc4aed8e8ab928054c7590d59b906f3 Mon Sep 17 00:00:00 2001 From: Jonas Platte Date: Wed, 13 May 2020 21:26:54 +0200 Subject: [PATCH] Revert urlencoded to plain serde_urlencoded logic temporarily --- src/urlencoded.rs | 1 - src/urlencoded/de.rs | 100 +++----------- src/urlencoded/error.rs | 69 ---------- src/urlencoded/ser.rs | 191 ++++++++++++++++---------- src/urlencoded/ser/key.rs | 7 +- src/urlencoded/ser/pair.rs | 262 +++++++++++++++--------------------- src/urlencoded/ser/part.rs | 2 +- src/urlencoded/ser/value.rs | 8 +- tests/url_deserialize.rs | 8 ++ tests/url_serialize.rs | 10 ++ 10 files changed, 270 insertions(+), 388 deletions(-) delete mode 100644 src/urlencoded/error.rs diff --git a/src/urlencoded.rs b/src/urlencoded.rs index ee9ef0c4..9eb39786 100644 --- a/src/urlencoded.rs +++ b/src/urlencoded.rs @@ -1,7 +1,6 @@ //! `x-www-form-urlencoded` meets Serde pub mod de; -pub mod error; pub mod ser; #[doc(inline)] diff --git a/src/urlencoded/de.rs b/src/urlencoded/de.rs index cc35a0d2..0e09beb3 100644 --- a/src/urlencoded/de.rs +++ b/src/urlencoded/de.rs @@ -2,10 +2,9 @@ use std::{borrow::Cow, io::Read}; -use serde::de::{ - self, - value::{MapDeserializer, SeqDeserializer}, - Error as de_Error, IntoDeserializer, +use serde::{ + de::{self, value::MapDeserializer, Error as de_Error, IntoDeserializer}, + forward_to_deserialize_any, }; 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(self, visitor: V) -> Result where V: de::Visitor<'de>, { - visitor.visit_seq(MapDeserializer::new(PartIterator(self.parser))) - } - - fn deserialize_struct( - self, - _name: &'static str, - fields: &'static [&'static str], - visitor: V, - ) -> Result - where - V: de::Visitor<'de>, - { - let pairs = self.parser.collect::>(); - 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::>(); - 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)) + visitor.visit_seq(self.inner) } fn deserialize_unit(self, visitor: V) -> Result 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.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>>); +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(self, visitor: V) -> Result - 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( - self, - name: &'static str, - fields: &'static [&'static str], - visitor: V, - ) -> Result - 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! { + 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 } diff --git a/src/urlencoded/error.rs b/src/urlencoded/error.rs deleted file mode 100644 index 32a387cd..00000000 --- a/src/urlencoded/error.rs +++ /dev/null @@ -1,69 +0,0 @@ -use std::{borrow::Cow, error, fmt, str}; - -use serde::ser; - -pub type Result = std::result::Result; - -/// 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(msg: T) -> Self { - Error::Custom(format!("{}", msg).into()) - } -} diff --git a/src/urlencoded/ser.rs b/src/urlencoded/ser.rs index 71e4db16..e440ca25 100644 --- a/src/urlencoded/ser.rs +++ b/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::{ - Serializer as UrlEncodedSerializer, Target as UrlEncodedTarget, -}; - -use crate::urlencoded::error::{Error, Result}; +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 `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(input: T) -> Result { +pub fn to_string(input: T) -> Result { 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(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>, - count: usize, } /// Tuple serializer. @@ -133,82 +170,85 @@ where StructVariantSerializer<'input, 'output, Target>; /// Returns an error. - fn serialize_bool(self, _v: bool) -> Result { + fn serialize_bool(self, _v: bool) -> Result { Err(Error::top_level()) } /// Returns an error. - fn serialize_i8(self, _v: i8) -> Result { + fn serialize_i8(self, _v: i8) -> Result { Err(Error::top_level()) } /// Returns an error. - fn serialize_i16(self, _v: i16) -> Result { + fn serialize_i16(self, _v: i16) -> Result { Err(Error::top_level()) } /// Returns an error. - fn serialize_i32(self, _v: i32) -> Result { + fn serialize_i32(self, _v: i32) -> Result { Err(Error::top_level()) } /// Returns an error. - fn serialize_i64(self, _v: i64) -> Result { + fn serialize_i64(self, _v: i64) -> Result { Err(Error::top_level()) } /// Returns an error. - fn serialize_u8(self, _v: u8) -> Result { + fn serialize_u8(self, _v: u8) -> Result { Err(Error::top_level()) } /// Returns an error. - fn serialize_u16(self, _v: u16) -> Result { + fn serialize_u16(self, _v: u16) -> Result { Err(Error::top_level()) } /// Returns an error. - fn serialize_u32(self, _v: u32) -> Result { + fn serialize_u32(self, _v: u32) -> Result { Err(Error::top_level()) } /// Returns an error. - fn serialize_u64(self, _v: u64) -> Result { + fn serialize_u64(self, _v: u64) -> Result { Err(Error::top_level()) } /// Returns an error. - fn serialize_f32(self, _v: f32) -> Result { + fn serialize_f32(self, _v: f32) -> Result { Err(Error::top_level()) } /// Returns an error. - fn serialize_f64(self, _v: f64) -> Result { + fn serialize_f64(self, _v: f64) -> Result { Err(Error::top_level()) } /// Returns an error. - fn serialize_char(self, _v: char) -> Result { + fn serialize_char(self, _v: char) -> Result { Err(Error::top_level()) } /// Returns an error. - fn serialize_str(self, _value: &str) -> Result { + fn serialize_str(self, _value: &str) -> Result { Err(Error::top_level()) } /// Returns an error. - fn serialize_bytes(self, _value: &[u8]) -> Result { + fn serialize_bytes(self, _value: &[u8]) -> Result { Err(Error::top_level()) } /// Returns `Ok`. - fn serialize_unit(self) -> Result { + fn serialize_unit(self) -> Result { Ok(self.urlencoder) } /// Returns `Ok`. - fn serialize_unit_struct(self, _name: &'static str) -> Result { + fn serialize_unit_struct( + self, + _name: &'static str, + ) -> Result { Ok(self.urlencoder) } @@ -218,7 +258,7 @@ where _name: &'static str, _variant_index: u32, _variant: &'static str, - ) -> Result { + ) -> Result { Err(Error::top_level()) } @@ -227,7 +267,7 @@ where self, _name: &'static str, value: &T, - ) -> Result { + ) -> Result { value.serialize(self) } @@ -238,12 +278,12 @@ where _variant_index: u32, _variant: &'static str, _value: &T, - ) -> Result { + ) -> Result { Err(Error::top_level()) } /// Returns `Ok`. - fn serialize_none(self) -> Result { + fn serialize_none(self) -> Result { Ok(self.urlencoder) } @@ -251,21 +291,25 @@ where fn serialize_some( self, value: &T, - ) -> Result { + ) -> Result { value.serialize(self) } /// Serialize a sequence, given length (if any) is ignored. - fn serialize_seq(self, _len: Option) -> Result { + fn serialize_seq( + self, + _len: Option, + ) -> Result { Ok(SeqSerializer { urlencoder: self.urlencoder, - key: None, - count: 0, }) } /// Returns an error. - fn serialize_tuple(self, _len: usize) -> Result { + fn serialize_tuple( + self, + _len: usize, + ) -> Result { Ok(TupleSerializer { urlencoder: self.urlencoder, }) @@ -276,7 +320,7 @@ where self, _name: &'static str, _len: usize, - ) -> Result { + ) -> Result { Err(Error::top_level()) } @@ -287,12 +331,15 @@ where _variant_index: u32, _variant: &'static str, _len: usize, - ) -> Result { + ) -> Result { Err(Error::top_level()) } /// Serializes a map, given length is ignored. - fn serialize_map(self, _len: Option) -> Result { + fn serialize_map( + self, + _len: Option, + ) -> Result { Ok(MapSerializer { urlencoder: self.urlencoder, key: None, @@ -304,7 +351,7 @@ where self, _name: &'static str, _len: usize, - ) -> Result { + ) -> Result { Ok(StructSerializer { urlencoder: self.urlencoder, }) @@ -317,7 +364,7 @@ where _variant_index: u32, _variant: &'static str, _len: usize, - ) -> Result { + ) -> Result { Err(Error::top_level()) } } @@ -333,15 +380,11 @@ where fn serialize_element( &mut self, value: &T, - ) -> Result<()> { - value.serialize(pair::PairSerializer::new( - self.urlencoder, - self.key.as_ref(), - &mut self.count, - )) + ) -> Result<(), Error> { + value.serialize(pair::PairSerializer::new(self.urlencoder)) } - fn end(self) -> Result { + fn end(self) -> Result { Ok(self.urlencoder) } } @@ -357,15 +400,11 @@ where fn serialize_element( &mut self, value: &T, - ) -> Result<()> { - value.serialize(pair::PairSerializer::new( - self.urlencoder, - None, - &mut 0, - )) + ) -> Result<(), Error> { + value.serialize(pair::PairSerializer::new(self.urlencoder)) } - fn end(self) -> Result { + fn end(self) -> Result { Ok(self.urlencoder) } } @@ -381,11 +420,11 @@ where fn serialize_field( &mut self, value: &T, - ) -> Result<()> { + ) -> Result<(), Error> { self.inner.serialize_field(value) } - fn end(self) -> Result { + fn end(self) -> Result { self.inner.end() } } @@ -401,11 +440,11 @@ where fn serialize_field( &mut self, value: &T, - ) -> Result<()> { + ) -> Result<(), Error> { self.inner.serialize_field(value) } - fn end(self) -> Result { + fn end(self) -> Result { 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( &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( &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 { + fn end(self) -> Result { Ok(self.urlencoder) } } @@ -476,16 +515,12 @@ where &mut self, key: &'static str, value: &T, - ) -> Result<()> { - let key = Cow::Borrowed(key); - let mut count = 0; - let value_sink = - pair::PairSerializer::new(self.urlencoder, Some(&key), &mut count); - value.serialize(value_sink)?; - Ok(()) + ) -> Result<(), Error> { + let value_sink = value::ValueSink::new(self.urlencoder, key); + value.serialize(part::PartSerializer::new(value_sink)) } - fn end(self) -> Result { + fn end(self) -> Result { 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 { + fn end(self) -> Result { 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/urlencoded/ser/key.rs b/src/urlencoded/ser/key.rs index 6f65ecb4..d2c8a92e 100644 --- a/src/urlencoded/ser/key.rs +++ b/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), diff --git a/src/urlencoded/ser/pair.rs b/src/urlencoded/ser/pair.rs index ba2e521c..01e3f82a 100644 --- a/src/urlencoded/ser/pair.rs +++ b/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::{ - Serializer as UrlEncodedSerializer, 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) - } - )* - }; -} +use std::borrow::Cow; +use std::mem; +use url::form_urlencoded::Serializer as UrlEncodedSerializer; +use url::form_urlencoded::Target as UrlEncodedTarget; 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! { - 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<()> { + fn serialize_bool(self, _v: bool) -> Result<(), Error> { 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, - ) -> Result<()> { - let key = if let Some(key) = self.key { - 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) + _variant: &'static str, + ) -> Result<(), Error> { + Err(Error::unsupported_pair()) } fn serialize_newtype_struct( 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( self, value: &T, - ) -> Result<()> { + ) -> Result<(), Error> { value.serialize(self) } - fn serialize_seq(self, _len: Option) -> Result { - Ok(self) + fn serialize_seq( + self, + _len: Option, + ) -> Result { + Err(Error::unsupported_pair()) } - fn serialize_tuple(self, len: usize) -> Result { + fn serialize_tuple(self, len: usize) -> Result { if len == 2 { Ok(self) } else { @@ -162,7 +163,7 @@ where self, _name: &'static str, _len: usize, - ) -> Result { + ) -> Result { Err(Error::unsupported_pair()) } @@ -172,21 +173,23 @@ where _variant_index: u32, _variant: &'static str, _len: usize, - ) -> Result { + ) -> Result { Err(Error::unsupported_pair()) } - fn serialize_map(self, _len: Option) -> Result { + fn serialize_map( + self, + _len: Option, + ) -> Result { Err(Error::unsupported_pair()) } fn serialize_struct( - mut self, + self, _name: &'static str, - len: usize, - ) -> Result { - self.len = len; - Ok(self) + _len: usize, + ) -> Result { + Err(Error::unsupported_pair()) } fn serialize_struct_variant( @@ -195,80 +198,11 @@ where _variant_index: u32, _variant: &'static str, _len: usize, - ) -> Result { + ) -> Result { 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( - &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 { - 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( - &mut self, - value: &T, - ) -> Result<()> { - value.serialize(PairSerializer::new( - self.urlencoder, - self.key, - &mut self.count, - )) - } - - fn end(self) -> Result { - Ok(()) - } -} - impl<'input, 'target, Target> ser::SerializeTuple for PairSerializer<'input, 'target, Target> where @@ -280,7 +214,7 @@ where fn serialize_element( &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()) + } +} diff --git a/src/urlencoded/ser/part.rs b/src/urlencoded/ser/part.rs index 1f067c28..b55f2d15 100644 --- a/src/urlencoded/ser/part.rs +++ b/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 { sink: S, diff --git a/src/urlencoded/ser/value.rs b/src/urlencoded/ser/value.rs index e8db4576..37aa3b11 100644 --- a/src/urlencoded/ser/value.rs +++ b/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::{ - error::Error, - ser::part::{PartSerializer, Sink}, +use super::{ + part::{PartSerializer, Sink}, + Error, }; pub struct ValueSink<'input, 'key, 'target, Target> diff --git a/tests/url_deserialize.rs b/tests/url_deserialize.rs index 4728bfc3..2947035b 100644 --- a/tests/url_deserialize.rs +++ b/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 { } #[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()); diff --git a/tests/url_serialize.rs b/tests/url_serialize.rs index b9381420..c818187f 100644 --- a/tests/url_serialize.rs +++ b/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 { } #[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());