1 //! Deserialization support for the `application/x-www-form-urlencoded` format. 2 3 use form_urlencoded::parse; 4 use form_urlencoded::Parse as UrlEncodedParse; 5 use serde::de::value::MapDeserializer; 6 use serde::de::Error as de_Error; 7 use serde::de::{self, IntoDeserializer}; 8 use serde::forward_to_deserialize_any; 9 use std::borrow::Cow; 10 use std::io::Read; 11 12 #[doc(inline)] 13 pub use serde::de::value::Error; 14 15 /// Deserializes a `application/x-www-form-urlencoded` value from a `&[u8]`. 16 /// 17 /// ``` 18 /// let meal = vec![ 19 /// ("bread".to_owned(), "baguette".to_owned()), 20 /// ("cheese".to_owned(), "comté".to_owned()), 21 /// ("meat".to_owned(), "ham".to_owned()), 22 /// ("fat".to_owned(), "butter".to_owned()), 23 /// ]; 24 /// 25 /// assert_eq!( 26 /// serde_urlencoded::from_bytes::<Vec<(String, String)>>( 27 /// b"bread=baguette&cheese=comt%C3%A9&meat=ham&fat=butter"), 28 /// Ok(meal)); 29 /// ``` 30 pub fn from_bytes<'de, T>(input: &'de [u8]) -> Result<T, Error> 31 where 32 T: de::Deserialize<'de>, 33 { 34 T::deserialize(Deserializer::new(parse(input))) 35 } 36 37 /// Deserializes a `application/x-www-form-urlencoded` value from a `&str`. 38 /// 39 /// ``` 40 /// let meal = vec![ 41 /// ("bread".to_owned(), "baguette".to_owned()), 42 /// ("cheese".to_owned(), "comté".to_owned()), 43 /// ("meat".to_owned(), "ham".to_owned()), 44 /// ("fat".to_owned(), "butter".to_owned()), 45 /// ]; 46 /// 47 /// assert_eq!( 48 /// serde_urlencoded::from_str::<Vec<(String, String)>>( 49 /// "bread=baguette&cheese=comt%C3%A9&meat=ham&fat=butter"), 50 /// Ok(meal)); 51 /// ``` 52 pub fn from_str<'de, T>(input: &'de str) -> Result<T, Error> 53 where 54 T: de::Deserialize<'de>, 55 { 56 from_bytes(input.as_bytes()) 57 } 58 59 /// Convenience function that reads all bytes from `reader` and deserializes 60 /// them with `from_bytes`. 61 pub fn from_reader<T, R>(mut reader: R) -> Result<T, Error> 62 where 63 T: de::DeserializeOwned, 64 R: Read, 65 { 66 let mut buf = vec![]; 67 reader.read_to_end(&mut buf).map_err(|e| { 68 de::Error::custom(format_args!("could not read input: {}", e)) 69 })?; 70 from_bytes(&buf) 71 } 72 73 /// A deserializer for the `application/x-www-form-urlencoded` format. 74 /// 75 /// * Supported top-level outputs are structs, maps and sequences of pairs, 76 /// with or without a given length. 77 /// 78 /// * Main `deserialize` methods defers to `deserialize_map`. 79 /// 80 /// * Everything else but `deserialize_seq` and `deserialize_seq_fixed_size` 81 /// defers to `deserialize`. 82 pub struct Deserializer<'de> { 83 inner: MapDeserializer<'de, PartIterator<'de>, Error>, 84 } 85 86 impl<'de> Deserializer<'de> { 87 /// Returns a new `Deserializer`. 88 pub fn new(parser: UrlEncodedParse<'de>) -> Self { 89 Deserializer { 90 inner: MapDeserializer::new(PartIterator(parser)), 91 } 92 } 93 } 94 95 impl<'de> de::Deserializer<'de> for Deserializer<'de> { 96 type Error = Error; 97 98 fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error> 99 where 100 V: de::Visitor<'de>, 101 { 102 self.deserialize_map(visitor) 103 } 104 105 fn deserialize_map<V>(self, visitor: V) -> Result<V::Value, Self::Error> 106 where 107 V: de::Visitor<'de>, 108 { 109 visitor.visit_map(self.inner) 110 } 111 112 fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value, Self::Error> 113 where 114 V: de::Visitor<'de>, 115 { 116 visitor.visit_seq(self.inner) 117 } 118 119 fn deserialize_unit<V>(self, visitor: V) -> Result<V::Value, Self::Error> 120 where 121 V: de::Visitor<'de>, 122 { 123 self.inner.end()?; 124 visitor.visit_unit() 125 } 126 127 forward_to_deserialize_any! { 128 bool 129 u8 130 u16 131 u32 132 u64 133 i8 134 i16 135 i32 136 i64 137 f32 138 f64 139 char 140 str 141 string 142 option 143 bytes 144 byte_buf 145 unit_struct 146 newtype_struct 147 tuple_struct 148 struct 149 identifier 150 tuple 151 enum 152 ignored_any 153 } 154 } 155 156 struct PartIterator<'de>(UrlEncodedParse<'de>); 157 158 impl<'de> Iterator for PartIterator<'de> { 159 type Item = (Part<'de>, Part<'de>); 160 161 fn next(&mut self) -> Option<Self::Item> { 162 self.0.next().map(|(k, v)| (Part(k), Part(v))) 163 } 164 } 165 166 struct Part<'de>(Cow<'de, str>); 167 168 impl<'de> IntoDeserializer<'de> for Part<'de> { 169 type Deserializer = Self; 170 171 fn into_deserializer(self) -> Self::Deserializer { 172 self 173 } 174 } 175 176 macro_rules! forward_parsed_value { 177 ($($ty:ident => $method:ident,)*) => { 178 $( 179 fn $method<V>(self, visitor: V) -> Result<V::Value, Self::Error> 180 where V: de::Visitor<'de> 181 { 182 match self.0.parse::<$ty>() { 183 Ok(val) => val.into_deserializer().$method(visitor), 184 Err(e) => Err(de::Error::custom(e)) 185 } 186 } 187 )* 188 } 189 } 190 191 impl<'de> de::Deserializer<'de> for Part<'de> { 192 type Error = Error; 193 194 fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error> 195 where 196 V: de::Visitor<'de>, 197 { 198 match self.0 { 199 Cow::Borrowed(value) => visitor.visit_borrowed_str(value), 200 Cow::Owned(value) => visitor.visit_string(value), 201 } 202 } 203 204 fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Self::Error> 205 where 206 V: de::Visitor<'de>, 207 { 208 visitor.visit_some(self) 209 } 210 211 fn deserialize_enum<V>( 212 self, 213 _name: &'static str, 214 _variants: &'static [&'static str], 215 visitor: V, 216 ) -> Result<V::Value, Self::Error> 217 where 218 V: de::Visitor<'de>, 219 { 220 visitor.visit_enum(ValueEnumAccess(self.0)) 221 } 222 223 fn deserialize_newtype_struct<V>( 224 self, 225 _name: &'static str, 226 visitor: V, 227 ) -> Result<V::Value, Self::Error> 228 where 229 V: de::Visitor<'de>, 230 { 231 visitor.visit_newtype_struct(self) 232 } 233 234 forward_to_deserialize_any! { 235 char 236 str 237 string 238 unit 239 bytes 240 byte_buf 241 unit_struct 242 tuple_struct 243 struct 244 identifier 245 tuple 246 ignored_any 247 seq 248 map 249 } 250 251 forward_parsed_value! { 252 bool => deserialize_bool, 253 u8 => deserialize_u8, 254 u16 => deserialize_u16, 255 u32 => deserialize_u32, 256 u64 => deserialize_u64, 257 i8 => deserialize_i8, 258 i16 => deserialize_i16, 259 i32 => deserialize_i32, 260 i64 => deserialize_i64, 261 f32 => deserialize_f32, 262 f64 => deserialize_f64, 263 } 264 } 265 266 struct ValueEnumAccess<'de>(Cow<'de, str>); 267 268 impl<'de> de::EnumAccess<'de> for ValueEnumAccess<'de> { 269 type Error = Error; 270 type Variant = UnitOnlyVariantAccess; 271 272 fn variant_seed<V>( 273 self, 274 seed: V, 275 ) -> Result<(V::Value, Self::Variant), Self::Error> 276 where 277 V: de::DeserializeSeed<'de>, 278 { 279 let variant = seed.deserialize(self.0.into_deserializer())?; 280 Ok((variant, UnitOnlyVariantAccess)) 281 } 282 } 283 284 struct UnitOnlyVariantAccess; 285 286 impl<'de> de::VariantAccess<'de> for UnitOnlyVariantAccess { 287 type Error = Error; 288 289 fn unit_variant(self) -> Result<(), Self::Error> { 290 Ok(()) 291 } 292 293 fn newtype_variant_seed<T>(self, _seed: T) -> Result<T::Value, Self::Error> 294 where 295 T: de::DeserializeSeed<'de>, 296 { 297 Err(Error::custom("expected unit variant")) 298 } 299 300 fn tuple_variant<V>( 301 self, 302 _len: usize, 303 _visitor: V, 304 ) -> Result<V::Value, Self::Error> 305 where 306 V: de::Visitor<'de>, 307 { 308 Err(Error::custom("expected unit variant")) 309 } 310 311 fn struct_variant<V>( 312 self, 313 _fields: &'static [&'static str], 314 _visitor: V, 315 ) -> Result<V::Value, Self::Error> 316 where 317 V: de::Visitor<'de>, 318 { 319 Err(Error::custom("expected unit variant")) 320 } 321 } 322