liquid_value/
ser.rs

1use std::fmt;
2
3use num_traits;
4use serde::ser::Impossible;
5use serde::{self, Serialize};
6
7use super::Object;
8use super::Value;
9use crate::error;
10
11/// Convert a `T` into `liquid_value:Value`.
12///
13/// # Examples
14///
15/// ```rust
16/// let s = "foo";
17/// let value = liquid_value::to_value(s).unwrap();
18/// assert_eq!(value, liquid_value::Value::scalar(s));
19/// ```
20pub fn to_value<T>(value: T) -> Result<Value, error::Error>
21where
22    T: Serialize,
23{
24    value.serialize(Serializer).map_err(|e| e.0)
25}
26
27#[derive(Debug)]
28struct SerError(error::Error);
29
30impl fmt::Display for SerError {
31    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
32        writeln!(f, "{}", self.0)
33    }
34}
35
36impl ::std::error::Error for SerError {
37    fn description(&self) -> &str {
38        self.0.description()
39    }
40
41    fn source(&self) -> Option<&(dyn (::std::error::Error) + 'static)> {
42        ::std::error::Error::source(&self.0)
43    }
44}
45
46impl serde::ser::Error for SerError {
47    fn custom<T>(msg: T) -> Self
48    where
49        T: fmt::Display,
50    {
51        SerError(error::Error::with_msg(format!("{}", msg)))
52    }
53}
54
55struct Serializer;
56
57impl Serializer {
58    #[inline]
59    fn serialize_as_i32<T: num_traits::cast::NumCast>(self, value: T) -> Result<Value, SerError> {
60        let value = num_traits::cast::cast::<T, i32>(value)
61            .ok_or_else(|| SerError(error::Error::with_msg("Cannot fit number")))?;
62        Ok(Value::scalar(value))
63    }
64}
65
66impl serde::Serializer for Serializer {
67    type Ok = Value;
68    type Error = SerError;
69
70    type SerializeSeq = SerializeVec;
71    type SerializeTuple = SerializeVec;
72    type SerializeTupleStruct = SerializeVec;
73    type SerializeTupleVariant = SerializeTupleVariant;
74    type SerializeMap = SerializeMap;
75    type SerializeStruct = SerializeMap;
76    type SerializeStructVariant = SerializeStructVariant;
77
78    #[inline]
79    fn serialize_bool(self, value: bool) -> Result<Value, SerError> {
80        Ok(Value::scalar(value))
81    }
82
83    #[inline]
84    fn serialize_i8(self, value: i8) -> Result<Value, SerError> {
85        self.serialize_as_i32(value)
86    }
87
88    #[inline]
89    fn serialize_i16(self, value: i16) -> Result<Value, SerError> {
90        self.serialize_as_i32(value)
91    }
92
93    #[inline]
94    fn serialize_i32(self, value: i32) -> Result<Value, SerError> {
95        Ok(Value::scalar(value))
96    }
97
98    fn serialize_i64(self, value: i64) -> Result<Value, SerError> {
99        self.serialize_as_i32(value)
100    }
101
102    #[inline]
103    fn serialize_u8(self, value: u8) -> Result<Value, SerError> {
104        self.serialize_as_i32(value)
105    }
106
107    #[inline]
108    fn serialize_u16(self, value: u16) -> Result<Value, SerError> {
109        self.serialize_as_i32(value)
110    }
111
112    #[inline]
113    fn serialize_u32(self, value: u32) -> Result<Value, SerError> {
114        self.serialize_as_i32(value)
115    }
116
117    #[inline]
118    fn serialize_u64(self, value: u64) -> Result<Value, SerError> {
119        self.serialize_as_i32(value)
120    }
121
122    #[inline]
123    fn serialize_f32(self, value: f32) -> Result<Value, SerError> {
124        self.serialize_f64(f64::from(value))
125    }
126
127    #[inline]
128    fn serialize_f64(self, value: f64) -> Result<Value, SerError> {
129        Ok(Value::scalar(value))
130    }
131
132    #[inline]
133    fn serialize_char(self, value: char) -> Result<Value, SerError> {
134        let mut s = String::new();
135        s.push(value);
136        self.serialize_str(&s)
137    }
138
139    #[inline]
140    fn serialize_str(self, value: &str) -> Result<Value, SerError> {
141        Ok(Value::scalar(value.to_owned()))
142    }
143
144    fn serialize_bytes(self, value: &[u8]) -> Result<Value, SerError> {
145        let vec = value.iter().map(|&b| Value::scalar(i32::from(b))).collect();
146        Ok(Value::Array(vec))
147    }
148
149    #[inline]
150    fn serialize_unit(self) -> Result<Value, SerError> {
151        Ok(Value::Nil)
152    }
153
154    #[inline]
155    fn serialize_unit_struct(self, _name: &'static str) -> Result<Value, SerError> {
156        self.serialize_unit()
157    }
158
159    #[inline]
160    fn serialize_unit_variant(
161        self,
162        _name: &'static str,
163        _variant_index: u32,
164        variant: &'static str,
165    ) -> Result<Value, SerError> {
166        self.serialize_str(variant)
167    }
168
169    #[inline]
170    fn serialize_newtype_struct<T: ?Sized>(
171        self,
172        _name: &'static str,
173        value: &T,
174    ) -> Result<Value, SerError>
175    where
176        T: Serialize,
177    {
178        value.serialize(Serializer)
179    }
180
181    fn serialize_newtype_variant<T: ?Sized>(
182        self,
183        _name: &'static str,
184        _variant_index: u32,
185        variant: &'static str,
186        value: &T,
187    ) -> Result<Value, SerError>
188    where
189        T: Serialize,
190    {
191        let mut values = Object::new();
192        values.insert(String::from(variant).into(), value.serialize(Serializer)?);
193        Ok(Value::Object(values))
194    }
195
196    #[inline]
197    fn serialize_none(self) -> Result<Value, SerError> {
198        self.serialize_unit()
199    }
200
201    #[inline]
202    fn serialize_some<T: ?Sized>(self, value: &T) -> Result<Value, SerError>
203    where
204        T: Serialize,
205    {
206        value.serialize(Serializer)
207    }
208
209    fn serialize_seq(self, len: Option<usize>) -> Result<Self::SerializeSeq, SerError> {
210        Ok(SerializeVec {
211            vec: Vec::with_capacity(len.unwrap_or(0)),
212        })
213    }
214
215    fn serialize_tuple(self, len: usize) -> Result<Self::SerializeTuple, SerError> {
216        self.serialize_seq(Some(len))
217    }
218
219    fn serialize_tuple_struct(
220        self,
221        _name: &'static str,
222        len: usize,
223    ) -> Result<Self::SerializeTupleStruct, SerError> {
224        Ok(SerializeVec {
225            vec: Vec::with_capacity(len),
226        })
227    }
228
229    fn serialize_tuple_variant(
230        self,
231        _name: &'static str,
232        _variant_index: u32,
233        variant: &'static str,
234        len: usize,
235    ) -> Result<Self::SerializeTupleVariant, SerError> {
236        Ok(SerializeTupleVariant {
237            name: String::from(variant),
238            vec: Vec::with_capacity(len),
239        })
240    }
241
242    fn serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap, SerError> {
243        Ok(SerializeMap::Map {
244            map: Object::new(),
245            next_key: None,
246        })
247    }
248
249    fn serialize_struct(
250        self,
251        _name: &'static str,
252        len: usize,
253    ) -> Result<Self::SerializeStruct, SerError> {
254        self.serialize_map(Some(len))
255    }
256
257    fn serialize_struct_variant(
258        self,
259        _name: &'static str,
260        _variant_index: u32,
261        variant: &'static str,
262        _len: usize,
263    ) -> Result<Self::SerializeStructVariant, SerError> {
264        Ok(SerializeStructVariant {
265            name: String::from(variant),
266            map: Object::new(),
267        })
268    }
269}
270
271struct SerializeVec {
272    vec: Vec<Value>,
273}
274
275struct SerializeTupleVariant {
276    name: String,
277    vec: Vec<Value>,
278}
279
280enum SerializeMap {
281    Map {
282        map: Object,
283        next_key: Option<String>,
284    },
285}
286
287struct SerializeStructVariant {
288    name: String,
289    map: Object,
290}
291
292impl serde::ser::SerializeSeq for SerializeVec {
293    type Ok = Value;
294    type Error = SerError;
295
296    fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<(), SerError>
297    where
298        T: Serialize,
299    {
300        self.vec.push(value.serialize(Serializer)?);
301        Ok(())
302    }
303
304    fn end(self) -> Result<Value, SerError> {
305        Ok(Value::Array(self.vec))
306    }
307}
308
309impl serde::ser::SerializeTuple for SerializeVec {
310    type Ok = Value;
311    type Error = SerError;
312
313    fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<(), SerError>
314    where
315        T: Serialize,
316    {
317        serde::ser::SerializeSeq::serialize_element(self, value)
318    }
319
320    fn end(self) -> Result<Value, SerError> {
321        serde::ser::SerializeSeq::end(self)
322    }
323}
324
325impl serde::ser::SerializeTupleStruct for SerializeVec {
326    type Ok = Value;
327    type Error = SerError;
328
329    fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<(), SerError>
330    where
331        T: Serialize,
332    {
333        serde::ser::SerializeSeq::serialize_element(self, value)
334    }
335
336    fn end(self) -> Result<Value, SerError> {
337        serde::ser::SerializeSeq::end(self)
338    }
339}
340
341impl serde::ser::SerializeTupleVariant for SerializeTupleVariant {
342    type Ok = Value;
343    type Error = SerError;
344
345    fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<(), SerError>
346    where
347        T: Serialize,
348    {
349        self.vec.push(value.serialize(Serializer)?);
350        Ok(())
351    }
352
353    fn end(self) -> Result<Value, SerError> {
354        let mut object = Object::new();
355
356        object.insert(self.name.into(), Value::Array(self.vec));
357
358        Ok(Value::Object(object))
359    }
360}
361
362impl serde::ser::SerializeMap for SerializeMap {
363    type Ok = Value;
364    type Error = SerError;
365
366    fn serialize_key<T: ?Sized>(&mut self, key: &T) -> Result<(), SerError>
367    where
368        T: Serialize,
369    {
370        match *self {
371            SerializeMap::Map {
372                ref mut next_key, ..
373            } => {
374                *next_key = Some(r#try!(key.serialize(MapKeySerializer)));
375                Ok(())
376            }
377        }
378    }
379
380    fn serialize_value<T: ?Sized>(&mut self, value: &T) -> Result<(), SerError>
381    where
382        T: Serialize,
383    {
384        match *self {
385            SerializeMap::Map {
386                ref mut map,
387                ref mut next_key,
388            } => {
389                let key = next_key.take();
390                // Panic because this indicates a bug in the program rather than an
391                // expected failure.
392                let key = key.expect("serialize_value called before serialize_key");
393                map.insert(key.into(), value.serialize(Serializer)?);
394                Ok(())
395            }
396        }
397    }
398
399    fn end(self) -> Result<Value, SerError> {
400        match self {
401            SerializeMap::Map { map, .. } => Ok(Value::Object(map)),
402        }
403    }
404}
405
406struct MapKeySerializer;
407
408fn key_must_be_a_string() -> SerError {
409    SerError(error::Error::with_msg("Key must be a string."))
410}
411
412impl serde::Serializer for MapKeySerializer {
413    type Ok = String;
414    type Error = SerError;
415
416    type SerializeSeq = Impossible<String, SerError>;
417    type SerializeTuple = Impossible<String, SerError>;
418    type SerializeTupleStruct = Impossible<String, SerError>;
419    type SerializeTupleVariant = Impossible<String, SerError>;
420    type SerializeMap = Impossible<String, SerError>;
421    type SerializeStruct = Impossible<String, SerError>;
422    type SerializeStructVariant = Impossible<String, SerError>;
423
424    #[inline]
425    fn serialize_unit_variant(
426        self,
427        _name: &'static str,
428        _variant_index: u32,
429        variant: &'static str,
430    ) -> Result<Self::Ok, Self::Error> {
431        Ok(variant.to_owned())
432    }
433
434    #[inline]
435    fn serialize_newtype_struct<T: ?Sized>(
436        self,
437        _name: &'static str,
438        value: &T,
439    ) -> Result<Self::Ok, Self::Error>
440    where
441        T: Serialize,
442    {
443        value.serialize(self)
444    }
445
446    fn serialize_bool(self, _value: bool) -> Result<Self::Ok, Self::Error> {
447        Err(key_must_be_a_string())
448    }
449
450    fn serialize_i8(self, value: i8) -> Result<Self::Ok, Self::Error> {
451        Ok(value.to_string())
452    }
453
454    fn serialize_i16(self, value: i16) -> Result<Self::Ok, Self::Error> {
455        Ok(value.to_string())
456    }
457
458    fn serialize_i32(self, value: i32) -> Result<Self::Ok, Self::Error> {
459        Ok(value.to_string())
460    }
461
462    fn serialize_i64(self, value: i64) -> Result<Self::Ok, Self::Error> {
463        Ok(value.to_string())
464    }
465
466    fn serialize_u8(self, value: u8) -> Result<Self::Ok, Self::Error> {
467        Ok(value.to_string())
468    }
469
470    fn serialize_u16(self, value: u16) -> Result<Self::Ok, Self::Error> {
471        Ok(value.to_string())
472    }
473
474    fn serialize_u32(self, value: u32) -> Result<Self::Ok, Self::Error> {
475        Ok(value.to_string())
476    }
477
478    fn serialize_u64(self, value: u64) -> Result<Self::Ok, Self::Error> {
479        Ok(value.to_string())
480    }
481
482    fn serialize_f32(self, _value: f32) -> Result<Self::Ok, Self::Error> {
483        Err(key_must_be_a_string())
484    }
485
486    fn serialize_f64(self, _value: f64) -> Result<Self::Ok, Self::Error> {
487        Err(key_must_be_a_string())
488    }
489
490    #[inline]
491    fn serialize_char(self, value: char) -> Result<Self::Ok, Self::Error> {
492        Ok({
493            let mut s = String::new();
494            s.push(value);
495            s
496        })
497    }
498
499    #[inline]
500    fn serialize_str(self, value: &str) -> Result<Self::Ok, Self::Error> {
501        Ok(value.to_owned())
502    }
503
504    fn serialize_bytes(self, _value: &[u8]) -> Result<Self::Ok, Self::Error> {
505        Err(key_must_be_a_string())
506    }
507
508    fn serialize_unit(self) -> Result<Self::Ok, Self::Error> {
509        Err(key_must_be_a_string())
510    }
511
512    fn serialize_unit_struct(self, _name: &'static str) -> Result<Self::Ok, Self::Error> {
513        Err(key_must_be_a_string())
514    }
515
516    fn serialize_newtype_variant<T: ?Sized>(
517        self,
518        _name: &'static str,
519        _variant_index: u32,
520        _variant: &'static str,
521        _value: &T,
522    ) -> Result<Self::Ok, Self::Error>
523    where
524        T: Serialize,
525    {
526        Err(key_must_be_a_string())
527    }
528
529    fn serialize_none(self) -> Result<Self::Ok, Self::Error> {
530        Err(key_must_be_a_string())
531    }
532
533    fn serialize_some<T: ?Sized>(self, _value: &T) -> Result<Self::Ok, Self::Error>
534    where
535        T: Serialize,
536    {
537        Err(key_must_be_a_string())
538    }
539
540    fn serialize_seq(self, _len: Option<usize>) -> Result<Self::SerializeSeq, Self::Error> {
541        Err(key_must_be_a_string())
542    }
543
544    fn serialize_tuple(self, _len: usize) -> Result<Self::SerializeTuple, Self::Error> {
545        Err(key_must_be_a_string())
546    }
547
548    fn serialize_tuple_struct(
549        self,
550        _name: &'static str,
551        _len: usize,
552    ) -> Result<Self::SerializeTupleStruct, Self::Error> {
553        Err(key_must_be_a_string())
554    }
555
556    fn serialize_tuple_variant(
557        self,
558        _name: &'static str,
559        _variant_index: u32,
560        _variant: &'static str,
561        _len: usize,
562    ) -> Result<Self::SerializeTupleVariant, Self::Error> {
563        Err(key_must_be_a_string())
564    }
565
566    fn serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap, Self::Error> {
567        Err(key_must_be_a_string())
568    }
569
570    fn serialize_struct(
571        self,
572        _name: &'static str,
573        _len: usize,
574    ) -> Result<Self::SerializeStruct, Self::Error> {
575        Err(key_must_be_a_string())
576    }
577
578    fn serialize_struct_variant(
579        self,
580        _name: &'static str,
581        _variant_index: u32,
582        _variant: &'static str,
583        _len: usize,
584    ) -> Result<Self::SerializeStructVariant, Self::Error> {
585        Err(key_must_be_a_string())
586    }
587}
588
589impl serde::ser::SerializeStruct for SerializeMap {
590    type Ok = Value;
591    type Error = SerError;
592
593    fn serialize_field<T: ?Sized>(&mut self, key: &'static str, value: &T) -> Result<(), SerError>
594    where
595        T: Serialize,
596    {
597        match *self {
598            SerializeMap::Map { .. } => {
599                r#try!(serde::ser::SerializeMap::serialize_key(self, key));
600                serde::ser::SerializeMap::serialize_value(self, value)
601            }
602        }
603    }
604
605    fn end(self) -> Result<Value, SerError> {
606        match self {
607            SerializeMap::Map { .. } => serde::ser::SerializeMap::end(self),
608        }
609    }
610}
611
612impl serde::ser::SerializeStructVariant for SerializeStructVariant {
613    type Ok = Value;
614    type Error = SerError;
615
616    fn serialize_field<T: ?Sized>(&mut self, key: &'static str, value: &T) -> Result<(), SerError>
617    where
618        T: Serialize,
619    {
620        self.map
621            .insert(String::from(key).into(), value.serialize(Serializer)?);
622        Ok(())
623    }
624
625    fn end(self) -> Result<Value, SerError> {
626        let mut object = Object::new();
627
628        object.insert(self.name.into(), Value::Object(self.map));
629
630        Ok(Value::Object(object))
631    }
632}
liquid_value/ser.rs

liquid_value/
ser.rs
