From 61ccfb416e553301d9db604d0986d184796b0280 Mon Sep 17 00:00:00 2001 From: Sam Scott Date: Thu, 9 Nov 2017 16:28:07 +0000 Subject: Let rustfmt do its thing. --- examples/introduction.rs | 8 +- src/de/mod.rs | 210 ++++++++++++++++++++-------------------------- src/de/parse.rs | 145 +++++++++++++++++--------------- src/error.rs | 14 ++-- src/lib.rs | 3 +- src/ser.rs | 204 ++++++++++++++++++++++---------------------- tests/test_deserialize.rs | 103 +++++++++++++---------- tests/test_serialize.rs | 49 +++++------ 8 files changed, 358 insertions(+), 378 deletions(-) diff --git a/examples/introduction.rs b/examples/introduction.rs index cee6bdf..d980719 100644 --- a/examples/introduction.rs +++ b/examples/introduction.rs @@ -143,9 +143,7 @@ fn main() { e: AdjTaggedEnum, } - let example_params = EnumQuery { - e: AdjTaggedEnum::B(false), - }; + let example_params = EnumQuery { e: AdjTaggedEnum::B(false) }; // encodes as: // "e[B]=false" let encoded = qs::to_string(&example_params).unwrap(); @@ -154,9 +152,7 @@ fn main() { println!("`serde_qs` from_str for enum:\n\t{:?}", params); println!(""); - let example_params = EnumQuery { - e: AdjTaggedEnum::A, - }; + let example_params = EnumQuery { e: AdjTaggedEnum::A }; // encodes as: // "e=A" let encoded = qs::to_string(&example_params).unwrap(); diff --git a/src/de/mod.rs b/src/de/mod.rs index c28c459..5d8115a 100644 --- a/src/de/mod.rs +++ b/src/de/mod.rs @@ -16,7 +16,7 @@ //! order. //! //! The `parse` module handles this step of deserializing a querystring into the -//! map structure. This uses `rust_url::percent_encoding` to handle +//! map structure. This uses `rust_url::percent_encoding` to handle //! first converting the string. //! //! From here, there are two main `Deserializer` objects: `QsDeserializer` and @@ -101,8 +101,8 @@ impl Config { /// Create a new `Config` with the specified `max_depth` and `strict` mode. pub fn new(max_depth: usize, strict: bool) -> Self { Self { - max_depth, - strict + max_depth: max_depth, + strict: strict, } } @@ -115,9 +115,8 @@ impl Config { impl Config { /// Deserializes a querystring from a `&[u8]` using this `Config`. pub fn deserialize_bytes<'de, T: de::Deserialize<'de>>(&self, - input: &'de [u8]) - -> Result - { + input: &'de [u8]) + -> Result { T::deserialize(QsDeserializer::with_config(self, input)?) } @@ -132,8 +131,8 @@ impl Config { /// Deserializes a querystring from a `&str` using this `Config`. pub fn deserialize_str<'de, T: de::Deserialize<'de>>(&self, - input: &'de str) - -> Result { + input: &'de str) + -> Result { self.deserialize_bytes(input.as_bytes()) } } @@ -225,7 +224,8 @@ impl<'a> QsDeserializer<'a> { /// Returns a new `QsDeserializer<'a>`. fn with_config(config: &Config, input: &'a [u8]) -> Result { - parse::Parser::new(input, config.max_depth(), config.strict).as_deserializer() + parse::Parser::new(input, config.max_depth(), config.strict) + .as_deserializer() } } @@ -263,12 +263,11 @@ impl<'de> de::Deserializer<'de> for QsDeserializer<'de> { Err(Error::top_level("sequence")) } - fn deserialize_newtype_struct( - self, - _name: &'static str, - visitor: V - ) -> Result - where V: de::Visitor<'de> + fn deserialize_newtype_struct(self, + _name: &'static str, + visitor: V) + -> Result + where V: de::Visitor<'de>, { self.deserialize_map(visitor) } @@ -276,12 +275,8 @@ impl<'de> de::Deserializer<'de> for QsDeserializer<'de> { /// Throws an error. /// /// Tuples are not supported at the top level. - fn deserialize_tuple( - self, - _len: usize, - _visitor: V - ) -> Result - where V: de::Visitor<'de> + fn deserialize_tuple(self, _len: usize, _visitor: V) -> Result + where V: de::Visitor<'de>, { Err(Error::top_level("tuple")) @@ -290,24 +285,22 @@ impl<'de> de::Deserializer<'de> for QsDeserializer<'de> { /// Throws an error. /// /// TupleStructs are not supported at the top level. - fn deserialize_tuple_struct( - self, - _name: &'static str, - _len: usize, - _visitor: V - ) -> Result - where V: de::Visitor<'de> + fn deserialize_tuple_struct(self, + _name: &'static str, + _len: usize, + _visitor: V) + -> Result + where V: de::Visitor<'de>, { Err(Error::top_level("tuple struct")) } - fn deserialize_enum( - self, - _name: &'static str, - _variants: &'static [&'static str], - visitor: V - ) -> Result - where V: de::Visitor<'de> + fn deserialize_enum(self, + _name: &'static str, + _variants: &'static [&'static str], + visitor: V) + -> Result + where V: de::Visitor<'de>, { visitor.visit_enum(self) } @@ -367,7 +360,7 @@ impl<'de> de::EnumAccess<'de> for QsDeserializer<'de> { type Variant = Self; fn variant_seed(mut self, seed: V) -> Result<(V::Value, Self::Variant)> - where V: de::DeserializeSeed<'de> + where V: de::DeserializeSeed<'de>, { if let Some((key, value)) = self.iter.next() { self.value = Some(value); @@ -385,8 +378,7 @@ impl<'de> de::VariantAccess<'de> for QsDeserializer<'de> { } fn newtype_variant_seed(self, seed: T) -> Result - where - T: de::DeserializeSeed<'de> + where T: de::DeserializeSeed<'de>, { if let Some(value) = self.value { seed.deserialize(LevelDeserializer(value)) @@ -395,13 +387,8 @@ impl<'de> de::VariantAccess<'de> for QsDeserializer<'de> { } } - 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>, { if let Some(value) = self.value { de::Deserializer::deserialize_seq(LevelDeserializer(value), visitor) @@ -409,13 +396,11 @@ impl<'de> de::VariantAccess<'de> for QsDeserializer<'de> { Err(de::Error::custom("no value to deserialize")) } } - 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>, { if let Some(value) = self.value { de::Deserializer::deserialize_map(LevelDeserializer(value), visitor) @@ -430,16 +415,19 @@ impl<'de> de::EnumAccess<'de> for LevelDeserializer<'de> { type Variant = Self; fn variant_seed(self, seed: V) -> Result<(V::Value, Self::Variant)> - where V: de::DeserializeSeed<'de> + where V: de::DeserializeSeed<'de>, { match self.0 { Level::Flat(x) => { Ok((seed.deserialize(ParsableStringDeserializer(x))?, - LevelDeserializer(Level::Invalid("this value can only deserialize to a UnitVariant")))) + LevelDeserializer(Level::Invalid("this value can only \ + deserialize to a \ + UnitVariant")))) }, _ => { - Err(de::Error::custom("this value can only deserialize to a UnitVariant")) - } + Err(de::Error::custom("this value can only deserialize to a \ + UnitVariant")) + }, } } } @@ -451,41 +439,35 @@ impl<'de> de::VariantAccess<'de> for LevelDeserializer<'de> { } fn newtype_variant_seed(self, seed: T) -> Result - where - T: de::DeserializeSeed<'de> + where T: de::DeserializeSeed<'de>, { seed.deserialize(self) } - 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>, { de::Deserializer::deserialize_seq(self, 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_map(self, visitor) } } -struct LevelSeq<'a, I: Iterator>>(I); +struct LevelSeq<'a, I: Iterator>>(I); -impl<'de, I: Iterator>> de::SeqAccess<'de> for LevelSeq<'de, I> { +impl<'de, I: Iterator>> de::SeqAccess<'de> + for + LevelSeq<'de, I> { type Error = Error; fn next_element_seed(&mut self, seed: T) -> Result> - where T: de::DeserializeSeed<'de> + where T: de::DeserializeSeed<'de>, { if let Some(v) = self.0.next() { seed.deserialize(LevelDeserializer(v)).map(Some) @@ -534,14 +516,12 @@ macro_rules! deserialize_primitive { impl<'a> LevelDeserializer<'a> { fn into_deserializer(self) -> Result> { match self.0 { - Level::Nested(map) => { - Ok(QsDeserializer::with_map(map)) - }, - Level::Invalid(e) => { - Err(de::Error::custom(e)) - }, + Level::Nested(map) => Ok(QsDeserializer::with_map(map)), + Level::Invalid(e) => Err(de::Error::custom(e)), l => { - Err(de::Error::custom(format!("could not convert {:?} to QsDeserializer<'a>", l))) + Err(de::Error::custom(format!("could not convert {:?} to \ + QsDeserializer<'a>", + l))) }, } } @@ -569,12 +549,11 @@ impl<'de> de::Deserializer<'de> for LevelDeserializer<'de> { Cow::Borrowed(s) => visitor.visit_borrowed_str(s), } }, - Level::Invalid(e) => { - Err(de::Error::custom(e)) - }, + Level::Invalid(e) => Err(de::Error::custom(e)), Level::Uninitialised => { - Err(de::Error::custom("attempted to deserialize unitialised value")) - } + Err(de::Error::custom("attempted to deserialize unitialised \ + value")) + }, } } @@ -582,42 +561,37 @@ impl<'de> de::Deserializer<'de> for LevelDeserializer<'de> { where V: de::Visitor<'de>, { match self.0 { - Level::Flat(ref x) if x == "" => { - visitor.visit_none() - }, - _ => { - visitor.visit_some(self) - }, + Level::Flat(ref x) if x == "" => visitor.visit_none(), + _ => visitor.visit_some(self), } } - fn deserialize_enum( - self, - name: &'static str, - variants: &'static [&'static str], - visitor: V - ) -> Result - where V: de::Visitor<'de> + fn deserialize_enum(self, + name: &'static str, + variants: &'static [&'static str], + visitor: V) + -> Result + where V: de::Visitor<'de>, { match self.0 { Level::Nested(map) => { - QsDeserializer::with_map(map).deserialize_enum(name, variants, visitor) - }, - Level::Flat(_) => { - visitor.visit_enum(self) + QsDeserializer::with_map(map) + .deserialize_enum(name, variants, visitor) }, + Level::Flat(_) => visitor.visit_enum(self), x => { - Err(de::Error::custom(format!("{:?} does not appear to be an enum", x))) + Err(de::Error::custom(format!("{:?} does not appear to be \ + an enum", + x))) }, } } - fn deserialize_newtype_struct( - self, - _name: &'static str, - visitor: V - ) -> Result - where V: de::Visitor<'de> + fn deserialize_newtype_struct(self, + _name: &'static str, + visitor: V) + -> Result + where V: de::Visitor<'de>, { match self.0 { Level::Nested(_) => { @@ -630,26 +604,25 @@ impl<'de> de::Deserializer<'de> for LevelDeserializer<'de> { visitor.visit_seq(LevelSeq(seq.into_iter())) }, Level::Flat(_) => { - // For a newtype_struct, attempt to deserialize a flat value as a + // For a newtype_struct, attempt to deserialize a flat value as a // single element sequence. visitor.visit_seq(LevelSeq(vec![self.0].into_iter())) }, - Level::Invalid(e) => { - Err(de::Error::custom(e)) - }, + Level::Invalid(e) => Err(de::Error::custom(e)), Level::Uninitialised => { - Err(de::Error::custom("attempted to deserialize unitialised value")) + Err(de::Error::custom("attempted to deserialize unitialised \ + value")) }, } } deserialize_primitive!(bool, deserialize_bool, visit_bool); - deserialize_primitive!(i8, deserialize_i8, visit_i8); + deserialize_primitive!(i8, deserialize_i8, visit_i8); deserialize_primitive!(i16, deserialize_i16, visit_i16); deserialize_primitive!(i32, deserialize_i32, visit_i32); deserialize_primitive!(i64, deserialize_i64, visit_i64); - deserialize_primitive!(u8, deserialize_u8, visit_u8); + deserialize_primitive!(u8, deserialize_u8, visit_u8); deserialize_primitive!(u16, deserialize_u16, visit_u16); deserialize_primitive!(u32, deserialize_u32, visit_u32); deserialize_primitive!(u64, deserialize_u64, visit_u64); @@ -736,5 +709,4 @@ impl<'de> de::Deserializer<'de> for ParsableStringDeserializer<'de> { f32 => deserialize_f32, f64 => deserialize_f64, } - } diff --git a/src/de/parse.rs b/src/de/parse.rs index 3b39c46..1c13aaf 100644 --- a/src/de/parse.rs +++ b/src/de/parse.rs @@ -1,3 +1,5 @@ +use super::*; + use percent_encoding; use serde::de; @@ -6,8 +8,6 @@ use std::iter::Iterator; use std::slice::Iter; use std::str; -use super::*; - macro_rules! tu { ($x:expr) => ( @@ -29,19 +29,21 @@ impl<'a> Level<'a> { match map.entry(key) { Entry::Occupied(mut o) => { // Throw away old result; map is now invalid anyway. - let _ = o.insert(Level::Invalid("Multiple values for one key")); + let _ = + o.insert(Level::Invalid("Multiple values for one key")); }, Entry::Vacant(vm) => { // Map is empty, result is None let _ = vm.insert(Level::Flat(value)); }, } - } else if let Level::Uninitialised = *self { + } else if let Level::Uninitialised = *self { let mut map = BTreeMap::default(); let _ = map.insert(key, Level::Flat(value)); *self = Level::Nested(map); } else { - *self = Level::Invalid("Attempted to insert map value into non-map structure"); + *self = Level::Invalid("Attempted to insert map value into \ + non-map structure"); } } @@ -51,20 +53,22 @@ impl<'a> Level<'a> { match map.entry(key) { Entry::Occupied(mut o) => { // Throw away old result; map is now invalid anyway. - let _ = o.insert(Level::Invalid("Multiple values for one key")); + let _ = + o.insert(Level::Invalid("Multiple values for one key")); }, Entry::Vacant(vm) => { // Map is empty, result is None let _ = vm.insert(Level::Flat(value)); }, } - } else if let Level::Uninitialised = *self { + } else if let Level::Uninitialised = *self { // To reach here, self is either an OrderedSeq or nothing. let mut map = BTreeMap::default(); let _ = map.insert(key, Level::Flat(value)); *self = Level::OrderedSeq(map); } else { - *self = Level::Invalid("Attempted to insert seq value into non-seq structure"); + *self = Level::Invalid("Attempted to insert seq value into \ + non-seq structure"); } } @@ -81,7 +85,8 @@ impl<'a> Level<'a> { seq.push(Level::Flat(value)); *self = Level::Sequence(seq); } else { - *self = Level::Invalid("Attempted to insert seq value into non-seq structure"); + *self = Level::Invalid("Attempted to insert seq value into \ + non-seq structure"); } } } @@ -113,10 +118,10 @@ impl<'a> Iterator for Parser<'a> { self.index += 1; self.acc.1 += 1; self.iter.next() - } + }, } } else { - // in non-strict mode, we will happily decode any bracket + // in non-strict mode, we will happily decode any bracket match self.peeked.take() { Some(v) => Some(v), None => { @@ -139,15 +144,13 @@ impl<'a> Iterator for Parser<'a> { self.index += 2; Some(&b']') }, - _ => { - Some(v) - } + _ => Some(v), } - } + }, Some(v) => Some(v), None => None, } - } + }, } } } @@ -180,8 +183,9 @@ fn replace_plus(input: Cow) -> Cow { *byte = b' '; } } - Cow::Owned(String::from_utf8(replaced).expect("replacing '+' with ' ' cannot panic")) - } + Cow::Owned(String::from_utf8(replaced) + .expect("replacing '+' with ' ' cannot panic")) + }, } } @@ -193,8 +197,8 @@ impl<'a> Parser<'a> { acc: (0, 0), index: 0, peeked: None, - depth, - strict, + depth: depth, + strict: strict, } } @@ -204,11 +208,13 @@ impl<'a> Parser<'a> { } /// Extracts a string from the internal byte slice from the range tracked by - /// the parser. + /// the parser. /// Avoids allocations when neither percent encoded, nor `'+'` values are /// present. fn collect_str(&mut self) -> Result> { - let res: Cow<'a, str> = percent_encoding::percent_decode(&self.inner[self.acc.0..self.acc.1 - 1]).decode_utf8()?; + let res: Cow<'a, str> = + percent_encoding::percent_decode(&self.inner[self.acc.0.. + self.acc.1 - 1]).decode_utf8()?; let res: Result> = Ok(replace_plus(res)); self.clear_acc(); res.map_err(Error::from) @@ -221,11 +227,11 @@ impl<'a> Parser<'a> { let mut root = Level::Nested(map); // Parses all top level nodes into the `root` map. - while self.parse(&mut root)? { } + while self.parse(&mut root)? {} let iter = match root { Level::Nested(map) => map.into_iter(), - _ => BTreeMap::default().into_iter() + _ => BTreeMap::default().into_iter(), }; Ok(QsDeserializer { iter: iter, @@ -258,7 +264,7 @@ impl<'a> Parser<'a> { b'[' => { // If we're in strict mode, error, otherwise just ignore it. if self.strict { - return Err(super::Error::parse_err("found another opening bracket before the closed bracket", self.index)) + return Err(super::Error::parse_err("found another opening bracket before the closed bracket", self.index)); } else { let _ = self.next(); } @@ -277,16 +283,17 @@ impl<'a> Parser<'a> { let key = usize::from_str_radix(&key, 10).map_err(Error::from)?; self.parse_ord_seq_value(key, node)?; return Ok(true); - } + }, // Key is "[a..." so parse up to the closing "]" - 0x20...0x2f | 0x3a...0x5a | 0x5c | 0x5e...0x7e => { + 0x20...0x2f | 0x3a...0x5a | 0x5c | + 0x5e...0x7e => { let key = self.parse_key(b']', true)?; self.parse_map_value(key, node)?; return Ok(true); }, c => { if self.strict { - return Err(super::Error::parse_err(&format!("unexpected character: {}", String::from_utf8_lossy(&[c])), self.index)) + return Err(super::Error::parse_err(&format!("unexpected character: {}", String::from_utf8_lossy(&[c])), self.index)); } else { let _ = self.next(); } @@ -319,14 +326,11 @@ impl<'a> Parser<'a> { /// or `']'` when the key is a nested key. In the former case, `'='` will /// also finish the key parsing. /// - /// The `consume` flag determines whether the end character should be + /// The `consume` flag determines whether the end character should be /// returned to the buffer to be peeked. This is important when - /// parsing keys like `abc[def][ghi]` since the `'['` character is + /// parsing keys like `abc[def][ghi]` since the `'['` character is /// needed to for the next iteration of `parse`. - fn parse_key(&mut self, - end_on: u8, - consume: bool) - -> Result> { + fn parse_key(&mut self, end_on: u8, consume: bool) -> Result> { loop { if let Some(x) = self.next() { match *x { @@ -401,22 +405,22 @@ impl<'a> Parser<'a> { // Either take the existing entry, or add a new // unitialised level // Use this new node to keep parsing - let _ = self.parse( - map.entry(key).or_insert(Level::Uninitialised) - )?; + let _ = self.parse(map.entry(key) + .or_insert(Level::Uninitialised))?; break Ok(()); } else { // We expected to parse into a map here. break Err(super::Error::parse_err(&format!("tried to insert a \ new key into {:?}", - node), self.index)); + node), + self.index)); } }, c => { // Anything else is unexpected since we just finished // parsing a key. if self.strict { - break Err(super::Error::parse_err(format!("Unexpected character: '{}' found when parsing", String::from_utf8_lossy(&[c])), self.index)) + break Err(super::Error::parse_err(format!("Unexpected character: '{}' found when parsing", String::from_utf8_lossy(&[c])), self.index)); } else { let _ = self.next(); } @@ -429,7 +433,7 @@ impl<'a> Parser<'a> { } }; // We have finished parsing this level, so go back up a level. - self.depth +=1; + self.depth += 1; res } @@ -437,7 +441,10 @@ impl<'a> Parser<'a> { /// ordered sequence. /// Basically the same as the above, but we insert into `OrderedSeq` /// Can potentially be merged? - fn parse_ord_seq_value(&mut self, key: usize, node: &mut Level<'a>) -> Result<()> { + fn parse_ord_seq_value(&mut self, + key: usize, + node: &mut Level<'a>) + -> Result<()> { let res = loop { if let Some(x) = self.peek() { match *x { @@ -448,12 +455,12 @@ impl<'a> Parser<'a> { let value = self.collect_str()?; // Reached the end of the key string node.insert_ord_seq_value(key, value); - break Ok(()) + break Ok(()); }, b'&' => { // No value node.insert_ord_seq_value(key, Cow::Borrowed("")); - break Ok(()) + break Ok(()); }, b'[' => { // The key continues to another level of nested. @@ -469,19 +476,22 @@ impl<'a> Parser<'a> { // unitialised level // Use this new node to keep parsing map.entry(key).or_insert(Level::Uninitialised))?; - break Ok(()) + break Ok(()); } else { // We expected to parse into a seq here. break Err(super::Error::parse_err(&format!("tried to insert a \ new key into {:?}", - node), self.index)) + node), + self.index)); } }, c => { // Anything else is unexpected since we just finished // parsing a key. if self.strict { - break Err(super::Error::parse_err(format!("Unexpected character: {:?} found when parsing", c), self.index)) + break Err(super::Error::parse_err(format!("Unexpected character: {:?} found when parsing", + c), + self.index)); } else { let _ = self.next(); } @@ -490,7 +500,7 @@ impl<'a> Parser<'a> { } else { // The string has ended, so the value is empty. node.insert_ord_seq_value(key, Cow::Borrowed("")); - break Ok(()) + break Ok(()); } }; // We have finished parsing this level, so go back up a level. @@ -503,35 +513,36 @@ impl<'a> Parser<'a> { /// This must be the final level of nesting, so assume we have a value fn parse_seq_value(&mut self, node: &mut Level<'a>) -> Result<()> { let res = match self.peek() { - Some(x) => match *x { - b'=' => { - // Key is finished, parse up until the '&' as the value - self.clear_acc(); - for _ in self.take_while(|b| *b != &b'&') {} - let value = self.collect_str()?; - node.insert_seq_value(value); - Ok(()) - }, - b'&' => { - // key value is empty - node.insert_seq_value(Cow::Borrowed("")); - Ok(()) + Some(x) => { + match *x { + b'=' => { + // Key is finished, parse up until the '&' as the value + self.clear_acc(); + for _ in self.take_while(|b| *b != &b'&') {} + let value = self.collect_str()?; + node.insert_seq_value(value); + Ok(()) + }, + b'&' => { + // key value is empty + node.insert_seq_value(Cow::Borrowed("")); + Ok(()) + }, + _ => { + Err(super::Error::parse_err("non-indexed sequence of \ + structs not supported", + self.index)) + }, } - _ => { - Err(super::Error::parse_err("non-indexed sequence of structs not \ - supported", self.index)) - }, }, None => { // The string has ended, so the value is empty. node.insert_seq_value(Cow::Borrowed("")); Ok(()) - } + }, }; // We have finished parsing this level, so go back up a level. self.depth += 1; res } - - } diff --git a/src/error.rs b/src/error.rs index 555bf5e..aecc2d0 100644 --- a/src/error.rs +++ b/src/error.rs @@ -33,20 +33,24 @@ impl Error { /// Generate error to show top-level type cannot be deserialized. pub fn top_level(object: &'static str) -> Self { ErrorKind::Custom(format!("cannot deserialize {} at the top level.\ - Try deserializing into a struct.", object)).into() + Try deserializing into a struct.", + object)) + .into() } /// Generate a parsing error message with position. pub fn parse_err(msg: T, position: usize) -> Self - where T: Display { + where T: Display, + { ErrorKind::Parse(msg.to_string(), position).into() } } impl de::Error for Error { - fn custom(msg: T) -> Self - where T: Display { - ErrorKind::Custom(msg.to_string()).into() + fn custom(msg: T) -> Self + where T: Display, + { + ErrorKind::Custom(msg.to_string()).into() } } diff --git a/src/lib.rs b/src/lib.rs index 16d4683..e5ee7e2 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -131,12 +131,11 @@ mod de; mod error; mod ser; -pub use error::Error; #[doc(inline)] pub use de::{from_bytes, from_str}; #[doc(inline)] pub use de::Config; +pub use error::Error; #[doc(inline)] pub use ser::{QsSerializer, to_string}; - diff --git a/src/ser.rs b/src/ser.rs index cb6834f..a78d6be 100644 --- a/src/ser.rs +++ b/src/ser.rs @@ -2,16 +2,16 @@ //! Serialization support for querystrings. use data_encoding::BASE64URL_NOPAD as BASE64; -use percent_encoding::{percent_encode, EncodeSet}; +use percent_encoding::{EncodeSet, percent_encode}; use serde::ser; +use error::*; + use std::borrow::Cow; use std::fmt::Display; use std::io::Write; use std::str; -use error::*; - #[allow(non_camel_case_types)] #[derive(Clone)] struct QS_ENCODE_SET; @@ -19,8 +19,9 @@ struct QS_ENCODE_SET; impl EncodeSet for QS_ENCODE_SET { fn contains(&self, byte: u8) -> bool { match byte { - b' ' | b'*' | b'-' | b'.' | b'0' ... b'9' | b'A' ... b'Z' | b'_' | b'a' ... b'z' => false, - _ => true + b' ' | b'*' | b'-' | b'.' | b'0'...b'9' | b'A'...b'Z' | b'_' | + b'a'...b'z' => false, + _ => true, } } } @@ -54,7 +55,11 @@ impl EncodeSet for QS_ENCODE_SET { pub fn to_string(input: &T) -> Result { let mut buffer = Vec::new(); let mut first = true; - input.serialize(&mut QsSerializer { writer: &mut buffer, key: None, first: &mut first })?; + input.serialize(&mut QsSerializer { + writer: &mut buffer, + key: None, + first: &mut first, + })?; String::from_utf8(buffer).map_err(Error::from) } @@ -83,14 +88,17 @@ fn replace_space(input: &str) -> Cow { *byte = b'+'; } } - Cow::Owned(String::from_utf8(replaced).expect("replacing ' ' with '+' cannot panic")) - } + Cow::Owned(String::from_utf8(replaced) + .expect("replacing ' ' with '+' cannot panic")) + }, } } impl<'a, W: 'a + Write> QsSerializer<'a, W> { fn extend_key(&mut self, newkey: &str) { - let newkey = percent_encode(replace_space(newkey).as_bytes(), QS_ENCODE_SET).collect::>(); + let newkey = percent_encode(replace_space(newkey).as_bytes(), + QS_ENCODE_SET) + .collect::>(); let key = if let Some(ref key) = self.key { format!("{}[{}]", key, newkey).into() } else { @@ -101,11 +109,19 @@ impl<'a, W: 'a + Write> QsSerializer<'a, W> { fn write_value(&mut self, value: &str) -> Result<()> { if let Some(ref key) = self.key { - write!(self.writer, "{}{}={}", - if *self.first { *self.first = false; "" } else { "&" }, - key, - percent_encode(value.as_bytes(), QS_ENCODE_SET).map(replace_space).collect::() - ).map_err(Error::from) + write!(self.writer, + "{}{}={}", + if *self.first { + *self.first = false; + "" + } else { + "&" + }, + key, + percent_encode(value.as_bytes(), QS_ENCODE_SET) + .map(replace_space) + .collect::()) + .map_err(Error::from) } else { Err(Error::no_key()) } @@ -113,8 +129,8 @@ impl<'a, W: 'a + Write> QsSerializer<'a, W> { /// Creates a new `QsSerializer` with a distinct key, but `writer` and ///`first` referring to the original data. - fn new_from_ref<'b: 'a>(other: &'a mut QsSerializer<'b, W>) -> QsSerializer<'a, W> - { + fn new_from_ref<'b: 'a>(other: &'a mut QsSerializer<'b, W>) + -> QsSerializer<'a, W> { Self { key: other.key.clone(), writer: other.writer, @@ -185,9 +201,7 @@ impl<'a, W: Write> ser::Serializer for &'a mut QsSerializer<'a, W> { } /// Returns an error. - fn serialize_unit_struct(self, - name: &'static str) - -> Result { + fn serialize_unit_struct(self, name: &'static str) -> Result { self.write_value(name) } @@ -225,25 +239,20 @@ impl<'a, W: Write> ser::Serializer for &'a mut QsSerializer<'a, W> { Ok(()) } - fn serialize_some - (self, - value: &T) - -> Result { + fn serialize_some(self, + value: &T) + -> Result { // Err(ErrorKind::Unsupported.into()) value.serialize(self) } /// Returns an error. - fn serialize_seq(self, - _len: Option) - -> Result { + fn serialize_seq(self, _len: Option) -> Result { Ok(QsSeq(self, 0)) } - fn serialize_tuple(self, - _len: usize) - -> Result { + fn serialize_tuple(self, _len: usize) -> Result { Ok(QsSeq(self, 0)) } @@ -255,22 +264,18 @@ impl<'a, W: Write> ser::Serializer for &'a mut QsSerializer<'a, W> { Ok(QsSeq(self, 0)) } - fn serialize_tuple_variant - (self, - _name: &'static str, - _variant_index: u32, - variant: &'static str, - _len: usize) - -> Result - { + fn serialize_tuple_variant(self, + _name: &'static str, + _variant_index: u32, + variant: &'static str, + _len: usize) + -> Result { // self.write(variant)?; self.extend_key(variant); Ok(QsSeq(self, 0)) } - fn serialize_map(self, - _len: Option) - -> Result { + fn serialize_map(self, _len: Option) -> Result { Ok(QsMap(self, None)) } @@ -281,14 +286,12 @@ impl<'a, W: Write> ser::Serializer for &'a mut QsSerializer<'a, W> { Ok(self) } - fn serialize_struct_variant - (self, - _name: &'static str, - _variant_index: u32, - variant: &'static str, - _len: usize) - -> Result - { + fn serialize_struct_variant(self, + _name: &'static str, + _variant_index: u32, + variant: &'static str, + _len: usize) + -> Result { self.extend_key(variant); Ok(self) } @@ -296,21 +299,23 @@ impl<'a, W: Write> ser::Serializer for &'a mut QsSerializer<'a, W> { impl ser::Error for Error { - fn custom(msg: T) -> Self - where T: Display { - ErrorKind::Custom(msg.to_string()).into() + fn custom(msg: T) -> Self + where T: Display, + { + ErrorKind::Custom(msg.to_string()).into() } } pub struct QsSeq<'a, W: 'a + Write>(&'a mut QsSerializer<'a, W>, usize); -pub struct QsMap<'a, W: 'a + Write>(&'a mut QsSerializer<'a, W>, Option>); +pub struct QsMap<'a, W: 'a + Write>(&'a mut QsSerializer<'a, W>, + Option>); impl<'a, W: Write> ser::SerializeTuple for QsSeq<'a, W> { type Ok = (); type Error = Error; fn serialize_element(&mut self, value: &T) -> Result<()> - where T: ser::Serialize + where T: ser::Serialize, { let mut serializer = QsSerializer::new_from_ref(self.0); serializer.extend_key(&self.1.to_string()); @@ -328,7 +333,7 @@ impl<'a, W: Write> ser::SerializeSeq for QsSeq<'a, W> { type Ok = (); type Error = Error; fn serialize_element(&mut self, value: &T) -> Result<()> - where T: ser::Serialize + where T: ser::Serialize, { let mut serializer = QsSerializer::new_from_ref(self.0); serializer.extend_key(&self.1.to_string()); @@ -341,11 +346,14 @@ impl<'a, W: Write> ser::SerializeSeq for QsSeq<'a, W> { } } -impl<'a, W: Write> ser::SerializeStruct for &'a mut QsSerializer<'a, W> { +impl<'a, W: Write> ser::SerializeStruct for &'a mut QsSerializer<'a, W> { type Ok = (); type Error = Error; - 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, { let mut serializer = QsSerializer::new_from_ref(self); serializer.extend_key(key); @@ -360,8 +368,11 @@ impl<'a, W: Write> ser::SerializeStructVariant for &'a mut QsSerializer<'a, W> { type Ok = (); type Error = Error; - 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, { let mut serializer = QsSerializer::new_from_ref(self); serializer.extend_key(key); @@ -371,7 +382,6 @@ impl<'a, W: Write> ser::SerializeStructVariant for &'a mut QsSerializer<'a, W> { fn end(self) -> Result { Ok(()) } - } impl<'a, W: Write> ser::SerializeTupleVariant for QsSeq<'a, W> { @@ -379,7 +389,7 @@ impl<'a, W: Write> ser::SerializeTupleVariant for QsSeq<'a, W> { type Error = Error; fn serialize_field(&mut self, value: &T) -> Result<()> - where T: ser::Serialize + where T: ser::Serialize, { let mut serializer = QsSerializer::new_from_ref(self.0); serializer.extend_key(&self.1.to_string()); @@ -390,7 +400,6 @@ impl<'a, W: Write> ser::SerializeTupleVariant for QsSeq<'a, W> { fn end(self) -> Result { Ok(()) } - } impl<'a, W: Write> ser::SerializeTupleStruct for QsSeq<'a, W> { @@ -398,7 +407,7 @@ impl<'a, W: Write> ser::SerializeTupleStruct for QsSeq<'a, W> { type Error = Error; fn serialize_field(&mut self, value: &T) -> Result<()> - where T: ser::Serialize + where T: ser::Serialize, { let mut serializer = QsSerializer::new_from_ref(self.0); serializer.extend_key(&self.1.to_string()); @@ -409,7 +418,6 @@ impl<'a, W: Write> ser::SerializeTupleStruct for QsSeq<'a, W> { fn end(self) -> Result { Ok(()) } - } impl<'a, W: Write> ser::SerializeMap for QsMap<'a, W> { @@ -417,14 +425,14 @@ impl<'a, W: Write> ser::SerializeMap for QsMap<'a, W> { type Error = Error; fn serialize_key(&mut self, key: &T) -> Result<()> - where T: ser::Serialize + where T: ser::Serialize, { self.1 = Some(Cow::from(key.serialize(StringSerializer)?)); Ok(()) } fn serialize_value(&mut self, value: &T) -> Result<()> - where T: ser::Serialize + where T: ser::Serialize, { let mut serializer = QsSerializer::new_from_ref(self.0); if let Some(ref key) = self.1 { @@ -440,14 +448,17 @@ impl<'a, W: Write> ser::SerializeMap for QsMap<'a, W> { Ok(()) } - fn serialize_entry(&mut self, key: &K, value: &V) -> Result<()> - where K: ser::Serialize, V: ser::Serialize, + fn serialize_entry(&mut self, + key: &K, + value: &V) + -> Result<()> + where K: ser::Serialize, + V: ser::Serialize, { let mut serializer = QsSerializer::new_from_ref(self.0); serializer.extend_key(&key.serialize(StringSerializer)?); value.serialize(&mut serializer) } - } struct StringSerializer; @@ -490,9 +501,7 @@ impl ser::Serializer for StringSerializer { } /// Returns an error. - fn serialize_unit_struct(self, - _name: &'static str) - -> Result { + fn serialize_unit_struct(self, _name: &'static str) -> Result { Err(ErrorKind::Unsupported.into()) } @@ -519,7 +528,7 @@ impl ser::Serializer for StringSerializer { (self, _name: &'static str, _variant_index: u32, - _variant: &'static str, + _variant: &'static str, _value: &T) -> Result { Err(ErrorKind::Unsupported.into()) @@ -531,24 +540,19 @@ impl ser::Serializer for StringSerializer { } /// Returns an error. - fn serialize_some - (self, - _value: &T) - -> Result { + fn serialize_some(self, + _value: &T) + -> Result { Err(ErrorKind::Unsupported.into()) } /// Returns an error. - fn serialize_seq(self, - _len: Option) - -> Result { + fn serialize_seq(self, _len: Option) -> Result { Err(ErrorKind::Unsupported.into()) } - fn serialize_tuple(self, - _len: usize) - -> Result { + fn serialize_tuple(self, _len: usize) -> Result { Err(ErrorKind::Unsupported.into()) } @@ -560,20 +564,16 @@ impl ser::Serializer for StringSerializer { Err(ErrorKind::Unsupported.into()) } - fn serialize_tuple_variant - (self, - _name: &'static str, - _variant_index: u32, - _variant: &'static str, - _len: usize) - -> Result - { + fn serialize_tuple_variant(self, + _name: &'static str, + _variant_index: u32, + _variant: &'static str, + _len: usize) + -> Result { Err(ErrorKind::Unsupported.into()) } - fn serialize_map(self, - _len: Option) - -> Result { + fn serialize_map(self, _len: Option) -> Result { Err(ErrorKind::Unsupported.into()) } @@ -585,16 +585,12 @@ impl ser::Serializer for StringSerializer { Err(ErrorKind::Unsupported.into()) } - fn serialize_struct_variant - (self, - _name: &'static str, - _variant_index: u32, - _variant: &'static str, - _len: usize) - -> Result - { + fn serialize_struct_variant(self, + _name: &'static str, + _variant_index: u32, + _variant: &'static str, + _len: usize) + -> Result { Err(ErrorKind::Unsupported.into()) } - } - diff --git a/tests/test_deserialize.rs b/tests/test_deserialize.rs index a71e4bf..ec84a75 100644 --- a/tests/test_deserialize.rs +++ b/tests/test_deserialize.rs @@ -183,7 +183,7 @@ fn qs_test_simple() { fn no_panic_on_parse_error() { #[derive(Debug,Serialize,Deserialize,PartialEq)] struct Query { - vec: Vec + vec: Vec, } let params: Result = qs::from_str("vec[]=a&vec[]=2"); @@ -217,23 +217,17 @@ fn optional_seq() { } let params = ""; - let query = Query { - vec: None, - }; + let query = Query { vec: None }; let rec_params: Query = qs::from_str(params).unwrap(); assert_eq!(rec_params, query); let params = "vec="; - let query = Query { - vec: None, - }; + let query = Query { vec: None }; let rec_params: Query = qs::from_str(params).unwrap(); assert_eq!(rec_params, query); let params = "vec[0]=1&vec[1]=2"; - let query = Query { - vec: Some(vec![1,2]), - }; + let query = Query { vec: Some(vec![1, 2]) }; let rec_params: Query = qs::from_str(params).unwrap(); assert_eq!(rec_params, query); } @@ -246,16 +240,12 @@ fn optional_struct() { } let params = ""; - let query = Query { - address: None, - }; + let query = Query { address: None }; let rec_params: Query = qs::from_str(params).unwrap(); assert_eq!(rec_params, query); let params = "address="; - let query = Query { - address: None, - }; + let query = Query { address: None }; let rec_params: Query = qs::from_str(params).unwrap(); assert_eq!(rec_params, query); @@ -264,7 +254,7 @@ fn optional_struct() { address: Some(Address { city: "Carrot City".to_string(), postcode: "12345".to_string(), - },), + }), }; let rec_params: Query = qs::from_str(params).unwrap(); assert_eq!(rec_params, query); @@ -308,18 +298,24 @@ fn deserialize_enum_adjacently() { #[derive(Deserialize, Debug, PartialEq)] struct Query { e: E, - v: Option + v: Option, } let params = "e[type]=B&e[val]=true&v[type]=V1&v[val][x]=12&v[val][y]=300"; let rec_params: Query = qs::from_str(params).unwrap(); assert_eq!(rec_params, - Query { e: E::B(true), v: Some(V::V1 { x: 12, y: 300 }) } - ); + Query { + e: E::B(true), + v: Some(V::V1 { x: 12, y: 300 }), + }); let params = "e[type]=S&e[val]=other"; let rec_params: Query = qs::from_str(params).unwrap(); - assert_eq!(rec_params, Query { e: E::S("other".to_string()), v: None }); + assert_eq!(rec_params, + Query { + e: E::S("other".to_string()), + v: None, + }); } #[test] @@ -349,12 +345,20 @@ fn deserialize_enum() { let params = "e=B&v[V1][x]=12&v[V1][y]=300&u=12"; let rec_params: Query = qs::from_str(params).unwrap(); assert_eq!(rec_params, - Query { e: E::B, v: Some(V::V1 { x: 12, y: 300 }), u: NewU8(12) } - ); + Query { + e: E::B, + v: Some(V::V1 { x: 12, y: 300 }), + u: NewU8(12), + }); let params = "e[S]=other&u=1"; let rec_params: Query = qs::from_str(params).unwrap(); - assert_eq!(rec_params, Query { e: E::S("other".to_string()), v: None, u: NewU8(1) }); + assert_eq!(rec_params, + Query { + e: E::S("other".to_string()), + v: None, + u: NewU8(1), + }); let params = "B="; let rec_params: E = qs::from_str(params).unwrap(); @@ -370,7 +374,7 @@ fn seq_of_struct() { #[derive(Deserialize, Debug, PartialEq)] struct Test { - a: u8 + a: u8, } #[derive(Deserialize, Debug, PartialEq)] struct Query { @@ -379,15 +383,13 @@ fn seq_of_struct() { let params = "b[0][a]=1&b[1][a]=2"; let rec_params: Query = qs::from_str(params).unwrap(); - assert_eq!(rec_params, - Query { b: vec![Test { a: 1 }, Test { a: 2 }] } - ); + assert_eq!(rec_params, Query { b: vec![Test { a: 1 }, Test { a: 2 }] }); } #[test] fn correct_decoding() { map_test!("foo=%24", "foo"["$"]); - + map_test!("foo=%26", "foo"["&"]); } @@ -395,7 +397,7 @@ fn correct_decoding() { fn returns_errors() { #[derive(Debug,Serialize,Deserialize,PartialEq)] struct Query { - vec: Vec + vec: Vec, } let params: Result = qs::from_str("vec[[]=1&vec[]=2"); @@ -416,48 +418,59 @@ fn returns_errors() { fn strict_mode() { #[derive(Deserialize,Serialize,Debug, PartialEq)] struct Test { - a: u8 + a: u8, } #[derive(Debug,Serialize,Deserialize,PartialEq)] #[serde(deny_unknown_fields)] struct Query { - vec: Vec + vec: Vec, } let strict_config = qs::Config::default(); - let params: Result = strict_config.deserialize_str("vec%5B0%5D%5Ba%5D=1&vec[1][a]=2"); + let params: Result = + strict_config.deserialize_str("vec%5B0%5D%5Ba%5D=1&vec[1][a]=2"); assert!(params.is_err()); println!("{}", params.unwrap_err()); let loose_config = qs::Config::new(5, false); - let params: Result = loose_config.deserialize_str("vec%5B0%5D%5Ba%5D=1&vec[1][a]=2"); - assert_eq!(params.unwrap(), Query { vec: vec![Test { a: 1 }, Test { a: 2 }] }); + let params: Result = + loose_config.deserialize_str("vec%5B0%5D%5Ba%5D=1&vec[1][a]=2"); + assert_eq!(params.unwrap(), + Query { vec: vec![Test { a: 1 }, Test { a: 2 }] }); - let params: Result = loose_config.deserialize_str("vec[%5B0%5D%5Ba%5D]=1&vec[1][a]=2"); - assert_eq!(params.unwrap(), Query { vec: vec![Test { a: 1 }, Test { a: 2 }] }); + let params: Result = + loose_config.deserialize_str("vec[%5B0%5D%5Ba%5D]=1&vec[1][a]=2"); + assert_eq!(params.unwrap(), + Query { vec: vec![Test { a: 1 }, Test { a: 2 }] }); - let params: Result = loose_config.deserialize_str("vec[%5B0%5D%5Ba%5D=1&vec[1][a]=2"); - assert_eq!(params.unwrap(), Query { vec: vec![Test { a: 1 }, Test { a: 2 }] }); + let params: Result = + loose_config.deserialize_str("vec[%5B0%5D%5Ba%5D=1&vec[1][a]=2"); + assert_eq!(params.unwrap(), + Query { vec: vec![Test { a: 1 }, Test { a: 2 }] }); - let params: Result = loose_config.deserialize_str("vec%5B0%5D%5Ba%5D]=1&vec[1][a]=2"); - assert_eq!(params.unwrap(), Query { vec: vec![Test { a: 1 }, Test { a: 2 }] }); + let params: Result = + loose_config.deserialize_str("vec%5B0%5D%5Ba%5D]=1&vec[1][a]=2"); + assert_eq!(params.unwrap(), + Query { vec: vec![Test { a: 1 }, Test { a: 2 }] }); #[derive(Deserialize,Serialize,Debug, PartialEq)] struct OddTest { #[serde(rename="[but&why=?]")] - a: u8 + a: u8, } let params = OddTest { a: 12 }; let enc_params = qs::to_string(¶ms).unwrap(); println!("Enocded as: {}", enc_params); - let rec_params: Result = strict_config.deserialize_str(&enc_params); + let rec_params: Result = + strict_config.deserialize_str(&enc_params); assert_eq!(rec_params.unwrap(), params); // Non-strict decoding cannot necessarily handle these weird scenerios. - let rec_params: Result = loose_config.deserialize_str(&enc_params); + let rec_params: Result = + loose_config.deserialize_str(&enc_params); assert!(rec_params.is_err()); println!("{}", rec_params.unwrap_err()); -} \ No newline at end of file +} diff --git a/tests/test_serialize.rs b/tests/test_serialize.rs index a2b725f..80e2d7c 100644 --- a/tests/test_serialize.rs +++ b/tests/test_serialize.rs @@ -31,7 +31,8 @@ fn serialize_struct() { user_ids: vec![1, 2, 3, 4], }; - assert_eq!(qs::to_string(¶ms).unwrap(),"\ + assert_eq!(qs::to_string(¶ms).unwrap(), + "\ id=42&name=Acme&phone=12345&address[city]=Carrot+City&\ address[postcode]=12345&user_ids[0]=1&user_ids[1]=2&\ user_ids[2]=3&user_ids[3]=4"); @@ -45,16 +46,12 @@ fn serialize_option() { } let params = ""; - let query = Query { - vec: None, - }; + let query = Query { vec: None }; let rec_params = qs::to_string(&query).unwrap(); assert_eq!(rec_params, params); let params = "vec[0]=1&vec[1]=2"; - let query = Query { - vec: Some(vec![1,2]), - }; + let query = Query { vec: Some(vec![1, 2]) }; let rec_params = qs::to_string(&query).unwrap(); assert_eq!(rec_params, params); } @@ -66,7 +63,7 @@ fn serialize_enum() { enum TestEnum { A, B(bool), - C { x: u8, y: u8}, + C { x: u8, y: u8 }, D(u8, u8), } @@ -76,30 +73,22 @@ fn serialize_enum() { } let params = "e=a"; - let query = Query { - e: TestEnum::A, - }; + let query = Query { e: TestEnum::A }; let rec_params = qs::to_string(&query).unwrap(); assert_eq!(rec_params, params); - let params = "e[b]=true"; - let query = Query { - e: TestEnum::B(true), - }; - let rec_params = qs::to_string(&query).unwrap(); - assert_eq!(rec_params, params); + let params = "e[b]=true"; + let query = Query { e: TestEnum::B(true) }; + let rec_params = qs::to_string(&query).unwrap(); + assert_eq!(rec_params, params); - let params = "e[c][x]=2&e[c][y]=3"; - let query = Query { - e: TestEnum::C { x: 2, y: 3 }, - }; - let rec_params = qs::to_string(&query).unwrap(); - assert_eq!(rec_params, params); + let params = "e[c][x]=2&e[c][y]=3"; + let query = Query { e: TestEnum::C { x: 2, y: 3 } }; + let rec_params = qs::to_string(&query).unwrap(); + assert_eq!(rec_params, params); - let params = "e[d][0]=128&e[d][1]=1"; - let query = Query { - e: TestEnum::D(128, 1), - }; - let rec_params = qs::to_string(&query).unwrap(); - assert_eq!(rec_params, params); -} \ No newline at end of file + let params = "e[d][0]=128&e[d][1]=1"; + let query = Query { e: TestEnum::D(128, 1) }; + let rec_params = qs::to_string(&query).unwrap(); + assert_eq!(rec_params, params); +} -- cgit v1.2.3