serde_html_form/
ser.rs

1//! Serialization support for the `application/x-www-form-urlencoded` format.
2
3mod error;
4mod key;
5mod pair;
6mod part;
7mod value;
8
9use std::{borrow::Cow, str};
10
11use form_urlencoded::{Serializer as UrlEncodedSerializer, Target as UrlEncodedTarget};
12use serde::ser;
13
14pub use self::error::Error;
15
16/// Serializes a value into a `application/x-www-form-urlencoded` `String` buffer.
17///
18/// ```
19/// let meal = &[("bread", "baguette"), ("cheese", "comté"), ("meat", "ham"), ("fat", "butter")];
20///
21/// assert_eq!(
22///     serde_html_form::to_string(meal),
23///     Ok("bread=baguette&cheese=comt%C3%A9&meat=ham&fat=butter".to_owned())
24/// );
25/// ```
26pub fn to_string<T: ser::Serialize>(input: T) -> Result<String, Error> {
27    let mut target = String::new();
28    push_to_string(&mut target, input)?;
29    Ok(target)
30}
31
32/// Serializes a value into the provided `application/x-www-form-urlencoded` `String` buffer.
33///
34/// ```
35/// let meal = &[("bread", "baguette"), ("cheese", "comté"), ("meat", "ham"), ("fat", "butter")];
36///
37/// let mut target = "/cook?".to_owned();
38///
39/// serde_html_form::ser::push_to_string(&mut target, meal).unwrap();
40///
41/// assert_eq!(target, "/cook?bread=baguette&cheese=comt%C3%A9&meat=ham&fat=butter");
42/// ```
43pub fn push_to_string<T: ser::Serialize>(target: &mut String, input: T) -> Result<(), Error> {
44    let start_position = target.len();
45    let mut urlencoder = UrlEncodedSerializer::for_suffix(target, start_position);
46    input.serialize(Serializer::new(&mut urlencoder))?;
47    urlencoder.finish();
48    Ok(())
49}
50
51/// A serializer for the `application/x-www-form-urlencoded` format.
52///
53/// * Supported top-level inputs are structs, maps and sequences of pairs,
54///   with or without a given length.
55///
56/// * Supported keys and values are integers, bytes (if convertible to strings),
57///   unit structs and unit variants.
58///
59/// * Newtype structs defer to their inner values.
60pub struct Serializer<'input, 'output, Target: UrlEncodedTarget> {
61    urlencoder: &'output mut UrlEncodedSerializer<'input, Target>,
62}
63
64impl<'input, 'output, Target: 'output + UrlEncodedTarget> Serializer<'input, 'output, Target> {
65    /// Returns a new `Serializer`.
66    pub fn new(urlencoder: &'output mut UrlEncodedSerializer<'input, Target>) -> Self {
67        Serializer { urlencoder }
68    }
69}
70
71/// Sequence serializer.
72pub struct SeqSerializer<'input, 'output, Target: UrlEncodedTarget> {
73    urlencoder: &'output mut UrlEncodedSerializer<'input, Target>,
74}
75
76/// Tuple serializer.
77///
78/// Mostly used for arrays.
79pub struct TupleSerializer<'input, 'output, Target: UrlEncodedTarget> {
80    urlencoder: &'output mut UrlEncodedSerializer<'input, Target>,
81}
82
83/// Tuple struct serializer.
84///
85/// Never instantiated, tuple structs are not supported.
86pub struct TupleStructSerializer<'input, 'output, T: UrlEncodedTarget> {
87    inner: ser::Impossible<&'output mut UrlEncodedSerializer<'input, T>, Error>,
88}
89
90/// Tuple variant serializer.
91///
92/// Never instantiated, tuple variants are not supported.
93pub struct TupleVariantSerializer<'input, 'output, T: UrlEncodedTarget> {
94    inner: ser::Impossible<&'output mut UrlEncodedSerializer<'input, T>, Error>,
95}
96
97/// Map serializer.
98pub struct MapSerializer<'input, 'output, Target: UrlEncodedTarget> {
99    urlencoder: &'output mut UrlEncodedSerializer<'input, Target>,
100    key: Option<Cow<'static, str>>,
101}
102
103/// Struct serializer.
104pub struct StructSerializer<'input, 'output, Target: UrlEncodedTarget> {
105    urlencoder: &'output mut UrlEncodedSerializer<'input, Target>,
106}
107
108/// Struct variant serializer.
109///
110/// Never instantiated, struct variants are not supported.
111pub struct StructVariantSerializer<'input, 'output, T: UrlEncodedTarget> {
112    inner: ser::Impossible<&'output mut UrlEncodedSerializer<'input, T>, Error>,
113}
114
115impl<'input, 'output, Target> ser::Serializer for Serializer<'input, 'output, Target>
116where
117    Target: 'output + UrlEncodedTarget,
118{
119    type Ok = &'output mut UrlEncodedSerializer<'input, Target>;
120    type Error = Error;
121    type SerializeSeq = SeqSerializer<'input, 'output, Target>;
122    type SerializeTuple = TupleSerializer<'input, 'output, Target>;
123    type SerializeTupleStruct = TupleStructSerializer<'input, 'output, Target>;
124    type SerializeTupleVariant = TupleVariantSerializer<'input, 'output, Target>;
125    type SerializeMap = MapSerializer<'input, 'output, Target>;
126    type SerializeStruct = StructSerializer<'input, 'output, Target>;
127    type SerializeStructVariant = StructVariantSerializer<'input, 'output, Target>;
128
129    /// Returns an error.
130    fn serialize_bool(self, _v: bool) -> Result<Self::Ok, Error> {
131        Err(Error::top_level())
132    }
133
134    /// Returns an error.
135    fn serialize_i8(self, _v: i8) -> Result<Self::Ok, Error> {
136        Err(Error::top_level())
137    }
138
139    /// Returns an error.
140    fn serialize_i16(self, _v: i16) -> Result<Self::Ok, Error> {
141        Err(Error::top_level())
142    }
143
144    /// Returns an error.
145    fn serialize_i32(self, _v: i32) -> Result<Self::Ok, Error> {
146        Err(Error::top_level())
147    }
148
149    /// Returns an error.
150    fn serialize_i64(self, _v: i64) -> Result<Self::Ok, Error> {
151        Err(Error::top_level())
152    }
153
154    /// Returns an error.
155    fn serialize_u8(self, _v: u8) -> Result<Self::Ok, Error> {
156        Err(Error::top_level())
157    }
158
159    /// Returns an error.
160    fn serialize_u16(self, _v: u16) -> Result<Self::Ok, Error> {
161        Err(Error::top_level())
162    }
163
164    /// Returns an error.
165    fn serialize_u32(self, _v: u32) -> Result<Self::Ok, Error> {
166        Err(Error::top_level())
167    }
168
169    /// Returns an error.
170    fn serialize_u64(self, _v: u64) -> Result<Self::Ok, Error> {
171        Err(Error::top_level())
172    }
173
174    /// Returns an error.
175    fn serialize_f32(self, _v: f32) -> Result<Self::Ok, Error> {
176        Err(Error::top_level())
177    }
178
179    /// Returns an error.
180    fn serialize_f64(self, _v: f64) -> Result<Self::Ok, Error> {
181        Err(Error::top_level())
182    }
183
184    /// Returns an error.
185    fn serialize_char(self, _v: char) -> Result<Self::Ok, Error> {
186        Err(Error::top_level())
187    }
188
189    /// Returns an error.
190    fn serialize_str(self, _value: &str) -> Result<Self::Ok, Error> {
191        Err(Error::top_level())
192    }
193
194    /// Returns an error.
195    fn serialize_bytes(self, _value: &[u8]) -> Result<Self::Ok, Error> {
196        Err(Error::top_level())
197    }
198
199    /// Returns `Ok`.
200    fn serialize_unit(self) -> Result<Self::Ok, Error> {
201        Ok(self.urlencoder)
202    }
203
204    /// Returns `Ok`.
205    fn serialize_unit_struct(self, _name: &'static str) -> Result<Self::Ok, Error> {
206        Ok(self.urlencoder)
207    }
208
209    /// Returns an error.
210    fn serialize_unit_variant(
211        self,
212        _name: &'static str,
213        _variant_index: u32,
214        _variant: &'static str,
215    ) -> Result<Self::Ok, Error> {
216        Err(Error::top_level())
217    }
218
219    /// Serializes the inner value, ignoring the newtype name.
220    fn serialize_newtype_struct<T: ?Sized + ser::Serialize>(
221        self,
222        _name: &'static str,
223        value: &T,
224    ) -> Result<Self::Ok, Error> {
225        value.serialize(self)
226    }
227
228    /// Returns an error.
229    fn serialize_newtype_variant<T: ?Sized + ser::Serialize>(
230        self,
231        _name: &'static str,
232        _variant_index: u32,
233        _variant: &'static str,
234        _value: &T,
235    ) -> Result<Self::Ok, Error> {
236        Err(Error::top_level())
237    }
238
239    /// Returns `Ok`.
240    fn serialize_none(self) -> Result<Self::Ok, Error> {
241        Ok(self.urlencoder)
242    }
243
244    /// Serializes the given value.
245    fn serialize_some<T: ?Sized + ser::Serialize>(self, value: &T) -> Result<Self::Ok, Error> {
246        value.serialize(self)
247    }
248
249    /// Serialize a sequence, given length (if any) is ignored.
250    fn serialize_seq(self, _len: Option<usize>) -> Result<Self::SerializeSeq, Error> {
251        Ok(SeqSerializer { urlencoder: self.urlencoder })
252    }
253
254    /// Returns an error.
255    fn serialize_tuple(self, _len: usize) -> Result<Self::SerializeTuple, Error> {
256        Ok(TupleSerializer { urlencoder: self.urlencoder })
257    }
258
259    /// Returns an error.
260    fn serialize_tuple_struct(
261        self,
262        _name: &'static str,
263        _len: usize,
264    ) -> Result<Self::SerializeTupleStruct, Error> {
265        Err(Error::top_level())
266    }
267
268    /// Returns an error.
269    fn serialize_tuple_variant(
270        self,
271        _name: &'static str,
272        _variant_index: u32,
273        _variant: &'static str,
274        _len: usize,
275    ) -> Result<Self::SerializeTupleVariant, Error> {
276        Err(Error::top_level())
277    }
278
279    /// Serializes a map, given length is ignored.
280    fn serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap, Error> {
281        Ok(MapSerializer { urlencoder: self.urlencoder, key: None })
282    }
283
284    /// Serializes a struct, given length is ignored.
285    fn serialize_struct(
286        self,
287        _name: &'static str,
288        _len: usize,
289    ) -> Result<Self::SerializeStruct, Error> {
290        Ok(StructSerializer { urlencoder: self.urlencoder })
291    }
292
293    /// Returns an error.
294    fn serialize_struct_variant(
295        self,
296        _name: &'static str,
297        _variant_index: u32,
298        _variant: &'static str,
299        _len: usize,
300    ) -> Result<Self::SerializeStructVariant, Error> {
301        Err(Error::top_level())
302    }
303}
304
305impl<'input, 'output, Target> ser::SerializeSeq for SeqSerializer<'input, 'output, Target>
306where
307    Target: 'output + UrlEncodedTarget,
308{
309    type Ok = &'output mut UrlEncodedSerializer<'input, Target>;
310    type Error = Error;
311
312    fn serialize_element<T: ?Sized + ser::Serialize>(&mut self, value: &T) -> Result<(), Error> {
313        value.serialize(pair::PairSerializer::new(self.urlencoder))
314    }
315
316    fn end(self) -> Result<Self::Ok, Error> {
317        Ok(self.urlencoder)
318    }
319}
320
321impl<'input, 'output, Target> ser::SerializeTuple for TupleSerializer<'input, 'output, Target>
322where
323    Target: 'output + UrlEncodedTarget,
324{
325    type Ok = &'output mut UrlEncodedSerializer<'input, Target>;
326    type Error = Error;
327
328    fn serialize_element<T: ?Sized + ser::Serialize>(&mut self, value: &T) -> Result<(), Error> {
329        value.serialize(pair::PairSerializer::new(self.urlencoder))
330    }
331
332    fn end(self) -> Result<Self::Ok, Error> {
333        Ok(self.urlencoder)
334    }
335}
336
337impl<'input, 'output, Target> ser::SerializeTupleStruct
338    for TupleStructSerializer<'input, 'output, Target>
339where
340    Target: 'output + UrlEncodedTarget,
341{
342    type Ok = &'output mut UrlEncodedSerializer<'input, Target>;
343    type Error = Error;
344
345    fn serialize_field<T: ?Sized + ser::Serialize>(&mut self, value: &T) -> Result<(), Error> {
346        self.inner.serialize_field(value)
347    }
348
349    fn end(self) -> Result<Self::Ok, Error> {
350        self.inner.end()
351    }
352}
353
354impl<'input, 'output, Target> ser::SerializeTupleVariant
355    for TupleVariantSerializer<'input, 'output, Target>
356where
357    Target: 'output + UrlEncodedTarget,
358{
359    type Ok = &'output mut UrlEncodedSerializer<'input, Target>;
360    type Error = Error;
361
362    fn serialize_field<T: ?Sized + ser::Serialize>(&mut self, value: &T) -> Result<(), Error> {
363        self.inner.serialize_field(value)
364    }
365
366    fn end(self) -> Result<Self::Ok, Error> {
367        self.inner.end()
368    }
369}
370
371impl<'input, 'output, Target> ser::SerializeMap for MapSerializer<'input, 'output, Target>
372where
373    Target: 'output + UrlEncodedTarget,
374{
375    type Ok = &'output mut UrlEncodedSerializer<'input, Target>;
376    type Error = Error;
377
378    fn serialize_entry<K: ?Sized + ser::Serialize, V: ?Sized + ser::Serialize>(
379        &mut self,
380        key: &K,
381        value: &V,
382    ) -> Result<(), Error> {
383        let key_sink = key::KeySink::new(|key| {
384            let value_sink = value::ValueSink::new(self.urlencoder, &key);
385            value.serialize(part::PartSerializer::new(value_sink))?;
386            self.key = None;
387            Ok(())
388        });
389        let entry_serializer = part::PartSerializer::new(key_sink);
390        key.serialize(entry_serializer)
391    }
392
393    fn serialize_key<T: ?Sized + ser::Serialize>(&mut self, key: &T) -> Result<(), Error> {
394        let key_sink = key::KeySink::new(|key| Ok(key.into()));
395        let key_serializer = part::PartSerializer::new(key_sink);
396        self.key = Some(key.serialize(key_serializer)?);
397        Ok(())
398    }
399
400    fn serialize_value<T: ?Sized + ser::Serialize>(&mut self, value: &T) -> Result<(), Error> {
401        {
402            let key = self.key.as_ref().ok_or_else(Error::no_key)?;
403            let value_sink = value::ValueSink::new(self.urlencoder, key);
404            value.serialize(part::PartSerializer::new(value_sink))?;
405        }
406        self.key = None;
407        Ok(())
408    }
409
410    fn end(self) -> Result<Self::Ok, Error> {
411        Ok(self.urlencoder)
412    }
413}
414
415impl<'input, 'output, Target> ser::SerializeStruct for StructSerializer<'input, 'output, Target>
416where
417    Target: 'output + UrlEncodedTarget,
418{
419    type Ok = &'output mut UrlEncodedSerializer<'input, Target>;
420    type Error = Error;
421
422    fn serialize_field<T: ?Sized + ser::Serialize>(
423        &mut self,
424        key: &'static str,
425        value: &T,
426    ) -> Result<(), Error> {
427        let value_sink = value::ValueSink::new(self.urlencoder, key);
428        value.serialize(part::PartSerializer::new(value_sink))
429    }
430
431    fn end(self) -> Result<Self::Ok, Error> {
432        Ok(self.urlencoder)
433    }
434}
435
436impl<'input, 'output, Target> ser::SerializeStructVariant
437    for StructVariantSerializer<'input, 'output, Target>
438where
439    Target: 'output + UrlEncodedTarget,
440{
441    type Ok = &'output mut UrlEncodedSerializer<'input, Target>;
442    type Error = Error;
443
444    fn serialize_field<T: ?Sized + ser::Serialize>(
445        &mut self,
446        key: &'static str,
447        value: &T,
448    ) -> Result<(), Error> {
449        self.inner.serialize_field(key, value)
450    }
451
452    fn end(self) -> Result<Self::Ok, Error> {
453        self.inner.end()
454    }
455}
456
457#[cfg(test)]
458mod tests;
serde_html_form/ser.rs

serde_html_form/
ser.rs
