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

Reformat

Browse Source
This commit is contained in:
Anthony Ramine 2019-04-16 11:15:32 +02:00
parent 11cc5bb88f
commit 92eadc25be
10 changed files with 379 additions and 292 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
rustfmt.toml
View File

@ -1,7 +1,5 @@
match_block_trailing_comma = true
max_width = 80
newline_style = "Unix"
reorder_imported_names = true
reorder_imports = true
use_try_shorthand = true
where_trailing_comma = true

63
src/de.rs
View File

@ -1,12 +1,12 @@
//! Deserialization support for the `application/x-www-form-urlencoded` format.
use serde::de::{self, IntoDeserializer};
use serde::de::Error as de_Error;
use serde::de::value::MapDeserializer;
use serde::de::Error as de_Error;
use serde::de::{self, IntoDeserializer};
use std::borrow::Cow;
use std::io::Read;
use url::form_urlencoded::Parse as UrlEncodedParse;
use url::form_urlencoded::parse;
use url::form_urlencoded::Parse as UrlEncodedParse;
#[doc(inline)]
pub use serde::de::value::Error;
@ -27,7 +27,8 @@ pub use serde::de::value::Error;
/// Ok(meal));
/// ```
pub fn from_bytes<'de, T>(input: &'de [u8]) -> Result<T, Error>
where T: de::Deserialize<'de>,
where
T: de::Deserialize<'de>,
{
T::deserialize(Deserializer::new(parse(input)))
}
@ -48,7 +49,8 @@ pub fn from_bytes<'de, T>(input: &'de [u8]) -> Result<T, Error>
/// Ok(meal));
/// ```
pub fn from_str<'de, T>(input: &'de str) -> Result<T, Error>
where T: de::Deserialize<'de>,
where
T: de::Deserialize<'de>,
{
from_bytes(input.as_bytes())
}
@ -56,14 +58,14 @@ pub fn from_str<'de, T>(input: &'de str) -> Result<T, Error>
/// Convenience function that reads all bytes from `reader` and deserializes
/// them with `from_bytes`.
pub fn from_reader<T, R>(mut reader: R) -> Result<T, Error>
where T: de::DeserializeOwned,
R: Read,
where
T: de::DeserializeOwned,
R: Read,
{
let mut buf = vec![];
reader.read_to_end(&mut buf)
.map_err(|e| {
de::Error::custom(format_args!("could not read input: {}", e))
})?;
reader.read_to_end(&mut buf).map_err(|e| {
de::Error::custom(format_args!("could not read input: {}", e))
})?;
from_bytes(&buf)
}
@ -93,25 +95,29 @@ impl<'de> de::Deserializer<'de> for Deserializer<'de> {
type Error = Error;
fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
where V: de::Visitor<'de>,
where
V: de::Visitor<'de>,
{
self.deserialize_map(visitor)
}
fn deserialize_map<V>(self, visitor: V) -> Result<V::Value, Self::Error>
where V: de::Visitor<'de>,
where
V: de::Visitor<'de>,
{
visitor.visit_map(self.inner)
}
fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value, Self::Error>
where V: de::Visitor<'de>,
where
V: de::Visitor<'de>,
{
visitor.visit_seq(self.inner)
}
fn deserialize_unit<V>(self, visitor: V) -> Result<V::Value, Self::Error>
where V: de::Visitor<'de>,
where
V: de::Visitor<'de>,
{
self.inner.end()?;
visitor.visit_unit()
@ -158,8 +164,7 @@ impl<'de> Iterator for PartIterator<'de> {
struct Part<'de>(Cow<'de, str>);
impl<'de> IntoDeserializer<'de> for Part<'de>
{
impl<'de> IntoDeserializer<'de> for Part<'de> {
type Deserializer = Self;
fn into_deserializer(self) -> Self::Deserializer {
@ -186,13 +191,15 @@ impl<'de> de::Deserializer<'de> for Part<'de> {
type Error = Error;
fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
where V: de::Visitor<'de>,
where
V: de::Visitor<'de>,
{
self.0.into_deserializer().deserialize_any(visitor)
}
fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Self::Error>
where V: de::Visitor<'de>,
where
V: de::Visitor<'de>,
{
visitor.visit_some(self)
}
@ -203,7 +210,8 @@ impl<'de> de::Deserializer<'de> for Part<'de> {
_variants: &'static [&'static str],
visitor: V,
) -> Result<V::Value, Self::Error>
where V: de::Visitor<'de>,
where
V: de::Visitor<'de>,
{
visitor.visit_enum(ValueEnumAccess(self.0))
}
@ -213,7 +221,8 @@ impl<'de> de::Deserializer<'de> for Part<'de> {
_name: &'static str,
visitor: V,
) -> Result<V::Value, Self::Error>
where V: de::Visitor<'de>,
where
V: de::Visitor<'de>,
{
visitor.visit_newtype_struct(self)
}
@ -260,7 +269,8 @@ impl<'de> de::EnumAccess<'de> for ValueEnumAccess<'de> {
self,
seed: V,
) -> Result<(V::Value, Self::Variant), Self::Error>
where V: de::DeserializeSeed<'de>,
where
V: de::DeserializeSeed<'de>,
{
let variant = seed.deserialize(self.0.into_deserializer())?;
Ok((variant, UnitOnlyVariantAccess))
@ -277,7 +287,8 @@ impl<'de> de::VariantAccess<'de> for UnitOnlyVariantAccess {
}
fn newtype_variant_seed<T>(self, _seed: T) -> Result<T::Value, Self::Error>
where T: de::DeserializeSeed<'de>,
where
T: de::DeserializeSeed<'de>,
{
Err(Error::custom("expected unit variant"))
}
@ -287,7 +298,8 @@ impl<'de> de::VariantAccess<'de> for UnitOnlyVariantAccess {
_len: usize,
_visitor: V,
) -> Result<V::Value, Self::Error>
where V: de::Visitor<'de>,
where
V: de::Visitor<'de>,
{
Err(Error::custom("expected unit variant"))
}
@ -297,7 +309,8 @@ impl<'de> de::VariantAccess<'de> for UnitOnlyVariantAccess {
_fields: &'static [&'static str],
_visitor: V,
) -> Result<V::Value, Self::Error>
where V: de::Visitor<'de>,
where
V: de::Visitor<'de>,
{
Err(Error::custom("expected unit variant"))
}

6
src/lib.rs
View File

@ -2,8 +2,8 @@
#![warn(unused_extern_crates)]
extern crate itoa;
extern crate dtoa;
extern crate itoa;
#[macro_use]
extern crate serde;
extern crate url;
@ -12,6 +12,6 @@ pub mod de;
pub mod ser;
#[doc(inline)]
pub use de::{Deserializer, from_bytes, from_reader, from_str};
pub use de::{from_bytes, from_reader, from_str, Deserializer};
#[doc(inline)]
pub use ser::{Serializer, to_string};
pub use ser::{to_string, Serializer};

19
src/ser/key.rs
View File

@ -1,5 +1,5 @@
use ser::Error;
use ser::part::Sink;
use ser::Error;
use serde::Serialize;
use std::borrow::Cow;
use std::ops::Deref;
@ -34,7 +34,8 @@ pub struct KeySink<End> {
}
impl<End, Ok> KeySink<End>
where End: for<'key> FnOnce(Key<'key>) -> Result<Ok, Error>
where
End: for<'key> FnOnce(Key<'key>) -> Result<Ok, Error>,
{
pub fn new(end: End) -> Self {
KeySink { end: end }
@ -42,13 +43,12 @@ impl<End, Ok> KeySink<End>
}
impl<End, Ok> Sink for KeySink<End>
where End: for<'key> FnOnce(Key<'key>) -> Result<Ok, Error>
where
End: for<'key> FnOnce(Key<'key>) -> Result<Ok, Error>,
{
type Ok = Ok;
fn serialize_static_str(self,
value: &'static str)
-> Result<Ok, Error> {
fn serialize_static_str(self, value: &'static str) -> Result<Ok, Error> {
(self.end)(Key::Static(value))
}
@ -64,9 +64,10 @@ impl<End, Ok> Sink for KeySink<End>
Err(self.unsupported())
}
fn serialize_some<T: ?Sized + Serialize>(self,
_value: &T)
-> Result<Ok, Error> {
fn serialize_some<T: ?Sized + Serialize>(
self,
_value: &T,
) -> Result<Ok, Error> {
Err(self.unsupported())
}

239
src/ser/mod.rs
View File

@ -49,7 +49,9 @@ pub struct Serializer<'output, Target: 'output + UrlEncodedTarget> {
impl<'output, Target: 'output + UrlEncodedTarget> Serializer<'output, Target> {
/// Returns a new `Serializer`.
pub fn new(urlencoder: &'output mut UrlEncodedSerializer<Target>) -> Self {
Serializer { urlencoder: urlencoder }
Serializer {
urlencoder: urlencoder,
}
}
}
@ -137,7 +139,8 @@ pub struct StructVariantSerializer<'output, T: 'output + UrlEncodedTarget> {
}
impl<'output, Target> ser::Serializer for Serializer<'output, Target>
where Target: 'output + UrlEncodedTarget,
where
Target: 'output + UrlEncodedTarget,
{
type Ok = &'output mut UrlEncodedSerializer<Target>;
type Error = Error;
@ -225,38 +228,40 @@ impl<'output, Target> ser::Serializer for Serializer<'output, Target>
}
/// Returns an error.
fn serialize_unit_struct(self,
_name: &'static str)
-> Result<Self::Ok, 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> {
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> {
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> {
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())
}
@ -266,50 +271,58 @@ impl<'output, Target> ser::Serializer for Serializer<'output, Target>
}
/// Serializes the given value.
fn serialize_some<T: ?Sized + ser::Serialize>
(self,
value: &T)
-> Result<Self::Ok, Error> {
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> {
Ok(SeqSerializer { urlencoder: self.urlencoder })
fn serialize_seq(
self,
_len: Option<usize>,
) -> Result<Self::SerializeSeq, Error> {
Ok(SeqSerializer {
urlencoder: self.urlencoder,
})
}
/// Returns an error.
fn serialize_tuple(self,
_len: usize)
-> Result<Self::SerializeTuple, Error> {
Ok(TupleSerializer { urlencoder: self.urlencoder })
fn serialize_tuple(
self,
_len: usize,
) -> Result<Self::SerializeTuple, Error> {
Ok(TupleSerializer {
urlencoder: self.urlencoder,
})
}
/// Returns an error.
fn serialize_tuple_struct(self,
_name: &'static str,
_len: usize)
-> Result<Self::SerializeTupleStruct, 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> {
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> {
fn serialize_map(
self,
_len: Option<usize>,
) -> Result<Self::SerializeMap, Error> {
Ok(MapSerializer {
urlencoder: self.urlencoder,
key: None,
@ -317,34 +330,39 @@ impl<'output, Target> ser::Serializer for Serializer<'output, Target>
}
/// 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 })
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> {
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,
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> {
fn serialize_element<T: ?Sized + ser::Serialize>(
&mut self,
value: &T,
) -> Result<(), Error> {
value.serialize(pair::PairSerializer::new(self.urlencoder))
}
@ -354,14 +372,16 @@ impl<'output, Target> ser::SerializeSeq for SeqSerializer<'output, Target>
}
impl<'output, Target> ser::SerializeTuple for TupleSerializer<'output, Target>
where Target: 'output + UrlEncodedTarget,
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> {
fn serialize_element<T: ?Sized + ser::Serialize>(
&mut self,
value: &T,
) -> Result<(), Error> {
value.serialize(pair::PairSerializer::new(self.urlencoder))
}
@ -371,16 +391,17 @@ impl<'output, Target> ser::SerializeTuple for TupleSerializer<'output, Target>
}
impl<'output, Target> ser::SerializeTupleStruct
for
TupleStructSerializer<'output, Target>
where Target: 'output + UrlEncodedTarget,
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> {
fn serialize_field<T: ?Sized + ser::Serialize>(
&mut self,
value: &T,
) -> Result<(), Error> {
self.inner.serialize_field(value)
}
@ -390,16 +411,17 @@ impl<'output, Target> ser::SerializeTupleStruct
}
impl<'output, Target> ser::SerializeTupleVariant
for
TupleVariantSerializer<'output, Target>
where Target: 'output + UrlEncodedTarget,
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> {
fn serialize_field<T: ?Sized + ser::Serialize>(
&mut self,
value: &T,
) -> Result<(), Error> {
self.inner.serialize_field(value)
}
@ -409,16 +431,20 @@ impl<'output, Target> ser::SerializeTupleVariant
}
impl<'output, Target> ser::SerializeMap for MapSerializer<'output, Target>
where Target: 'output + UrlEncodedTarget,
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> {
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))?;
@ -429,18 +455,20 @@ impl<'output, Target> ser::SerializeMap for MapSerializer<'output, Target>
key.serialize(entry_serializer)
}
fn serialize_key<T: ?Sized + ser::Serialize>(&mut self,
key: &T)
-> Result<(), Error> {
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> {
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);
@ -456,15 +484,17 @@ impl<'output, Target> ser::SerializeMap for MapSerializer<'output, Target>
}
impl<'output, Target> ser::SerializeStruct for StructSerializer<'output, Target>
where Target: 'output + UrlEncodedTarget,
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> {
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))
}
@ -475,17 +505,18 @@ impl<'output, Target> ser::SerializeStruct for StructSerializer<'output, Target>
}
impl<'output, Target> ser::SerializeStructVariant
for
StructVariantSerializer<'output, Target>
where Target: 'output + UrlEncodedTarget,
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> {
fn serialize_field<T: ?Sized + ser::Serialize>(
&mut self,
key: &'static str,
value: &T,
) -> Result<(), Error> {
self.inner.serialize_field(key, value)
}

120
src/ser/pair.rs
View File

@ -1,7 +1,7 @@
use ser::Error;
use ser::key::KeySink;
use ser::part::PartSerializer;
use ser::value::ValueSink;
use ser::Error;
use serde::ser;
use std::borrow::Cow;
use std::mem;
@ -14,7 +14,8 @@ pub struct PairSerializer<'target, Target: 'target + UrlEncodedTarget> {
}
impl<'target, Target> PairSerializer<'target, Target>
where Target: 'target + UrlEncodedTarget,
where
Target: 'target + UrlEncodedTarget,
{
pub fn new(urlencoder: &'target mut UrlEncodedSerializer<Target>) -> Self {
PairSerializer {
@ -25,7 +26,8 @@ impl<'target, Target> PairSerializer<'target, Target>
}
impl<'target, Target> ser::Serializer for PairSerializer<'target, Target>
where Target: 'target + UrlEncodedTarget,
where
Target: 'target + UrlEncodedTarget,
{
type Ok = ();
type Error = Error;
@ -101,29 +103,30 @@ impl<'target, Target> ser::Serializer for PairSerializer<'target, Target>
Err(Error::unsupported_pair())
}
fn serialize_unit_variant(self,
_name: &'static str,
_variant_index: u32,
_variant: &'static str)
-> Result<(), Error> {
fn serialize_unit_variant(
self,
_name: &'static str,
_variant_index: u32,
_variant: &'static str,
) -> Result<(), Error> {
Err(Error::unsupported_pair())
}
fn serialize_newtype_struct<T: ?Sized + ser::Serialize>
(self,
_name: &'static str,
value: &T)
-> Result<(), Error> {
fn serialize_newtype_struct<T: ?Sized + ser::Serialize>(
self,
_name: &'static str,
value: &T,
) -> Result<(), 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<(), Error> {
fn serialize_newtype_variant<T: ?Sized + ser::Serialize>(
self,
_name: &'static str,
_variant_index: u32,
_variant: &'static str,
_value: &T,
) -> Result<(), Error> {
Err(Error::unsupported_pair())
}
@ -131,15 +134,17 @@ impl<'target, Target> ser::Serializer for PairSerializer<'target, Target>
Ok(())
}
fn serialize_some<T: ?Sized + ser::Serialize>(self,
value: &T)
-> Result<(), Error> {
fn serialize_some<T: ?Sized + ser::Serialize>(
self,
value: &T,
) -> Result<(), Error> {
value.serialize(self)
}
fn serialize_seq(self,
_len: Option<usize>)
-> Result<Self::SerializeSeq, Error> {
fn serialize_seq(
self,
_len: Option<usize>,
) -> Result<Self::SerializeSeq, Error> {
Err(Error::unsupported_pair())
}
@ -151,56 +156,61 @@ impl<'target, Target> ser::Serializer for PairSerializer<'target, Target>
}
}
fn serialize_tuple_struct(self,
_name: &'static str,
_len: usize)
-> Result<Self::SerializeTupleStruct, Error> {
fn serialize_tuple_struct(
self,
_name: &'static str,
_len: usize,
) -> Result<Self::SerializeTupleStruct, Error> {
Err(Error::unsupported_pair())
}
fn serialize_tuple_variant
(self,
_name: &'static str,
_variant_index: u32,
_variant: &'static str,
_len: usize)
-> Result<Self::SerializeTupleVariant, Error> {
fn serialize_tuple_variant(
self,
_name: &'static str,
_variant_index: u32,
_variant: &'static str,
_len: usize,
) -> Result<Self::SerializeTupleVariant, Error> {
Err(Error::unsupported_pair())
}
fn serialize_map(self,
_len: Option<usize>)
-> Result<Self::SerializeMap, Error> {
fn serialize_map(
self,
_len: Option<usize>,
) -> Result<Self::SerializeMap, Error> {
Err(Error::unsupported_pair())
}
fn serialize_struct(self,
_name: &'static str,
_len: usize)
-> Result<Self::SerializeStruct, Error> {
fn serialize_struct(
self,
_name: &'static str,
_len: usize,
) -> Result<Self::SerializeStruct, Error> {
Err(Error::unsupported_pair())
}
fn serialize_struct_variant
(self,
_name: &'static str,
_variant_index: u32,
_variant: &'static str,
_len: usize)
-> Result<Self::SerializeStructVariant, Error> {
fn serialize_struct_variant(
self,
_name: &'static str,
_variant_index: u32,
_variant: &'static str,
_len: usize,
) -> Result<Self::SerializeStructVariant, Error> {
Err(Error::unsupported_pair())
}
}
impl<'target, Target> ser::SerializeTuple for PairSerializer<'target, Target>
where Target: 'target + UrlEncodedTarget,
where
Target: 'target + UrlEncodedTarget,
{
type Ok = ();
type Error = Error;
fn serialize_element<T: ?Sized + ser::Serialize>(&mut self,
value: &T)
-> Result<(), Error> {
fn serialize_element<T: ?Sized + ser::Serialize>(
&mut self,
value: &T,
) -> Result<(), Error> {
match mem::replace(&mut self.state, PairState::Done) {
PairState::WaitingForKey => {
let key_sink = KeySink::new(|key| Ok(key.into()));

133
src/ser/part.rs
View File

@ -17,18 +17,19 @@ impl<S: Sink> PartSerializer<S> {
pub trait Sink: Sized {
type Ok;
fn serialize_static_str(self,
value: &'static str)
-> Result<Self::Ok, Error>;
fn serialize_static_str(
self,
value: &'static str,
) -> Result<Self::Ok, Error>;
fn serialize_str(self, value: &str) -> Result<Self::Ok, Error>;
fn serialize_string(self, value: String) -> Result<Self::Ok, Error>;
fn serialize_none(self) -> Result<Self::Ok, Error>;
fn serialize_some<T: ?Sized + ser::Serialize>
(self,
value: &T)
-> Result<Self::Ok, Error>;
fn serialize_some<T: ?Sized + ser::Serialize>(
self,
value: &T,
) -> Result<Self::Ok, Error>;
fn unsupported(self) -> Error;
}
@ -45,7 +46,8 @@ impl<S: Sink> ser::Serializer for PartSerializer<S> {
type SerializeStructVariant = ser::Impossible<S::Ok, Error>;
fn serialize_bool(self, v: bool) -> Result<S::Ok, Error> {
self.sink.serialize_static_str(if v { "true" } else { "false" })
self.sink
.serialize_static_str(if v { "true" } else { "false" })
}
fn serialize_i8(self, v: i8) -> Result<S::Ok, Error> {
@ -111,29 +113,30 @@ impl<S: Sink> ser::Serializer for PartSerializer<S> {
self.sink.serialize_static_str(name.into())
}
fn serialize_unit_variant(self,
_name: &'static str,
_variant_index: u32,
variant: &'static str)
-> Result<S::Ok, Error> {
fn serialize_unit_variant(
self,
_name: &'static str,
_variant_index: u32,
variant: &'static str,
) -> Result<S::Ok, Error> {
self.sink.serialize_static_str(variant.into())
}
fn serialize_newtype_struct<T: ?Sized + ser::Serialize>
(self,
_name: &'static str,
value: &T)
-> Result<S::Ok, Error> {
fn serialize_newtype_struct<T: ?Sized + ser::Serialize>(
self,
_name: &'static str,
value: &T,
) -> Result<S::Ok, 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<S::Ok, Error> {
fn serialize_newtype_variant<T: ?Sized + ser::Serialize>(
self,
_name: &'static str,
_variant_index: u32,
_variant: &'static str,
_value: &T,
) -> Result<S::Ok, Error> {
Err(self.sink.unsupported())
}
@ -141,68 +144,75 @@ impl<S: Sink> ser::Serializer for PartSerializer<S> {
self.sink.serialize_none()
}
fn serialize_some<T: ?Sized + ser::Serialize>(self,
value: &T)
-> Result<S::Ok, Error> {
fn serialize_some<T: ?Sized + ser::Serialize>(
self,
value: &T,
) -> Result<S::Ok, Error> {
self.sink.serialize_some(value)
}
fn serialize_seq(self,
_len: Option<usize>)
-> Result<Self::SerializeSeq, Error> {
fn serialize_seq(
self,
_len: Option<usize>,
) -> Result<Self::SerializeSeq, Error> {
Err(self.sink.unsupported())
}
fn serialize_tuple(self,
_len: usize)
-> Result<Self::SerializeTuple, Error> {
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> {
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> {
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> {
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> {
fn serialize_struct(
self,
_name: &'static str,
_len: usize,
) -> Result<Self::SerializeStruct, Error> {
Err(self.sink.unsupported())
}
fn serialize_struct_variant
(self,
_name: &'static str,
_variant_index: u32,
_variant: &'static str,
_len: usize)
-> Result<Self::SerializeStructVariant, Error> {
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<S: Sink> PartSerializer<S> {
fn serialize_integer<I>(self, value: I) -> Result<S::Ok, Error>
where I: itoa::Integer,
where
I: itoa::Integer,
{
let mut buf = [b'\0'; 20];
let len = itoa::write(&mut buf[..], value).unwrap();
@ -211,7 +221,8 @@ impl<S: Sink> PartSerializer<S> {
}
fn serialize_floating<F>(self, value: F) -> Result<S::Ok, Error>
where F: dtoa::Floating,
where
F: dtoa::Floating,
{
let mut buf = [b'\0'; 24];
let len = dtoa::write(&mut buf[..], value).unwrap();

25
src/ser/value.rs
View File

@ -1,23 +1,26 @@
use ser::Error;
use ser::part::{PartSerializer, Sink};
use ser::Error;
use serde::ser::Serialize;
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,
where
Target: 'target + UrlEncodedTarget,
{
urlencoder: &'target mut UrlEncodedSerializer<Target>,
key: &'key str,
}
impl<'key, 'target, Target> ValueSink<'key, 'target, Target>
where Target: 'target + UrlEncodedTarget,
where
Target: 'target + UrlEncodedTarget,
{
pub fn new(urlencoder: &'target mut UrlEncodedSerializer<Target>,
key: &'key str)
-> Self {
pub fn new(
urlencoder: &'target mut UrlEncodedSerializer<Target>,
key: &'key str,
) -> Self {
ValueSink {
urlencoder: urlencoder,
key: key,
@ -26,7 +29,8 @@ impl<'key, 'target, Target> ValueSink<'key, 'target, Target>
}
impl<'key, 'target, Target> Sink for ValueSink<'key, 'target, Target>
where Target: 'target + UrlEncodedTarget,
where
Target: 'target + UrlEncodedTarget,
{
type Ok = ();
@ -47,9 +51,10 @@ impl<'key, 'target, Target> Sink for ValueSink<'key, 'target, Target>
Ok(())
}
fn serialize_some<T: ?Sized + Serialize>(self,
value: &T)
-> Result<Self::Ok, Error> {
fn serialize_some<T: ?Sized + Serialize>(
self,
value: &T,
) -> Result<Self::Ok, Error> {
value.serialize(PartSerializer::new(self))
}

25
tests/test_deserialize.rs
View File

@ -9,32 +9,34 @@ struct NewType<T>(T);
fn deserialize_newtype_i32() {
let result = vec![("field".to_owned(), NewType(11))];
assert_eq!(serde_urlencoded::from_str("field=11"),
Ok(result));
assert_eq!(serde_urlencoded::from_str("field=11"), Ok(result));
}
#[test]
fn deserialize_bytes() {
let result = vec![("first".to_owned(), 23), ("last".to_owned(), 42)];
assert_eq!(serde_urlencoded::from_bytes(b"first=23&last=42"),
Ok(result));
assert_eq!(
serde_urlencoded::from_bytes(b"first=23&last=42"),
Ok(result)
);
}
#[test]
fn deserialize_str() {
let result = vec![("first".to_owned(), 23), ("last".to_owned(), 42)];
assert_eq!(serde_urlencoded::from_str("first=23&last=42"),
Ok(result));
assert_eq!(serde_urlencoded::from_str("first=23&last=42"), Ok(result));
}
#[test]
fn deserialize_reader() {
let result = vec![("first".to_owned(), 23), ("last".to_owned(), 42)];
assert_eq!(serde_urlencoded::from_reader(b"first=23&last=42" as &[_]),
Ok(result));
assert_eq!(
serde_urlencoded::from_reader(b"first=23&last=42" as &[_]),
Ok(result)
);
}
#[test]
@ -66,8 +68,11 @@ fn deserialize_unit_enum() {
let result = vec![
("one".to_owned(), X::A),
("two".to_owned(), X::B),
("three".to_owned(), X::C)
("three".to_owned(), X::C),
];
assert_eq!(serde_urlencoded::from_str("one=A&two=B&three=C"), Ok(result));
assert_eq!(
serde_urlencoded::from_str("one=A&two=B&three=C"),
Ok(result)
);
}

39
tests/test_serialize.rs
View File

@ -7,7 +7,7 @@ struct NewType<T>(T);
#[test]
fn serialize_newtype_i32() {
let params = &[("field", Some(NewType(11))),];
let params = &[("field", Some(NewType(11)))];
assert_eq!(
serde_urlencoded::to_string(params),
Ok("field=11".to_owned())
@ -18,33 +18,44 @@ fn serialize_newtype_i32() {
fn serialize_option_map_int() {
let params = &[("first", Some(23)), ("middle", None), ("last", Some(42))];
assert_eq!(serde_urlencoded::to_string(params),
Ok("first=23&last=42".to_owned()));
assert_eq!(
serde_urlencoded::to_string(params),
Ok("first=23&last=42".to_owned())
);
}
#[test]
fn serialize_option_map_string() {
let params =
&[("first", Some("hello")), ("middle", None), ("last", Some("world"))];
let params = &[
("first", Some("hello")),
("middle", None),
("last", Some("world")),
];
assert_eq!(serde_urlencoded::to_string(params),
Ok("first=hello&last=world".to_owned()));
assert_eq!(
serde_urlencoded::to_string(params),
Ok("first=hello&last=world".to_owned())
);
}
#[test]
fn serialize_option_map_bool() {
let params = &[("one", Some(true)), ("two", Some(false))];
assert_eq!(serde_urlencoded::to_string(params),
Ok("one=true&two=false".to_owned()));
assert_eq!(
serde_urlencoded::to_string(params),
Ok("one=true&two=false".to_owned())
);
}
#[test]
fn serialize_map_bool() {
let params = &[("one", true), ("two", false)];
assert_eq!(serde_urlencoded::to_string(params),
Ok("one=true&two=false".to_owned()));
assert_eq!(
serde_urlencoded::to_string(params),
Ok("one=true&two=false".to_owned())
);
}
#[derive(Serialize)]
@ -57,6 +68,8 @@ enum X {
#[test]
fn serialize_unit_enum() {
let params = &[("one", X::A), ("two", X::B), ("three", X::C)];
assert_eq!(serde_urlencoded::to_string(params),
Ok("one=A&two=B&three=C".to_owned()));
assert_eq!(
serde_urlencoded::to_string(params),
Ok("one=A&two=B&three=C".to_owned())
);
}