chris/ruwuma
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Update to serde 1.0.0

Browse Source
This commit is contained in:
Ted Driggs 2017-04-20 15:49:30 -07:00 committed by Anthony Ramine
parent 43858d329e
commit abb8d81f9f
5 changed files with 100 additions and 116 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
Cargo.toml
View File

@ -1,6 +1,6 @@
[package] [package]
name = "serde_urlencoded" name = "serde_urlencoded"
version = "0.4.3" version = "0.5.0"
authors = ["Anthony Ramine <n.oxyde@gmail.com>"] authors = ["Anthony Ramine <n.oxyde@gmail.com>"]
license = "MIT/Apache-2.0" license = "MIT/Apache-2.0"
repository = "https://github.com/nox/serde_urlencoded" repository = "https://github.com/nox/serde_urlencoded"
@ -18,5 +18,5 @@ test = false
[dependencies] [dependencies]
dtoa = "0.4.0" dtoa = "0.4.0"
itoa = "0.3.0" itoa = "0.3.0"
serde = "0.9.3" serde = "1.0.0"
url = "1.0.0" url = "1.0.0"

147
src/de.rs
View File

@ -1,16 +1,15 @@
//! Deserialization support for the `application/x-www-form-urlencoded` format. //! Deserialization support for the `application/x-www-form-urlencoded` format.
use serde::de; use serde::de::{self, IntoDeserializer};
use serde::de::value::{MapDeserializer, ValueDeserializer as SerdeValueDeserializer};
use serde::de::value::MapDeserializer;
use std::borrow::Cow;
use std::io::Read;
use url::form_urlencoded::Parse as UrlEncodedParse;
use url::form_urlencoded::parse;
#[doc(inline)] #[doc(inline)]
pub use serde::de::value::Error; pub use serde::de::value::Error;
use std::borrow::Cow;
use std::io::Read;
use std::iter::Map;
use std::marker::PhantomData;
use url::form_urlencoded::Parse as UrlEncodedParse;
use url::form_urlencoded::parse;
/// Deserializes a `application/x-wwww-url-encoded` value from a `&[u8]`. /// Deserializes a `application/x-wwww-url-encoded` value from a `&[u8]`.
/// ///
@ -27,7 +26,9 @@ use url::form_urlencoded::parse;
/// b"bread=baguette&cheese=comt%C3%A9&meat=ham&fat=butter"), /// b"bread=baguette&cheese=comt%C3%A9&meat=ham&fat=butter"),
/// Ok(meal)); /// Ok(meal));
/// ``` /// ```
pub fn from_bytes<T: de::Deserialize>(input: &[u8]) -> Result<T, Error> { pub fn from_bytes<'de, T>(input: &'de [u8]) -> Result<T, Error>
where T: de::Deserialize<'de>,
{
T::deserialize(Deserializer::new(parse(input))) T::deserialize(Deserializer::new(parse(input)))
} }
@ -46,14 +47,16 @@ pub fn from_bytes<T: de::Deserialize>(input: &[u8]) -> Result<T, Error> {
/// "bread=baguette&cheese=comt%C3%A9&meat=ham&fat=butter"), /// "bread=baguette&cheese=comt%C3%A9&meat=ham&fat=butter"),
/// Ok(meal)); /// Ok(meal));
/// ``` /// ```
pub fn from_str<T: de::Deserialize>(input: &str) -> Result<T, Error> { pub fn from_str<'de, T>(input: &'de str) -> Result<T, Error>
where T: de::Deserialize<'de>,
{
from_bytes(input.as_bytes()) from_bytes(input.as_bytes())
} }
/// Convenience function that reads all bytes from `reader` and deserializes /// Convenience function that reads all bytes from `reader` and deserializes
/// them with `from_bytes`. /// them with `from_bytes`.
pub fn from_reader<T, R>(mut reader: R) -> Result<T, Error> pub fn from_reader<T, R>(mut reader: R) -> Result<T, Error>
where T: de::Deserialize, where T: de::DeserializeOwned,
R: Read, R: Read,
{ {
let mut buf = vec![]; let mut buf = vec![];
@ -73,53 +76,41 @@ pub fn from_reader<T, R>(mut reader: R) -> Result<T, Error>
/// ///
/// * Everything else but `deserialize_seq` and `deserialize_seq_fixed_size` /// * Everything else but `deserialize_seq` and `deserialize_seq_fixed_size`
/// defers to `deserialize`. /// defers to `deserialize`.
pub struct Deserializer<'a> { pub struct Deserializer<'de> {
inner: MapDeserializer<Map<UrlEncodedParse<'a>, inner: MapDeserializer<'de, PartIterator<'de>, Error>,
fn((Cow<'a, str>, Cow<'a, str>))
-> (Cow<'a, str>, Value<'a>)>,
Error>,
} }
impl<'a> Deserializer<'a> { impl<'de> Deserializer<'de> {
/// Returns a new `Deserializer`. /// Returns a new `Deserializer`.
pub fn new(parser: UrlEncodedParse<'a>) -> Self { pub fn new(parser: UrlEncodedParse<'de>) -> Self {
Deserializer { Deserializer {
inner: MapDeserializer::new(parser.map(Value::wrap_pair)), inner: MapDeserializer::new(PartIterator(parser)),
} }
} }
} }
impl<'a> de::Deserializer for Deserializer<'a> { impl<'de> de::Deserializer<'de> for Deserializer<'de> {
type Error = Error; type Error = Error;
fn deserialize<V>(self, visitor: V) -> Result<V::Value, Self::Error> fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
where V: de::Visitor, where V: de::Visitor<'de>,
{ {
self.deserialize_map(visitor) self.deserialize_map(visitor)
} }
fn deserialize_map<V>(self, visitor: V) -> Result<V::Value, Self::Error> fn deserialize_map<V>(self, visitor: V) -> Result<V::Value, Self::Error>
where V: de::Visitor, where V: de::Visitor<'de>,
{ {
visitor.visit_map(self.inner) visitor.visit_map(self.inner)
} }
fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value, Self::Error> fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value, Self::Error>
where V: de::Visitor, where V: de::Visitor<'de>,
{ {
visitor.visit_seq(self.inner) visitor.visit_seq(self.inner)
} }
fn deserialize_seq_fixed_size<V>(self, forward_to_deserialize_any! {
_len: usize,
visitor: V)
-> Result<V::Value, Self::Error>
where V: de::Visitor,
{
visitor.visit_seq(self.inner)
}
forward_to_deserialize! {
bool bool
u8 u8
u16 u16
@ -142,68 +133,65 @@ impl<'a> de::Deserializer for Deserializer<'a> {
newtype_struct newtype_struct
tuple_struct tuple_struct
struct struct
struct_field identifier
tuple tuple
enum enum
ignored_any ignored_any
} }
} }
struct Value<'a>(Cow<'a, str>); struct PartIterator<'de>(UrlEncodedParse<'de>);
impl<'a> Value<'a> { impl<'de> Iterator for PartIterator<'de> {
fn wrap_pair((k, v): (Cow<'a, str>, Cow<'a, str>)) -> (Cow<'a, str>, Self) { type Item = (Part<'de>, Part<'de>);
(k, Value(v))
fn next(&mut self) -> Option<Self::Item> {
self.0.next().map(|(k, v)| (Part(k), Part(v)))
} }
} }
impl<'a, E> SerdeValueDeserializer<E> for Value<'a> struct Part<'de>(Cow<'de, str>);
where E: de::Error,
impl<'de> IntoDeserializer<'de> for Part<'de>
{ {
type Deserializer = ValueDeserializer<'a, E>; type Deserializer = Self;
fn into_deserializer(self) -> Self::Deserializer { fn into_deserializer(self) -> Self::Deserializer {
ValueDeserializer { self
value: self.0,
marker: PhantomData,
}
} }
} }
struct ValueDeserializer<'a, E> { macro_rules! forward_parsed_value {
value: Cow<'a, str>, ($($ty:ident => $method:ident,)*) => {
marker: PhantomData<E>, $(
} fn $method<V>(self, visitor: V) -> Result<V::Value, Self::Error>
where V: de::Visitor<'de>
impl<'a, E> de::Deserializer for ValueDeserializer<'a, E>
where E: de::Error,
{ {
type Error = E; match self.0.parse::<$ty>() {
Ok(val) => val.into_deserializer().$method(visitor),
Err(e) => Err(de::Error::custom(e))
}
}
)*
}
}
fn deserialize<V>(self, visitor: V) -> Result<V::Value, Self::Error> impl<'de> de::Deserializer<'de> for Part<'de> {
where V: de::Visitor, type Error = Error;
fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
where V: de::Visitor<'de>,
{ {
self.value.into_deserializer().deserialize(visitor) self.0.into_deserializer().deserialize_any(visitor)
} }
fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Self::Error> fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Self::Error>
where V: de::Visitor, where V: de::Visitor<'de>,
{ {
visitor.visit_some(self.value.into_deserializer()) visitor.visit_some(self)
} }
forward_to_deserialize! { forward_to_deserialize_any! {
bool
u8
u16
u32
u64
i8
i16
i32
i64
f32
f64
char char
str str
string string
@ -214,12 +202,25 @@ impl<'a, E> de::Deserializer for ValueDeserializer<'a, E>
newtype_struct newtype_struct
tuple_struct tuple_struct
struct struct
struct_field identifier
tuple tuple
enum enum
ignored_any ignored_any
seq seq
seq_fixed_size
map map
} }
forward_parsed_value! {
bool => deserialize_bool,
u8 => deserialize_u8,
u16 => deserialize_u16,
u32 => deserialize_u32,
u64 => deserialize_u64,
i8 => deserialize_i8,
i16 => deserialize_i16,
i32 => deserialize_i32,
i64 => deserialize_i64,
f32 => deserialize_f32,
f64 => deserialize_f64,
}
} }

38
src/ser/mod.rs
View File

@ -27,7 +27,7 @@ use url::form_urlencoded::Target as UrlEncodedTarget;
/// serde_urlencoded::to_string(meal), /// serde_urlencoded::to_string(meal),
/// Ok("bread=baguette&cheese=comt%C3%A9&meat=ham&fat=butter".to_owned())); /// Ok("bread=baguette&cheese=comt%C3%A9&meat=ham&fat=butter".to_owned()));
/// ``` /// ```
pub fn to_string<T: ser::Serialize>(input: &T) -> Result<String, Error> { pub fn to_string<T: ser::Serialize>(input: T) -> Result<String, Error> {
let mut urlencoder = UrlEncodedSerializer::new("".to_owned()); let mut urlencoder = UrlEncodedSerializer::new("".to_owned());
input.serialize(Serializer::new(&mut urlencoder))?; input.serialize(Serializer::new(&mut urlencoder))?;
Ok(urlencoder.finish()) Ok(urlencoder.finish())
@ -99,9 +99,9 @@ pub struct SeqSerializer<'output, Target: 'output + UrlEncodedTarget> {
/// Tuple serializer. /// Tuple serializer.
/// ///
/// Never instantiated, tuples are not supported at top-level. /// Mostly used for arrays.
pub struct TupleSerializer<'output, T: 'output + UrlEncodedTarget> { pub struct TupleSerializer<'output, Target: 'output + UrlEncodedTarget> {
inner: ser::Impossible<&'output mut UrlEncodedSerializer<T>, Error>, urlencoder: &'output mut UrlEncodedSerializer<Target>,
} }
/// Tuple struct serializer. /// Tuple struct serializer.
@ -234,7 +234,7 @@ impl<'output, Target> ser::Serializer for Serializer<'output, Target>
/// Returns an error. /// Returns an error.
fn serialize_unit_variant(self, fn serialize_unit_variant(self,
_name: &'static str, _name: &'static str,
_variant_index: usize, _variant_index: u32,
_variant: &'static str) _variant: &'static str)
-> Result<Self::Ok, Error> { -> Result<Self::Ok, Error> {
Err(Error::top_level()) Err(Error::top_level())
@ -253,7 +253,7 @@ impl<'output, Target> ser::Serializer for Serializer<'output, Target>
fn serialize_newtype_variant<T: ?Sized + ser::Serialize> fn serialize_newtype_variant<T: ?Sized + ser::Serialize>
(self, (self,
_name: &'static str, _name: &'static str,
_variant_index: usize, _variant_index: u32,
_variant: &'static str, _variant: &'static str,
_value: &T) _value: &T)
-> Result<Self::Ok, Error> { -> Result<Self::Ok, Error> {
@ -280,18 +280,11 @@ impl<'output, Target> ser::Serializer for Serializer<'output, Target>
Ok(SeqSerializer { urlencoder: self.urlencoder }) Ok(SeqSerializer { urlencoder: self.urlencoder })
} }
/// Serializes a sequence, given length is ignored.
fn serialize_seq_fixed_size(self,
_len: usize)
-> Result<Self::SerializeSeq, Error> {
Ok(SeqSerializer { urlencoder: self.urlencoder })
}
/// Returns an error. /// Returns an error.
fn serialize_tuple(self, fn serialize_tuple(self,
_len: usize) _len: usize)
-> Result<Self::SerializeTuple, Error> { -> Result<Self::SerializeTuple, Error> {
Err(Error::top_level()) Ok(TupleSerializer { urlencoder: self.urlencoder })
} }
/// Returns an error. /// Returns an error.
@ -306,7 +299,7 @@ impl<'output, Target> ser::Serializer for Serializer<'output, Target>
fn serialize_tuple_variant fn serialize_tuple_variant
(self, (self,
_name: &'static str, _name: &'static str,
_variant_index: usize, _variant_index: u32,
_variant: &'static str, _variant: &'static str,
_len: usize) _len: usize)
-> Result<Self::SerializeTupleVariant, Error> { -> Result<Self::SerializeTupleVariant, Error> {
@ -335,7 +328,7 @@ impl<'output, Target> ser::Serializer for Serializer<'output, Target>
fn serialize_struct_variant fn serialize_struct_variant
(self, (self,
_name: &'static str, _name: &'static str,
_variant_index: usize, _variant_index: u32,
_variant: &'static str, _variant: &'static str,
_len: usize) _len: usize)
-> Result<Self::SerializeStructVariant, Error> { -> Result<Self::SerializeStructVariant, Error> {
@ -369,16 +362,17 @@ impl<'output, Target> ser::SerializeTuple for TupleSerializer<'output, Target>
fn serialize_element<T: ?Sized + ser::Serialize>(&mut self, fn serialize_element<T: ?Sized + ser::Serialize>(&mut self,
value: &T) value: &T)
-> Result<(), Error> { -> Result<(), Error> {
self.inner.serialize_element(value) value.serialize(pair::PairSerializer::new(self.urlencoder))
} }
fn end(self) -> Result<Self::Ok, Error> { fn end(self) -> Result<Self::Ok, Error> {
self.inner.end() Ok(self.urlencoder)
} }
} }
impl<'output, Target> ser::SerializeTupleStruct impl<'output, Target> ser::SerializeTupleStruct
for TupleStructSerializer<'output, Target> for
TupleStructSerializer<'output, Target>
where Target: 'output + UrlEncodedTarget, where Target: 'output + UrlEncodedTarget,
{ {
type Ok = &'output mut UrlEncodedSerializer<Target>; type Ok = &'output mut UrlEncodedSerializer<Target>;
@ -396,7 +390,8 @@ impl<'output, Target> ser::SerializeTupleStruct
} }
impl<'output, Target> ser::SerializeTupleVariant impl<'output, Target> ser::SerializeTupleVariant
for TupleVariantSerializer<'output, Target> for
TupleVariantSerializer<'output, Target>
where Target: 'output + UrlEncodedTarget, where Target: 'output + UrlEncodedTarget,
{ {
type Ok = &'output mut UrlEncodedSerializer<Target>; type Ok = &'output mut UrlEncodedSerializer<Target>;
@ -480,7 +475,8 @@ impl<'output, Target> ser::SerializeStruct for StructSerializer<'output, Target>
} }
impl<'output, Target> ser::SerializeStructVariant impl<'output, Target> ser::SerializeStructVariant
for StructVariantSerializer<'output, Target> for
StructVariantSerializer<'output, Target>
where Target: 'output + UrlEncodedTarget, where Target: 'output + UrlEncodedTarget,
{ {
type Ok = &'output mut UrlEncodedSerializer<Target>; type Ok = &'output mut UrlEncodedSerializer<Target>;

14
src/ser/pair.rs
View File

@ -103,7 +103,7 @@ impl<'target, Target> ser::Serializer for PairSerializer<'target, Target>
fn serialize_unit_variant(self, fn serialize_unit_variant(self,
_name: &'static str, _name: &'static str,
_variant_index: usize, _variant_index: u32,
_variant: &'static str) _variant: &'static str)
-> Result<(), Error> { -> Result<(), Error> {
Err(Error::unsupported_pair()) Err(Error::unsupported_pair())
@ -120,7 +120,7 @@ impl<'target, Target> ser::Serializer for PairSerializer<'target, Target>
fn serialize_newtype_variant<T: ?Sized + ser::Serialize> fn serialize_newtype_variant<T: ?Sized + ser::Serialize>
(self, (self,
_name: &'static str, _name: &'static str,
_variant_index: usize, _variant_index: u32,
_variant: &'static str, _variant: &'static str,
_value: &T) _value: &T)
-> Result<(), Error> { -> Result<(), Error> {
@ -143,12 +143,6 @@ impl<'target, Target> ser::Serializer for PairSerializer<'target, Target>
Err(Error::unsupported_pair()) Err(Error::unsupported_pair())
} }
fn serialize_seq_fixed_size(self,
_len: usize)
-> Result<Self::SerializeSeq, Error> {
Err(Error::unsupported_pair())
}
fn serialize_tuple(self, len: usize) -> Result<Self, Error> { fn serialize_tuple(self, len: usize) -> Result<Self, Error> {
if len == 2 { if len == 2 {
Ok(self) Ok(self)
@ -167,7 +161,7 @@ impl<'target, Target> ser::Serializer for PairSerializer<'target, Target>
fn serialize_tuple_variant fn serialize_tuple_variant
(self, (self,
_name: &'static str, _name: &'static str,
_variant_index: usize, _variant_index: u32,
_variant: &'static str, _variant: &'static str,
_len: usize) _len: usize)
-> Result<Self::SerializeTupleVariant, Error> { -> Result<Self::SerializeTupleVariant, Error> {
@ -190,7 +184,7 @@ impl<'target, Target> ser::Serializer for PairSerializer<'target, Target>
fn serialize_struct_variant fn serialize_struct_variant
(self, (self,
_name: &'static str, _name: &'static str,
_variant_index: usize, _variant_index: u32,
_variant: &'static str, _variant: &'static str,
_len: usize) _len: usize)
-> Result<Self::SerializeStructVariant, Error> { -> Result<Self::SerializeStructVariant, Error> {

15
src/ser/part.rs
View File

@ -113,7 +113,7 @@ impl<S: Sink> ser::Serializer for PartSerializer<S> {
fn serialize_unit_variant(self, fn serialize_unit_variant(self,
_name: &'static str, _name: &'static str,
_variant_index: usize, _variant_index: u32,
variant: &'static str) variant: &'static str)
-> Result<S::Ok, Error> { -> Result<S::Ok, Error> {
self.sink.serialize_static_str(variant.into()) self.sink.serialize_static_str(variant.into())
@ -130,7 +130,7 @@ impl<S: Sink> ser::Serializer for PartSerializer<S> {
fn serialize_newtype_variant<T: ?Sized + ser::Serialize> fn serialize_newtype_variant<T: ?Sized + ser::Serialize>
(self, (self,
_name: &'static str, _name: &'static str,
_variant_index: usize, _variant_index: u32,
_variant: &'static str, _variant: &'static str,
_value: &T) _value: &T)
-> Result<S::Ok, Error> { -> Result<S::Ok, Error> {
@ -153,13 +153,6 @@ impl<S: Sink> ser::Serializer for PartSerializer<S> {
Err(self.sink.unsupported()) Err(self.sink.unsupported())
} }
fn serialize_seq_fixed_size(self,
_len: usize)
-> Result<Self::SerializeSeq, Error> {
Err(self.sink.unsupported())
}
fn serialize_tuple(self, fn serialize_tuple(self,
_len: usize) _len: usize)
-> Result<Self::SerializeTuple, Error> { -> Result<Self::SerializeTuple, Error> {
@ -176,7 +169,7 @@ impl<S: Sink> ser::Serializer for PartSerializer<S> {
fn serialize_tuple_variant fn serialize_tuple_variant
(self, (self,
_name: &'static str, _name: &'static str,
_variant_index: usize, _variant_index: u32,
_variant: &'static str, _variant: &'static str,
_len: usize) _len: usize)
-> Result<Self::SerializeTupleVariant, Error> { -> Result<Self::SerializeTupleVariant, Error> {
@ -199,7 +192,7 @@ impl<S: Sink> ser::Serializer for PartSerializer<S> {
fn serialize_struct_variant fn serialize_struct_variant
(self, (self,
_name: &'static str, _name: &'static str,
_variant_index: usize, _variant_index: u32,
_variant: &'static str, _variant: &'static str,
_len: usize) _len: usize)
-> Result<Self::SerializeStructVariant, Error> { -> Result<Self::SerializeStructVariant, Error> {