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

Reformat with rustfmt

Browse Source
This commit is contained in:
Anthony Ramine 2017-01-27 22:56:04 +01:00
parent 9aefb1c02d
commit 8e5cf19e07
7 changed files with 439 additions and 434 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
rustfmt.toml Normal file
View File

@ -0,0 +1,7 @@
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

38
src/de.rs
View File

@ -1,13 +1,13 @@
//! 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;
pub use serde::de::value::Error;
use serde::de::value::MapDeserializer; use serde::de::value::MapDeserializer;
use std::borrow::Cow; use std::borrow::Cow;
use url::form_urlencoded::Parse as UrlEncodedParse; use url::form_urlencoded::Parse as UrlEncodedParse;
use url::form_urlencoded::parse; use url::form_urlencoded::parse;
pub use serde::de::value::Error;
/// Deserializes a `application/x-wwww-url-encoded` value from a `&[u8]`. /// Deserializes a `application/x-wwww-url-encoded` value from a `&[u8]`.
/// ///
/// ``` /// ```
@ -56,8 +56,10 @@ pub fn from_str<T: de::Deserialize>(input: &str) -> 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<'a> {
inner: inner: MapDeserializer<UrlEncodedParse<'a>,
MapDeserializer<UrlEncodedParse<'a>, Cow<'a, str>, Cow<'a, str>, Error>, Cow<'a, str>,
Cow<'a, str>,
Error>,
} }
impl<'a> Deserializer<'a> { impl<'a> Deserializer<'a> {
@ -67,38 +69,36 @@ impl<'a> Deserializer<'a> {
} }
} }
impl<'a> de::Deserializer for Deserializer<'a> impl<'a> de::Deserializer for Deserializer<'a> {
{
type Error = Error; type Error = Error;
fn deserialize<V>( fn deserialize<V>(&mut self, visitor: V) -> Result<V::Value, Self::Error>
&mut self, visitor: V)
-> Result<V::Value, Self::Error>
where V: de::Visitor, where V: de::Visitor,
{ {
self.deserialize_map(visitor) self.deserialize_map(visitor)
} }
fn deserialize_map<V>( fn deserialize_map<V>(&mut self,
&mut self, mut visitor: V) mut visitor: V)
-> Result<V::Value, Self::Error> -> Result<V::Value, Self::Error>
where V: de::Visitor, where V: de::Visitor,
{ {
visitor.visit_map(&mut self.inner) visitor.visit_map(&mut self.inner)
} }
fn deserialize_seq<V>( fn deserialize_seq<V>(&mut self,
&mut self, mut visitor: V) mut visitor: V)
-> Result<V::Value, Self::Error> -> Result<V::Value, Self::Error>
where V: de::Visitor, where V: de::Visitor,
{ {
visitor.visit_seq(&mut self.inner) visitor.visit_seq(&mut self.inner)
} }
fn deserialize_seq_fixed_size<V>( fn deserialize_seq_fixed_size<V>(&mut self,
&mut self, _len: usize, mut visitor: V) _len: usize,
-> Result<V::Value, Self::Error> mut visitor: V)
where V: de::Visitor -> Result<V::Value, Self::Error>
where V: de::Visitor,
{ {
visitor.visit_seq(&mut self.inner) visitor.visit_seq(&mut self.inner)
} }

166
src/ser/key.rs
View File

@ -1,5 +1,6 @@
use serde::{Serialize, Serializer};
use ser::Error; use ser::Error;
use serde::{Serialize, Serializer};
use std::borrow::Cow; use std::borrow::Cow;
use std::str; use std::str;
@ -11,7 +12,7 @@ impl<'key> MapKeySerializer<'key> {
} }
fn set_key<T>(&mut self, key: T) -> Result<(), Error> fn set_key<T>(&mut self, key: T) -> Result<(), Error>
where T: Into<Cow<'static, str>> where T: Into<Cow<'static, str>>,
{ {
*self.0 = Some(key.into()); *self.0 = Some(key.into());
Ok(()) Ok(())
@ -99,37 +100,36 @@ impl<'key> Serializer for MapKeySerializer<'key> {
Err(Error::unsupported_key()) Err(Error::unsupported_key())
} }
fn serialize_unit_struct( fn serialize_unit_struct(&mut self,
&mut self, name: &'static str) name: &'static str)
-> Result<(), Error> { -> Result<(), Error> {
self.set_key(name) self.set_key(name)
} }
fn serialize_unit_variant( fn serialize_unit_variant(&mut self,
&mut self, _name: &'static str,
_name: &'static str, _variant_index: usize,
_variant_index: usize, variant: &'static str)
variant: &'static str) -> Result<(), Error> {
-> Result<(), Error> {
self.set_key(variant) self.set_key(variant)
} }
fn serialize_newtype_struct<T>( fn serialize_newtype_struct<T>(&mut self,
&mut self, _name: &'static str, value: T) _name: &'static str,
-> Result<(), Error> value: T)
where T: Serialize -> Result<(), Error>
where T: Serialize,
{ {
value.serialize(self) value.serialize(self)
} }
fn serialize_newtype_variant<T>( fn serialize_newtype_variant<T>(&mut self,
&mut self, _name: &'static str,
_name: &'static str, _variant_index: usize,
_variant_index: usize, _variant: &'static str,
_variant: &'static str, _value: T)
_value: T) -> Result<(), Error>
-> Result<(), Error> where T: Serialize,
where T: Serialize
{ {
Err(Error::unsupported_key()) Err(Error::unsupported_key())
} }
@ -139,7 +139,7 @@ impl<'key> Serializer for MapKeySerializer<'key> {
} }
fn serialize_some<T>(&mut self, _value: T) -> Result<(), Error> fn serialize_some<T>(&mut self, _value: T) -> Result<(), Error>
where T: Serialize where T: Serialize,
{ {
Err(Error::unsupported_key()) Err(Error::unsupported_key())
} }
@ -148,10 +148,11 @@ impl<'key> Serializer for MapKeySerializer<'key> {
Err(Error::unsupported_key()) Err(Error::unsupported_key())
} }
fn serialize_seq_elt<T>( fn serialize_seq_elt<T>(&mut self,
&mut self, _state: &mut (), _value: T) _state: &mut (),
-> Result<(), Error> _value: T)
where T: Serialize -> Result<(), Error>
where T: Serialize,
{ {
Err(Error::unsupported_key()) Err(Error::unsupported_key())
} }
@ -168,10 +169,11 @@ impl<'key> Serializer for MapKeySerializer<'key> {
Err(Error::unsupported_key()) Err(Error::unsupported_key())
} }
fn serialize_tuple_elt<T>( fn serialize_tuple_elt<T>(&mut self,
&mut self, _state: &mut (), _value: T) _state: &mut (),
-> Result<(), Error> _value: T)
where T: Serialize -> Result<(), Error>
where T: Serialize,
{ {
Err(Error::unsupported_key()) Err(Error::unsupported_key())
} }
@ -180,16 +182,18 @@ impl<'key> Serializer for MapKeySerializer<'key> {
Err(Error::unsupported_key()) Err(Error::unsupported_key())
} }
fn serialize_tuple_struct( fn serialize_tuple_struct(&mut self,
&mut self, _name: &'static str, _len: usize) _name: &'static str,
-> Result<(), Error> { _len: usize)
-> Result<(), Error> {
Err(Error::unsupported_key()) Err(Error::unsupported_key())
} }
fn serialize_tuple_struct_elt<T>( fn serialize_tuple_struct_elt<T>(&mut self,
&mut self, _state: &mut (), _value: T) _state: &mut (),
-> Result<(), Error> _value: T)
where T: Serialize -> Result<(), Error>
where T: Serialize,
{ {
Err(Error::unsupported_key()) Err(Error::unsupported_key())
} }
@ -198,20 +202,20 @@ impl<'key> Serializer for MapKeySerializer<'key> {
Err(Error::unsupported_key()) Err(Error::unsupported_key())
} }
fn serialize_tuple_variant( fn serialize_tuple_variant(&mut self,
&mut self, _name: &'static str,
_name: &'static str, _variant_index: usize,
_variant_index: usize, _variant: &'static str,
_variant: &'static str, _len: usize)
_len: usize) -> Result<(), Error> {
-> Result<(), Error> {
Err(Error::unsupported_key()) Err(Error::unsupported_key())
} }
fn serialize_tuple_variant_elt<T>( fn serialize_tuple_variant_elt<T>(&mut self,
&mut self, _state: &mut (), _value: T) _state: &mut (),
-> Result<(), Error> _value: T)
where T: Serialize -> Result<(), Error>
where T: Serialize,
{ {
Err(Error::unsupported_key()) Err(Error::unsupported_key())
} }
@ -224,18 +228,20 @@ impl<'key> Serializer for MapKeySerializer<'key> {
Err(Error::unsupported_key()) Err(Error::unsupported_key())
} }
fn serialize_map_key<T>( fn serialize_map_key<T>(&mut self,
&mut self, _state: &mut (), _key: T) _state: &mut (),
-> Result<(), Error> _key: T)
where T: Serialize -> Result<(), Error>
where T: Serialize,
{ {
Err(Error::unsupported_key()) Err(Error::unsupported_key())
} }
fn serialize_map_value<T>( fn serialize_map_value<T>(&mut self,
&mut self, _state: &mut (), _value: T) _state: &mut (),
-> Result<(), Error> _value: T)
where T: Serialize -> Result<(), Error>
where T: Serialize,
{ {
Err(Error::unsupported_key()) Err(Error::unsupported_key())
} }
@ -244,16 +250,19 @@ impl<'key> Serializer for MapKeySerializer<'key> {
Err(Error::unsupported_key()) Err(Error::unsupported_key())
} }
fn serialize_struct( fn serialize_struct(&mut self,
&mut self, _name: &'static str, _len: usize) _name: &'static str,
-> Result<(), Error> { _len: usize)
-> Result<(), Error> {
Err(Error::unsupported_key()) Err(Error::unsupported_key())
} }
fn serialize_struct_elt<T>( fn serialize_struct_elt<T>(&mut self,
&mut self, _state: &mut (), _key: &'static str, _value: T) _state: &mut (),
-> Result<(), Error> _key: &'static str,
where T: Serialize _value: T)
-> Result<(), Error>
where T: Serialize,
{ {
Err(Error::unsupported_key()) Err(Error::unsupported_key())
} }
@ -262,25 +271,26 @@ impl<'key> Serializer for MapKeySerializer<'key> {
Err(Error::unsupported_key()) Err(Error::unsupported_key())
} }
fn serialize_struct_variant( fn serialize_struct_variant(&mut self,
&mut self, _name: &'static str,
_name: &'static str, _variant_index: usize,
_variant_index: usize, _variant: &'static str,
_variant: &'static str, _len: usize)
_len: usize) -> Result<(), Error> {
-> Result<(), Error> {
Err(Error::unsupported_key()) Err(Error::unsupported_key())
} }
fn serialize_struct_variant_elt<T>( fn serialize_struct_variant_elt<T>(&mut self,
&mut self, _state: &mut (), _key: &'static str, _value: T) _state: &mut (),
-> Result<(), Error> { _key: &'static str,
_value: T)
-> Result<(), Error> {
Err(Error::unsupported_key()) Err(Error::unsupported_key())
} }
fn serialize_struct_variant_end( fn serialize_struct_variant_end(&mut self,
&mut self, _state: ()) _state: ())
-> Result<(), Error> { -> Result<(), Error> {
Err(Error::unsupported_key()) Err(Error::unsupported_key())
} }
} }

234
src/ser/mod.rs
View File

@ -30,7 +30,7 @@ pub fn to_string<T: ser::Serialize>(input: &T) -> Result<String, Error> {
let mut output = String::new(); let mut output = String::new();
{ {
let mut urlencoder = UrlEncodedSerializer::new(&mut output); let mut urlencoder = UrlEncodedSerializer::new(&mut output);
try!(input.serialize(&mut Serializer::new(&mut urlencoder))); input.serialize(&mut Serializer::new(&mut urlencoder))?;
} }
Ok(output) Ok(output)
} }
@ -45,7 +45,7 @@ pub fn to_string<T: ser::Serialize>(input: &T) -> Result<String, Error> {
/// ///
/// * Newtype structs defer to their inner values. /// * Newtype structs defer to their inner values.
pub struct Serializer<'output, T: 'output + UrlEncodedTarget> { pub struct Serializer<'output, T: 'output + UrlEncodedTarget> {
urlencoder: &'output mut UrlEncodedSerializer<T> urlencoder: &'output mut UrlEncodedSerializer<T>,
} }
impl<'output, T: 'output + UrlEncodedTarget> Serializer<'output, T> { impl<'output, T: 'output + UrlEncodedTarget> Serializer<'output, T> {
@ -85,7 +85,8 @@ impl error::Error for Error {
/// The lower-level cause of this error, in the case of a `Utf8` error. /// The lower-level cause of this error, in the case of a `Utf8` error.
fn cause(&self) -> Option<&error::Error> { fn cause(&self) -> Option<&error::Error> {
match *self { match *self {
Error::Custom(_) | Error::InvalidValue(_) => None, Error::Custom(_) |
Error::InvalidValue(_) => None,
Error::Utf8(ref err) => Some(err), Error::Utf8(ref err) => Some(err),
} }
} }
@ -123,7 +124,7 @@ pub struct TupleVariantState {
/// State used when serializing maps. /// State used when serializing maps.
pub struct MapState { pub struct MapState {
key: Option<Cow<'static, str>> key: Option<Cow<'static, str>>,
} }
/// State used when serializing structs. /// State used when serializing structs.
@ -137,7 +138,7 @@ pub struct StructVariantState {
} }
impl<'output, Target> ser::Serializer for Serializer<'output, Target> impl<'output, Target> ser::Serializer for Serializer<'output, Target>
where Target: 'output + UrlEncodedTarget where Target: 'output + UrlEncodedTarget,
{ {
type Error = Error; type Error = Error;
@ -248,40 +249,39 @@ impl<'output, Target> ser::Serializer for Serializer<'output, Target>
} }
/// Returns an error. /// Returns an error.
fn serialize_unit_struct( fn serialize_unit_struct(&mut self,
&mut self, _name: &'static str) _name: &'static str)
-> Result<(), Error> { -> Result<(), Error> {
Err(Error::top_level()) Err(Error::top_level())
} }
/// Returns an error. /// Returns an error.
fn serialize_unit_variant( fn serialize_unit_variant(&mut self,
&mut self, _name: &'static str,
_name: &'static str, _variant_index: usize,
_variant_index: usize, _variant: &'static str)
_variant: &'static str) -> Result<(), Error> {
-> Result<(), Error> {
Err(Error::top_level()) Err(Error::top_level())
} }
/// Serializes the inner value, ignoring the newtype name. /// Serializes the inner value, ignoring the newtype name.
fn serialize_newtype_struct<T>( fn serialize_newtype_struct<T>(&mut self,
&mut self, _name: &'static str, value: T) _name: &'static str,
-> Result<(), Error> value: T)
where T: ser::Serialize -> Result<(), Error>
where T: ser::Serialize,
{ {
value.serialize(self) value.serialize(self)
} }
/// Returns an error. /// Returns an error.
fn serialize_newtype_variant<T>( fn serialize_newtype_variant<T>(&mut self,
&mut self, _name: &'static str,
_name: &'static str, _variant_index: usize,
_variant_index: usize, _variant: &'static str,
_variant: &'static str, _value: T)
_value: T) -> Result<(), Error>
-> Result<(), Error> where T: ser::Serialize,
where T: ser::Serialize
{ {
Err(Error::top_level()) Err(Error::top_level())
} }
@ -293,23 +293,24 @@ impl<'output, Target> ser::Serializer for Serializer<'output, Target>
/// Returns an error. /// Returns an error.
fn serialize_some<T>(&mut self, value: T) -> Result<(), Error> fn serialize_some<T>(&mut self, value: T) -> Result<(), Error>
where T: ser::Serialize where T: ser::Serialize,
{ {
value.serialize(self) value.serialize(self)
} }
/// Begins to serialize a sequence, given length (if any) is ignored. /// Begins to serialize a sequence, given length (if any) is ignored.
fn serialize_seq( fn serialize_seq(&mut self,
&mut self, _len: Option<usize>) _len: Option<usize>)
-> Result<SeqState, Error> { -> Result<SeqState, Error> {
Ok(SeqState { _state: () }) Ok(SeqState { _state: () })
} }
/// Serializes a sequence element. /// Serializes a sequence element.
fn serialize_seq_elt<T>( fn serialize_seq_elt<T>(&mut self,
&mut self, _state: &mut SeqState, value: T) _state: &mut SeqState,
-> Result<(), Error> value: T)
where T: ser::Serialize -> Result<(), Error>
where T: ser::Serialize,
{ {
value.serialize(&mut pair::PairSerializer::new(self.urlencoder)) value.serialize(&mut pair::PairSerializer::new(self.urlencoder))
} }
@ -320,9 +321,9 @@ impl<'output, Target> ser::Serializer for Serializer<'output, Target>
} }
/// Begins to serialize a sequence, given length is ignored. /// Begins to serialize a sequence, given length is ignored.
fn serialize_seq_fixed_size( fn serialize_seq_fixed_size(&mut self,
&mut self, _length: usize) _length: usize)
-> Result<SeqState, Error> { -> Result<SeqState, Error> {
Ok(SeqState { _state: () }) Ok(SeqState { _state: () })
} }
@ -332,10 +333,11 @@ impl<'output, Target> ser::Serializer for Serializer<'output, Target>
} }
/// Returns an error. /// Returns an error.
fn serialize_tuple_elt<T>( fn serialize_tuple_elt<T>(&mut self,
&mut self, _state: &mut TupleState, _value: T) _state: &mut TupleState,
-> Result<(), Error> _value: T)
where T: ser::Serialize -> Result<(), Error>
where T: ser::Serialize,
{ {
Err(Error::top_level()) Err(Error::top_level())
} }
@ -346,80 +348,83 @@ impl<'output, Target> ser::Serializer for Serializer<'output, Target>
} }
/// Returns an error. /// Returns an error.
fn serialize_tuple_struct( fn serialize_tuple_struct(&mut self,
&mut self, _name: &'static str, _len: usize) _name: &'static str,
-> Result<TupleStructState, Error> { _len: usize)
-> Result<TupleStructState, Error> {
Err(Error::top_level()) Err(Error::top_level())
} }
/// Returns an error. /// Returns an error.
fn serialize_tuple_struct_elt<T>( fn serialize_tuple_struct_elt<T>(&mut self,
&mut self, _state: &mut TupleStructState, _value: T) _state: &mut TupleStructState,
-> Result<(), Error> _value: T)
where T: ser::Serialize -> Result<(), Error>
where T: ser::Serialize,
{ {
Err(Error::top_level()) Err(Error::top_level())
} }
/// Returns an error. /// Returns an error.
fn serialize_tuple_struct_end( fn serialize_tuple_struct_end(&mut self,
&mut self, _state: TupleStructState) _state: TupleStructState)
-> Result<(), Error> -> Result<(), Error> {
Err(Error::top_level())
}
/// Returns an error.
fn serialize_tuple_variant(&mut self,
_name: &'static str,
_variant_index: usize,
_variant: &'static str,
_len: usize)
-> Result<TupleVariantState, Error> {
Err(Error::top_level())
}
/// Returns an error.
fn serialize_tuple_variant_elt<T>(&mut self,
_state: &mut TupleVariantState,
_value: T)
-> Result<(), Error>
where T: ser::Serialize,
{ {
Err(Error::top_level()) Err(Error::top_level())
} }
/// Returns an error. /// Returns an error.
fn serialize_tuple_variant( fn serialize_tuple_variant_end(&mut self,
&mut self, _state: TupleVariantState)
_name: &'static str, -> Result<(), Error> {
_variant_index: usize,
_variant: &'static str,
_len: usize)
-> Result<TupleVariantState, Error> {
Err(Error::top_level())
}
/// Returns an error.
fn serialize_tuple_variant_elt<T>(
&mut self, _state: &mut TupleVariantState, _value: T)
-> Result<(), Error>
where T: ser::Serialize
{
Err(Error::top_level())
}
/// Returns an error.
fn serialize_tuple_variant_end(
&mut self, _state: TupleVariantState)
-> Result<(), Error> {
Err(Error::top_level()) Err(Error::top_level())
} }
/// Begins to serialize a map, given length (if any) is ignored. /// Begins to serialize a map, given length (if any) is ignored.
fn serialize_map( fn serialize_map(&mut self,
&mut self, _len: Option<usize>) _len: Option<usize>)
-> Result<MapState, Error> { -> Result<MapState, Error> {
Ok(MapState { key: None }) Ok(MapState { key: None })
} }
/// Serializes a map key. /// Serializes a map key.
fn serialize_map_key<T>( fn serialize_map_key<T>(&mut self,
&mut self, state: &mut MapState, key: T) state: &mut MapState,
-> Result<(), Error> key: T)
where T: ser::Serialize -> Result<(), Error>
where T: ser::Serialize,
{ {
key.serialize(&mut key::MapKeySerializer::new(&mut state.key)) key.serialize(&mut key::MapKeySerializer::new(&mut state.key))
} }
/// Serializes a map value. /// Serializes a map value.
fn serialize_map_value<T>( fn serialize_map_value<T>(&mut self,
&mut self, state: &mut MapState, value: T) state: &mut MapState,
-> Result<(), Error> value: T)
where T: ser::Serialize -> Result<(), Error>
where T: ser::Serialize,
{ {
let mut value_serializer = let mut value_serializer =
try!(value::ValueSerializer::new(&mut state.key, self.urlencoder)); value::ValueSerializer::new(&mut state.key, self.urlencoder)?;
value.serialize(&mut value_serializer) value.serialize(&mut value_serializer)
} }
@ -429,20 +434,20 @@ impl<'output, Target> ser::Serializer for Serializer<'output, Target>
} }
/// Begins to serialize a struct, given length is ignored. /// Begins to serialize a struct, given length is ignored.
fn serialize_struct( fn serialize_struct(&mut self,
&mut self, _name: &'static str, _len: usize) _name: &'static str,
-> Result<StructState, Error> { _len: usize)
-> Result<StructState, Error> {
Ok(StructState { _state: () }) Ok(StructState { _state: () })
} }
/// Serializes a struct element. /// Serializes a struct element.
fn serialize_struct_elt<T>( fn serialize_struct_elt<T>(&mut self,
&mut self, _state: &mut StructState,
_state: &mut StructState, key: &'static str,
key: &'static str, value: T)
value: T) -> Result<(), Error>
-> Result<(), Error> where T: ser::Serialize,
where T: ser::Serialize
{ {
let mut key = Some(key.into()); let mut key = Some(key.into());
let mut value_serializer = let mut value_serializer =
@ -451,43 +456,42 @@ impl<'output, Target> ser::Serializer for Serializer<'output, Target>
} }
/// Finishes serializing a struct. /// Finishes serializing a struct.
fn serialize_struct_end(&mut self, _state: StructState) fn serialize_struct_end(&mut self,
_state: StructState)
-> Result<(), Error> { -> Result<(), Error> {
Ok(()) Ok(())
} }
/// Returns an error. /// Returns an error.
fn serialize_struct_variant( fn serialize_struct_variant(&mut self,
&mut self, _name: &'static str,
_name: &'static str, _variant_index: usize,
_variant_index: usize, _variant: &'static str,
_variant: &'static str, _len: usize)
_len: usize) -> Result<StructVariantState, Error> {
-> Result<StructVariantState, Error> {
Err(Error::top_level()) Err(Error::top_level())
} }
/// Returns an error. /// Returns an error.
fn serialize_struct_variant_elt<T>( fn serialize_struct_variant_elt<T>(&mut self,
&mut self, _state: &mut StructVariantState,
_state: &mut StructVariantState, _key: &'static str,
_key: &'static str, _value: T)
_value: T) -> Result<(), Error> {
-> Result<(), Error> {
Err(Error::top_level()) Err(Error::top_level())
} }
/// Returns an error. /// Returns an error.
fn serialize_struct_variant_end( fn serialize_struct_variant_end(&mut self,
&mut self, _state: StructVariantState) _state: StructVariantState)
-> Result<(), Error> { -> Result<(), Error> {
Err(Error::top_level()) Err(Error::top_level())
} }
} }
impl Error { impl Error {
fn top_level() -> Self { fn top_level() -> Self {
Error::Custom( Error::Custom("top-level serializer supports only maps and structs"
"top-level serializer supports only maps and structs".into()) .into())
} }
} }

200
src/ser/pair.rs
View File

@ -8,11 +8,10 @@ pub struct PairSerializer<'target, Target>(
where Target: 'target + form_urlencoded::Target; where Target: 'target + form_urlencoded::Target;
impl<'target, Target> PairSerializer<'target, Target> impl<'target, Target> PairSerializer<'target, Target>
where Target: 'target + form_urlencoded::Target where Target: 'target + form_urlencoded::Target,
{ {
pub fn new( pub fn new(serializer: &'target mut form_urlencoded::Serializer<Target>)
serializer: &'target mut form_urlencoded::Serializer<Target>) -> Self {
-> Self {
PairSerializer(serializer) PairSerializer(serializer)
} }
} }
@ -21,7 +20,7 @@ pub struct TupleState(Option<Option<Cow<'static, str>>>);
pub struct TupleStructState(TupleState); pub struct TupleStructState(TupleState);
impl<'target, Target> Serializer for PairSerializer<'target, Target> impl<'target, Target> Serializer for PairSerializer<'target, Target>
where Target: 'target + form_urlencoded::Target where Target: 'target + form_urlencoded::Target,
{ {
type Error = Error; type Error = Error;
type SeqState = (); type SeqState = ();
@ -100,37 +99,36 @@ impl<'target, Target> Serializer for PairSerializer<'target, Target>
Err(Error::unsupported_pair()) Err(Error::unsupported_pair())
} }
fn serialize_unit_struct( fn serialize_unit_struct(&mut self,
&mut self, _name: &'static str) _name: &'static str)
-> Result<(), Error> { -> Result<(), Error> {
Err(Error::unsupported_pair()) Err(Error::unsupported_pair())
} }
fn serialize_unit_variant( fn serialize_unit_variant(&mut self,
&mut self, _name: &'static str,
_name: &'static str, _variant_index: usize,
_variant_index: usize, _variant: &'static str)
_variant: &'static str) -> Result<(), Error> {
-> Result<(), Error> {
Err(Error::unsupported_pair()) Err(Error::unsupported_pair())
} }
fn serialize_newtype_struct<T>( fn serialize_newtype_struct<T>(&mut self,
&mut self, _name: &'static str, value: T) _name: &'static str,
-> Result<(), Error> value: T)
where T: Serialize -> Result<(), Error>
where T: Serialize,
{ {
value.serialize(self) value.serialize(self)
} }
fn serialize_newtype_variant<T>( fn serialize_newtype_variant<T>(&mut self,
&mut self, _name: &'static str,
_name: &'static str, _variant_index: usize,
_variant_index: usize, _variant: &'static str,
_variant: &'static str, _value: T)
_value: T) -> Result<(), Error>
-> Result<(), Error> where T: Serialize,
where T: Serialize
{ {
Err(Error::unsupported_pair()) Err(Error::unsupported_pair())
} }
@ -140,19 +138,20 @@ impl<'target, Target> Serializer for PairSerializer<'target, Target>
} }
fn serialize_some<T>(&mut self, value: T) -> Result<(), Error> fn serialize_some<T>(&mut self, value: T) -> Result<(), Error>
where T: Serialize where T: Serialize,
{ {
value.serialize(self) value.serialize(self)
} }
fn serialize_seq(&mut self, _len: Option<usize>) fn serialize_seq(&mut self, _len: Option<usize>) -> Result<(), Error> {
-> Result<(), Error> {
Err(Error::unsupported_pair()) Err(Error::unsupported_pair())
} }
fn serialize_seq_elt<T>(&mut self, _state: &mut (), _value: T) fn serialize_seq_elt<T>(&mut self,
_state: &mut (),
_value: T)
-> Result<(), Error> -> Result<(), Error>
where T: Serialize where T: Serialize,
{ {
Err(Error::unsupported_pair()) Err(Error::unsupported_pair())
} }
@ -161,8 +160,7 @@ impl<'target, Target> Serializer for PairSerializer<'target, Target>
Err(Error::unsupported_pair()) Err(Error::unsupported_pair())
} }
fn serialize_seq_fixed_size(&mut self, _size: usize) fn serialize_seq_fixed_size(&mut self, _size: usize) -> Result<(), Error> {
-> Result<(), Error> {
Err(Error::unsupported_pair()) Err(Error::unsupported_pair())
} }
@ -174,10 +172,11 @@ impl<'target, Target> Serializer for PairSerializer<'target, Target>
} }
} }
fn serialize_tuple_elt<T>( fn serialize_tuple_elt<T>(&mut self,
&mut self, state: &mut TupleState, value: T) state: &mut TupleState,
-> Result<(), Error> value: T)
where T: Serialize -> Result<(), Error>
where T: Serialize,
{ {
match state.0.take() { match state.0.take() {
None => { None => {
@ -185,7 +184,7 @@ impl<'target, Target> Serializer for PairSerializer<'target, Target>
{ {
let mut key_serializer = let mut key_serializer =
key::MapKeySerializer::new(&mut key); key::MapKeySerializer::new(&mut key);
try!(value.serialize(&mut key_serializer)); value.serialize(&mut key_serializer)?;
} }
state.0 = Some(key); state.0 = Some(key);
Ok(()) Ok(())
@ -194,11 +193,11 @@ impl<'target, Target> Serializer for PairSerializer<'target, Target>
{ {
let mut value_serializer = let mut value_serializer =
value::ValueSerializer::new(key, &mut self.0).unwrap(); value::ValueSerializer::new(key, &mut self.0).unwrap();
try!(value.serialize(&mut value_serializer)); value.serialize(&mut value_serializer)?;
} }
state.0 = Some(None); state.0 = Some(None);
Ok(()) Ok(())
} },
} }
} }
@ -206,68 +205,68 @@ impl<'target, Target> Serializer for PairSerializer<'target, Target>
Ok(()) Ok(())
} }
fn serialize_tuple_struct( fn serialize_tuple_struct(&mut self,
&mut self, _name: &'static str, len: usize) _name: &'static str,
-> Result<TupleStructState, Error> { len: usize)
-> Result<TupleStructState, Error> {
self.serialize_tuple(len).map(TupleStructState) self.serialize_tuple(len).map(TupleStructState)
} }
fn serialize_tuple_struct_elt<T>( fn serialize_tuple_struct_elt<T>(&mut self,
&mut self, state: &mut TupleStructState, value: T) state: &mut TupleStructState,
-> Result<(), Error> value: T)
where T: Serialize -> Result<(), Error>
where T: Serialize,
{ {
self.serialize_tuple_elt(&mut state.0, value) self.serialize_tuple_elt(&mut state.0, value)
} }
fn serialize_tuple_struct_end( fn serialize_tuple_struct_end(&mut self,
&mut self, _state: TupleStructState) _state: TupleStructState)
-> Result<(), Error> { -> Result<(), Error> {
Ok(()) Ok(())
} }
fn serialize_tuple_variant( fn serialize_tuple_variant(&mut self,
&mut self, _name: &'static str,
_name: &'static str, _variant_index: usize,
_variant_index: usize, _variant: &'static str,
_variant: &'static str, _len: usize)
_len: usize) -> Result<(), Error> {
-> Result<(), Error> {
Err(Error::unsupported_pair()) Err(Error::unsupported_pair())
} }
fn serialize_tuple_variant_elt<T>( fn serialize_tuple_variant_elt<T>(&mut self,
&mut self, _state: &mut (), _value: T) _state: &mut (),
-> Result<(), Error> _value: T)
where T: Serialize -> Result<(), Error>
where T: Serialize,
{ {
Err(Error::unsupported_pair()) Err(Error::unsupported_pair())
} }
fn serialize_tuple_variant_end( fn serialize_tuple_variant_end(&mut self, _state: ()) -> Result<(), Error> {
&mut self, _state: ())
-> Result<(), Error> {
Err(Error::unsupported_pair()) Err(Error::unsupported_pair())
} }
fn serialize_map( fn serialize_map(&mut self, _len: Option<usize>) -> Result<(), Error> {
&mut self, _len: Option<usize>)
-> Result<(), Error> {
Err(Error::unsupported_pair()) Err(Error::unsupported_pair())
} }
fn serialize_map_key<T>( fn serialize_map_key<T>(&mut self,
&mut self, _state: &mut (), _key: T) _state: &mut (),
-> Result<(), Error> _key: T)
where T: Serialize -> Result<(), Error>
where T: Serialize,
{ {
Err(Error::unsupported_pair()) Err(Error::unsupported_pair())
} }
fn serialize_map_value<T>( fn serialize_map_value<T>(&mut self,
&mut self, _state: &mut (), _value: T) _state: &mut (),
-> Result<(), Error> _value: T)
where T: Serialize -> Result<(), Error>
where T: Serialize,
{ {
Err(Error::unsupported_pair()) Err(Error::unsupported_pair())
} }
@ -276,49 +275,46 @@ impl<'target, Target> Serializer for PairSerializer<'target, Target>
Err(Error::unsupported_pair()) Err(Error::unsupported_pair())
} }
fn serialize_struct(&mut self, _name: &'static str, _len: usize) fn serialize_struct(&mut self,
_name: &'static str,
_len: usize)
-> Result<(), Error> { -> Result<(), Error> {
Err(Error::unsupported_pair()) Err(Error::unsupported_pair())
} }
fn serialize_struct_elt<T>( fn serialize_struct_elt<T>(&mut self,
&mut self, _state: &mut (),
_state: &mut (), _key: &'static str,
_key: &'static str, _value: T)
_value: T) -> Result<(), Error>
-> Result<(), Error> where T: Serialize,
where T: Serialize
{ {
Err(Error::unsupported_pair()) Err(Error::unsupported_pair())
} }
fn serialize_struct_end( fn serialize_struct_end(&mut self, _state: ()) -> Result<(), Error> {
&mut self, _state: ())
-> Result<(), Error> {
Err(Error::unsupported_pair()) Err(Error::unsupported_pair())
} }
fn serialize_struct_variant( fn serialize_struct_variant(&mut self,
&mut self, _name: &'static str,
_name: &'static str, _variant_index: usize,
_variant_index: usize, _variant: &'static str,
_variant: &'static str, _len: usize)
_len: usize) -> Result<(), Error> {
-> Result<(), Error> {
Err(Error::unsupported_pair()) Err(Error::unsupported_pair())
} }
fn serialize_struct_variant_elt<T>( fn serialize_struct_variant_elt<T>(&mut self,
&mut self, _state: &mut (),
_state: &mut (), _key: &'static str,
_key: &'static str, _value: T)
_value: T) -> Result<(), Error> {
-> Result<(), Error> {
Err(Error::unsupported_pair()) Err(Error::unsupported_pair())
} }
fn serialize_struct_variant_end( fn serialize_struct_variant_end(&mut self,
&mut self, _state: ()) _state: ())
-> Result<(), Error> { -> Result<(), Error> {
Err(Error::unsupported_pair()) Err(Error::unsupported_pair())
} }
} }

183
src/ser/value.rs
View File

@ -5,19 +5,18 @@ use std::str;
use url::form_urlencoded; use url::form_urlencoded;
pub struct ValueSerializer<'key, 'target, Target> pub struct ValueSerializer<'key, 'target, Target>
where Target: 'target + form_urlencoded::Target where Target: 'target + form_urlencoded::Target,
{ {
key: &'key mut Option<Cow<'static, str>>, key: &'key mut Option<Cow<'static, str>>,
serializer: &'target mut form_urlencoded::Serializer<Target> serializer: &'target mut form_urlencoded::Serializer<Target>,
} }
impl<'key, 'target, Target> ValueSerializer<'key, 'target, Target> impl<'key, 'target, Target> ValueSerializer<'key, 'target, Target>
where Target: 'target + form_urlencoded::Target where Target: 'target + form_urlencoded::Target,
{ {
pub fn new( pub fn new(key: &'key mut Option<Cow<'static, str>>,
key: &'key mut Option<Cow<'static, str>>, serializer: &'target mut form_urlencoded::Serializer<Target>)
serializer: &'target mut form_urlencoded::Serializer<Target>) -> Result<Self, Error> {
-> Result<Self, Error> {
if key.is_some() { if key.is_some() {
Ok(ValueSerializer { Ok(ValueSerializer {
key: key, key: key,
@ -40,7 +39,7 @@ impl<'key, 'target, Target> ValueSerializer<'key, 'target, Target>
impl<'key, 'target, Target> Serializer impl<'key, 'target, Target> Serializer
for ValueSerializer<'key, 'target, Target> for ValueSerializer<'key, 'target, Target>
where Target: 'target + form_urlencoded::Target where Target: 'target + form_urlencoded::Target,
{ {
type Error = Error; type Error = Error;
type SeqState = (); type SeqState = ();
@ -122,37 +121,36 @@ impl<'key, 'target, Target> Serializer
Err(Error::unsupported_value()) Err(Error::unsupported_value())
} }
fn serialize_unit_struct( fn serialize_unit_struct(&mut self,
&mut self, name: &'static str) name: &'static str)
-> Result<(), Error> { -> Result<(), Error> {
self.append_pair(name) self.append_pair(name)
} }
fn serialize_unit_variant( fn serialize_unit_variant(&mut self,
&mut self, _name: &'static str,
_name: &'static str, _variant_index: usize,
_variant_index: usize, variant: &'static str)
variant: &'static str) -> Result<(), Error> {
-> Result<(), Error> {
self.append_pair(variant) self.append_pair(variant)
} }
fn serialize_newtype_struct<T>( fn serialize_newtype_struct<T>(&mut self,
&mut self, _name: &'static str, value: T) _name: &'static str,
-> Result<(), Error> value: T)
where T: Serialize -> Result<(), Error>
where T: Serialize,
{ {
value.serialize(self) value.serialize(self)
} }
fn serialize_newtype_variant<T>( fn serialize_newtype_variant<T>(&mut self,
&mut self, _name: &'static str,
_name: &'static str, _variant_index: usize,
_variant_index: usize, _variant: &'static str,
_variant: &'static str, _value: T)
_value: T) -> Result<(), Error>
-> Result<(), Error> where T: Serialize,
where T: Serialize
{ {
Err(Error::unsupported_value()) Err(Error::unsupported_value())
} }
@ -166,7 +164,7 @@ impl<'key, 'target, Target> Serializer
} }
fn serialize_some<T>(&mut self, value: T) -> Result<(), Error> fn serialize_some<T>(&mut self, value: T) -> Result<(), Error>
where T: Serialize where T: Serialize,
{ {
value.serialize(self) value.serialize(self)
} }
@ -175,10 +173,11 @@ impl<'key, 'target, Target> Serializer
Err(Error::unsupported_value()) Err(Error::unsupported_value())
} }
fn serialize_seq_elt<T>( fn serialize_seq_elt<T>(&mut self,
&mut self, _state: &mut (), _value: T) _state: &mut (),
-> Result<(), Error> _value: T)
where T: Serialize -> Result<(), Error>
where T: Serialize,
{ {
Err(Error::unsupported_value()) Err(Error::unsupported_value())
} }
@ -195,10 +194,11 @@ impl<'key, 'target, Target> Serializer
Err(Error::unsupported_value()) Err(Error::unsupported_value())
} }
fn serialize_tuple_elt<T>( fn serialize_tuple_elt<T>(&mut self,
&mut self, _state: &mut (), _value: T) _state: &mut (),
-> Result<(), Error> _value: T)
where T: Serialize -> Result<(), Error>
where T: Serialize,
{ {
Err(Error::unsupported_value()) Err(Error::unsupported_value())
} }
@ -207,16 +207,18 @@ impl<'key, 'target, Target> Serializer
Err(Error::unsupported_value()) Err(Error::unsupported_value())
} }
fn serialize_tuple_struct( fn serialize_tuple_struct(&mut self,
&mut self, _name: &'static str, _len: usize) _name: &'static str,
-> Result<(), Error> { _len: usize)
-> Result<(), Error> {
Err(Error::unsupported_value()) Err(Error::unsupported_value())
} }
fn serialize_tuple_struct_elt<T>( fn serialize_tuple_struct_elt<T>(&mut self,
&mut self, _state: &mut (), _value: T) _state: &mut (),
-> Result<(), Error> _value: T)
where T: Serialize -> Result<(), Error>
where T: Serialize,
{ {
Err(Error::unsupported_value()) Err(Error::unsupported_value())
} }
@ -225,20 +227,20 @@ impl<'key, 'target, Target> Serializer
Err(Error::unsupported_value()) Err(Error::unsupported_value())
} }
fn serialize_tuple_variant( fn serialize_tuple_variant(&mut self,
&mut self, _name: &'static str,
_name: &'static str, _variant_index: usize,
_variant_index: usize, _variant: &'static str,
_variant: &'static str, _len: usize)
_len: usize) -> Result<(), Error> {
-> Result<(), Error> {
Err(Error::unsupported_value()) Err(Error::unsupported_value())
} }
fn serialize_tuple_variant_elt<T>( fn serialize_tuple_variant_elt<T>(&mut self,
&mut self, _state: &mut (), _value: T) _state: &mut (),
-> Result<(), Error> _value: T)
where T: Serialize -> Result<(), Error>
where T: Serialize,
{ {
Err(Error::unsupported_value()) Err(Error::unsupported_value())
} }
@ -251,18 +253,20 @@ impl<'key, 'target, Target> Serializer
Err(Error::unsupported_value()) Err(Error::unsupported_value())
} }
fn serialize_map_key<T>( fn serialize_map_key<T>(&mut self,
&mut self, _state: &mut (), _key: T) _state: &mut (),
-> Result<(), Error> _key: T)
where T: Serialize -> Result<(), Error>
where T: Serialize,
{ {
Err(Error::unsupported_value()) Err(Error::unsupported_value())
} }
fn serialize_map_value<T>( fn serialize_map_value<T>(&mut self,
&mut self, _state: &mut (), _value: T) _state: &mut (),
-> Result<(), Error> _value: T)
where T: Serialize -> Result<(), Error>
where T: Serialize,
{ {
Err(Error::unsupported_value()) Err(Error::unsupported_value())
} }
@ -271,19 +275,19 @@ impl<'key, 'target, Target> Serializer
Err(Error::unsupported_value()) Err(Error::unsupported_value())
} }
fn serialize_struct( fn serialize_struct(&mut self,
&mut self, _name: &'static str, _len: usize) _name: &'static str,
-> Result<(), Error> { _len: usize)
-> Result<(), Error> {
Err(Error::unsupported_value()) Err(Error::unsupported_value())
} }
fn serialize_struct_elt<T>( fn serialize_struct_elt<T>(&mut self,
&mut self, _state: &mut (),
_state: &mut (), _key: &'static str,
_key: &'static str, _value: T)
_value: T) -> Result<(), Error>
-> Result<(), Error> where T: Serialize,
where T: Serialize
{ {
Err(Error::unsupported_value()) Err(Error::unsupported_value())
} }
@ -292,32 +296,33 @@ impl<'key, 'target, Target> Serializer
Err(Error::unsupported_value()) Err(Error::unsupported_value())
} }
fn serialize_struct_variant( fn serialize_struct_variant(&mut self,
&mut self, _name: &'static str,
_name: &'static str, _variant_index: usize,
_variant_index: usize, _variant: &'static str,
_variant: &'static str, _len: usize)
_len: usize) -> Result<(), Error> {
-> Result<(), Error> {
Err(Error::unsupported_value()) Err(Error::unsupported_value())
} }
fn serialize_struct_variant_elt<T>( fn serialize_struct_variant_elt<T>(&mut self,
&mut self, _state: &mut (), _key: &'static str, _value: T) _state: &mut (),
-> Result<(), Error> { _key: &'static str,
_value: T)
-> Result<(), Error> {
Err(Error::unsupported_value()) Err(Error::unsupported_value())
} }
fn serialize_struct_variant_end( fn serialize_struct_variant_end(&mut self,
&mut self, _state: ()) _state: ())
-> Result<(), Error> { -> Result<(), Error> {
Err(Error::unsupported_value()) Err(Error::unsupported_value())
} }
} }
impl Error { impl Error {
fn no_key() -> Self { fn no_key() -> Self {
Error::Custom( Error::Custom("tried to serialize a value before serializing key"
"tried to serialize a value before serializing key".into()) .into())
} }
fn unsupported_value() -> Self { fn unsupported_value() -> Self {

43
tests/test_serialize.rs
View File

@ -2,50 +2,33 @@ extern crate serde_urlencoded;
#[test] #[test]
fn serialize_option_map_int() { fn serialize_option_map_int() {
let params = &[ let params = &[("first", Some(23)), ("middle", None), ("last", Some(42))];
("first", Some(23)),
("middle", None),
("last", Some(42)),
];
assert_eq!( assert_eq!(serde_urlencoded::to_string(params),
serde_urlencoded::to_string(params), Ok("first=23&last=42".to_owned()));
Ok("first=23&last=42".to_owned()));
} }
#[test] #[test]
fn serialize_option_map_string() { fn serialize_option_map_string() {
let params = &[ let params =
("first", Some("hello")), &[("first", Some("hello")), ("middle", None), ("last", Some("world"))];
("middle", None),
("last", Some("world")),
];
assert_eq!( assert_eq!(serde_urlencoded::to_string(params),
serde_urlencoded::to_string(params), Ok("first=hello&last=world".to_owned()));
Ok("first=hello&last=world".to_owned()));
} }
#[test] #[test]
fn serialize_option_map_bool() { fn serialize_option_map_bool() {
let params = &[ let params = &[("one", Some(true)), ("two", Some(false))];
("one", Some(true)),
("two", Some(false))
];
assert_eq!( assert_eq!(serde_urlencoded::to_string(params),
serde_urlencoded::to_string(params), Ok("one=true&two=false".to_owned()));
Ok("one=true&two=false".to_owned()));
} }
#[test] #[test]
fn serialize_map_bool() { fn serialize_map_bool() {
let params = &[ let params = &[("one", true), ("two", false)];
("one", true),
("two", false)
];
assert_eq!( assert_eq!(serde_urlencoded::to_string(params),
serde_urlencoded::to_string(params), Ok("one=true&two=false".to_owned()));
Ok("one=true&two=false".to_owned()));
} }