From 4595e1a7bd1c2434e237a9a6f18af9988755f1c8 Mon Sep 17 00:00:00 2001 From: David Tolnay Date: Tue, 18 Apr 2017 14:23:59 -0700 Subject: [PATCH] Format in rfc style --- .gitignore | 5 +- rustfmt.toml | 5 + src/de.rs | 223 +++++----- src/error.rs | 141 +++---- src/iter.rs | 6 +- src/lib.rs | 7 +- src/map.rs | 118 +++--- src/number.rs | 15 +- src/read.rs | 216 +++++----- src/ser.rs | 493 +++++++++++++--------- src/value.rs | 367 ++++++++++------- tests/stream.rs | 78 ++-- tests/test.rs | 1035 ++++++++++++++++++++++------------------------- 13 files changed, 1413 insertions(+), 1296 deletions(-) create mode 100644 rustfmt.toml diff --git a/.gitignore b/.gitignore index d5f8235..165eb22 100644 --- a/.gitignore +++ b/.gitignore @@ -1,3 +1,4 @@ -.cargo/ -Cargo.lock target/ +**/*.rs.bk +*.sw[po] +Cargo.lock diff --git a/rustfmt.toml b/rustfmt.toml new file mode 100644 index 0000000..914d19d --- /dev/null +++ b/rustfmt.toml @@ -0,0 +1,5 @@ +fn_args_layout = "Block" +array_layout = "Block" +where_style = "Rfc" +generics_indent = "Block" +fn_call_style = "Block" diff --git a/src/de.rs b/src/de.rs index 34e148d..a12a04d 100644 --- a/src/de.rs +++ b/src/de.rs @@ -30,7 +30,8 @@ pub struct Deserializer { } impl<'de, R> Deserializer - where R: read::Read<'de> +where + R: read::Read<'de>, { /// Create a JSON deserializer from one of the possible serde_json input /// sources. @@ -51,7 +52,8 @@ impl<'de, R> Deserializer } impl Deserializer> - where I: Iterator> +where + I: Iterator>, { /// Creates a JSON deserializer from a `std::iter::Iterator`. pub fn from_iter(iter: I) -> Self { @@ -60,7 +62,8 @@ impl Deserializer> } impl Deserializer> - where R: io::Read +where + R: io::Read, { /// Creates a JSON deserializer from an `io::Read`. pub fn from_reader(reader: R) -> Self { @@ -101,7 +104,8 @@ impl<'de, R: Read<'de>> Deserializer { /// Turn a JSON deserializer into an iterator over values of type T. pub fn into_iter(self) -> StreamDeserializer<'de, R, T> - where T: de::Deserialize<'de> + where + T: de::Deserialize<'de>, { // This cannot be an implementation of std::iter::IntoIterator because // we need the caller to choose what T is. @@ -162,7 +166,8 @@ impl<'de, R: Read<'de>> Deserializer { } fn parse_value(&mut self, visitor: V) -> Result - where V: de::Visitor<'de>, + where + V: de::Visitor<'de>, { let peek = match try!(self.parse_whitespace()) { Some(b) => b, @@ -258,15 +263,14 @@ impl<'de, R: Read<'de>> Deserializer { } fn parse_integer(&mut self, pos: bool, visitor: V) -> Result - where V: de::Visitor<'de>, + where + V: de::Visitor<'de>, { match try!(self.next_char_or_null()) { b'0' => { // There can be only one leading '0'. match try!(self.peek_or_null()) { - b'0'...b'9' => { - Err(self.peek_error(ErrorCode::InvalidNumber)) - } + b'0'...b'9' => Err(self.peek_error(ErrorCode::InvalidNumber)), _ => self.parse_number(pos, 0, visitor), } } @@ -283,10 +287,12 @@ impl<'de, R: Read<'de>> Deserializer { // number as a `u64` until we grow too large. At that point, switch to // parsing the value as a `f64`. if overflow!(res * 10 + digit, u64::MAX) { - return self.parse_long_integer(pos, - res, - 1, // res * 10^1 - visitor); + return self.parse_long_integer( + pos, + res, + 1, // res * 10^1 + visitor, + ); } res = res * 10 + digit; @@ -306,9 +312,10 @@ impl<'de, R: Read<'de>> Deserializer { pos: bool, significand: u64, mut exponent: i32, - visitor: V + visitor: V, ) -> Result - where V: de::Visitor<'de>, + where + V: de::Visitor<'de>, { loop { match try!(self.peek_or_null()) { @@ -325,22 +332,15 @@ impl<'de, R: Read<'de>> Deserializer { return self.parse_exponent(pos, significand, exponent, visitor); } _ => { - return self.visit_f64_from_parts(pos, - significand, - exponent, - visitor); + return self.visit_f64_from_parts(pos, significand, exponent, visitor); } } } } - fn parse_number( - &mut self, - pos: bool, - significand: u64, - visitor: V - ) -> Result - where V: de::Visitor<'de>, + fn parse_number(&mut self, pos: bool, significand: u64, visitor: V) -> Result + where + V: de::Visitor<'de>, { match try!(self.peek_or_null()) { b'.' => self.parse_decimal(pos, significand, 0, visitor), @@ -367,9 +367,10 @@ impl<'de, R: Read<'de>> Deserializer { pos: bool, mut significand: u64, mut exponent: i32, - visitor: V + visitor: V, ) -> Result - where V: de::Visitor<'de>, + where + V: de::Visitor<'de>, { self.eat_char(); @@ -397,9 +398,7 @@ impl<'de, R: Read<'de>> Deserializer { } match try!(self.peek_or_null()) { - b'e' | b'E' => { - self.parse_exponent(pos, significand, exponent, visitor) - } + b'e' | b'E' => self.parse_exponent(pos, significand, exponent, visitor), _ => self.visit_f64_from_parts(pos, significand, exponent, visitor), } } @@ -409,9 +408,10 @@ impl<'de, R: Read<'de>> Deserializer { pos: bool, significand: u64, starting_exp: i32, - visitor: V + visitor: V, ) -> Result - where V: de::Visitor<'de>, + where + V: de::Visitor<'de>, { self.eat_char(); @@ -440,10 +440,7 @@ impl<'de, R: Read<'de>> Deserializer { let digit = (c - b'0') as i32; if overflow!(exp * 10 + digit, i32::MAX) { - return self.parse_exponent_overflow(pos, - significand, - pos_exp, - visitor); + return self.parse_exponent_overflow(pos, significand, pos_exp, visitor); } exp = exp * 10 + digit; @@ -467,9 +464,10 @@ impl<'de, R: Read<'de>> Deserializer { pos: bool, significand: u64, pos_exp: bool, - visitor: V + visitor: V, ) -> Result - where V: de::Visitor<'de>, + where + V: de::Visitor<'de>, { // Error instead of +/- infinity. if significand != 0 && pos_exp { @@ -479,11 +477,7 @@ impl<'de, R: Read<'de>> Deserializer { while let b'0'...b'9' = try!(self.peek_or_null()) { self.eat_char(); } - visitor.visit_f64(if pos { - 0.0 - } else { - -0.0 - }) + visitor.visit_f64(if pos { 0.0 } else { -0.0 }) } fn visit_f64_from_parts( @@ -491,9 +485,10 @@ impl<'de, R: Read<'de>> Deserializer { pos: bool, significand: u64, mut exponent: i32, - visitor: V + visitor: V, ) -> Result - where V: de::Visitor<'de>, + where + V: de::Visitor<'de>, { let mut f = significand as f64; loop { @@ -521,11 +516,7 @@ impl<'de, R: Read<'de>> Deserializer { } } } - visitor.visit_f64(if pos { - f - } else { - -f - }) + visitor.visit_f64(if pos { f } else { -f }) } fn parse_object_colon(&mut self) -> Result<()> { @@ -562,6 +553,7 @@ impl<'de, R: Read<'de>> Deserializer { } } +#[cfg_attr(rustfmt, rustfmt_skip)] static POW10: [f64; 309] = [1e000, 1e001, 1e002, 1e003, 1e004, 1e005, 1e006, 1e007, 1e008, 1e009, 1e010, 1e011, 1e012, 1e013, 1e014, 1e015, 1e016, 1e017, 1e018, 1e019, @@ -600,7 +592,8 @@ impl<'de, 'a, R: Read<'de>> de::Deserializer<'de> for &'a mut Deserializer { #[inline] fn deserialize_any(self, visitor: V) -> Result - where V: de::Visitor<'de>, + where + V: de::Visitor<'de>, { self.parse_value(visitor) } @@ -608,7 +601,8 @@ impl<'de, 'a, R: Read<'de>> de::Deserializer<'de> for &'a mut Deserializer { /// Parses a `null` as a None, and any other values as a `Some(...)`. #[inline] fn deserialize_option(self, visitor: V) -> Result - where V: de::Visitor<'de>, + where + V: de::Visitor<'de>, { match try!(self.parse_whitespace()) { Some(b'n') => { @@ -622,12 +616,9 @@ impl<'de, 'a, R: Read<'de>> de::Deserializer<'de> for &'a mut Deserializer { /// Parses a newtype struct as the underlying value. #[inline] - fn deserialize_newtype_struct( - self, - _name: &str, - visitor: V - ) -> Result - where V: de::Visitor<'de>, + fn deserialize_newtype_struct(self, _name: &str, visitor: V) -> Result + where + V: de::Visitor<'de>, { visitor.visit_newtype_struct(self) } @@ -639,9 +630,10 @@ impl<'de, 'a, R: Read<'de>> de::Deserializer<'de> for &'a mut Deserializer { self, _name: &str, _variants: &'static [&'static str], - visitor: V + visitor: V, ) -> Result - where V: de::Visitor<'de>, + where + V: de::Visitor<'de>, { match try!(self.parse_whitespace()) { Some(b'{') => { @@ -752,7 +744,8 @@ impl<'de, 'a, R: Read<'de>> de::Deserializer<'de> for &'a mut Deserializer { /// # } /// ``` fn deserialize_bytes(self, visitor: V) -> Result - where V: de::Visitor<'de> + where + V: de::Visitor<'de>, { match try!(self.parse_whitespace()) { Some(b'"') => { @@ -770,7 +763,8 @@ impl<'de, 'a, R: Read<'de>> de::Deserializer<'de> for &'a mut Deserializer { #[inline] fn deserialize_byte_buf(self, visitor: V) -> Result - where V: de::Visitor<'de> + where + V: de::Visitor<'de>, { self.deserialize_bytes(visitor) } @@ -799,7 +793,8 @@ impl<'de, 'a, R: Read<'de> + 'a> de::SeqAccess<'de> for SeqAccess<'a, R> { type Error = Error; fn next_element_seed(&mut self, seed: T) -> Result> - where T: de::DeserializeSeed<'de>, + where + T: de::DeserializeSeed<'de>, { match try!(self.de.parse_whitespace()) { Some(b']') => { @@ -812,8 +807,7 @@ impl<'de, 'a, R: Read<'de> + 'a> de::SeqAccess<'de> for SeqAccess<'a, R> { if self.first { self.first = false; } else { - return Err(self.de - .peek_error(ErrorCode::ExpectedListCommaOrEnd)); + return Err(self.de.peek_error(ErrorCode::ExpectedListCommaOrEnd)); } } None => { @@ -844,7 +838,8 @@ impl<'de, 'a, R: Read<'de> + 'a> de::MapAccess<'de> for MapAccess<'a, R> { type Error = Error; fn next_key_seed(&mut self, seed: K) -> Result> - where K: de::DeserializeSeed<'de>, + where + K: de::DeserializeSeed<'de>, { let peek = match try!(self.de.parse_whitespace()) { Some(b'}') => { @@ -859,13 +854,11 @@ impl<'de, 'a, R: Read<'de> + 'a> de::MapAccess<'de> for MapAccess<'a, R> { self.first = false; Some(b) } else { - return Err(self.de - .peek_error(ErrorCode::ExpectedObjectCommaOrEnd)); + return Err(self.de.peek_error(ErrorCode::ExpectedObjectCommaOrEnd)); } } None => { - return Err(self.de - .peek_error(ErrorCode::EofWhileParsingObject)); + return Err(self.de.peek_error(ErrorCode::EofWhileParsingObject)); } }; @@ -877,7 +870,8 @@ impl<'de, 'a, R: Read<'de> + 'a> de::MapAccess<'de> for MapAccess<'a, R> { } fn next_value_seed(&mut self, seed: V) -> Result - where V: de::DeserializeSeed<'de>, + where + V: de::DeserializeSeed<'de>, { try!(self.de.parse_object_colon()); @@ -891,9 +885,7 @@ struct VariantAccess<'a, R: 'a> { impl<'a, R: 'a> VariantAccess<'a, R> { fn new(de: &'a mut Deserializer) -> Self { - VariantAccess { - de: de, - } + VariantAccess { de: de } } } @@ -902,7 +894,8 @@ impl<'de, 'a, R: Read<'de> + 'a> de::EnumAccess<'de> for VariantAccess<'a, R> { type Variant = Self; fn variant_seed(self, seed: V) -> Result<(V::Value, Self)> - where V: de::DeserializeSeed<'de>, + where + V: de::DeserializeSeed<'de>, { let val = try!(seed.deserialize(&mut *self.de)); try!(self.de.parse_object_colon()); @@ -918,23 +911,22 @@ impl<'de, 'a, R: Read<'de> + 'a> de::VariantAccess<'de> for VariantAccess<'a, R> } fn newtype_variant_seed(self, seed: T) -> Result - where T: de::DeserializeSeed<'de>, + where + T: de::DeserializeSeed<'de>, { seed.deserialize(self.de) } fn tuple_variant(self, _len: usize, visitor: V) -> Result - where V: de::Visitor<'de>, + where + V: de::Visitor<'de>, { de::Deserializer::deserialize_any(self.de, visitor) } - fn struct_variant( - self, - _fields: &'static [&'static str], - visitor: V - ) -> Result - where V: de::Visitor<'de>, + fn struct_variant(self, _fields: &'static [&'static str], visitor: V) -> Result + where + V: de::Visitor<'de>, { de::Deserializer::deserialize_any(self.de, visitor) } @@ -946,9 +938,7 @@ struct UnitVariantAccess<'a, R: 'a> { impl<'a, R: 'a> UnitVariantAccess<'a, R> { fn new(de: &'a mut Deserializer) -> Self { - UnitVariantAccess { - de: de, - } + UnitVariantAccess { de: de } } } @@ -957,7 +947,8 @@ impl<'de, 'a, R: Read<'de> + 'a> de::EnumAccess<'de> for UnitVariantAccess<'a, R type Variant = Self; fn variant_seed(self, seed: V) -> Result<(V::Value, Self)> - where V: de::DeserializeSeed<'de>, + where + V: de::DeserializeSeed<'de>, { let variant = try!(seed.deserialize(&mut *self.de)); Ok((variant, self)) @@ -972,25 +963,24 @@ impl<'de, 'a, R: Read<'de> + 'a> de::VariantAccess<'de> for UnitVariantAccess<'a } fn newtype_variant_seed(self, _seed: T) -> Result - where T: de::DeserializeSeed<'de>, + where + T: de::DeserializeSeed<'de>, { - Err(de::Error::invalid_type(Unexpected::UnitVariant, &"newtype variant")) + Err(de::Error::invalid_type(Unexpected::UnitVariant, &"newtype variant"),) } fn tuple_variant(self, _len: usize, _visitor: V) -> Result - where V: de::Visitor<'de>, + where + V: de::Visitor<'de>, { - Err(de::Error::invalid_type(Unexpected::UnitVariant, &"tuple variant")) + Err(de::Error::invalid_type(Unexpected::UnitVariant, &"tuple variant"),) } - fn struct_variant( - self, - _fields: &'static [&'static str], - _visitor: V - ) -> Result - where V: de::Visitor<'de>, + fn struct_variant(self, _fields: &'static [&'static str], _visitor: V) -> Result + where + V: de::Visitor<'de>, { - Err(de::Error::invalid_type(Unexpected::UnitVariant, &"struct variant")) + Err(de::Error::invalid_type(Unexpected::UnitVariant, &"struct variant"),) } } @@ -1028,8 +1018,9 @@ pub struct StreamDeserializer<'de, R, T> { } impl<'de, R, T> StreamDeserializer<'de, R, T> - where R: read::Read<'de>, - T: de::Deserialize<'de> +where + R: read::Read<'de>, + T: de::Deserialize<'de>, { /// Create a JSON stream deserializer from one of the possible serde_json /// input sources. @@ -1087,8 +1078,9 @@ impl<'de, R, T> StreamDeserializer<'de, R, T> } impl<'de, R, T> Iterator for StreamDeserializer<'de, R, T> - where R: Read<'de>, - T: de::Deserialize<'de>, +where + R: Read<'de>, + T: de::Deserialize<'de>, { type Item = Result; @@ -1109,9 +1101,7 @@ impl<'de, R, T> Iterator for StreamDeserializer<'de, R, T> } Some(result) } - Ok(Some(_)) => { - Some(Err(self.de.peek_error(ErrorCode::ExpectedObjectOrArray))) - } + Ok(Some(_)) => Some(Err(self.de.peek_error(ErrorCode::ExpectedObjectOrArray))), Err(e) => Some(Err(e)), } } @@ -1120,8 +1110,9 @@ impl<'de, R, T> Iterator for StreamDeserializer<'de, R, T> ////////////////////////////////////////////////////////////////////////////// fn from_trait<'de, R, T>(read: R) -> Result - where R: Read<'de>, - T: de::Deserialize<'de>, +where + R: Read<'de>, + T: de::Deserialize<'de>, { let mut de = Deserializer::new(read); let value = try!(de::Deserialize::deserialize(&mut de)); @@ -1141,8 +1132,9 @@ fn from_trait<'de, R, T>(read: R) -> Result /// the JSON map or some number is too big to fit in the expected primitive /// type. pub fn from_iter(iter: I) -> Result - where I: Iterator>, - T: de::DeserializeOwned, +where + I: Iterator>, + T: de::DeserializeOwned, { from_trait(read::IteratorRead::new(iter)) } @@ -1157,8 +1149,9 @@ pub fn from_iter(iter: I) -> Result /// the JSON map or some number is too big to fit in the expected primitive /// type. pub fn from_reader(rdr: R) -> Result - where R: io::Read, - T: de::DeserializeOwned, +where + R: io::Read, + T: de::DeserializeOwned, { from_iter(rdr.bytes()) } @@ -1173,7 +1166,8 @@ pub fn from_reader(rdr: R) -> Result /// the JSON map or some number is too big to fit in the expected primitive /// type. pub fn from_slice<'a, T>(v: &'a [u8]) -> Result - where T: de::Deserialize<'a>, +where + T: de::Deserialize<'a>, { from_trait(read::SliceRead::new(v)) } @@ -1188,7 +1182,8 @@ pub fn from_slice<'a, T>(v: &'a [u8]) -> Result /// the JSON map or some number is too big to fit in the expected primitive /// type. pub fn from_str<'a, T>(s: &'a str) -> Result - where T: de::Deserialize<'a>, +where + T: de::Deserialize<'a>, { from_trait(read::StrRead::new(s)) } diff --git a/src/error.rs b/src/error.rs index ab61e2d..6fbd79e 100644 --- a/src/error.rs +++ b/src/error.rs @@ -169,12 +169,8 @@ impl From for io::Error { } else { match j.classify() { Category::Io => unreachable!(), - Category::Syntax | Category::Data => { - io::Error::new(io::ErrorKind::InvalidData, j) - } - Category::Eof => { - io::Error::new(io::ErrorKind::UnexpectedEof, j) - } + Category::Syntax | Category::Data => io::Error::new(io::ErrorKind::InvalidData, j), + Category::Eof => io::Error::new(io::ErrorKind::UnexpectedEof, j), } } } @@ -263,14 +259,21 @@ impl Error { #[doc(hidden)] pub fn syntax(code: ErrorCode, line: usize, column: usize) -> Self { Error { - err: Box::new(ErrorImpl { code: code, line: line, column: column }), + err: Box::new( + ErrorImpl { + code: code, + line: line, + column: column, + }, + ), } } // Not public API. Should be pub(crate). #[doc(hidden)] pub fn fix_position(self, f: F) -> Self - where F: FnOnce(ErrorCode) -> Error + where + F: FnOnce(ErrorCode) -> Error, { if self.err.line == 0 { f(self.err.code) @@ -285,66 +288,28 @@ impl Display for ErrorCode { match *self { ErrorCode::Message(ref msg) => f.write_str(msg), ErrorCode::Io(ref err) => Display::fmt(err, f), - ErrorCode::EofWhileParsingList => { - f.write_str("EOF while parsing a list") - } - ErrorCode::EofWhileParsingObject => { - f.write_str("EOF while parsing an object") - } - ErrorCode::EofWhileParsingString => { - f.write_str("EOF while parsing a string") - } - ErrorCode::EofWhileParsingValue => { - f.write_str("EOF while parsing a value") - } - ErrorCode::ExpectedColon => { - f.write_str("expected `:`") - } - ErrorCode::ExpectedListCommaOrEnd => { - f.write_str("expected `,` or `]`") - } - ErrorCode::ExpectedObjectCommaOrEnd => { - f.write_str("expected `,` or `}`") - } - ErrorCode::ExpectedObjectOrArray => { - f.write_str("expected `{` or `[`") - } - ErrorCode::ExpectedSomeIdent => { - f.write_str("expected ident") - } - ErrorCode::ExpectedSomeValue => { - f.write_str("expected value") - } - ErrorCode::ExpectedSomeString => { - f.write_str("expected string") - } - ErrorCode::InvalidEscape => { - f.write_str("invalid escape") - } - ErrorCode::InvalidNumber => { - f.write_str("invalid number") - } - ErrorCode::NumberOutOfRange => { - f.write_str("number out of range") - } - ErrorCode::InvalidUnicodeCodePoint => { - f.write_str("invalid unicode code point") - } - ErrorCode::KeyMustBeAString => { - f.write_str("key must be a string") - } + ErrorCode::EofWhileParsingList => f.write_str("EOF while parsing a list"), + ErrorCode::EofWhileParsingObject => f.write_str("EOF while parsing an object"), + ErrorCode::EofWhileParsingString => f.write_str("EOF while parsing a string"), + ErrorCode::EofWhileParsingValue => f.write_str("EOF while parsing a value"), + ErrorCode::ExpectedColon => f.write_str("expected `:`"), + ErrorCode::ExpectedListCommaOrEnd => f.write_str("expected `,` or `]`"), + ErrorCode::ExpectedObjectCommaOrEnd => f.write_str("expected `,` or `}`"), + ErrorCode::ExpectedObjectOrArray => f.write_str("expected `{` or `[`"), + ErrorCode::ExpectedSomeIdent => f.write_str("expected ident"), + ErrorCode::ExpectedSomeValue => f.write_str("expected value"), + ErrorCode::ExpectedSomeString => f.write_str("expected string"), + ErrorCode::InvalidEscape => f.write_str("invalid escape"), + ErrorCode::InvalidNumber => f.write_str("invalid number"), + ErrorCode::NumberOutOfRange => f.write_str("number out of range"), + ErrorCode::InvalidUnicodeCodePoint => f.write_str("invalid unicode code point"), + ErrorCode::KeyMustBeAString => f.write_str("key must be a string"), ErrorCode::LoneLeadingSurrogateInHexEscape => { f.write_str("lone leading surrogate in hex escape") } - ErrorCode::TrailingCharacters => { - f.write_str("trailing characters") - } - ErrorCode::UnexpectedEndOfHexEscape => { - f.write_str("unexpected end of hex escape") - } - ErrorCode::RecursionLimitExceeded => { - f.write_str("recursion limit exceeded") - } + ErrorCode::TrailingCharacters => f.write_str("trailing characters"), + ErrorCode::UnexpectedEndOfHexEscape => f.write_str("unexpected end of hex escape"), + ErrorCode::RecursionLimitExceeded => f.write_str("recursion limit exceeded"), } } } @@ -379,7 +344,13 @@ impl Display for ErrorImpl { if self.line == 0 { Display::fmt(&self.code, f) } else { - write!(f, "{} at line {} column {}", self.code, self.line, self.column) + write!( + f, + "{} at line {} column {}", + self.code, + self.line, + self.column + ) } } } @@ -393,17 +364,21 @@ impl Debug for Error { } impl From for Error { - fn from(error: ErrorImpl) -> Error { - Error { - err: Box::new(error), - } + fn from(error: ErrorImpl) -> Error { + Error { err: Box::new(error) } } } impl From for Error { fn from(error: io::Error) -> Error { Error { - err: Box::new(ErrorImpl { code: ErrorCode::Io(error), line: 0, column: 0 }), + err: Box::new( + ErrorImpl { + code: ErrorCode::Io(error), + line: 0, + column: 0, + }, + ), } } } @@ -411,7 +386,13 @@ impl From for Error { impl From for Error { fn from(error: de::value::Error) -> Error { Error { - err: Box::new(ErrorImpl { code: ErrorCode::Message(error.to_string()), line: 0, column: 0 }), + err: Box::new( + ErrorImpl { + code: ErrorCode::Message(error.to_string()), + line: 0, + column: 0, + }, + ), } } } @@ -419,7 +400,13 @@ impl From for Error { impl de::Error for Error { fn custom(msg: T) -> Error { Error { - err: Box::new(ErrorImpl { code: ErrorCode::Message(msg.to_string()), line: 0, column: 0 }), + err: Box::new( + ErrorImpl { + code: ErrorCode::Message(msg.to_string()), + line: 0, + column: 0, + }, + ), } } } @@ -427,7 +414,13 @@ impl de::Error for Error { impl ser::Error for Error { fn custom(msg: T) -> Error { Error { - err: Box::new(ErrorImpl { code: ErrorCode::Message(msg.to_string()), line: 0, column: 0 }), + err: Box::new( + ErrorImpl { + code: ErrorCode::Message(msg.to_string()), + line: 0, + column: 0, + }, + ), } } } diff --git a/src/iter.rs b/src/iter.rs index 1514e4f..344e8a4 100644 --- a/src/iter.rs +++ b/src/iter.rs @@ -28,7 +28,8 @@ pub struct LineColIterator { } impl LineColIterator - where I: Iterator> +where + I: Iterator>, { pub fn new(iter: I) -> LineColIterator { LineColIterator { @@ -53,7 +54,8 @@ impl LineColIterator } impl Iterator for LineColIterator - where I: Iterator> +where + I: Iterator>, { type Item = io::Result; diff --git a/src/lib.rs b/src/lib.rs index 4b0b7ab..c1fbb97 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -330,13 +330,12 @@ extern crate dtoa; extern crate linked_hash_map; #[doc(inline)] -pub use self::de::{Deserializer, StreamDeserializer, from_iter, from_reader, - from_slice, from_str}; +pub use self::de::{Deserializer, StreamDeserializer, from_iter, from_reader, from_slice, from_str}; #[doc(inline)] pub use self::error::{Error, Result}; #[doc(inline)] -pub use self::ser::{Serializer, to_string, to_string_pretty, to_vec, - to_vec_pretty, to_writer, to_writer_pretty}; +pub use self::ser::{Serializer, to_string, to_string_pretty, to_vec, to_vec_pretty, to_writer, + to_writer_pretty}; #[doc(inline)] pub use self::value::{Map, Number, Value, from_value, to_value}; diff --git a/src/map.rs b/src/map.rs index 10cfc53..b3ab696 100644 --- a/src/map.rs +++ b/src/map.rs @@ -39,9 +39,7 @@ impl Map { /// Makes a new empty Map. #[inline] pub fn new() -> Self { - Map { - map: MapImpl::new(), - } + Map { map: MapImpl::new() } } #[cfg(not(feature = "preserve_order"))] @@ -50,18 +48,14 @@ impl Map { pub fn with_capacity(capacity: usize) -> Self { // does not support with_capacity let _ = capacity; - Map { - map: BTreeMap::new(), - } + Map { map: BTreeMap::new() } } #[cfg(feature = "preserve_order")] /// Makes a new empty Map with the given initial capacity. #[inline] pub fn with_capacity(capacity: usize) -> Self { - Map { - map: LinkedHashMap::with_capacity(capacity), - } + Map { map: LinkedHashMap::with_capacity(capacity) } } /// Clears the map, removing all values. @@ -76,8 +70,9 @@ impl Map { /// on the borrowed form *must* match the ordering on the key type. #[inline] pub fn get(&self, key: &Q) -> Option<&Value> - where String: Borrow, - Q: Ord + Eq + Hash + where + String: Borrow, + Q: Ord + Eq + Hash, { self.map.get(key) } @@ -88,8 +83,9 @@ impl Map { /// on the borrowed form *must* match the ordering on the key type. #[inline] pub fn contains_key(&self, key: &Q) -> bool - where String: Borrow, - Q: Ord + Eq + Hash + where + String: Borrow, + Q: Ord + Eq + Hash, { self.map.contains_key(key) } @@ -100,8 +96,9 @@ impl Map { /// on the borrowed form *must* match the ordering on the key type. #[inline] pub fn get_mut(&mut self, key: &Q) -> Option<&mut Value> - where String: Borrow, - Q: Ord + Eq + Hash + where + String: Borrow, + Q: Ord + Eq + Hash, { self.map.get_mut(key) } @@ -125,8 +122,9 @@ impl Map { /// on the borrowed form *must* match the ordering on the key type. #[inline] pub fn remove(&mut self, key: &Q) -> Option - where String: Borrow, - Q: Ord + Eq + Hash + where + String: Borrow, + Q: Ord + Eq + Hash, { self.map.remove(key) } @@ -134,7 +132,8 @@ impl Map { /// Gets the given key's corresponding entry in the map for in-place /// manipulation. pub fn entry(&mut self, key: S) -> Entry - where S: Into + where + S: Into, { #[cfg(not(feature = "preserve_order"))] use std::collections::btree_map::Entry as EntryImpl; @@ -142,12 +141,8 @@ impl Map { use linked_hash_map::Entry as EntryImpl; match self.map.entry(key.into()) { - EntryImpl::Vacant(vacant) => { - Entry::Vacant(VacantEntry { vacant: vacant }) - } - EntryImpl::Occupied(occupied) => { - Entry::Occupied(OccupiedEntry { occupied: occupied }) - } + EntryImpl::Vacant(vacant) => Entry::Vacant(VacantEntry { vacant: vacant }), + EntryImpl::Occupied(occupied) => Entry::Occupied(OccupiedEntry { occupied: occupied }), } } @@ -166,51 +161,39 @@ impl Map { /// Gets an iterator over the entries of the map. #[inline] pub fn iter(&self) -> Iter { - Iter { - iter: self.map.iter(), - } + Iter { iter: self.map.iter() } } /// Gets a mutable iterator over the entries of the map. #[inline] pub fn iter_mut(&mut self) -> IterMut { - IterMut { - iter: self.map.iter_mut(), - } + IterMut { iter: self.map.iter_mut() } } /// Gets an iterator over the keys of the map. #[inline] pub fn keys(&self) -> Keys { - Keys { - iter: self.map.keys(), - } + Keys { iter: self.map.keys() } } /// Gets an iterator over the values of the map. #[inline] pub fn values(&self) -> Values { - Values { - iter: self.map.values(), - } + Values { iter: self.map.values() } } } impl Default for Map { #[inline] fn default() -> Self { - Map { - map: MapImpl::new(), - } + Map { map: MapImpl::new() } } } impl Clone for Map { #[inline] fn clone(&self) -> Self { - Map { - map: self.map.clone(), - } + Map { map: self.map.clone() } } } @@ -238,8 +221,9 @@ impl PartialEq for Map { /// # ; /// ``` impl<'a, Q: ?Sized> ops::Index<&'a Q> for Map - where String: Borrow, - Q: Ord + Eq + Hash +where + String: Borrow, + Q: Ord + Eq + Hash, { type Output = Value; @@ -263,8 +247,9 @@ impl<'a, Q: ?Sized> ops::Index<&'a Q> for Map /// # } /// ``` impl<'a, Q: ?Sized> ops::IndexMut<&'a Q> for Map - where String: Borrow, - Q: Ord + Eq + Hash +where + String: Borrow, + Q: Ord + Eq + Hash, { fn index_mut(&mut self, index: &Q) -> &mut Value { self.map.get_mut(index).expect("no entry found for key") @@ -281,7 +266,8 @@ impl Debug for Map { impl ser::Serialize for Map { #[inline] fn serialize(&self, serializer: S) -> Result - where S: ser::Serializer + where + S: ser::Serializer, { use serde::ser::SerializeMap; let mut map = try!(serializer.serialize_map(Some(self.len()))); @@ -296,7 +282,8 @@ impl ser::Serialize for Map { impl<'de> de::Deserialize<'de> for Map { #[inline] fn deserialize(deserializer: D) -> Result - where D: de::Deserializer<'de> + where + D: de::Deserializer<'de>, { struct Visitor; @@ -309,14 +296,16 @@ impl<'de> de::Deserialize<'de> for Map { #[inline] fn visit_unit(self) -> Result - where E: de::Error + where + E: de::Error, { Ok(Map::new()) } #[inline] fn visit_map(self, mut visitor: V) -> Result - where V: de::MapAccess<'de> + where + V: de::MapAccess<'de>, { let mut values = Map::new(); @@ -333,15 +322,19 @@ impl<'de> de::Deserialize<'de> for Map { } impl FromIterator<(String, Value)> for Map { - fn from_iter(iter: T) -> Self where T: IntoIterator { - Map { - map: FromIterator::from_iter(iter) - } + fn from_iter(iter: T) -> Self + where + T: IntoIterator, + { + Map { map: FromIterator::from_iter(iter) } } } impl Extend<(String, Value)> for Map { - fn extend(&mut self, iter: T) where T: IntoIterator { + fn extend(&mut self, iter: T) + where + T: IntoIterator, + { self.map.extend(iter); } } @@ -471,7 +464,8 @@ impl<'a> Entry<'a> { /// # } /// ``` pub fn or_insert_with(self, default: F) -> &'a mut Value - where F: FnOnce() -> Value + where + F: FnOnce() -> Value, { match self { Entry::Vacant(entry) => entry.insert(default()), @@ -708,9 +702,7 @@ impl<'a> IntoIterator for &'a Map { type IntoIter = Iter<'a>; #[inline] fn into_iter(self) -> Self::IntoIter { - Iter { - iter: self.map.iter(), - } + Iter { iter: self.map.iter() } } } @@ -733,9 +725,7 @@ impl<'a> IntoIterator for &'a mut Map { type IntoIter = IterMut<'a>; #[inline] fn into_iter(self) -> Self::IntoIter { - IterMut { - iter: self.map.iter_mut(), - } + IterMut { iter: self.map.iter_mut() } } } @@ -758,9 +748,7 @@ impl IntoIterator for Map { type IntoIter = IntoIter; #[inline] fn into_iter(self) -> Self::IntoIter { - IntoIter { - iter: self.map.into_iter(), - } + IntoIter { iter: self.map.into_iter() } } } diff --git a/src/number.rs b/src/number.rs index c548c10..da09bdc 100644 --- a/src/number.rs +++ b/src/number.rs @@ -240,7 +240,8 @@ impl Debug for Number { impl Serialize for Number { #[inline] fn serialize(&self, serializer: S) -> Result - where S: Serializer + where + S: Serializer, { match self.n { N::PosInt(i) => serializer.serialize_u64(i), @@ -253,7 +254,8 @@ impl Serialize for Number { impl<'de> Deserialize<'de> for Number { #[inline] fn deserialize(deserializer: D) -> Result - where D: Deserializer<'de> + where + D: Deserializer<'de>, { struct NumberVisitor; @@ -276,7 +278,8 @@ impl<'de> Deserialize<'de> for Number { #[inline] fn visit_f64(self, value: f64) -> Result - where E: de::Error + where + E: de::Error, { Number::from_f64(value).ok_or_else(|| de::Error::custom("not a JSON number")) } @@ -291,7 +294,8 @@ impl<'de> Deserializer<'de> for Number { #[inline] fn deserialize_any(self, visitor: V) -> Result - where V: Visitor<'de> + where + V: Visitor<'de>, { match self.n { N::PosInt(i) => visitor.visit_u64(i), @@ -312,7 +316,8 @@ impl<'de, 'a> Deserializer<'de> for &'a Number { #[inline] fn deserialize_any(self, visitor: V) -> Result - where V: Visitor<'de> + where + V: Visitor<'de>, { match self.n { N::PosInt(i) => visitor.visit_u64(i), diff --git a/src/read.rs b/src/read.rs index cf5a522..770c004 100644 --- a/src/read.rs +++ b/src/read.rs @@ -51,16 +51,13 @@ pub trait Read<'de>: private::Sealed { /// Offset from the beginning of the input to the next byte that would be /// returned by next() or peek(). #[doc(hidden)] - fn byte_offset(&self) -> usize; + fn byte_offset(&self) -> usize; /// Assumes the previous byte was a quotation mark. Parses a JSON-escaped /// string until the next quotation mark using the given scratch space if /// necessary. The scratch space is initially empty. #[doc(hidden)] - fn parse_str<'s>( - &'s mut self, - scratch: &'s mut Vec - ) -> Result>; + fn parse_str<'s>(&'s mut self, scratch: &'s mut Vec) -> Result>; /// Assumes the previous byte was a quotation mark. Parses a JSON-escaped /// string until the next quotation mark using the given scratch space if @@ -71,7 +68,7 @@ pub trait Read<'de>: private::Sealed { #[doc(hidden)] fn parse_str_raw<'s>( &'s mut self, - scratch: &'s mut Vec + scratch: &'s mut Vec, ) -> Result>; } @@ -87,7 +84,8 @@ pub enum Reference<'b, 'c, T: ?Sized + 'static> { /// JSON input source that reads from an iterator of bytes. pub struct IteratorRead - where Iter: Iterator>, +where + Iter: Iterator>, { iter: LineColIterator, /// Temporary storage of peeked byte. @@ -96,7 +94,8 @@ pub struct IteratorRead /// JSON input source that reads from a std::io input stream. pub struct IoRead - where R: io::Read +where + R: io::Read, { delegate: IteratorRead>, } @@ -126,7 +125,8 @@ mod private { ////////////////////////////////////////////////////////////////////////////// impl IteratorRead - where Iter: Iterator>, +where + Iter: Iterator>, { /// Create a JSON input source to read from an iterator of bytes. pub fn new(iter: Iter) -> Self { @@ -138,19 +138,24 @@ impl IteratorRead } impl private::Sealed for IteratorRead - where Iter: Iterator> {} +where + Iter: Iterator>, +{ +} impl IteratorRead - where Iter: Iterator> +where + Iter: Iterator>, { fn parse_str_bytes<'s, T, F>( &'s mut self, scratch: &'s mut Vec, validate: bool, - result: F + result: F, ) -> Result - where T: 's, - F: FnOnce(&'s Self, &'s [u8]) -> Result, + where + T: 's, + F: FnOnce(&'s Self, &'s [u8]) -> Result, { loop { let ch = try!(next_or_eof(self)); @@ -177,7 +182,8 @@ impl IteratorRead } impl<'de, Iter> Read<'de> for IteratorRead - where Iter: Iterator>, +where + Iter: Iterator>, { #[inline] fn next(&mut self) -> io::Result> { @@ -235,39 +241,41 @@ impl<'de, Iter> Read<'de> for IteratorRead } } - fn parse_str<'s>( - &'s mut self, - scratch: &'s mut Vec - ) -> Result> { - self.parse_str_bytes(scratch, true, as_str).map(Reference::Copied) + fn parse_str<'s>(&'s mut self, scratch: &'s mut Vec) -> Result> { + self.parse_str_bytes(scratch, true, as_str) + .map(Reference::Copied) } fn parse_str_raw<'s>( &'s mut self, - scratch: &'s mut Vec + scratch: &'s mut Vec, ) -> Result> { - self.parse_str_bytes(scratch, false, |_, bytes| Ok(bytes)).map(Reference::Copied) + self.parse_str_bytes(scratch, false, |_, bytes| Ok(bytes)) + .map(Reference::Copied) } } ////////////////////////////////////////////////////////////////////////////// impl IoRead - where R: io::Read +where + R: io::Read, { /// Create a JSON input source to read from a std::io input stream. pub fn new(reader: R) -> Self { - IoRead { - delegate: IteratorRead::new(reader.bytes()), - } + IoRead { delegate: IteratorRead::new(reader.bytes()) } } } impl private::Sealed for IoRead - where R: io::Read {} +where + R: io::Read, +{ +} impl<'de, R> Read<'de> for IoRead - where R: io::Read +where + R: io::Read, { #[inline] fn next(&mut self) -> io::Result> { @@ -300,17 +308,14 @@ impl<'de, R> Read<'de> for IoRead } #[inline] - fn parse_str<'s>( - &'s mut self, - scratch: &'s mut Vec - ) -> Result> { + fn parse_str<'s>(&'s mut self, scratch: &'s mut Vec) -> Result> { self.delegate.parse_str(scratch) } #[inline] fn parse_str_raw<'s>( &'s mut self, - scratch: &'s mut Vec + scratch: &'s mut Vec, ) -> Result> { self.delegate.parse_str_raw(scratch) } @@ -328,10 +333,7 @@ impl<'a> SliceRead<'a> { } fn position_of_index(&self, i: usize) -> Position { - let mut pos = Position { - line: 1, - column: 0, - }; + let mut pos = Position { line: 1, column: 0 }; for ch in &self.slice[..i] { match *ch { b'\n' => { @@ -353,17 +355,17 @@ impl<'a> SliceRead<'a> { &'s mut self, scratch: &'s mut Vec, validate: bool, - result: F + result: F, ) -> Result> - where T: 's, - F: for<'f> FnOnce(&'s Self, &'f [u8]) -> Result<&'f T>, + where + T: 's, + F: for<'f> FnOnce(&'s Self, &'f [u8]) -> Result<&'f T>, { // Index of the first byte not yet copied into the scratch space. let mut start = self.index; loop { - while self.index < self.slice.len() && - !ESCAPE[self.slice[self.index] as usize] { + while self.index < self.slice.len() && !ESCAPE[self.slice[self.index] as usize] { self.index += 1; } if self.index == self.slice.len() { @@ -378,7 +380,7 @@ impl<'a> SliceRead<'a> { self.index += 1; return result(self, borrowed).map(Reference::Borrowed); } else { - scratch.extend_from_slice(&self.slice[start .. self.index]); + scratch.extend_from_slice(&self.slice[start..self.index]); // "as &[u8]" is required for rustc 1.8.0 let copied = scratch as &[u8]; self.index += 1; @@ -409,24 +411,28 @@ impl<'a> Read<'a> for SliceRead<'a> { fn next(&mut self) -> io::Result> { // `Ok(self.slice.get(self.index).map(|ch| { self.index += 1; *ch }))` // is about 10% slower. - Ok(if self.index < self.slice.len() { - let ch = self.slice[self.index]; - self.index += 1; - Some(ch) - } else { - None - }) + Ok( + if self.index < self.slice.len() { + let ch = self.slice[self.index]; + self.index += 1; + Some(ch) + } else { + None + }, + ) } #[inline] fn peek(&mut self) -> io::Result> { // `Ok(self.slice.get(self.index).map(|ch| *ch))` is about 10% slower // for some reason. - Ok(if self.index < self.slice.len() { - Some(self.slice[self.index]) - } else { - None - }) + Ok( + if self.index < self.slice.len() { + Some(self.slice[self.index]) + } else { + None + }, + ) } #[inline] @@ -448,20 +454,16 @@ impl<'a> Read<'a> for SliceRead<'a> { self.index } - fn parse_str<'s>( - &'s mut self, - scratch: &'s mut Vec - ) -> Result> { + fn parse_str<'s>(&'s mut self, scratch: &'s mut Vec) -> Result> { self.parse_str_bytes(scratch, true, as_str) } fn parse_str_raw<'s>( &'s mut self, - scratch: &'s mut Vec + scratch: &'s mut Vec, ) -> Result> { self.parse_str_bytes(scratch, false, |_, bytes| Ok(bytes)) } - } ////////////////////////////////////////////////////////////////////////////// @@ -469,9 +471,7 @@ impl<'a> Read<'a> for SliceRead<'a> { impl<'a> StrRead<'a> { /// Create a JSON input source to read from a UTF-8 string. pub fn new(s: &'a str) -> Self { - StrRead { - delegate: SliceRead::new(s.as_bytes()), - } + StrRead { delegate: SliceRead::new(s.as_bytes()) } } } @@ -505,20 +505,20 @@ impl<'a> Read<'a> for StrRead<'a> { self.delegate.byte_offset() } - fn parse_str<'s>( - &'s mut self, - scratch: &'s mut Vec - ) -> Result> { - self.delegate.parse_str_bytes(scratch, true, |_, bytes| { - // The input is assumed to be valid UTF-8 and the \u-escapes are - // checked along the way, so don't need to check here. - Ok(unsafe { str::from_utf8_unchecked(bytes) }) - }) + fn parse_str<'s>(&'s mut self, scratch: &'s mut Vec) -> Result> { + self.delegate + .parse_str_bytes( + scratch, true, |_, bytes| { + // The input is assumed to be valid UTF-8 and the \u-escapes are + // checked along the way, so don't need to check here. + Ok(unsafe { str::from_utf8_unchecked(bytes) }) + } + ) } fn parse_str_raw<'s>( &'s mut self, - scratch: &'s mut Vec + scratch: &'s mut Vec, ) -> Result> { self.delegate.parse_str_raw(scratch) } @@ -567,8 +567,7 @@ fn error<'de, R: Read<'de>, T>(read: &R, reason: ErrorCode) -> Result { } fn as_str<'de, 's, R: Read<'de>>(read: &R, slice: &'s [u8]) -> Result<&'s str> { - str::from_utf8(slice) - .or_else(|_| error(read, ErrorCode::InvalidUnicodeCodePoint)) + str::from_utf8(slice).or_else(|_| error(read, ErrorCode::InvalidUnicodeCodePoint)) } /// Parses a JSON escape sequence and appends it into the scratch space. Assumes @@ -586,49 +585,46 @@ fn parse_escape<'de, R: Read<'de>>(read: &mut R, scratch: &mut Vec) -> Resul b'r' => scratch.push(b'\r'), b't' => scratch.push(b'\t'), b'u' => { - let c = - match try!(decode_hex_escape(read)) { - 0xDC00...0xDFFF => { + let c = match try!(decode_hex_escape(read)) { + 0xDC00...0xDFFF => { + return error(read, ErrorCode::LoneLeadingSurrogateInHexEscape); + } + + // Non-BMP characters are encoded as a sequence of + // two hex escapes, representing UTF-16 surrogates. + n1 @ 0xD800...0xDBFF => { + if try!(next_or_eof(read)) != b'\\' { + return error(read, ErrorCode::UnexpectedEndOfHexEscape); + } + if try!(next_or_eof(read)) != b'u' { + return error(read, ErrorCode::UnexpectedEndOfHexEscape); + } + + let n2 = try!(decode_hex_escape(read)); + + if n2 < 0xDC00 || n2 > 0xDFFF { return error(read, ErrorCode::LoneLeadingSurrogateInHexEscape); } - // Non-BMP characters are encoded as a sequence of - // two hex escapes, representing UTF-16 surrogates. - n1 @ 0xD800...0xDBFF => { - if try!(next_or_eof(read)) != b'\\' { - return error(read, ErrorCode::UnexpectedEndOfHexEscape); - } - if try!(next_or_eof(read)) != b'u' { - return error(read, ErrorCode::UnexpectedEndOfHexEscape); - } + let n = (((n1 - 0xD800) as u32) << 10 | (n2 - 0xDC00) as u32) + 0x1_0000; - let n2 = try!(decode_hex_escape(read)); - - if n2 < 0xDC00 || n2 > 0xDFFF { - return error(read, ErrorCode::LoneLeadingSurrogateInHexEscape); - } - - let n = (((n1 - 0xD800) as u32) << 10 | - (n2 - 0xDC00) as u32) + - 0x1_0000; - - match char::from_u32(n as u32) { - Some(c) => c, - None => { - return error(read, ErrorCode::InvalidUnicodeCodePoint); - } + match char::from_u32(n as u32) { + Some(c) => c, + None => { + return error(read, ErrorCode::InvalidUnicodeCodePoint); } } + } - n => { - match char::from_u32(n as u32) { - Some(c) => c, - None => { - return error(read, ErrorCode::InvalidUnicodeCodePoint); - } + n => { + match char::from_u32(n as u32) { + Some(c) => c, + None => { + return error(read, ErrorCode::InvalidUnicodeCodePoint); } } - }; + } + }; // FIXME: this allocation is required in order to be compatible with stable // rust, which doesn't support encoding a `char` into a stack buffer. diff --git a/src/ser.rs b/src/ser.rs index 75fce14..f466876 100644 --- a/src/ser.rs +++ b/src/ser.rs @@ -26,7 +26,8 @@ pub struct Serializer { } impl Serializer - where W: io::Write, +where + W: io::Write, { /// Creates a new JSON serializer. #[inline] @@ -36,7 +37,8 @@ impl Serializer } impl<'a, W> Serializer> - where W: io::Write, +where + W: io::Write, { /// Creates a new JSON pretty print serializer. #[inline] @@ -46,8 +48,9 @@ impl<'a, W> Serializer> } impl Serializer - where W: io::Write, - F: Formatter, +where + W: io::Write, + F: Formatter, { /// Creates a new JSON visitor whose output will be written to the writer /// specified. @@ -67,8 +70,9 @@ impl Serializer } impl<'a, W, F> ser::Serializer for &'a mut Serializer - where W: io::Write, - F: Formatter, +where + W: io::Write, + F: Formatter, { type Ok = (); type Error = Error; @@ -199,19 +203,16 @@ impl<'a, W, F> ser::Serializer for &'a mut Serializer self, _name: &'static str, _variant_index: u32, - variant: &'static str + variant: &'static str, ) -> Result<()> { self.serialize_str(variant) } /// Serialize newtypes without an object wrapper. #[inline] - fn serialize_newtype_struct( - self, - _name: &'static str, - value: &T - ) -> Result<()> - where T: ser::Serialize, + fn serialize_newtype_struct(self, _name: &'static str, value: &T) -> Result<()> + where + T: ser::Serialize, { value.serialize(self) } @@ -222,9 +223,10 @@ impl<'a, W, F> ser::Serializer for &'a mut Serializer _name: &'static str, _variant_index: u32, variant: &'static str, - value: &T + value: &T, ) -> Result<()> - where T: ser::Serialize, + where + T: ser::Serialize, { try!(self.formatter.begin_object(&mut self.writer)); try!(self.formatter.begin_object_key(&mut self.writer, true)); @@ -244,7 +246,8 @@ impl<'a, W, F> ser::Serializer for &'a mut Serializer #[inline] fn serialize_some(self, value: &T) -> Result<()> - where T: ser::Serialize, + where + T: ser::Serialize, { value.serialize(self) } @@ -254,10 +257,20 @@ impl<'a, W, F> ser::Serializer for &'a mut Serializer if len == Some(0) { try!(self.formatter.begin_array(&mut self.writer)); try!(self.formatter.end_array(&mut self.writer)); - Ok(Compound { ser: self, state: State::Empty }) + Ok( + Compound { + ser: self, + state: State::Empty, + }, + ) } else { try!(self.formatter.begin_array(&mut self.writer)); - Ok(Compound { ser: self, state: State::First }) + Ok( + Compound { + ser: self, + state: State::First, + }, + ) } } @@ -270,7 +283,7 @@ impl<'a, W, F> ser::Serializer for &'a mut Serializer fn serialize_tuple_struct( self, _name: &'static str, - len: usize + len: usize, ) -> Result { self.serialize_seq(Some(len)) } @@ -281,7 +294,7 @@ impl<'a, W, F> ser::Serializer for &'a mut Serializer _name: &'static str, _variant_index: u32, variant: &'static str, - len: usize + len: usize, ) -> Result { try!(self.formatter.begin_object(&mut self.writer)); try!(self.formatter.begin_object_key(&mut self.writer, true)); @@ -296,19 +309,25 @@ impl<'a, W, F> ser::Serializer for &'a mut Serializer if len == Some(0) { try!(self.formatter.begin_object(&mut self.writer)); try!(self.formatter.end_object(&mut self.writer)); - Ok(Compound { ser: self, state: State::Empty }) + Ok( + Compound { + ser: self, + state: State::Empty, + }, + ) } else { try!(self.formatter.begin_object(&mut self.writer)); - Ok(Compound { ser: self, state: State::First }) + Ok( + Compound { + ser: self, + state: State::First, + }, + ) } } #[inline] - fn serialize_struct( - self, - _name: &'static str, - len: usize - ) -> Result { + fn serialize_struct(self, _name: &'static str, len: usize) -> Result { self.serialize_map(Some(len)) } @@ -318,7 +337,7 @@ impl<'a, W, F> ser::Serializer for &'a mut Serializer _name: &'static str, _variant_index: u32, variant: &'static str, - len: usize + len: usize, ) -> Result { try!(self.formatter.begin_object(&mut self.writer)); try!(self.formatter.begin_object_key(&mut self.writer, true)); @@ -329,7 +348,8 @@ impl<'a, W, F> ser::Serializer for &'a mut Serializer } fn collect_str(self, value: &T) -> Result - where T: fmt::Display, + where + T: fmt::Display, { use std::fmt::Write; @@ -340,8 +360,9 @@ impl<'a, W, F> ser::Serializer for &'a mut Serializer } impl<'ser, W, F> Write for Adapter<'ser, W, F> - where W: io::Write, - F: Formatter, + where + W: io::Write, + F: Formatter, { fn write_str(&mut self, s: &str) -> fmt::Result { assert!(self.error.is_none()); @@ -389,20 +410,23 @@ pub struct Compound<'a, W: 'a, F: 'a> { } impl<'a, W, F> ser::SerializeSeq for Compound<'a, W, F> - where W: io::Write, - F: Formatter +where + W: io::Write, + F: Formatter, { type Ok = (); type Error = Error; #[inline] - fn serialize_element( - &mut self, - value: &T - ) -> Result<()> - where T: ser::Serialize, + fn serialize_element(&mut self, value: &T) -> Result<()> + where + T: ser::Serialize, { - try!(self.ser.formatter.begin_array_value(&mut self.ser.writer, self.state == State::First)); + try!( + self.ser + .formatter + .begin_array_value(&mut self.ser.writer, self.state == State::First) + ); self.state = State::Rest; try!(value.serialize(&mut *self.ser)); try!(self.ser.formatter.end_array_value(&mut self.ser.writer)); @@ -420,18 +444,17 @@ impl<'a, W, F> ser::SerializeSeq for Compound<'a, W, F> } impl<'a, W, F> ser::SerializeTuple for Compound<'a, W, F> - where W: io::Write, - F: Formatter +where + W: io::Write, + F: Formatter, { type Ok = (); type Error = Error; #[inline] - fn serialize_element( - &mut self, - value: &T, - ) -> Result<()> - where T: ser::Serialize, + fn serialize_element(&mut self, value: &T) -> Result<()> + where + T: ser::Serialize, { ser::SerializeSeq::serialize_element(self, value) } @@ -443,18 +466,17 @@ impl<'a, W, F> ser::SerializeTuple for Compound<'a, W, F> } impl<'a, W, F> ser::SerializeTupleStruct for Compound<'a, W, F> - where W: io::Write, - F: Formatter +where + W: io::Write, + F: Formatter, { type Ok = (); type Error = Error; #[inline] - fn serialize_field( - &mut self, - value: &T - ) -> Result<()> - where T: ser::Serialize, + fn serialize_field(&mut self, value: &T) -> Result<()> + where + T: ser::Serialize, { ser::SerializeSeq::serialize_element(self, value) } @@ -466,18 +488,17 @@ impl<'a, W, F> ser::SerializeTupleStruct for Compound<'a, W, F> } impl<'a, W, F> ser::SerializeTupleVariant for Compound<'a, W, F> - where W: io::Write, - F: Formatter +where + W: io::Write, + F: Formatter, { type Ok = (); type Error = Error; #[inline] - fn serialize_field( - &mut self, - value: &T - ) -> Result<()> - where T: ser::Serialize, + fn serialize_field(&mut self, value: &T) -> Result<()> + where + T: ser::Serialize, { ser::SerializeSeq::serialize_element(self, value) } @@ -488,47 +509,58 @@ impl<'a, W, F> ser::SerializeTupleVariant for Compound<'a, W, F> State::Empty => {} _ => try!(self.ser.formatter.end_array(&mut self.ser.writer)), } - try!(self.ser.formatter.end_object_value(&mut self.ser.writer)); + try!( + self.ser + .formatter + .end_object_value(&mut self.ser.writer) + ); try!(self.ser.formatter.end_object(&mut self.ser.writer)); Ok(()) } } impl<'a, W, F> ser::SerializeMap for Compound<'a, W, F> - where W: io::Write, - F: Formatter +where + W: io::Write, + F: Formatter, { type Ok = (); type Error = Error; #[inline] - fn serialize_key( - &mut self, - key: &T, - ) -> Result<()> - where T: ser::Serialize, + fn serialize_key(&mut self, key: &T) -> Result<()> + where + T: ser::Serialize, { - try!(self.ser.formatter.begin_object_key(&mut self.ser.writer, self.state == State::First)); + try!( + self.ser + .formatter + .begin_object_key(&mut self.ser.writer, self.state == State::First) + ); self.state = State::Rest; - try!(key.serialize(MapKeySerializer { - ser: self.ser, - })); + try!(key.serialize(MapKeySerializer { ser: self.ser })); try!(self.ser.formatter.end_object_key(&mut self.ser.writer)); Ok(()) } #[inline] - fn serialize_value( - &mut self, - value: &T, - ) -> Result<()> - where T: ser::Serialize, + fn serialize_value(&mut self, value: &T) -> Result<()> + where + T: ser::Serialize, { - try!(self.ser.formatter.begin_object_value(&mut self.ser.writer)); + try!( + self.ser + .formatter + .begin_object_value(&mut self.ser.writer) + ); try!(value.serialize(&mut *self.ser)); - try!(self.ser.formatter.end_object_value(&mut self.ser.writer)); + try!( + self.ser + .formatter + .end_object_value(&mut self.ser.writer) + ); Ok(()) } @@ -543,19 +575,17 @@ impl<'a, W, F> ser::SerializeMap for Compound<'a, W, F> } impl<'a, W, F> ser::SerializeStruct for Compound<'a, W, F> - where W: io::Write, - F: Formatter +where + W: io::Write, + F: Formatter, { type Ok = (); type Error = Error; #[inline] - fn serialize_field( - &mut self, - key: &'static str, - value: &T - ) -> Result<()> - where T: ser::Serialize, + fn serialize_field(&mut self, key: &'static str, value: &T) -> Result<()> + where + T: ser::Serialize, { try!(ser::SerializeMap::serialize_key(self, key)); ser::SerializeMap::serialize_value(self, value) @@ -568,19 +598,17 @@ impl<'a, W, F> ser::SerializeStruct for Compound<'a, W, F> } impl<'a, W, F> ser::SerializeStructVariant for Compound<'a, W, F> - where W: io::Write, - F: Formatter +where + W: io::Write, + F: Formatter, { type Ok = (); type Error = Error; #[inline] - fn serialize_field( - &mut self, - key: &'static str, - value: &T - ) -> Result<()> - where T: ser::Serialize, + fn serialize_field(&mut self, key: &'static str, value: &T) -> Result<()> + where + T: ser::Serialize, { ser::SerializeStruct::serialize_field(self, key, value) } @@ -591,7 +619,11 @@ impl<'a, W, F> ser::SerializeStructVariant for Compound<'a, W, F> State::Empty => {} _ => try!(self.ser.formatter.end_object(&mut self.ser.writer)), } - try!(self.ser.formatter.end_object_value(&mut self.ser.writer)); + try!( + self.ser + .formatter + .end_object_value(&mut self.ser.writer) + ); try!(self.ser.formatter.end_object(&mut self.ser.writer)); Ok(()) } @@ -606,8 +638,9 @@ fn key_must_be_a_string() -> Error { } impl<'a, W, F> ser::Serializer for MapKeySerializer<'a, W, F> - where W: io::Write, - F: Formatter, +where + W: io::Write, + F: Formatter, { type Ok = (); type Error = Error; @@ -622,18 +655,15 @@ impl<'a, W, F> ser::Serializer for MapKeySerializer<'a, W, F> self, _name: &'static str, _variant_index: u32, - variant: &'static str + variant: &'static str, ) -> Result<()> { self.ser.serialize_str(variant) } #[inline] - fn serialize_newtype_struct( - self, - _name: &'static str, - value: &T - ) -> Result<()> - where T: ser::Serialize, + fn serialize_newtype_struct(self, _name: &'static str, value: &T) -> Result<()> + where + T: ser::Serialize, { value.serialize(self) } @@ -659,21 +689,33 @@ impl<'a, W, F> ser::Serializer for MapKeySerializer<'a, W, F> fn serialize_i16(self, value: i16) -> Result<()> { try!(self.ser.formatter.begin_string(&mut self.ser.writer)); - try!(self.ser.formatter.write_i16(&mut self.ser.writer, value)); + try!( + self.ser + .formatter + .write_i16(&mut self.ser.writer, value) + ); try!(self.ser.formatter.end_string(&mut self.ser.writer)); Ok(()) } fn serialize_i32(self, value: i32) -> Result<()> { try!(self.ser.formatter.begin_string(&mut self.ser.writer)); - try!(self.ser.formatter.write_i32(&mut self.ser.writer, value)); + try!( + self.ser + .formatter + .write_i32(&mut self.ser.writer, value) + ); try!(self.ser.formatter.end_string(&mut self.ser.writer)); Ok(()) } fn serialize_i64(self, value: i64) -> Result<()> { try!(self.ser.formatter.begin_string(&mut self.ser.writer)); - try!(self.ser.formatter.write_i64(&mut self.ser.writer, value)); + try!( + self.ser + .formatter + .write_i64(&mut self.ser.writer, value) + ); try!(self.ser.formatter.end_string(&mut self.ser.writer)); Ok(()) } @@ -687,21 +729,33 @@ impl<'a, W, F> ser::Serializer for MapKeySerializer<'a, W, F> fn serialize_u16(self, value: u16) -> Result<()> { try!(self.ser.formatter.begin_string(&mut self.ser.writer)); - try!(self.ser.formatter.write_u16(&mut self.ser.writer, value)); + try!( + self.ser + .formatter + .write_u16(&mut self.ser.writer, value) + ); try!(self.ser.formatter.end_string(&mut self.ser.writer)); Ok(()) } fn serialize_u32(self, value: u32) -> Result<()> { try!(self.ser.formatter.begin_string(&mut self.ser.writer)); - try!(self.ser.formatter.write_u32(&mut self.ser.writer, value)); + try!( + self.ser + .formatter + .write_u32(&mut self.ser.writer, value) + ); try!(self.ser.formatter.end_string(&mut self.ser.writer)); Ok(()) } fn serialize_u64(self, value: u64) -> Result<()> { try!(self.ser.formatter.begin_string(&mut self.ser.writer)); - try!(self.ser.formatter.write_u64(&mut self.ser.writer, value)); + try!( + self.ser + .formatter + .write_u64(&mut self.ser.writer, value) + ); try!(self.ser.formatter.end_string(&mut self.ser.writer)); Ok(()) } @@ -735,9 +789,10 @@ impl<'a, W, F> ser::Serializer for MapKeySerializer<'a, W, F> _name: &'static str, _variant_index: u32, _variant: &'static str, - _value: &T + _value: &T, ) -> Result<()> - where T: ser::Serialize, + where + T: ser::Serialize, { Err(key_must_be_a_string()) } @@ -747,7 +802,8 @@ impl<'a, W, F> ser::Serializer for MapKeySerializer<'a, W, F> } fn serialize_some(self, _value: &T) -> Result<()> - where T: ser::Serialize, + where + T: ser::Serialize, { Err(key_must_be_a_string()) } @@ -763,7 +819,7 @@ impl<'a, W, F> ser::Serializer for MapKeySerializer<'a, W, F> fn serialize_tuple_struct( self, _name: &'static str, - _len: usize + _len: usize, ) -> Result { Err(key_must_be_a_string()) } @@ -773,7 +829,7 @@ impl<'a, W, F> ser::Serializer for MapKeySerializer<'a, W, F> _name: &'static str, _variant_index: u32, _variant: &'static str, - _len: usize + _len: usize, ) -> Result { Err(key_must_be_a_string()) } @@ -782,11 +838,7 @@ impl<'a, W, F> ser::Serializer for MapKeySerializer<'a, W, F> Err(key_must_be_a_string()) } - fn serialize_struct( - self, - _name: &'static str, - _len: usize - ) -> Result { + fn serialize_struct(self, _name: &'static str, _len: usize) -> Result { Err(key_must_be_a_string()) } @@ -795,7 +847,7 @@ impl<'a, W, F> ser::Serializer for MapKeySerializer<'a, W, F> _name: &'static str, _variant_index: u32, _variant: &'static str, - _len: usize + _len: usize, ) -> Result { Err(key_must_be_a_string()) } @@ -847,7 +899,8 @@ pub trait Formatter { /// Writes a `null` value to the specified writer. #[inline] fn write_null(&mut self, writer: &mut W) -> io::Result<()> - where W: io::Write + where + W: io::Write, { writer.write_all(b"null") } @@ -855,7 +908,8 @@ pub trait Formatter { /// Writes a `true` or `false` value to the specified writer. #[inline] fn write_bool(&mut self, writer: &mut W, value: bool) -> io::Result<()> - where W: io::Write + where + W: io::Write, { let s = if value { b"true" as &[u8] @@ -868,7 +922,8 @@ pub trait Formatter { /// Writes an integer value like `-123` to the specified writer. #[inline] fn write_i8(&mut self, writer: &mut W, value: i8) -> io::Result<()> - where W: io::Write + where + W: io::Write, { itoa::write(writer, value).map(|_| ()) } @@ -876,7 +931,8 @@ pub trait Formatter { /// Writes an integer value like `-123` to the specified writer. #[inline] fn write_i16(&mut self, writer: &mut W, value: i16) -> io::Result<()> - where W: io::Write + where + W: io::Write, { itoa::write(writer, value).map(|_| ()) } @@ -884,7 +940,8 @@ pub trait Formatter { /// Writes an integer value like `-123` to the specified writer. #[inline] fn write_i32(&mut self, writer: &mut W, value: i32) -> io::Result<()> - where W: io::Write + where + W: io::Write, { itoa::write(writer, value).map(|_| ()) } @@ -892,7 +949,8 @@ pub trait Formatter { /// Writes an integer value like `-123` to the specified writer. #[inline] fn write_i64(&mut self, writer: &mut W, value: i64) -> io::Result<()> - where W: io::Write + where + W: io::Write, { itoa::write(writer, value).map(|_| ()) } @@ -900,7 +958,8 @@ pub trait Formatter { /// Writes an integer value like `123` to the specified writer. #[inline] fn write_u8(&mut self, writer: &mut W, value: u8) -> io::Result<()> - where W: io::Write + where + W: io::Write, { itoa::write(writer, value).map(|_| ()) } @@ -908,7 +967,8 @@ pub trait Formatter { /// Writes an integer value like `123` to the specified writer. #[inline] fn write_u16(&mut self, writer: &mut W, value: u16) -> io::Result<()> - where W: io::Write + where + W: io::Write, { itoa::write(writer, value).map(|_| ()) } @@ -916,7 +976,8 @@ pub trait Formatter { /// Writes an integer value like `123` to the specified writer. #[inline] fn write_u32(&mut self, writer: &mut W, value: u32) -> io::Result<()> - where W: io::Write + where + W: io::Write, { itoa::write(writer, value).map(|_| ()) } @@ -924,7 +985,8 @@ pub trait Formatter { /// Writes an integer value like `123` to the specified writer. #[inline] fn write_u64(&mut self, writer: &mut W, value: u64) -> io::Result<()> - where W: io::Write + where + W: io::Write, { itoa::write(writer, value).map(|_| ()) } @@ -932,7 +994,8 @@ pub trait Formatter { /// Writes a floating point value like `-31.26e+12` to the specified writer. #[inline] fn write_f32(&mut self, writer: &mut W, value: f32) -> io::Result<()> - where W: io::Write + where + W: io::Write, { dtoa::write(writer, value).map(|_| ()) } @@ -940,7 +1003,8 @@ pub trait Formatter { /// Writes a floating point value like `-31.26e+12` to the specified writer. #[inline] fn write_f64(&mut self, writer: &mut W, value: f64) -> io::Result<()> - where W: io::Write + where + W: io::Write, { dtoa::write(writer, value).map(|_| ()) } @@ -949,7 +1013,8 @@ pub trait Formatter { /// `write_char_escape`. Writes a `"` to the specified writer. #[inline] fn begin_string(&mut self, writer: &mut W) -> io::Result<()> - where W: io::Write + where + W: io::Write, { writer.write_all(b"\"") } @@ -958,7 +1023,8 @@ pub trait Formatter { /// `write_char_escape`. Writes a `"` to the specified writer. #[inline] fn end_string(&mut self, writer: &mut W) -> io::Result<()> - where W: io::Write + where + W: io::Write, { writer.write_all(b"\"") } @@ -967,15 +1033,21 @@ pub trait Formatter { /// specified writer. #[inline] fn write_string_fragment(&mut self, writer: &mut W, fragment: &str) -> io::Result<()> - where W: io::Write + where + W: io::Write, { writer.write_all(fragment.as_bytes()) } /// Writes a character escape code to the specified writer. #[inline] - fn write_char_escape(&mut self, writer: &mut W, char_escape: CharEscape) -> io::Result<()> - where W: io::Write + fn write_char_escape( + &mut self, + writer: &mut W, + char_escape: CharEscape, + ) -> io::Result<()> + where + W: io::Write, { use self::CharEscape::*; @@ -990,9 +1062,14 @@ pub trait Formatter { Tab => b"\\t", AsciiControl(byte) => { static HEX_DIGITS: [u8; 16] = *b"0123456789abcdef"; - let bytes = &[b'\\', b'u', b'0', b'0', - HEX_DIGITS[(byte >> 4) as usize], - HEX_DIGITS[(byte & 0xF) as usize]]; + let bytes = &[ + b'\\', + b'u', + b'0', + b'0', + HEX_DIGITS[(byte >> 4) as usize], + HEX_DIGITS[(byte & 0xF) as usize], + ]; return writer.write_all(bytes); } }; @@ -1004,7 +1081,8 @@ pub trait Formatter { /// writer. #[inline] fn begin_array(&mut self, writer: &mut W) -> io::Result<()> - where W: io::Write + where + W: io::Write, { writer.write_all(b"[") } @@ -1013,7 +1091,8 @@ pub trait Formatter { /// writer. #[inline] fn end_array(&mut self, writer: &mut W) -> io::Result<()> - where W: io::Write + where + W: io::Write, { writer.write_all(b"]") } @@ -1022,7 +1101,8 @@ pub trait Formatter { /// the specified writer. #[inline] fn begin_array_value(&mut self, writer: &mut W, first: bool) -> io::Result<()> - where W: io::Write + where + W: io::Write, { if first { Ok(()) @@ -1034,7 +1114,8 @@ pub trait Formatter { /// Called after every array value. #[inline] fn end_array_value(&mut self, _writer: &mut W) -> io::Result<()> - where W: io::Write + where + W: io::Write, { Ok(()) } @@ -1043,7 +1124,8 @@ pub trait Formatter { /// writer. #[inline] fn begin_object(&mut self, writer: &mut W) -> io::Result<()> - where W: io::Write + where + W: io::Write, { writer.write_all(b"{") } @@ -1052,7 +1134,8 @@ pub trait Formatter { /// writer. #[inline] fn end_object(&mut self, writer: &mut W) -> io::Result<()> - where W: io::Write + where + W: io::Write, { writer.write_all(b"}") } @@ -1060,7 +1143,8 @@ pub trait Formatter { /// Called before every object key. #[inline] fn begin_object_key(&mut self, writer: &mut W, first: bool) -> io::Result<()> - where W: io::Write + where + W: io::Write, { if first { Ok(()) @@ -1074,7 +1158,8 @@ pub trait Formatter { /// `begin_object_value`. #[inline] fn end_object_key(&mut self, _writer: &mut W) -> io::Result<()> - where W: io::Write + where + W: io::Write, { Ok(()) } @@ -1084,7 +1169,8 @@ pub trait Formatter { /// `end_object_key`. #[inline] fn begin_object_value(&mut self, writer: &mut W) -> io::Result<()> - where W: io::Write + where + W: io::Write, { writer.write_all(b":") } @@ -1092,7 +1178,8 @@ pub trait Formatter { /// Called after every object value. #[inline] fn end_object_value(&mut self, _writer: &mut W) -> io::Result<()> - where W: io::Write + where + W: io::Write, { Ok(()) } @@ -1137,7 +1224,8 @@ impl<'a> Default for PrettyFormatter<'a> { impl<'a> Formatter for PrettyFormatter<'a> { #[inline] fn begin_array(&mut self, writer: &mut W) -> io::Result<()> - where W: io::Write + where + W: io::Write, { self.current_indent += 1; self.has_value = false; @@ -1146,7 +1234,8 @@ impl<'a> Formatter for PrettyFormatter<'a> { #[inline] fn end_array(&mut self, writer: &mut W) -> io::Result<()> - where W: io::Write + where + W: io::Write, { self.current_indent -= 1; @@ -1160,7 +1249,8 @@ impl<'a> Formatter for PrettyFormatter<'a> { #[inline] fn begin_array_value(&mut self, writer: &mut W, first: bool) -> io::Result<()> - where W: io::Write + where + W: io::Write, { if first { try!(writer.write_all(b"\n")); @@ -1173,7 +1263,8 @@ impl<'a> Formatter for PrettyFormatter<'a> { #[inline] fn end_array_value(&mut self, _writer: &mut W) -> io::Result<()> - where W: io::Write + where + W: io::Write, { self.has_value = true; Ok(()) @@ -1181,7 +1272,8 @@ impl<'a> Formatter for PrettyFormatter<'a> { #[inline] fn begin_object(&mut self, writer: &mut W) -> io::Result<()> - where W: io::Write + where + W: io::Write, { self.current_indent += 1; self.has_value = false; @@ -1190,7 +1282,8 @@ impl<'a> Formatter for PrettyFormatter<'a> { #[inline] fn end_object(&mut self, writer: &mut W) -> io::Result<()> - where W: io::Write + where + W: io::Write, { self.current_indent -= 1; @@ -1204,7 +1297,8 @@ impl<'a> Formatter for PrettyFormatter<'a> { #[inline] fn begin_object_key(&mut self, writer: &mut W, first: bool) -> io::Result<()> - where W: io::Write + where + W: io::Write, { if first { try!(writer.write_all(b"\n")); @@ -1216,23 +1310,30 @@ impl<'a> Formatter for PrettyFormatter<'a> { #[inline] fn begin_object_value(&mut self, writer: &mut W) -> io::Result<()> - where W: io::Write + where + W: io::Write, { writer.write_all(b": ") } #[inline] fn end_object_value(&mut self, _writer: &mut W) -> io::Result<()> - where W: io::Write + where + W: io::Write, { self.has_value = true; Ok(()) } } -fn format_escaped_str(writer: &mut W, formatter: &mut F, value: &str) -> io::Result<()> - where W: io::Write, - F: Formatter +fn format_escaped_str( + writer: &mut W, + formatter: &mut F, + value: &str, +) -> io::Result<()> +where + W: io::Write, + F: Formatter, { try!(formatter.begin_string(writer)); try!(format_escaped_str_contents(writer, formatter, value)); @@ -1240,12 +1341,14 @@ fn format_escaped_str(writer: &mut W, formatter: &mut F, v Ok(()) } -fn format_escaped_str_contents(writer: &mut W, - formatter: &mut F, - value: &str) - -> io::Result<()> - where W: io::Write, - F: Formatter, +fn format_escaped_str_contents( + writer: &mut W, + formatter: &mut F, + value: &str, +) -> io::Result<()> +where + W: io::Write, + F: Formatter, { let bytes = value.as_bytes(); @@ -1274,14 +1377,14 @@ fn format_escaped_str_contents(writer: &mut W, Ok(()) } -const BB: u8 = b'b'; // \x08 -const TT: u8 = b't'; // \x09 -const NN: u8 = b'n'; // \x0A -const FF: u8 = b'f'; // \x0C -const RR: u8 = b'r'; // \x0D -const QU: u8 = b'"'; // \x22 +const BB: u8 = b'b'; // \x08 +const TT: u8 = b't'; // \x09 +const NN: u8 = b'n'; // \x0A +const FF: u8 = b'f'; // \x0C +const RR: u8 = b'r'; // \x0D +const QU: u8 = b'"'; // \x22 const BS: u8 = b'\\'; // \x5C -const U: u8 = b'u'; // \x00...\x1F except the ones above +const U: u8 = b'u'; // \x00...\x1F except the ones above // Lookup table of escape sequences. A value of b'x' at index i means that byte // i is escaped as "\x" in JSON. A value of 0 means that byte i is not escaped. @@ -1307,9 +1410,14 @@ static ESCAPE: [u8; 256] = [ ]; #[inline] -fn format_escaped_char(wr: &mut W, formatter: &mut F, value: char) -> io::Result<()> - where W: io::Write, - F: Formatter, +fn format_escaped_char( + wr: &mut W, + formatter: &mut F, + value: char, +) -> io::Result<()> +where + W: io::Write, + F: Formatter, { use std::io::Write; // A char encoded as UTF-8 takes 4 bytes at most. @@ -1329,8 +1437,9 @@ fn format_escaped_char(wr: &mut W, formatter: &mut F, valu /// fail, or if `T` contains a map with non-string keys. #[inline] pub fn to_writer(writer: &mut W, value: &T) -> Result<()> - where W: io::Write, - T: ser::Serialize, +where + W: io::Write, + T: ser::Serialize, { let mut ser = Serializer::new(writer); try!(value.serialize(&mut ser)); @@ -1344,8 +1453,9 @@ pub fn to_writer(writer: &mut W, value: &T) -> Result<()> /// fail, or if `T` contains a map with non-string keys. #[inline] pub fn to_writer_pretty(writer: &mut W, value: &T) -> Result<()> - where W: io::Write, - T: ser::Serialize, +where + W: io::Write, + T: ser::Serialize, { let mut ser = Serializer::pretty(writer); try!(value.serialize(&mut ser)); @@ -1358,7 +1468,8 @@ pub fn to_writer_pretty(writer: &mut W, value: &T) -> Resu /// fail, or if `T` contains a map with non-string keys. #[inline] pub fn to_vec(value: &T) -> Result> - where T: ser::Serialize, +where + T: ser::Serialize, { let mut writer = Vec::with_capacity(128); try!(to_writer(&mut writer, value)); @@ -1371,7 +1482,8 @@ pub fn to_vec(value: &T) -> Result> /// fail, or if `T` contains a map with non-string keys. #[inline] pub fn to_vec_pretty(value: &T) -> Result> - where T: ser::Serialize, +where + T: ser::Serialize, { let mut writer = Vec::with_capacity(128); try!(to_writer_pretty(&mut writer, value)); @@ -1384,7 +1496,8 @@ pub fn to_vec_pretty(value: &T) -> Result> /// fail, or if `T` contains a map with non-string keys. #[inline] pub fn to_string(value: &T) -> Result - where T: ser::Serialize, +where + T: ser::Serialize, { let vec = try!(to_vec(value)); let string = unsafe { @@ -1400,7 +1513,8 @@ pub fn to_string(value: &T) -> Result /// fail, or if `T` contains a map with non-string keys. #[inline] pub fn to_string_pretty(value: &T) -> Result - where T: ser::Serialize, +where + T: ser::Serialize, { let vec = try!(to_vec_pretty(value)); let string = unsafe { @@ -1411,7 +1525,8 @@ pub fn to_string_pretty(value: &T) -> Result } fn indent(wr: &mut W, n: usize, s: &[u8]) -> io::Result<()> - where W: io::Write, +where + W: io::Write, { for _ in 0..n { try!(wr.write_all(s)); diff --git a/src/value.rs b/src/value.rs index b2af49d..ca6a0b9 100644 --- a/src/value.rs +++ b/src/value.rs @@ -779,7 +779,10 @@ impl Value { if !pointer.starts_with('/') { return None; } - let tokens = pointer.split('/').skip(1).map(|x| x.replace("~1", "/").replace("~0", "~")); + let tokens = pointer + .split('/') + .skip(1) + .map(|x| x.replace("~1", "/").replace("~0", "~")); let mut target = self; for token in tokens { @@ -842,7 +845,10 @@ impl Value { if !pointer.starts_with('/') { return None; } - let tokens = pointer.split('/').skip(1).map(|x| x.replace("~1", "/").replace("~0", "~")); + let tokens = pointer + .split('/') + .skip(1) + .map(|x| x.replace("~1", "/").replace("~0", "~")); let mut target = self; for token in tokens { @@ -851,7 +857,9 @@ impl Value { let target_once = target; let target_opt = match *target_once { Value::Object(ref mut map) => map.get_mut(&token), - Value::Array(ref mut list) => parse_index(&token).and_then(move |x| list.get_mut(x)), + Value::Array(ref mut list) => { + parse_index(&token).and_then(move |x| list.get_mut(x)) + } _ => return None, }; if let Some(t) = target_opt { @@ -944,10 +952,16 @@ impl Index for usize { match *v { Value::Array(ref mut vec) => { let len = vec.len(); - vec.get_mut(*self).unwrap_or_else(|| { - panic!("cannot access index {} of JSON array of length {}", - self, len) - }) + vec.get_mut(*self) + .unwrap_or_else( + || { + panic!( + "cannot access index {} of JSON array of length {}", + self, + len + ) + }, + ) } _ => panic!("cannot access index {} of JSON {}", self, Type(v)), } @@ -999,7 +1013,10 @@ impl Index for String { } } -impl<'a, T: ?Sized> Index for &'a T where T: Index { +impl<'a, T: ?Sized> Index for &'a T +where + T: Index, +{ fn index_into<'v>(&self, v: &'v Value) -> Option<&'v Value> { (**self).index_into(v) } @@ -1017,7 +1034,11 @@ mod private { impl Sealed for usize {} impl Sealed for str {} impl Sealed for String {} - impl<'a, T: ?Sized> Sealed for &'a T where T: Sealed {} + impl<'a, T: ?Sized> Sealed for &'a T + where + T: Sealed, + { + } } /// Used in panic messages. @@ -1055,7 +1076,10 @@ impl<'a> fmt::Display for Type<'a> { // as_array, or match. The value of this impl is that it adds a way of working // with Value that is not well served by the existing approaches: concise and // careless and sometimes that is exactly what you want. -impl ops::Index for Value where I: Index { +impl ops::Index for Value +where + I: Index, +{ type Output = Value; /// Index into a `serde_json::Value` using the syntax `value[0]` or @@ -1095,7 +1119,10 @@ impl ops::Index for Value where I: Index { } } -impl ops::IndexMut for Value where I: Index { +impl ops::IndexMut for Value +where + I: Index, +{ /// Write into a `serde_json::Value` using the syntax `value[0] = ...` or /// `value["k"] = ...`. /// @@ -1458,7 +1485,7 @@ impl> ::std::iter::FromIterator for Value { /// let x: Value = Value::from_iter(vec!["lorem", "ipsum", "dolor"]); /// # } /// ``` - fn from_iter>(iter: I) -> Self { + fn from_iter>(iter: I) -> Self { let vec: Vec = iter.into_iter().map(|x| x.into()).collect(); Value::Array(vec) @@ -1468,7 +1495,8 @@ impl> ::std::iter::FromIterator for Value { impl ser::Serialize for Value { #[inline] fn serialize(&self, serializer: S) -> Result - where S: ser::Serializer, + where + S: ser::Serializer, { match *self { Value::Null => serializer.serialize_unit(), @@ -1492,7 +1520,8 @@ impl ser::Serialize for Value { impl<'de> de::Deserialize<'de> for Value { #[inline] fn deserialize(deserializer: D) -> Result - where D: de::Deserializer<'de>, + where + D: de::Deserializer<'de>, { struct ValueVisitor; @@ -1525,7 +1554,8 @@ impl<'de> de::Deserialize<'de> for Value { #[inline] fn visit_str(self, value: &str) -> Result - where E: de::Error, + where + E: de::Error, { self.visit_string(String::from(value)) } @@ -1541,11 +1571,9 @@ impl<'de> de::Deserialize<'de> for Value { } #[inline] - fn visit_some( - self, - deserializer: D - ) -> Result - where D: de::Deserializer<'de>, + fn visit_some(self, deserializer: D) -> Result + where + D: de::Deserializer<'de>, { de::Deserialize::deserialize(deserializer) } @@ -1557,7 +1585,8 @@ impl<'de> de::Deserialize<'de> for Value { #[inline] fn visit_seq(self, mut visitor: V) -> Result - where V: de::SeqAccess<'de>, + where + V: de::SeqAccess<'de>, { let mut vec = Vec::new(); @@ -1569,7 +1598,8 @@ impl<'de> de::Deserialize<'de> for Value { } fn visit_map(self, mut visitor: V) -> Result - where V: de::MapAccess<'de>, + where + V: de::MapAccess<'de>, { let mut values = Map::new(); @@ -1636,9 +1666,7 @@ impl fmt::Display for Value { /// ``` fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let alternate = f.alternate(); - let mut wr = WriterFormatter { - inner: f, - }; + let mut wr = WriterFormatter { inner: f }; if alternate { // {:#} super::ser::to_writer_pretty(&mut wr, self).map_err(|_| fmt::Error) @@ -1747,10 +1775,7 @@ impl ser::Serializer for Serializer { } #[inline] - fn serialize_unit_struct( - self, - _name: &'static str - ) -> Result { + fn serialize_unit_struct(self, _name: &'static str) -> Result { self.serialize_unit() } @@ -1759,7 +1784,7 @@ impl ser::Serializer for Serializer { self, _name: &'static str, _variant_index: u32, - variant: &'static str + variant: &'static str, ) -> Result { self.serialize_str(variant) } @@ -1768,9 +1793,10 @@ impl ser::Serializer for Serializer { fn serialize_newtype_struct( self, _name: &'static str, - value: &T + value: &T, ) -> Result - where T: ser::Serialize, + where + T: ser::Serialize, { value.serialize(self) } @@ -1780,9 +1806,10 @@ impl ser::Serializer for Serializer { _name: &'static str, _variant_index: u32, variant: &'static str, - value: &T + value: &T, ) -> Result - where T: ser::Serialize, + where + T: ser::Serialize, { let mut values = Map::new(); values.insert(String::from(variant), try!(to_value(&value))); @@ -1796,18 +1823,14 @@ impl ser::Serializer for Serializer { #[inline] fn serialize_some(self, value: &T) -> Result - where T: ser::Serialize, + where + T: ser::Serialize, { value.serialize(self) } - fn serialize_seq( - self, - len: Option - ) -> Result { - Ok(SerializeVec { - vec: Vec::with_capacity(len.unwrap_or(0)) - }) + fn serialize_seq(self, len: Option) -> Result { + Ok(SerializeVec { vec: Vec::with_capacity(len.unwrap_or(0)) }) } fn serialize_tuple(self, len: usize) -> Result { @@ -1817,7 +1840,7 @@ impl ser::Serializer for Serializer { fn serialize_tuple_struct( self, _name: &'static str, - len: usize + len: usize, ) -> Result { self.serialize_seq(Some(len)) } @@ -1827,28 +1850,29 @@ impl ser::Serializer for Serializer { _name: &'static str, _variant_index: u32, variant: &'static str, - len: usize + len: usize, ) -> Result { - Ok(SerializeTupleVariant { - name: String::from(variant), - vec: Vec::with_capacity(len), - }) + Ok( + SerializeTupleVariant { + name: String::from(variant), + vec: Vec::with_capacity(len), + }, + ) } - fn serialize_map( - self, - _len: Option - ) -> Result { - Ok(SerializeMap { - map: Map::new(), - next_key: None, - }) + fn serialize_map(self, _len: Option) -> Result { + Ok( + SerializeMap { + map: Map::new(), + next_key: None, + }, + ) } fn serialize_struct( self, _name: &'static str, - len: usize + len: usize, ) -> Result { self.serialize_map(Some(len)) } @@ -1858,12 +1882,14 @@ impl ser::Serializer for Serializer { _name: &'static str, _variant_index: u32, variant: &'static str, - _len: usize + _len: usize, ) -> Result { - Ok(SerializeStructVariant { - name: String::from(variant), - map: Map::new(), - }) + Ok( + SerializeStructVariant { + name: String::from(variant), + map: Map::new(), + }, + ) } } @@ -1895,7 +1921,8 @@ impl ser::SerializeSeq for SerializeVec { type Error = Error; fn serialize_element(&mut self, value: &T) -> Result<(), Error> - where T: ser::Serialize + where + T: ser::Serialize, { self.vec.push(try!(to_value(&value))); Ok(()) @@ -1911,7 +1938,8 @@ impl ser::SerializeTuple for SerializeVec { type Error = Error; fn serialize_element(&mut self, value: &T) -> Result<(), Error> - where T: ser::Serialize + where + T: ser::Serialize, { ser::SerializeSeq::serialize_element(self, value) } @@ -1926,7 +1954,8 @@ impl ser::SerializeTupleStruct for SerializeVec { type Error = Error; fn serialize_field(&mut self, value: &T) -> Result<(), Error> - where T: ser::Serialize + where + T: ser::Serialize, { ser::SerializeSeq::serialize_element(self, value) } @@ -1941,7 +1970,8 @@ impl ser::SerializeTupleVariant for SerializeTupleVariant { type Error = Error; fn serialize_field(&mut self, value: &T) -> Result<(), Error> - where T: ser::Serialize + where + T: ser::Serialize, { self.vec.push(try!(to_value(&value))); Ok(()) @@ -1961,7 +1991,8 @@ impl ser::SerializeMap for SerializeMap { type Error = Error; fn serialize_key(&mut self, key: &T) -> Result<(), Error> - where T: ser::Serialize + where + T: ser::Serialize, { match try!(to_value(&key)) { Value::String(s) => self.next_key = Some(s), @@ -1969,7 +2000,7 @@ impl ser::SerializeMap for SerializeMap { if n.is_u64() || n.is_i64() { self.next_key = Some(n.to_string()) } else { - return Err(Error::syntax(ErrorCode::KeyMustBeAString, 0, 0)) + return Err(Error::syntax(ErrorCode::KeyMustBeAString, 0, 0)); } } _ => return Err(Error::syntax(ErrorCode::KeyMustBeAString, 0, 0)), @@ -1978,7 +2009,8 @@ impl ser::SerializeMap for SerializeMap { } fn serialize_value(&mut self, value: &T) -> Result<(), Error> - where T: ser::Serialize + where + T: ser::Serialize, { let key = self.next_key.take(); // Panic because this indicates a bug in the program rather than an @@ -1998,7 +2030,8 @@ impl ser::SerializeStruct for SerializeMap { type Error = Error; fn serialize_field(&mut self, key: &'static str, value: &T) -> Result<(), Error> - where T: ser::Serialize + where + T: ser::Serialize, { try!(ser::SerializeMap::serialize_key(self, key)); ser::SerializeMap::serialize_value(self, value) @@ -2014,9 +2047,11 @@ impl ser::SerializeStructVariant for SerializeStructVariant { type Error = Error; fn serialize_field(&mut self, key: &'static str, value: &T) -> Result<(), Error> - where T: ser::Serialize + where + T: ser::Serialize, { - self.map.insert(String::from(key), try!(to_value(&value))); + self.map + .insert(String::from(key), try!(to_value(&value))); Ok(()) } @@ -2034,7 +2069,8 @@ impl<'de> de::Deserializer<'de> for Value { #[inline] fn deserialize_any(self, visitor: V) -> Result - where V: de::Visitor<'de>, + where + V: de::Visitor<'de>, { match self { Value::Null => visitor.visit_unit(), @@ -2067,11 +2103,9 @@ impl<'de> de::Deserializer<'de> for Value { } #[inline] - fn deserialize_option( - self, - visitor: V - ) -> Result - where V: de::Visitor<'de>, + fn deserialize_option(self, visitor: V) -> Result + where + V: de::Visitor<'de>, { match self { Value::Null => visitor.visit_none(), @@ -2084,9 +2118,10 @@ impl<'de> de::Deserializer<'de> for Value { self, _name: &str, _variants: &'static [&'static str], - visitor: V + visitor: V, ) -> Result - where V: de::Visitor<'de>, + where + V: de::Visitor<'de>, { let (variant, value) = match self { Value::Object(value) => { @@ -2094,34 +2129,42 @@ impl<'de> de::Deserializer<'de> for Value { let (variant, value) = match iter.next() { Some(v) => v, None => { - return Err(de::Error::invalid_value(Unexpected::Map, &"map with a single key")); + return Err( + de::Error::invalid_value( + Unexpected::Map, + &"map with a single key", + ), + ); } }; // enums are encoded in json as maps with a single key:value pair if iter.next().is_some() { - return Err(de::Error::invalid_value(Unexpected::Map, &"map with a single key")); + return Err(de::Error::invalid_value(Unexpected::Map, &"map with a single key"),); } (variant, Some(value)) } Value::String(variant) => (variant, None), other => { - return Err(de::Error::invalid_type(other.unexpected(), &"string or map")); + return Err(de::Error::invalid_type(other.unexpected(), &"string or map"),); } }; - visitor.visit_enum(EnumDeserializer { - variant: variant, - value: value, - }) + visitor.visit_enum( + EnumDeserializer { + variant: variant, + value: value, + }, + ) } #[inline] fn deserialize_newtype_struct( self, _name: &'static str, - visitor: V + visitor: V, ) -> Result - where V: de::Visitor<'de>, + where + V: de::Visitor<'de>, { visitor.visit_newtype_struct(self) } @@ -2143,7 +2186,8 @@ impl<'de> de::EnumAccess<'de> for EnumDeserializer { type Variant = VariantDeserializer; fn variant_seed(self, seed: V) -> Result<(V::Value, VariantDeserializer), Error> - where V: de::DeserializeSeed<'de>, + where + V: de::DeserializeSeed<'de>, { let variant = self.variant.into_deserializer(); let visitor = VariantDeserializer { value: self.value }; @@ -2166,43 +2210,42 @@ impl<'de> de::VariantAccess<'de> for VariantDeserializer { } fn newtype_variant_seed(self, seed: T) -> Result - where T: de::DeserializeSeed<'de>, + where + T: de::DeserializeSeed<'de>, { match self.value { Some(value) => seed.deserialize(value), - None => Err(de::Error::invalid_type(Unexpected::UnitVariant, &"newtype variant")), + None => Err(de::Error::invalid_type(Unexpected::UnitVariant, &"newtype variant"),), } } - fn tuple_variant( - self, - _len: usize, - visitor: V - ) -> Result - where V: de::Visitor<'de>, + fn tuple_variant(self, _len: usize, visitor: V) -> Result + where + V: de::Visitor<'de>, { match self.value { Some(Value::Array(v)) => { de::Deserializer::deserialize_any(SeqDeserializer::new(v), visitor) } - Some(other) => Err(de::Error::invalid_type(other.unexpected(), &"tuple variant")), - None => Err(de::Error::invalid_type(Unexpected::UnitVariant, &"tuple variant")) + Some(other) => Err(de::Error::invalid_type(other.unexpected(), &"tuple variant"),), + None => Err(de::Error::invalid_type(Unexpected::UnitVariant, &"tuple variant"),), } } fn struct_variant( self, _fields: &'static [&'static str], - visitor: V + visitor: V, ) -> Result - where V: de::Visitor<'de>, + where + V: de::Visitor<'de>, { match self.value { Some(Value::Object(v)) => { de::Deserializer::deserialize_any(MapDeserializer::new(v), visitor) } - Some(other) => Err(de::Error::invalid_type(other.unexpected(), &"struct variant")), - _ => Err(de::Error::invalid_type(Unexpected::UnitVariant, &"struct variant")) + Some(other) => Err(de::Error::invalid_type(other.unexpected(), &"struct variant"),), + _ => Err(de::Error::invalid_type(Unexpected::UnitVariant, &"struct variant"),), } } } @@ -2213,9 +2256,7 @@ struct SeqDeserializer { impl SeqDeserializer { fn new(vec: Vec) -> Self { - SeqDeserializer { - iter: vec.into_iter(), - } + SeqDeserializer { iter: vec.into_iter() } } } @@ -2224,7 +2265,8 @@ impl<'de> de::Deserializer<'de> for SeqDeserializer { #[inline] fn deserialize_any(mut self, visitor: V) -> Result - where V: de::Visitor<'de>, + where + V: de::Visitor<'de>, { let len = self.iter.len(); if len == 0 { @@ -2251,7 +2293,8 @@ impl<'de> de::SeqAccess<'de> for SeqDeserializer { type Error = Error; fn next_element_seed(&mut self, seed: T) -> Result, Error> - where T: de::DeserializeSeed<'de>, + where + T: de::DeserializeSeed<'de>, { match self.iter.next() { Some(value) => seed.deserialize(value).map(Some), @@ -2285,7 +2328,8 @@ impl<'de> de::MapAccess<'de> for MapDeserializer { type Error = Error; fn next_key_seed(&mut self, seed: T) -> Result, Error> - where T: de::DeserializeSeed<'de>, + where + T: de::DeserializeSeed<'de>, { match self.iter.next() { Some((key, value)) => { @@ -2297,7 +2341,8 @@ impl<'de> de::MapAccess<'de> for MapDeserializer { } fn next_value_seed(&mut self, seed: T) -> Result - where T: de::DeserializeSeed<'de>, + where + T: de::DeserializeSeed<'de>, { match self.value.take() { Some(value) => seed.deserialize(value), @@ -2318,7 +2363,8 @@ impl<'de> de::Deserializer<'de> for MapDeserializer { #[inline] fn deserialize_any(self, visitor: V) -> Result - where V: de::Visitor<'de>, + where + V: de::Visitor<'de>, { visitor.visit_map(self) } @@ -2334,7 +2380,8 @@ impl<'de, 'a> de::Deserializer<'de> for &'a Value { type Error = Error; fn deserialize_any(self, visitor: V) -> Result - where V: de::Visitor<'de>, + where + V: de::Visitor<'de>, { match *self { Value::Null => visitor.visit_unit(), @@ -2366,11 +2413,9 @@ impl<'de, 'a> de::Deserializer<'de> for &'a Value { } } - fn deserialize_option( - self, - visitor: V - ) -> Result - where V: de::Visitor<'de>, + fn deserialize_option(self, visitor: V) -> Result + where + V: de::Visitor<'de>, { match *self { Value::Null => visitor.visit_none(), @@ -2382,9 +2427,10 @@ impl<'de, 'a> de::Deserializer<'de> for &'a Value { self, _name: &str, _variants: &'static [&'static str], - visitor: V + visitor: V, ) -> Result - where V: de::Visitor<'de>, + where + V: de::Visitor<'de>, { let (variant, value) = match *self { Value::Object(ref value) => { @@ -2392,34 +2438,42 @@ impl<'de, 'a> de::Deserializer<'de> for &'a Value { let (variant, value) = match iter.next() { Some(v) => v, None => { - return Err(de::Error::invalid_value(Unexpected::Map, &"map with a single key")); + return Err( + de::Error::invalid_value( + Unexpected::Map, + &"map with a single key", + ), + ); } }; // enums are encoded in json as maps with a single key:value pair if iter.next().is_some() { - return Err(de::Error::invalid_value(Unexpected::Map, &"map with a single key")); + return Err(de::Error::invalid_value(Unexpected::Map, &"map with a single key"),); } (variant, Some(value)) } Value::String(ref variant) => (variant, None), ref other => { - return Err(de::Error::invalid_type(other.unexpected(), &"string or map")); + return Err(de::Error::invalid_type(other.unexpected(), &"string or map"),); } }; - visitor.visit_enum(EnumRefDeserializer { - variant: variant, - value: value, - }) + visitor.visit_enum( + EnumRefDeserializer { + variant: variant, + value: value, + }, + ) } #[inline] fn deserialize_newtype_struct( self, _name: &'static str, - visitor: V + visitor: V, ) -> Result - where V: de::Visitor<'de>, + where + V: de::Visitor<'de>, { visitor.visit_newtype_struct(self) } @@ -2441,7 +2495,8 @@ impl<'de, 'a> de::EnumAccess<'de> for EnumRefDeserializer<'a> { type Variant = VariantRefDeserializer<'a>; fn variant_seed(self, seed: V) -> Result<(V::Value, Self::Variant), Error> - where V: de::DeserializeSeed<'de>, + where + V: de::DeserializeSeed<'de>, { let variant = self.variant.into_deserializer(); let visitor = VariantRefDeserializer { value: self.value }; @@ -2464,43 +2519,42 @@ impl<'de, 'a> de::VariantAccess<'de> for VariantRefDeserializer<'a> { } fn newtype_variant_seed(self, seed: T) -> Result - where T: de::DeserializeSeed<'de>, + where + T: de::DeserializeSeed<'de>, { match self.value { Some(value) => seed.deserialize(value), - None => Err(de::Error::invalid_type(Unexpected::UnitVariant, &"newtype variant")), + None => Err(de::Error::invalid_type(Unexpected::UnitVariant, &"newtype variant"),), } } - fn tuple_variant( - self, - _len: usize, - visitor: V - ) -> Result - where V: de::Visitor<'de>, + fn tuple_variant(self, _len: usize, visitor: V) -> Result + where + V: de::Visitor<'de>, { match self.value { Some(&Value::Array(ref v)) => { de::Deserializer::deserialize_any(SeqRefDeserializer::new(v), visitor) } - Some(other) => Err(de::Error::invalid_type(other.unexpected(), &"tuple variant")), - None => Err(de::Error::invalid_type(Unexpected::UnitVariant, &"tuple variant")) + Some(other) => Err(de::Error::invalid_type(other.unexpected(), &"tuple variant"),), + None => Err(de::Error::invalid_type(Unexpected::UnitVariant, &"tuple variant"),), } } fn struct_variant( self, _fields: &'static [&'static str], - visitor: V + visitor: V, ) -> Result - where V: de::Visitor<'de>, + where + V: de::Visitor<'de>, { match self.value { Some(&Value::Object(ref v)) => { de::Deserializer::deserialize_any(MapRefDeserializer::new(v), visitor) } - Some(other) => Err(de::Error::invalid_type(other.unexpected(), &"struct variant")), - _ => Err(de::Error::invalid_type(Unexpected::UnitVariant, &"struct variant")) + Some(other) => Err(de::Error::invalid_type(other.unexpected(), &"struct variant"),), + _ => Err(de::Error::invalid_type(Unexpected::UnitVariant, &"struct variant"),), } } } @@ -2511,9 +2565,7 @@ struct SeqRefDeserializer<'a> { impl<'a> SeqRefDeserializer<'a> { fn new(slice: &'a [Value]) -> Self { - SeqRefDeserializer { - iter: slice.iter(), - } + SeqRefDeserializer { iter: slice.iter() } } } @@ -2522,7 +2574,8 @@ impl<'de, 'a> de::Deserializer<'de> for SeqRefDeserializer<'a> { #[inline] fn deserialize_any(mut self, visitor: V) -> Result - where V: de::Visitor<'de>, + where + V: de::Visitor<'de>, { let len = self.iter.len(); if len == 0 { @@ -2549,7 +2602,8 @@ impl<'de, 'a> de::SeqAccess<'de> for SeqRefDeserializer<'a> { type Error = Error; fn next_element_seed(&mut self, seed: T) -> Result, Error> - where T: de::DeserializeSeed<'de>, + where + T: de::DeserializeSeed<'de>, { match self.iter.next() { Some(value) => seed.deserialize(value).map(Some), @@ -2583,7 +2637,8 @@ impl<'de, 'a> de::MapAccess<'de> for MapRefDeserializer<'a> { type Error = Error; fn next_key_seed(&mut self, seed: T) -> Result, Error> - where T: de::DeserializeSeed<'de>, + where + T: de::DeserializeSeed<'de>, { match self.iter.next() { Some((key, value)) => { @@ -2595,7 +2650,8 @@ impl<'de, 'a> de::MapAccess<'de> for MapRefDeserializer<'a> { } fn next_value_seed(&mut self, seed: T) -> Result - where T: de::DeserializeSeed<'de>, + where + T: de::DeserializeSeed<'de>, { match self.value.take() { Some(value) => seed.deserialize(value), @@ -2616,7 +2672,8 @@ impl<'de, 'a> de::Deserializer<'de> for MapRefDeserializer<'a> { #[inline] fn deserialize_any(self, visitor: V) -> Result - where V: de::Visitor<'de>, + where + V: de::Visitor<'de>, { visitor.visit_map(self) } @@ -2667,7 +2724,8 @@ impl Value { // Taking by value is more friendly to iterator adapters, option and result // consumers, etc. See https://github.com/serde-rs/json/pull/149. pub fn to_value(value: T) -> Result - where T: ser::Serialize, +where + T: ser::Serialize, { value.serialize(Serializer) } @@ -2682,7 +2740,8 @@ pub fn to_value(value: T) -> Result /// the JSON map or some number is too big to fit in the expected primitive /// type. pub fn from_value(value: Value) -> Result - where T: de::DeserializeOwned, +where + T: de::DeserializeOwned, { de::Deserialize::deserialize(value) } diff --git a/tests/stream.rs b/tests/stream.rs index ada9e1a..4c835ee 100644 --- a/tests/stream.rs +++ b/tests/stream.rs @@ -49,69 +49,79 @@ macro_rules! test_stream { fn test_json_stream_newlines() { let data = "{\"x\":39} {\"x\":40}{\"x\":41}\n{\"x\":42}"; - test_stream!(data, Value, |stream| { - assert_eq!(stream.next().unwrap().unwrap()["x"], 39); - assert_eq!(stream.byte_offset(), 8); + test_stream!( + data, Value, |stream| { + assert_eq!(stream.next().unwrap().unwrap()["x"], 39); + assert_eq!(stream.byte_offset(), 8); - assert_eq!(stream.next().unwrap().unwrap()["x"], 40); - assert_eq!(stream.byte_offset(), 17); + assert_eq!(stream.next().unwrap().unwrap()["x"], 40); + assert_eq!(stream.byte_offset(), 17); - assert_eq!(stream.next().unwrap().unwrap()["x"], 41); - assert_eq!(stream.byte_offset(), 25); + assert_eq!(stream.next().unwrap().unwrap()["x"], 41); + assert_eq!(stream.byte_offset(), 25); - assert_eq!(stream.next().unwrap().unwrap()["x"], 42); - assert_eq!(stream.byte_offset(), 34); + assert_eq!(stream.next().unwrap().unwrap()["x"], 42); + assert_eq!(stream.byte_offset(), 34); - assert!(stream.next().is_none()); - assert_eq!(stream.byte_offset(), 34); - }); + assert!(stream.next().is_none()); + assert_eq!(stream.byte_offset(), 34); + } + ); } #[test] fn test_json_stream_trailing_whitespaces() { let data = "{\"x\":42} \t\n"; - test_stream!(data, Value, |stream| { - assert_eq!(stream.next().unwrap().unwrap()["x"], 42); - assert_eq!(stream.byte_offset(), 8); + test_stream!( + data, Value, |stream| { + assert_eq!(stream.next().unwrap().unwrap()["x"], 42); + assert_eq!(stream.byte_offset(), 8); - assert!(stream.next().is_none()); - assert_eq!(stream.byte_offset(), 11); - }); + assert!(stream.next().is_none()); + assert_eq!(stream.byte_offset(), 11); + } + ); } #[test] fn test_json_stream_truncated() { let data = "{\"x\":40}\n{\"x\":"; - test_stream!(data, Value, |stream| { - assert_eq!(stream.next().unwrap().unwrap()["x"], 40); - assert_eq!(stream.byte_offset(), 8); + test_stream!( + data, Value, |stream| { + assert_eq!(stream.next().unwrap().unwrap()["x"], 40); + assert_eq!(stream.byte_offset(), 8); - assert!(stream.next().unwrap().unwrap_err().is_eof()); - assert_eq!(stream.byte_offset(), 9); - }); + assert!(stream.next().unwrap().unwrap_err().is_eof()); + assert_eq!(stream.byte_offset(), 9); + } + ); } #[test] fn test_json_stream_empty() { let data = ""; - test_stream!(data, Value, |stream| { - assert!(stream.next().is_none()); - assert_eq!(stream.byte_offset(), 0); - }); + test_stream!( + data, Value, |stream| { + assert!(stream.next().is_none()); + assert_eq!(stream.byte_offset(), 0); + } + ); } #[test] fn test_json_stream_primitive() { let data = "{} true"; - test_stream!(data, Value, |stream| { - assert_eq!(stream.next().unwrap().unwrap(), json!({})); - assert_eq!(stream.byte_offset(), 2); + test_stream!( + data, Value, |stream| { + assert_eq!(stream.next().unwrap().unwrap(), json!({})); + assert_eq!(stream.byte_offset(), 2); - let second = stream.next().unwrap().unwrap_err(); - assert_eq!(second.to_string(), "expected `{` or `[` at line 1 column 4"); - }); + let second = stream.next().unwrap().unwrap_err(); + assert_eq!(second.to_string(), "expected `{` or `[` at line 1 column 4"); + } + ); } diff --git a/tests/test.rs b/tests/test.rs index c74b5ae..b5fedd4 100644 --- a/tests/test.rs +++ b/tests/test.rs @@ -39,20 +39,8 @@ use serde::ser::{self, Serialize, Serializer}; use serde_bytes::{ByteBuf, Bytes}; -use serde_json::{ - Deserializer, - Value, - from_iter, - from_reader, - from_slice, - from_str, - from_value, - to_string, - to_string_pretty, - to_value, - to_vec, - to_writer, -}; +use serde_json::{Deserializer, Value, from_iter, from_reader, from_slice, from_str, from_value, + to_string, to_string_pretty, to_value, to_vec, to_writer}; macro_rules! treemap { () => { @@ -91,7 +79,8 @@ struct Outer { } fn test_encode_ok(errors: &[(T, &str)]) - where T: PartialEq + Debug + ser::Serialize, +where + T: PartialEq + Debug + ser::Serialize, { for &(ref value, out) in errors { let out = out.to_string(); @@ -106,7 +95,8 @@ fn test_encode_ok(errors: &[(T, &str)]) } fn test_pretty_encode_ok(errors: &[(T, &str)]) - where T: PartialEq + Debug + ser::Serialize, +where + T: PartialEq + Debug + ser::Serialize, { for &(ref value, out) in errors { let out = out.to_string(); @@ -122,19 +112,14 @@ fn test_pretty_encode_ok(errors: &[(T, &str)]) #[test] fn test_write_null() { - let tests = &[ - ((), "null"), - ]; + let tests = &[((), "null")]; test_encode_ok(tests); test_pretty_encode_ok(tests); } #[test] fn test_write_u64() { - let tests = &[ - (3u64, "3"), - (u64::MAX, &u64::MAX.to_string()), - ]; + let tests = &[(3u64, "3"), (u64::MAX, &u64::MAX.to_string())]; test_encode_ok(tests); test_pretty_encode_ok(tests); } @@ -183,20 +168,14 @@ fn test_encode_nonfinite_float_yields_null() { #[test] fn test_write_str() { - let tests = &[ - ("", "\"\""), - ("foo", "\"foo\""), - ]; + let tests = &[("", "\"\""), ("foo", "\"foo\"")]; test_encode_ok(tests); test_pretty_encode_ok(tests); } #[test] fn test_write_bool() { - let tests = &[ - (true, "true"), - (false, "false"), - ]; + let tests = &[(true, "true"), (false, "false")]; test_encode_ok(tests); test_pretty_encode_ok(tests); } @@ -222,138 +201,78 @@ fn test_write_char() { #[test] fn test_write_list() { - test_encode_ok(&[ - (vec![], "[]"), - (vec![true], "[true]"), - (vec![true, false], "[true,false]"), - ]); + test_encode_ok( + &[ + (vec![], "[]"), + (vec![true], "[true]"), + (vec![true, false], "[true,false]"), + ], + ); - test_encode_ok(&[ - (vec![vec![], vec![], vec![]], "[[],[],[]]"), - (vec![vec![1, 2, 3], vec![], vec![]], "[[1,2,3],[],[]]"), - (vec![vec![], vec![1, 2, 3], vec![]], "[[],[1,2,3],[]]"), - (vec![vec![], vec![], vec![1, 2, 3]], "[[],[],[1,2,3]]"), - ]); + test_encode_ok( + &[ + (vec![vec![], vec![], vec![]], "[[],[],[]]"), + (vec![vec![1, 2, 3], vec![], vec![]], "[[1,2,3],[],[]]"), + (vec![vec![], vec![1, 2, 3], vec![]], "[[],[1,2,3],[]]"), + (vec![vec![], vec![], vec![1, 2, 3]], "[[],[],[1,2,3]]"), + ], + ); - test_pretty_encode_ok(&[ - ( - vec![vec![], vec![], vec![]], - pretty_str!([ - [], - [], - [] - ]), - ), - ( - vec![vec![1, 2, 3], vec![], vec![]], - pretty_str!([ - [ - 1, - 2, - 3 - ], - [], - [] - ]), - ), - ( - vec![vec![], vec![1, 2, 3], vec![]], - pretty_str!([ - [], - [ - 1, - 2, - 3 - ], - [] - ]), - ), - ( - vec![vec![], vec![], vec![1, 2, 3]], - pretty_str!([ - [], - [], - [ - 1, - 2, - 3 - ] - ]), - ), - ]); + test_pretty_encode_ok( + &[ + (vec![vec![], vec![], vec![]], pretty_str!([[], [], []])), + (vec![vec![1, 2, 3], vec![], vec![]], pretty_str!([[1, 2, 3], [], []])), + (vec![vec![], vec![1, 2, 3], vec![]], pretty_str!([[], [1, 2, 3], []])), + (vec![vec![], vec![], vec![1, 2, 3]], pretty_str!([[], [], [1, 2, 3]])), + ], + ); - test_pretty_encode_ok(&[ - (vec![], "[]"), - ( - vec![true], - pretty_str!([ - true - ]), - ), - ( - vec![true, false], - pretty_str!([ - true, - false - ]), - ), - ]); + test_pretty_encode_ok( + &[ + (vec![], "[]"), + (vec![true], pretty_str!([true])), + (vec![true, false], pretty_str!([true, false])), + ], + ); let long_test_list = json!([false, null, ["foo\nbar", 3.5]]); - test_encode_ok(&[ - ( - long_test_list.clone(), - json_str!([ - false, - null, - [ - "foo\nbar", - 3.5 - ] - ]), - ), - ]); + test_encode_ok( + &[ + (long_test_list.clone(), json_str!([false, null, ["foo\nbar", 3.5]])), + ], + ); - test_pretty_encode_ok(&[ - ( - long_test_list, - pretty_str!([ - false, - null, - [ - "foo\nbar", - 3.5 - ] - ]), - ) - ]); + test_pretty_encode_ok( + &[ + (long_test_list, pretty_str!([false, null, ["foo\nbar", 3.5]])), + ], + ); } #[test] fn test_write_object() { - test_encode_ok(&[ - (treemap!(), "{}"), - (treemap!("a".to_string() => true), "{\"a\":true}"), - ( - treemap!( + test_encode_ok( + &[ + (treemap!(), "{}"), + (treemap!("a".to_string() => true), "{\"a\":true}"), + (treemap!( "a".to_string() => true, "b".to_string() => false ), - "{\"a\":true,\"b\":false}"), - ]); + "{\"a\":true,\"b\":false}"), + ], + ); - test_encode_ok(&[ - ( - treemap![ + test_encode_ok( + &[ + (treemap![ "a".to_string() => treemap![], "b".to_string() => treemap![], "c".to_string() => treemap![] ], - "{\"a\":{},\"b\":{},\"c\":{}}", - ), - ( - treemap![ + "{\"a\":{},\"b\":{},\"c\":{}}"), + (treemap![ "a".to_string() => treemap![ "a".to_string() => treemap!["a" => vec![1,2,3]], "b".to_string() => treemap![], @@ -362,10 +281,8 @@ fn test_write_object() { "b".to_string() => treemap![], "c".to_string() => treemap![] ], - "{\"a\":{\"a\":{\"a\":[1,2,3]},\"b\":{},\"c\":{}},\"b\":{},\"c\":{}}", - ), - ( - treemap![ + "{\"a\":{\"a\":{\"a\":[1,2,3]},\"b\":{},\"c\":{}},\"b\":{},\"c\":{}}"), + (treemap![ "a".to_string() => treemap![], "b".to_string() => treemap![ "a".to_string() => treemap!["a" => vec![1,2,3]], @@ -374,10 +291,8 @@ fn test_write_object() { ], "c".to_string() => treemap![] ], - "{\"a\":{},\"b\":{\"a\":{\"a\":[1,2,3]},\"b\":{},\"c\":{}},\"c\":{}}", - ), - ( - treemap![ + "{\"a\":{},\"b\":{\"a\":{\"a\":[1,2,3]},\"b\":{},\"c\":{}},\"c\":{}}"), + (treemap![ "a".to_string() => treemap![], "b".to_string() => treemap![], "c".to_string() => treemap![ @@ -386,25 +301,23 @@ fn test_write_object() { "c".to_string() => treemap![] ] ], - "{\"a\":{},\"b\":{},\"c\":{\"a\":{\"a\":[1,2,3]},\"b\":{},\"c\":{}}}", - ), - ]); + "{\"a\":{},\"b\":{},\"c\":{\"a\":{\"a\":[1,2,3]},\"b\":{},\"c\":{}}}"), + ], + ); - test_pretty_encode_ok(&[ - ( - treemap![ + test_pretty_encode_ok( + &[ + (treemap![ "a".to_string() => treemap![], "b".to_string() => treemap![], "c".to_string() => treemap![] ], - pretty_str!({ + pretty_str!({ "a": {}, "b": {}, "c": {} - }), - ), - ( - treemap![ + })), + (treemap![ "a".to_string() => treemap![ "a".to_string() => treemap!["a" => vec![1,2,3]], "b".to_string() => treemap![], @@ -413,7 +326,7 @@ fn test_write_object() { "b".to_string() => treemap![], "c".to_string() => treemap![] ], - pretty_str!({ + pretty_str!({ "a": { "a": { "a": [ @@ -427,10 +340,8 @@ fn test_write_object() { }, "b": {}, "c": {} - }), - ), - ( - treemap![ + })), + (treemap![ "a".to_string() => treemap![], "b".to_string() => treemap![ "a".to_string() => treemap!["a" => vec![1,2,3]], @@ -439,7 +350,7 @@ fn test_write_object() { ], "c".to_string() => treemap![] ], - pretty_str!({ + pretty_str!({ "a": {}, "b": { "a": { @@ -453,10 +364,8 @@ fn test_write_object() { "c": {} }, "c": {} - }), - ), - ( - treemap![ + })), + (treemap![ "a".to_string() => treemap![], "b".to_string() => treemap![], "c".to_string() => treemap![ @@ -465,7 +374,7 @@ fn test_write_object() { "c".to_string() => treemap![] ] ], - pretty_str!({ + pretty_str!({ "a": {}, "b": {}, "c": { @@ -479,29 +388,27 @@ fn test_write_object() { "b": {}, "c": {} } - }), - ), - ]); + })), + ], + ); - test_pretty_encode_ok(&[ - (treemap!(), "{}"), - ( - treemap!("a".to_string() => true), - pretty_str!({ + test_pretty_encode_ok( + &[ + (treemap!(), "{}"), + (treemap!("a".to_string() => true), + pretty_str!({ "a": true - }), - ), - ( - treemap!( + })), + (treemap!( "a".to_string() => true, "b".to_string() => false ), - pretty_str!( { + pretty_str!( { "a": true, "b": false - }), - ), - ]); + })), + ], + ); let complex_obj = json!({ "b": [ @@ -510,10 +417,10 @@ fn test_write_object() { ] }); - test_encode_ok(&[ - ( - complex_obj.clone(), - json_str!({ + test_encode_ok( + &[ + (complex_obj.clone(), + json_str!({ "b": [ { "c": (r#""\f\u001f\r""#) @@ -522,14 +429,14 @@ fn test_write_object() { "d": "" } ] - }) - ), - ]); + })), + ], + ); - test_pretty_encode_ok(&[ - ( - complex_obj.clone(), - pretty_str!({ + test_pretty_encode_ok( + &[ + (complex_obj.clone(), + pretty_str!({ "b": [ { "c": (r#""\f\u001f\r""#) @@ -538,107 +445,79 @@ fn test_write_object() { "d": "" } ] - }), - ) - ]); + })), + ], + ); } #[test] fn test_write_tuple() { - test_encode_ok(&[ - ( - (5,), - "[5]", - ), - ]); + test_encode_ok(&[((5,), "[5]")]); - test_pretty_encode_ok(&[ - ( - (5,), - pretty_str!([ + test_pretty_encode_ok( + &[ + ((5,), + pretty_str!([ 5 - ]), - ), - ]); + ])), + ], + ); - test_encode_ok(&[ - ( - (5, (6, "abc")), - "[5,[6,\"abc\"]]", - ), - ]); + test_encode_ok(&[((5, (6, "abc")), "[5,[6,\"abc\"]]")]); - test_pretty_encode_ok(&[ - ( - (5, (6, "abc")), - pretty_str!([ + test_pretty_encode_ok( + &[ + ((5, (6, "abc")), + pretty_str!([ 5, [ 6, "abc" ] - ]), - ), - ]); + ])), + ], + ); } #[test] fn test_write_enum() { - test_encode_ok(&[ - ( - Animal::Dog, - "\"Dog\"", - ), - ( - Animal::Frog("Henry".to_string(), vec![]), - "{\"Frog\":[\"Henry\",[]]}", - ), - ( - Animal::Frog("Henry".to_string(), vec![349]), - "{\"Frog\":[\"Henry\",[349]]}", - ), - ( - Animal::Frog("Henry".to_string(), vec![349, 102]), - "{\"Frog\":[\"Henry\",[349,102]]}", - ), - ( - Animal::Cat { age: 5, name: "Kate".to_string() }, - "{\"Cat\":{\"age\":5,\"name\":\"Kate\"}}" - ), - ( - Animal::AntHive(vec!["Bob".to_string(), "Stuart".to_string()]), - "{\"AntHive\":[\"Bob\",\"Stuart\"]}", - ), - ]); + test_encode_ok( + &[ + (Animal::Dog, "\"Dog\""), + (Animal::Frog("Henry".to_string(), vec![]), "{\"Frog\":[\"Henry\",[]]}"), + (Animal::Frog("Henry".to_string(), vec![349]), "{\"Frog\":[\"Henry\",[349]]}"), + (Animal::Frog("Henry".to_string(), vec![349, 102]), "{\"Frog\":[\"Henry\",[349,102]]}"), + (Animal::Cat { + age: 5, + name: "Kate".to_string(), + }, + "{\"Cat\":{\"age\":5,\"name\":\"Kate\"}}"), + (Animal::AntHive(vec!["Bob".to_string(), "Stuart".to_string()]), + "{\"AntHive\":[\"Bob\",\"Stuart\"]}"), + ], + ); - test_pretty_encode_ok(&[ - ( - Animal::Dog, - "\"Dog\"", - ), - ( - Animal::Frog("Henry".to_string(), vec![]), - pretty_str!({ + test_pretty_encode_ok( + &[ + (Animal::Dog, "\"Dog\""), + (Animal::Frog("Henry".to_string(), vec![]), + pretty_str!({ "Frog": [ "Henry", [] ] - }), - ), - ( - Animal::Frog("Henry".to_string(), vec![349]), - pretty_str!({ + })), + (Animal::Frog("Henry".to_string(), vec![349]), + pretty_str!({ "Frog": [ "Henry", [ 349 ] ] - }), - ), - ( - Animal::Frog("Henry".to_string(), vec![349, 102]), - pretty_str!({ + })), + (Animal::Frog("Henry".to_string(), vec![349, 102]), + pretty_str!({ "Frog": [ "Henry", [ @@ -646,38 +525,34 @@ fn test_write_enum() { 102 ] ] - }), - ), - ]); + })), + ], + ); } #[test] fn test_write_option() { - test_encode_ok(&[ - (None, "null"), - (Some("jodhpurs"), "\"jodhpurs\""), - ]); + test_encode_ok(&[(None, "null"), (Some("jodhpurs"), "\"jodhpurs\"")]); - test_encode_ok(&[ - (None, "null"), - (Some(vec!["foo", "bar"]), "[\"foo\",\"bar\"]"), - ]); + test_encode_ok( + &[ + (None, "null"), + (Some(vec!["foo", "bar"]), "[\"foo\",\"bar\"]"), + ], + ); - test_pretty_encode_ok(&[ - (None, "null"), - (Some("jodhpurs"), "\"jodhpurs\""), - ]); + test_pretty_encode_ok(&[(None, "null"), (Some("jodhpurs"), "\"jodhpurs\"")]); - test_pretty_encode_ok(&[ - (None, "null"), - ( - Some(vec!["foo", "bar"]), - pretty_str!([ + test_pretty_encode_ok( + &[ + (None, "null"), + (Some(vec!["foo", "bar"]), + pretty_str!([ "foo", "bar" - ]), - ), - ]); + ])), + ], + ); } #[test] @@ -688,13 +563,9 @@ fn test_write_newtype_struct() { let inner = Newtype(treemap!(String::from("inner") => 123)); let outer = treemap!(String::from("outer") => to_value(&inner).unwrap()); - test_encode_ok(&[ - (inner, r#"{"inner":123}"#), - ]); + test_encode_ok(&[(inner, r#"{"inner":123}"#)]); - test_encode_ok(&[ - (outer, r#"{"outer":{"inner":123}}"#), - ]); + test_encode_ok(&[(outer, r#"{"outer":{"inner":123}}"#)]); } #[test] @@ -707,15 +578,14 @@ fn test_write_map_with_integer_keys_issue_221() { json!({"0": "x"}) ); - test_encode_ok(&[ - (&map, r#"{"0":"x"}"#), - ]); + test_encode_ok(&[(&map, r#"{"0":"x"}"#)]); #[derive(Eq, PartialEq, Ord, PartialOrd)] struct Float; impl Serialize for Float { fn serialize(&self, serializer: S) -> Result - where S: Serializer + where + S: Serializer, { serializer.serialize_f32(1.0) } @@ -726,7 +596,8 @@ fn test_write_map_with_integer_keys_issue_221() { } fn test_parse_ok(tests: Vec<(&str, T)>) - where T: Clone + Debug + PartialEq + ser::Serialize + de::DeserializeOwned, +where + T: Clone + Debug + PartialEq + ser::Serialize + de::DeserializeOwned, { for (s, value) in tests { let v: T = from_str(s).unwrap(); @@ -759,7 +630,8 @@ fn test_parse_ok(tests: Vec<(&str, T)>) // For testing representations that the deserializer accepts but the serializer // never generates. These do not survive a round-trip through Value. fn test_parse_unusual_ok(tests: Vec<(&str, T)>) - where T: Clone + Debug + PartialEq + ser::Serialize + de::DeserializeOwned, +where + T: Clone + Debug + PartialEq + ser::Serialize + de::DeserializeOwned, { for (s, value) in tests { let v: T = from_str(s).unwrap(); @@ -781,7 +653,8 @@ macro_rules! test_parse_err { } fn test_parse_err(errors: &[(&str, &'static str)]) - where T: Debug + PartialEq + de::DeserializeOwned, +where + T: Debug + PartialEq + de::DeserializeOwned, { for &(s, err) in errors { test_parse_err!(from_str::(s) => err); @@ -791,7 +664,8 @@ fn test_parse_err(errors: &[(&str, &'static str)]) } fn test_parse_slice_err(errors: &[(&[u8], &'static str)]) - where T: Debug + PartialEq + de::DeserializeOwned, +where + T: Debug + PartialEq + de::DeserializeOwned, { for &(s, err) in errors { test_parse_err!(from_slice::(s) => err); @@ -801,44 +675,55 @@ fn test_parse_slice_err(errors: &[(&[u8], &'static str)]) #[test] fn test_parse_null() { - test_parse_err::<()>(&[ - ("n", "expected ident at line 1 column 1"), - ("nul", "expected ident at line 1 column 3"), - ("nulla", "trailing characters at line 1 column 5"), - ]); + test_parse_err::<()>( + &[ + ("n", "expected ident at line 1 column 1"), + ("nul", "expected ident at line 1 column 3"), + ("nulla", "trailing characters at line 1 column 5"), + ], + ); - test_parse_ok(vec![ + test_parse_ok( + vec![ ("null", ()), - ]); + ], + ); } #[test] fn test_parse_bool() { - test_parse_err::(&[ - ("t", "expected ident at line 1 column 1"), - ("truz", "expected ident at line 1 column 4"), - ("f", "expected ident at line 1 column 1"), - ("faz", "expected ident at line 1 column 3"), - ("truea", "trailing characters at line 1 column 5"), - ("falsea", "trailing characters at line 1 column 6"), - ]); + test_parse_err::( + &[ + ("t", "expected ident at line 1 column 1"), + ("truz", "expected ident at line 1 column 4"), + ("f", "expected ident at line 1 column 1"), + ("faz", "expected ident at line 1 column 3"), + ("truea", "trailing characters at line 1 column 5"), + ("falsea", "trailing characters at line 1 column 6"), + ], + ); - test_parse_ok(vec![ + test_parse_ok( + vec![ ("true", true), (" true ", true), ("false", false), (" false ", false), - ]); + ], + ); } #[test] fn test_parse_char() { - test_parse_err::(&[ - ("\"ab\"", "invalid value: string \"ab\", expected a character at line 1 column 4"), - ("10", "invalid type: integer `10`, expected a character at line 1 column 2"), - ]); + test_parse_err::( + &[ + ("\"ab\"", "invalid value: string \"ab\", expected a character at line 1 column 4"), + ("10", "invalid type: integer `10`, expected a character at line 1 column 2"), + ], + ); - test_parse_ok(vec![ + test_parse_ok( + vec![ ("\"n\"", 'n'), ("\"\\\"\"", '"'), ("\"\\\\\"", '\\'), @@ -851,71 +736,76 @@ fn test_parse_char() { ("\"\\u000b\"", '\x0B'), ("\"\\u000B\"", '\x0B'), ("\"\u{3A3}\"", '\u{3A3}'), - ]); + ], + ); } #[test] fn test_parse_number_errors() { - test_parse_err::(&[ - ("+", "expected value at line 1 column 1"), - (".", "expected value at line 1 column 1"), - ("-", "invalid number at line 1 column 1"), - ("00", "invalid number at line 1 column 2"), - ("0x80", "trailing characters at line 1 column 2"), - ("\\0", "expected value at line 1 column 1"), - ("1.", "invalid number at line 1 column 2"), - ("1.a", "invalid number at line 1 column 3"), - ("1.e1", "invalid number at line 1 column 3"), - ("1e", "invalid number at line 1 column 2"), - ("1e+", "invalid number at line 1 column 3"), - ("1a", "trailing characters at line 1 column 2"), - ("100e777777777777777777777777777", - "number out of range at line 1 column 14"), - ("-100e777777777777777777777777777", - "number out of range at line 1 column 15"), - ("1000000000000000000000000000000000000000000000000000000000000\ + test_parse_err::( + &[ + ("+", "expected value at line 1 column 1"), + (".", "expected value at line 1 column 1"), + ("-", "invalid number at line 1 column 1"), + ("00", "invalid number at line 1 column 2"), + ("0x80", "trailing characters at line 1 column 2"), + ("\\0", "expected value at line 1 column 1"), + ("1.", "invalid number at line 1 column 2"), + ("1.a", "invalid number at line 1 column 3"), + ("1.e1", "invalid number at line 1 column 3"), + ("1e", "invalid number at line 1 column 2"), + ("1e+", "invalid number at line 1 column 3"), + ("1a", "trailing characters at line 1 column 2"), + ("100e777777777777777777777777777", "number out of range at line 1 column 14"), + ("-100e777777777777777777777777777", "number out of range at line 1 column 15"), + ("1000000000000000000000000000000000000000000000000000000000000\ 000000000000000000000000000000000000000000000000000000000000\ 000000000000000000000000000000000000000000000000000000000000\ 000000000000000000000000000000000000000000000000000000000000\ 000000000000000000000000000000000000000000000000000000000000\ 000000000", // 1e309 - "number out of range at line 1 column 310"), - ("1000000000000000000000000000000000000000000000000000000000000\ + "number out of range at line 1 column 310"), + ("1000000000000000000000000000000000000000000000000000000000000\ 000000000000000000000000000000000000000000000000000000000000\ 000000000000000000000000000000000000000000000000000000000000\ 000000000000000000000000000000000000000000000000000000000000\ 000000000000000000000000000000000000000000000000000000000000\ .0e9", // 1e309 - "number out of range at line 1 column 305"), - ("1000000000000000000000000000000000000000000000000000000000000\ + "number out of range at line 1 column 305"), + ("1000000000000000000000000000000000000000000000000000000000000\ 000000000000000000000000000000000000000000000000000000000000\ 000000000000000000000000000000000000000000000000000000000000\ 000000000000000000000000000000000000000000000000000000000000\ 000000000000000000000000000000000000000000000000000000000000\ e9", // 1e309 - "number out of range at line 1 column 303"), - ]); + "number out of range at line 1 column 303"), + ], + ); } #[test] fn test_parse_i64() { - test_parse_ok(vec![ + test_parse_ok( + vec![ ("-2", -2), ("-1234", -1234), (" -1234 ", -1234), (&i64::MIN.to_string(), i64::MIN), (&i64::MAX.to_string(), i64::MAX), - ]); + ], + ); } #[test] fn test_parse_u64() { - test_parse_ok(vec![ + test_parse_ok( + vec![ ("0", 0u64), ("3", 3u64), ("1234", 1234), (&u64::MAX.to_string(), u64::MAX), - ]); + ], + ); } #[test] @@ -934,7 +824,8 @@ fn test_parse_negative_zero() { #[test] fn test_parse_f64() { - test_parse_ok(vec![ + test_parse_ok( + vec![ ("0.0", 0.0f64), ("3.0", 3.0f64), ("3.00", 3.0f64), @@ -984,26 +875,31 @@ fn test_parse_f64() { 000000000000000000000000000000000000000000000000000000000000\ 000000000000000000000000000000000000000000000000000000000000\ 000000000000000000e-10", 1e308), - ]); + ], + ); } #[test] fn test_parse_string() { - test_parse_err::(&[ - ("\"", "EOF while parsing a string at line 1 column 1"), - ("\"lol", "EOF while parsing a string at line 1 column 4"), - ("\"lol\"a", "trailing characters at line 1 column 6"), - ("\"\\uD83C\\uFFFF\"", "lone leading surrogate in hex escape at line 1 column 13"), - ]); + test_parse_err::( + &[ + ("\"", "EOF while parsing a string at line 1 column 1"), + ("\"lol", "EOF while parsing a string at line 1 column 4"), + ("\"lol\"a", "trailing characters at line 1 column 6"), + ("\"\\uD83C\\uFFFF\"", "lone leading surrogate in hex escape at line 1 column 13"), + ], + ); - test_parse_slice_err::(&[ - (&[b'"', 159, 146, 150, b'"'], - "invalid unicode code point at line 1 column 5"), - (&[b'"', b'\\', b'n', 159, 146, 150, b'"'], - "invalid unicode code point at line 1 column 7"), - ]); + test_parse_slice_err::( + &[ + (&[b'"', 159, 146, 150, b'"'], "invalid unicode code point at line 1 column 5"), + (&[b'"', b'\\', b'n', 159, 146, 150, b'"'], + "invalid unicode code point at line 1 column 7"), + ], + ); - test_parse_ok(vec![ + test_parse_ok( + vec![ ("\"\"", "".to_string()), ("\"foo\"", "foo".to_string()), (" \"foo\" ", "foo".to_string()), @@ -1015,76 +911,98 @@ fn test_parse_string() { ("\"\\u12ab\"", "\u{12ab}".to_string()), ("\"\\uAB12\"", "\u{AB12}".to_string()), ("\"\\uD83C\\uDF95\"", "\u{1F395}".to_string()), - ]); + ], + ); } #[test] fn test_parse_list() { - test_parse_err::>(&[ - ("[", "EOF while parsing a list at line 1 column 1"), - ("[ ", "EOF while parsing a list at line 1 column 2"), - ("[1", "EOF while parsing a list at line 1 column 2"), - ("[1,", "EOF while parsing a value at line 1 column 3"), - ("[1,]", "expected value at line 1 column 4"), - ("[1 2]", "expected `,` or `]` at line 1 column 4"), - ("[]a", "trailing characters at line 1 column 3"), - ]); + test_parse_err::>( + &[ + ("[", "EOF while parsing a list at line 1 column 1"), + ("[ ", "EOF while parsing a list at line 1 column 2"), + ("[1", "EOF while parsing a list at line 1 column 2"), + ("[1,", "EOF while parsing a value at line 1 column 3"), + ("[1,]", "expected value at line 1 column 4"), + ("[1 2]", "expected `,` or `]` at line 1 column 4"), + ("[]a", "trailing characters at line 1 column 3"), + ], + ); - test_parse_ok(vec![ + test_parse_ok( + vec![ ("[]", vec![]), ("[ ]", vec![]), ("[null]", vec![()]), (" [ null ] ", vec![()]), - ]); + ], + ); - test_parse_ok(vec![ + test_parse_ok( + vec![ ("[true]", vec![true]), - ]); + ], + ); - test_parse_ok(vec![ + test_parse_ok( + vec![ ("[3,1]", vec![3u64, 1]), (" [ 3 , 1 ] ", vec![3, 1]), - ]); + ], + ); - test_parse_ok(vec![ + test_parse_ok( + vec![ ("[[3], [1, 2]]", vec![vec![3u64], vec![1, 2]]), - ]); + ], + ); - test_parse_ok(vec![ + test_parse_ok( + vec![ ("[1]", (1u64,)), - ]); + ], + ); - test_parse_ok(vec![ + test_parse_ok( + vec![ ("[1, 2]", (1u64, 2u64)), - ]); + ], + ); - test_parse_ok(vec![ + test_parse_ok( + vec![ ("[1, 2, 3]", (1u64, 2u64, 3u64)), - ]); + ], + ); - test_parse_ok(vec![ + test_parse_ok( + vec![ ("[1, [2, 3]]", (1u64, (2u64, 3u64))), - ]); + ], + ); } #[test] fn test_parse_object() { - test_parse_err::>(&[ - ("{", "EOF while parsing an object at line 1 column 1"), - ("{ ", "EOF while parsing an object at line 1 column 2"), - ("{1", "key must be a string at line 1 column 2"), - ("{ \"a\"", "EOF while parsing an object at line 1 column 5"), - ("{\"a\"", "EOF while parsing an object at line 1 column 4"), - ("{\"a\" ", "EOF while parsing an object at line 1 column 5"), - ("{\"a\" 1", "expected `:` at line 1 column 6"), - ("{\"a\":", "EOF while parsing a value at line 1 column 5"), - ("{\"a\":1", "EOF while parsing an object at line 1 column 6"), - ("{\"a\":1 1", "expected `,` or `}` at line 1 column 8"), - ("{\"a\":1,", "EOF while parsing a value at line 1 column 7"), - ("{}a", "trailing characters at line 1 column 3"), - ]); + test_parse_err::>( + &[ + ("{", "EOF while parsing an object at line 1 column 1"), + ("{ ", "EOF while parsing an object at line 1 column 2"), + ("{1", "key must be a string at line 1 column 2"), + ("{ \"a\"", "EOF while parsing an object at line 1 column 5"), + ("{\"a\"", "EOF while parsing an object at line 1 column 4"), + ("{\"a\" ", "EOF while parsing an object at line 1 column 5"), + ("{\"a\" 1", "expected `:` at line 1 column 6"), + ("{\"a\":", "EOF while parsing a value at line 1 column 5"), + ("{\"a\":1", "EOF while parsing an object at line 1 column 6"), + ("{\"a\":1 1", "expected `,` or `}` at line 1 column 8"), + ("{\"a\":1,", "EOF while parsing a value at line 1 column 7"), + ("{}a", "trailing characters at line 1 column 3"), + ], + ); - test_parse_ok(vec![ + test_parse_ok( + vec![ ("{}", treemap!()), ("{ }", treemap!()), ( @@ -1103,9 +1021,11 @@ fn test_parse_object() { " { \"a\" : 3 , \"b\" : 4 } ", treemap!("a".to_string() => 3, "b".to_string() => 4), ), - ]); + ], + ); - test_parse_ok(vec![ + test_parse_ok( + vec![ ( "{\"a\": {\"b\": 3, \"c\": 4}}", treemap!( @@ -1115,25 +1035,25 @@ fn test_parse_object() { ) ), ), - ]); + ], + ); } #[test] fn test_parse_struct() { - test_parse_err::(&[ - ("5", - "invalid type: integer `5`, expected struct Outer at line 1 column 1"), - ("\"hello\"", - "invalid type: string \"hello\", expected struct Outer at line 1 column 7"), - ("{\"inner\": true}", - "invalid type: boolean `true`, expected a sequence at line 1 column 14"), - ("{}", - "missing field `inner` at line 1 column 2"), - (r#"{"inner": [{"b": 42, "c": []}]}"#, - "missing field `a` at line 1 column 29"), - ]); + test_parse_err::( + &[ + ("5", "invalid type: integer `5`, expected struct Outer at line 1 column 1"), + ("\"hello\"", "invalid type: string \"hello\", expected struct Outer at line 1 column 7"), + ("{\"inner\": true}", + "invalid type: boolean `true`, expected a sequence at line 1 column 14"), + ("{}", "missing field `inner` at line 1 column 2"), + (r#"{"inner": [{"b": 42, "c": []}]}"#, "missing field `a` at line 1 column 29"), + ], + ); - test_parse_ok(vec![ + test_parse_ok( + vec![ ( "{ \"inner\": [] @@ -1154,14 +1074,17 @@ fn test_parse_struct() { ] }, ), - ]); + ], + ); let v: Outer = from_str( "[ [ [ null, 2, [\"abc\", \"xyz\"] ] ] - ]").unwrap(); + ]", + ) + .unwrap(); assert_eq!( v, @@ -1175,10 +1098,12 @@ fn test_parse_struct() { #[test] fn test_parse_option() { - test_parse_ok(vec![ + test_parse_ok( + vec![ ("null", None::), ("\"jodhpurs\"", Some("jodhpurs".to_string())), - ]); + ], + ); #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)] struct Foo { @@ -1188,49 +1113,44 @@ fn test_parse_option() { let value: Foo = from_str("{}").unwrap(); assert_eq!(value, Foo { x: None }); - test_parse_ok(vec![ + test_parse_ok( + vec![ ("{\"x\": null}", Foo { x: None }), ("{\"x\": 5}", Foo { x: Some(5) }), - ]); + ], + ); } #[test] fn test_parse_enum_errors() { - test_parse_err::(&[ - ("{}", - "expected value at line 1 column 2"), - ("[]", - "expected value at line 1 column 1"), - ("\"unknown\"", - "unknown variant `unknown`, expected one of `Dog`, `Frog`, `Cat`, `AntHive` at line 1 column 9"), - ("{\"unknown\":null}", - "unknown variant `unknown`, expected one of `Dog`, `Frog`, `Cat`, `AntHive` at line 1 column 10"), - ("{\"Dog\":", - "EOF while parsing a value at line 1 column 7"), - ("{\"Dog\":}", - "expected value at line 1 column 8"), - ("{\"Dog\":{}}", - "invalid type: map, expected unit at line 1 column 9"), - ("\"Frog\"", - "invalid type: unit variant, expected tuple variant"), - ("\"Frog\" 0 ", - "invalid type: unit variant, expected tuple variant"), - ("{\"Frog\":{}}", - "invalid type: map, expected tuple variant Animal::Frog at line 1 column 10"), - ("{\"Cat\":[]}", - "invalid length 0, expected tuple of 2 elements at line 1 column 9"), - ("{\"Cat\":[0]}", - "invalid length 1, expected tuple of 2 elements at line 1 column 10"), - ("{\"Cat\":[0, \"\", 2]}", - "trailing characters at line 1 column 14"), - ("{\"Cat\":{\"age\": 5, \"name\": \"Kate\", \"foo\":\"bar\"}", - "unknown field `foo`, expected `age` or `name` at line 1 column 39"), - ]); + test_parse_err::( + &[ + ("{}", "expected value at line 1 column 2"), + ("[]", "expected value at line 1 column 1"), + ("\"unknown\"", + "unknown variant `unknown`, expected one of `Dog`, `Frog`, `Cat`, `AntHive` at line 1 column 9"), + ("{\"unknown\":null}", + "unknown variant `unknown`, expected one of `Dog`, `Frog`, `Cat`, `AntHive` at line 1 column 10"), + ("{\"Dog\":", "EOF while parsing a value at line 1 column 7"), + ("{\"Dog\":}", "expected value at line 1 column 8"), + ("{\"Dog\":{}}", "invalid type: map, expected unit at line 1 column 9"), + ("\"Frog\"", "invalid type: unit variant, expected tuple variant"), + ("\"Frog\" 0 ", "invalid type: unit variant, expected tuple variant"), + ("{\"Frog\":{}}", + "invalid type: map, expected tuple variant Animal::Frog at line 1 column 10"), + ("{\"Cat\":[]}", "invalid length 0, expected tuple of 2 elements at line 1 column 9"), + ("{\"Cat\":[0]}", "invalid length 1, expected tuple of 2 elements at line 1 column 10"), + ("{\"Cat\":[0, \"\", 2]}", "trailing characters at line 1 column 14"), + ("{\"Cat\":{\"age\": 5, \"name\": \"Kate\", \"foo\":\"bar\"}", + "unknown field `foo`, expected `age` or `name` at line 1 column 39"), + ], + ); } #[test] fn test_parse_enum() { - test_parse_ok(vec![ + test_parse_ok( + vec![ ("\"Dog\"", Animal::Dog), (" \"Dog\" ", Animal::Dog), ( @@ -1253,14 +1173,18 @@ fn test_parse_enum() { " { \"AntHive\" : [\"Bob\", \"Stuart\"] } ", Animal::AntHive(vec!["Bob".to_string(), "Stuart".to_string()]), ), - ]); + ], + ); - test_parse_unusual_ok(vec![ + test_parse_unusual_ok( + vec![ ("{\"Dog\":null}", Animal::Dog), (" { \"Dog\" : null } ", Animal::Dog), - ]); + ], + ); - test_parse_ok(vec![ + test_parse_ok( + vec![ ( concat!( "{", @@ -1273,24 +1197,29 @@ fn test_parse_enum() { "b".to_string() => Animal::Frog("Henry".to_string(), vec![]) ) ), - ]); + ], + ); } #[test] fn test_parse_trailing_whitespace() { - test_parse_ok(vec![ + test_parse_ok( + vec![ ("[1, 2] ", vec![1u64, 2]), ("[1, 2]\n", vec![1, 2]), ("[1, 2]\t", vec![1, 2]), ("[1, 2]\t \n", vec![1, 2]), - ]); + ], + ); } #[test] fn test_multiline_errors() { - test_parse_err::>(&[ - ("{\n \"foo\":\n \"bar\"", "EOF while parsing an object at line 3 column 6"), - ]); + test_parse_err::>( + &[ + ("{\n \"foo\":\n \"bar\"", "EOF while parsing an object at line 3 column 6"), + ], + ); } #[test] @@ -1320,9 +1249,7 @@ fn test_missing_nonoption_field() { x: u32, } - test_parse_err::(&[ - ("{}", "missing field `x` at line 1 column 2"), - ]); + test_parse_err::(&[("{}", "missing field `x` at line 1 column 2")]); } #[test] @@ -1352,11 +1279,13 @@ fn test_serialize_seq_with_no_len() { struct MyVec(Vec); impl ser::Serialize for MyVec - where T: ser::Serialize, + where + T: ser::Serialize, { #[inline] fn serialize(&self, serializer: S) -> Result - where S: ser::Serializer, + where + S: ser::Serializer, { use serde::ser::SerializeSeq; let mut seq = try!(serializer.serialize_seq(None)); @@ -1372,7 +1301,8 @@ fn test_serialize_seq_with_no_len() { } impl<'de, T> de::Visitor<'de> for Visitor - where T: de::Deserialize<'de>, + where + T: de::Deserialize<'de>, { type Value = MyVec; @@ -1382,14 +1312,16 @@ fn test_serialize_seq_with_no_len() { #[inline] fn visit_unit(self) -> Result, E> - where E: de::Error, + where + E: de::Error, { Ok(MyVec(Vec::new())) } #[inline] fn visit_seq(self, mut visitor: V) -> Result, V::Error> - where V: de::SeqAccess<'de>, + where + V: de::SeqAccess<'de>, { let mut values = Vec::new(); @@ -1402,10 +1334,12 @@ fn test_serialize_seq_with_no_len() { } impl<'de, T> de::Deserialize<'de> for MyVec - where T: de::Deserialize<'de>, + where + T: de::Deserialize<'de>, { fn deserialize(deserializer: D) -> Result, D::Error> - where D: de::Deserializer<'de>, + where + D: de::Deserializer<'de>, { deserializer.deserialize_map(Visitor { marker: PhantomData }) } @@ -1416,12 +1350,7 @@ fn test_serialize_seq_with_no_len() { vec.push(MyVec(Vec::new())); let vec: MyVec> = MyVec(vec); - test_encode_ok(&[ - ( - vec.clone(), - "[[],[]]", - ), - ]); + test_encode_ok(&[(vec.clone(), "[[],[]]")]); let s = to_string_pretty(&vec).unwrap(); let expected = pretty_str!([ @@ -1437,12 +1366,14 @@ fn test_serialize_map_with_no_len() { struct MyMap(BTreeMap); impl ser::Serialize for MyMap - where K: ser::Serialize + Ord, - V: ser::Serialize, + where + K: ser::Serialize + Ord, + V: ser::Serialize, { #[inline] fn serialize(&self, serializer: S) -> Result - where S: ser::Serializer, + where + S: ser::Serializer, { use serde::ser::SerializeMap; let mut map = try!(serializer.serialize_map(None)); @@ -1459,8 +1390,9 @@ fn test_serialize_map_with_no_len() { } impl<'de, K, V> de::Visitor<'de> for Visitor - where K: de::Deserialize<'de> + Eq + Ord, - V: de::Deserialize<'de>, + where + K: de::Deserialize<'de> + Eq + Ord, + V: de::Deserialize<'de>, { type Value = MyMap; @@ -1470,14 +1402,16 @@ fn test_serialize_map_with_no_len() { #[inline] fn visit_unit(self) -> Result, E> - where E: de::Error, + where + E: de::Error, { Ok(MyMap(BTreeMap::new())) } #[inline] fn visit_map(self, mut visitor: Visitor) -> Result, Visitor::Error> - where Visitor: de::MapAccess<'de>, + where + Visitor: de::MapAccess<'de>, { let mut values = BTreeMap::new(); @@ -1490,11 +1424,13 @@ fn test_serialize_map_with_no_len() { } impl<'de, K, V> de::Deserialize<'de> for MyMap - where K: de::Deserialize<'de> + Eq + Ord, - V: de::Deserialize<'de>, + where + K: de::Deserialize<'de> + Eq + Ord, + V: de::Deserialize<'de>, { fn deserialize(deserializer: D) -> Result, D::Error> - where D: de::Deserializer<'de>, + where + D: de::Deserializer<'de>, { deserializer.deserialize_map(Visitor { marker: PhantomData }) } @@ -1505,12 +1441,7 @@ fn test_serialize_map_with_no_len() { map.insert("b", MyMap(BTreeMap::new())); let map: MyMap<_, MyMap> = MyMap(map); - test_encode_ok(&[ - ( - map.clone(), - "{\"a\":{},\"b\":{}}", - ), - ]); + test_encode_ok(&[(map.clone(), "{\"a\":{},\"b\":{}}")]); let s = to_string_pretty(&map).unwrap(); let expected = pretty_str!({ @@ -1533,18 +1464,20 @@ fn test_deserialize_from_stream() { let l = net::TcpListener::bind("localhost:20000").unwrap(); - thread::spawn(|| { - let l = l; - for stream in l.incoming() { - let mut stream = stream.unwrap(); - let read_stream = stream.try_clone().unwrap(); + thread::spawn( + || { + let l = l; + for stream in l.incoming() { + let mut stream = stream.unwrap(); + let read_stream = stream.try_clone().unwrap(); - let mut de = Deserializer::from_reader(read_stream); - let request = Message::deserialize(&mut de).unwrap(); - let response = Message { message: request.message }; - to_writer(&mut stream, &response).unwrap(); - } - }); + let mut de = Deserializer::from_reader(read_stream); + let request = Message::deserialize(&mut de).unwrap(); + let response = Message { message: request.message }; + to_writer(&mut stream, &response).unwrap(); + } + }, + ); let mut stream = net::TcpStream::connect("localhost:20000").unwrap(); let request = Message { message: "hi there".to_string() }; @@ -1582,7 +1515,10 @@ fn test_serialize_rejects_adt_keys() { #[test] fn test_effectively_string_keys() { #[derive(Eq, PartialEq, Ord, PartialOrd, Debug, Serialize, Deserialize)] - enum Enum { Zero, One } + enum Enum { + Zero, + One, + } let map = treemap! { Enum::Zero => 0, Enum::One => 1 @@ -1637,14 +1573,15 @@ fn test_byte_buf_de() { fn test_byte_buf_de_multiple() { let s: Vec = from_str(r#"["ab\nc", "cd\ne"]"#).unwrap(); let a = ByteBuf::from(b"ab\nc".to_vec()); - let b = ByteBuf::from(b"cd\ne".to_vec()); + let b = ByteBuf::from(b"cd\ne".to_vec()); assert_eq!(vec![a, b], s); } #[test] fn test_json_pointer() { // Test case taken from https://tools.ietf.org/html/rfc6901#page-5 - let data: Value = from_str(r#"{ + let data: Value = from_str( + r#"{ "foo": ["bar", "baz"], "": 0, "a/b": 1, @@ -1655,7 +1592,9 @@ fn test_json_pointer() { "k\"l": 6, " ": 7, "m~n": 8 - }"#).unwrap(); + }"#, + ) + .unwrap(); assert_eq!(data.pointer("").unwrap(), &data); assert_eq!(data.pointer("/foo").unwrap(), &json!(["bar", "baz"])); assert_eq!(data.pointer("/foo/0").unwrap(), &json!("bar")); @@ -1680,7 +1619,8 @@ fn test_json_pointer_mut() { use std::mem; // Test case taken from https://tools.ietf.org/html/rfc6901#page-5 - let mut data: Value = from_str(r#"{ + let mut data: Value = from_str( + r#"{ "foo": ["bar", "baz"], "": 0, "a/b": 1, @@ -1691,7 +1631,9 @@ fn test_json_pointer_mut() { "k\"l": 6, " ": 7, "m~n": 8 - }"#).unwrap(); + }"#, + ) + .unwrap(); // Basic pointer checks assert_eq!(data.pointer_mut("/foo").unwrap(), &json!(["bar", "baz"])); @@ -1730,13 +1672,14 @@ fn test_json_pointer_mut() { #[test] fn test_stack_overflow() { - let brackets: String = iter::repeat('[').take(127).chain(iter::repeat(']').take(127)).collect(); + let brackets: String = iter::repeat('[') + .take(127) + .chain(iter::repeat(']').take(127)) + .collect(); let _: Value = from_str(&brackets).unwrap(); let brackets: String = iter::repeat('[').take(128).collect(); - test_parse_err::(&[ - (&brackets, "recursion limit exceeded at line 1 column 128"), - ]); + test_parse_err::(&[(&brackets, "recursion limit exceeded at line 1 column 128")],); } #[test] @@ -1773,7 +1716,7 @@ fn test_from_iter_unfused() { None => { self.finished = true; None - }, + } } } } @@ -1783,16 +1726,22 @@ fn test_from_iter_unfused() { key: u32, } - let msg: Message = from_iter(Source { - iter: b"{\"key\": 1337}".iter().cloned(), - finished: false, - }).unwrap(); + let msg: Message = from_iter( + Source { + iter: b"{\"key\": 1337}".iter().cloned(), + finished: false, + }, + ) + .unwrap(); assert_eq!(msg.key, 1337); - let msg: Message = from_iter(Source { - iter: b"{\"key\": 1337} \t\t ".iter().cloned(), - finished: false, - }).unwrap(); + let msg: Message = from_iter( + Source { + iter: b"{\"key\": 1337} \t\t ".iter().cloned(), + finished: false, + }, + ) + .unwrap(); assert_eq!(msg.key, 1337); }