liquid_core/model/value/
ser.rs

1use serde::{self, de::IntoDeserializer, Deserialize, Serialize};
2
3use super::{Value, ValueView};
4use crate::model::scalar::ser::ScalarSerializer;
5use crate::model::ser::{SerError, SerializeMap, SerializeStructVariant, SerializeTupleVariant};
6use crate::model::Object;
7use crate::model::{ArrayView, ObjectView};
8use crate::model::{KString, KStringCow};
9
10/// Convert a `T` into `liquid_core::model::Value`.
11///
12/// # Examples
13///
14/// ```rust
15/// let s = "foo";
16/// let value = liquid_core::model::to_value(&s).unwrap();
17/// assert_eq!(value, liquid_core::model::Value::scalar(s));
18/// ```
19pub fn to_value<T>(value: &T) -> Result<Value, crate::error::Error>
20where
21    T: Serialize,
22{
23    value.serialize(ValueSerializer).map_err(|e| e.into())
24}
25
26/// Convert a value into `T`.
27pub fn from_value<'a, T>(v: &'a dyn ValueView) -> Result<T, crate::error::Error>
28where
29    T: Deserialize<'a>,
30{
31    let mut deserializer = ValueDeserializer::from_value(v);
32    T::deserialize(&mut deserializer).map_err(|e| e.into())
33}
34
35pub(crate) struct ValueSerializer;
36
37impl serde::Serializer for ValueSerializer {
38    type Ok = Value;
39    type Error = SerError;
40
41    type SerializeSeq = SerializeVec;
42    type SerializeTuple = SerializeVec;
43    type SerializeTupleStruct = SerializeVec;
44    type SerializeTupleVariant = SerializeTupleVariant<Value>;
45    type SerializeMap = SerializeMap<Value>;
46    type SerializeStruct = SerializeMap<Value>;
47    type SerializeStructVariant = SerializeStructVariant<Value>;
48
49    #[inline]
50    fn serialize_bool(self, value: bool) -> Result<Value, SerError> {
51        ScalarSerializer.serialize_bool(value).map(Value::Scalar)
52    }
53
54    #[inline]
55    fn serialize_i8(self, value: i8) -> Result<Value, SerError> {
56        ScalarSerializer.serialize_i8(value).map(Value::Scalar)
57    }
58
59    #[inline]
60    fn serialize_i16(self, value: i16) -> Result<Value, SerError> {
61        ScalarSerializer.serialize_i16(value).map(Value::Scalar)
62    }
63
64    #[inline]
65    fn serialize_i32(self, value: i32) -> Result<Value, SerError> {
66        ScalarSerializer.serialize_i32(value).map(Value::Scalar)
67    }
68
69    fn serialize_i64(self, value: i64) -> Result<Value, SerError> {
70        ScalarSerializer.serialize_i64(value).map(Value::Scalar)
71    }
72
73    #[inline]
74    fn serialize_u8(self, value: u8) -> Result<Value, SerError> {
75        ScalarSerializer.serialize_u8(value).map(Value::Scalar)
76    }
77
78    #[inline]
79    fn serialize_u16(self, value: u16) -> Result<Value, SerError> {
80        ScalarSerializer.serialize_u16(value).map(Value::Scalar)
81    }
82
83    #[inline]
84    fn serialize_u32(self, value: u32) -> Result<Value, SerError> {
85        ScalarSerializer.serialize_u32(value).map(Value::Scalar)
86    }
87
88    #[inline]
89    fn serialize_u64(self, value: u64) -> Result<Value, SerError> {
90        ScalarSerializer.serialize_u64(value).map(Value::Scalar)
91    }
92
93    #[inline]
94    fn serialize_f32(self, value: f32) -> Result<Value, SerError> {
95        ScalarSerializer.serialize_f32(value).map(Value::Scalar)
96    }
97
98    #[inline]
99    fn serialize_f64(self, value: f64) -> Result<Value, SerError> {
100        ScalarSerializer.serialize_f64(value).map(Value::Scalar)
101    }
102
103    #[inline]
104    fn serialize_char(self, value: char) -> Result<Value, SerError> {
105        ScalarSerializer.serialize_char(value).map(Value::Scalar)
106    }
107
108    #[inline]
109    fn serialize_str(self, value: &str) -> Result<Value, SerError> {
110        ScalarSerializer.serialize_str(value).map(Value::Scalar)
111    }
112
113    fn serialize_bytes(self, value: &[u8]) -> Result<Value, SerError> {
114        let vec = value.iter().map(|&b| Value::scalar(i64::from(b))).collect();
115        Ok(Value::Array(vec))
116    }
117
118    #[inline]
119    fn serialize_unit(self) -> Result<Value, SerError> {
120        Ok(Value::Nil)
121    }
122
123    #[inline]
124    fn serialize_unit_struct(self, _name: &'static str) -> Result<Value, SerError> {
125        self.serialize_unit()
126    }
127
128    #[inline]
129    fn serialize_unit_variant(
130        self,
131        name: &'static str,
132        variant_index: u32,
133        variant: &'static str,
134    ) -> Result<Value, SerError> {
135        ScalarSerializer
136            .serialize_unit_variant(name, variant_index, variant)
137            .map(Value::Scalar)
138    }
139
140    #[inline]
141    fn serialize_newtype_struct<T>(self, _name: &'static str, value: &T) -> Result<Value, SerError>
142    where
143        T: Serialize + ?Sized,
144    {
145        value.serialize(ValueSerializer)
146    }
147
148    fn serialize_newtype_variant<T>(
149        self,
150        _name: &'static str,
151        _variant_index: u32,
152        variant: &'static str,
153        value: &T,
154    ) -> Result<Value, SerError>
155    where
156        T: Serialize + ?Sized,
157    {
158        let mut values = Object::new();
159        values.insert(
160            KString::from_static(variant),
161            value.serialize(ValueSerializer)?,
162        );
163        Ok(Value::Object(values))
164    }
165
166    #[inline]
167    fn serialize_none(self) -> Result<Value, SerError> {
168        self.serialize_unit()
169    }
170
171    #[inline]
172    fn serialize_some<T>(self, value: &T) -> Result<Value, SerError>
173    where
174        T: Serialize + ?Sized,
175    {
176        value.serialize(ValueSerializer)
177    }
178
179    fn serialize_seq(self, len: Option<usize>) -> Result<Self::SerializeSeq, SerError> {
180        Ok(SerializeVec {
181            vec: Vec::with_capacity(len.unwrap_or(0)),
182        })
183    }
184
185    fn serialize_tuple(self, len: usize) -> Result<Self::SerializeTuple, SerError> {
186        self.serialize_seq(Some(len))
187    }
188
189    fn serialize_tuple_struct(
190        self,
191        _name: &'static str,
192        len: usize,
193    ) -> Result<Self::SerializeTupleStruct, SerError> {
194        Ok(SerializeVec {
195            vec: Vec::with_capacity(len),
196        })
197    }
198
199    fn serialize_tuple_variant(
200        self,
201        _name: &'static str,
202        _variant_index: u32,
203        variant: &'static str,
204        len: usize,
205    ) -> Result<Self::SerializeTupleVariant, SerError> {
206        Ok(SerializeTupleVariant {
207            name: KString::from_static(variant),
208            vec: Vec::with_capacity(len),
209            other: std::marker::PhantomData,
210        })
211    }
212
213    fn serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap, SerError> {
214        Ok(SerializeMap::Map {
215            map: Object::new(),
216            next_key: None,
217            other: std::marker::PhantomData,
218        })
219    }
220
221    fn serialize_struct(
222        self,
223        _name: &'static str,
224        len: usize,
225    ) -> Result<Self::SerializeStruct, SerError> {
226        self.serialize_map(Some(len))
227    }
228
229    fn serialize_struct_variant(
230        self,
231        _name: &'static str,
232        _variant_index: u32,
233        variant: &'static str,
234        _len: usize,
235    ) -> Result<Self::SerializeStructVariant, SerError> {
236        Ok(SerializeStructVariant {
237            name: KString::from_static(variant),
238            map: Object::new(),
239            other: std::marker::PhantomData,
240        })
241    }
242}
243
244pub(crate) struct SerializeVec {
245    vec: Vec<Value>,
246}
247
248impl serde::ser::SerializeSeq for SerializeVec {
249    type Ok = Value;
250    type Error = SerError;
251
252    fn serialize_element<T>(&mut self, value: &T) -> Result<(), SerError>
253    where
254        T: Serialize + ?Sized,
255    {
256        self.vec.push(value.serialize(ValueSerializer)?);
257        Ok(())
258    }
259
260    fn end(self) -> Result<Value, SerError> {
261        Ok(Value::Array(self.vec))
262    }
263}
264
265impl serde::ser::SerializeTuple for SerializeVec {
266    type Ok = Value;
267    type Error = SerError;
268
269    fn serialize_element<T>(&mut self, value: &T) -> Result<(), SerError>
270    where
271        T: Serialize + ?Sized,
272    {
273        serde::ser::SerializeSeq::serialize_element(self, value)
274    }
275
276    fn end(self) -> Result<Value, SerError> {
277        serde::ser::SerializeSeq::end(self)
278    }
279}
280
281impl serde::ser::SerializeTupleStruct for SerializeVec {
282    type Ok = Value;
283    type Error = SerError;
284
285    fn serialize_field<T>(&mut self, value: &T) -> Result<(), SerError>
286    where
287        T: Serialize + ?Sized,
288    {
289        serde::ser::SerializeSeq::serialize_element(self, value)
290    }
291
292    fn end(self) -> Result<Value, SerError> {
293        serde::ser::SerializeSeq::end(self)
294    }
295}
296
297#[allow(missing_debug_implementations)]
298pub(crate) struct ValueDeserializer<'de> {
299    input: &'de (dyn ValueView + 'de),
300}
301
302impl<'de> ValueDeserializer<'de> {
303    fn from_value(input: &'de (dyn ValueView + 'de)) -> Self {
304        Self { input }
305    }
306}
307
308impl<'de> serde::Deserializer<'de> for &mut ValueDeserializer<'de> {
309    type Error = SerError;
310
311    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
312    where
313        V: serde::de::Visitor<'de>,
314    {
315        if let Some(scalar) = self.input.as_scalar() {
316            if scalar.to_integer().is_some() {
317                self.deserialize_i64(visitor)
318            } else if scalar.to_float().is_some() {
319                self.deserialize_f64(visitor)
320            } else if scalar.to_bool().is_some() {
321                self.deserialize_bool(visitor)
322            } else {
323                self.deserialize_str(visitor)
324            }
325        } else if self.input.is_array() {
326            self.deserialize_seq(visitor)
327        } else if self.input.is_object() {
328            self.deserialize_map(visitor)
329        } else if self.input.is_state() || self.input.is_nil() {
330            self.deserialize_unit(visitor)
331        } else {
332            Err(SerError::unknown_type(self.input))
333        }
334    }
335
336    fn deserialize_bool<V>(self, visitor: V) -> Result<V::Value, Self::Error>
337    where
338        V: serde::de::Visitor<'de>,
339    {
340        let scalar = self
341            .input
342            .as_scalar()
343            .ok_or_else(|| SerError::invalid_type(self.input, "bool"))?;
344        let v = scalar
345            .to_bool()
346            .ok_or_else(|| SerError::invalid_type(self.input, "bool"))?;
347        visitor.visit_bool(v)
348    }
349
350    fn deserialize_i8<V>(self, visitor: V) -> Result<V::Value, Self::Error>
351    where
352        V: serde::de::Visitor<'de>,
353    {
354        self.deserialize_i64(visitor)
355    }
356    fn deserialize_i16<V>(self, visitor: V) -> Result<V::Value, Self::Error>
357    where
358        V: serde::de::Visitor<'de>,
359    {
360        self.deserialize_i64(visitor)
361    }
362    fn deserialize_i32<V>(self, visitor: V) -> Result<V::Value, Self::Error>
363    where
364        V: serde::de::Visitor<'de>,
365    {
366        self.deserialize_i64(visitor)
367    }
368    fn deserialize_i64<V>(self, visitor: V) -> Result<V::Value, Self::Error>
369    where
370        V: serde::de::Visitor<'de>,
371    {
372        let scalar = self
373            .input
374            .as_scalar()
375            .ok_or_else(|| SerError::invalid_type(self.input, "integer"))?;
376        let v = scalar
377            .to_integer()
378            .ok_or_else(|| SerError::invalid_type(self.input, "integer"))?;
379        visitor.visit_i64(v)
380    }
381    fn deserialize_u8<V>(self, visitor: V) -> Result<V::Value, Self::Error>
382    where
383        V: serde::de::Visitor<'de>,
384    {
385        self.deserialize_i64(visitor)
386    }
387    fn deserialize_u16<V>(self, visitor: V) -> Result<V::Value, Self::Error>
388    where
389        V: serde::de::Visitor<'de>,
390    {
391        self.deserialize_i64(visitor)
392    }
393    fn deserialize_u32<V>(self, visitor: V) -> Result<V::Value, Self::Error>
394    where
395        V: serde::de::Visitor<'de>,
396    {
397        self.deserialize_i64(visitor)
398    }
399    fn deserialize_u64<V>(self, visitor: V) -> Result<V::Value, Self::Error>
400    where
401        V: serde::de::Visitor<'de>,
402    {
403        self.deserialize_i64(visitor)
404    }
405
406    fn deserialize_f32<V>(self, visitor: V) -> Result<V::Value, Self::Error>
407    where
408        V: serde::de::Visitor<'de>,
409    {
410        self.deserialize_f64(visitor)
411    }
412    fn deserialize_f64<V>(self, visitor: V) -> Result<V::Value, Self::Error>
413    where
414        V: serde::de::Visitor<'de>,
415    {
416        let scalar = self
417            .input
418            .as_scalar()
419            .ok_or_else(|| SerError::invalid_type(self.input, "float"))?;
420        let v = scalar
421            .to_float()
422            .ok_or_else(|| SerError::invalid_type(self.input, "float"))?;
423        visitor.visit_f64(v)
424    }
425
426    fn deserialize_char<V>(self, visitor: V) -> Result<V::Value, Self::Error>
427    where
428        V: serde::de::Visitor<'de>,
429    {
430        let s = self.input.to_kstr();
431        if let Some(c) = s.as_str().chars().next() {
432            visitor.visit_char(c)
433        } else {
434            Err(SerError::invalid_type(self.input, "char"))
435        }
436    }
437    fn deserialize_str<V>(self, visitor: V) -> Result<V::Value, Self::Error>
438    where
439        V: serde::de::Visitor<'de>,
440    {
441        let scalar = self
442            .input
443            .as_scalar()
444            .ok_or_else(|| SerError::invalid_type(self.input, "string"))?;
445        match scalar.into_cow_str() {
446            std::borrow::Cow::Borrowed(s) => visitor.visit_borrowed_str(s),
447            std::borrow::Cow::Owned(s) => visitor.visit_string(s),
448        }
449    }
450    fn deserialize_string<V>(self, visitor: V) -> Result<V::Value, Self::Error>
451    where
452        V: serde::de::Visitor<'de>,
453    {
454        self.deserialize_str(visitor)
455    }
456    fn deserialize_bytes<V>(self, _visitor: V) -> Result<V::Value, Self::Error>
457    where
458        V: serde::de::Visitor<'de>,
459    {
460        Err(SerError::invalid_type(self.input, "bytes"))
461    }
462    fn deserialize_byte_buf<V>(self, _visitor: V) -> Result<V::Value, Self::Error>
463    where
464        V: serde::de::Visitor<'de>,
465    {
466        Err(SerError::invalid_type(self.input, "bytes"))
467    }
468
469    fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Self::Error>
470    where
471        V: serde::de::Visitor<'de>,
472    {
473        if self.input.is_state() || self.input.is_nil() {
474            visitor.visit_none()
475        } else {
476            visitor.visit_some(self)
477        }
478    }
479    fn deserialize_unit<V>(self, visitor: V) -> Result<V::Value, Self::Error>
480    where
481        V: serde::de::Visitor<'de>,
482    {
483        if self.input.is_state() || self.input.is_nil() {
484            visitor.visit_unit()
485        } else {
486            Err(SerError::invalid_type(self.input, "nil"))
487        }
488    }
489    fn deserialize_unit_struct<V>(
490        self,
491        _name: &'static str,
492        visitor: V,
493    ) -> Result<V::Value, Self::Error>
494    where
495        V: serde::de::Visitor<'de>,
496    {
497        self.deserialize_unit(visitor)
498    }
499
500    fn deserialize_newtype_struct<V>(
501        self,
502        _name: &'static str,
503        visitor: V,
504    ) -> Result<V::Value, Self::Error>
505    where
506        V: serde::de::Visitor<'de>,
507    {
508        visitor.visit_newtype_struct(self)
509    }
510
511    fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value, Self::Error>
512    where
513        V: serde::de::Visitor<'de>,
514    {
515        let input = self
516            .input
517            .as_array()
518            .ok_or_else(|| SerError::invalid_type(self.input, "array"))?;
519        visitor.visit_seq(ArrayDeserializer::new(input))
520    }
521    fn deserialize_tuple<V>(self, _len: usize, visitor: V) -> Result<V::Value, Self::Error>
522    where
523        V: serde::de::Visitor<'de>,
524    {
525        self.deserialize_seq(visitor)
526    }
527    fn deserialize_tuple_struct<V>(
528        self,
529        _name: &'static str,
530        _len: usize,
531        visitor: V,
532    ) -> Result<V::Value, Self::Error>
533    where
534        V: serde::de::Visitor<'de>,
535    {
536        self.deserialize_seq(visitor)
537    }
538
539    fn deserialize_map<V>(self, visitor: V) -> Result<V::Value, Self::Error>
540    where
541        V: serde::de::Visitor<'de>,
542    {
543        let input = self
544            .input
545            .as_object()
546            .ok_or_else(|| SerError::invalid_type(self.input, "object"))?;
547        visitor.visit_map(ObjectDeserializer::new(input))
548    }
549    fn deserialize_struct<V>(
550        self,
551        _name: &'static str,
552        _fields: &'static [&'static str],
553        visitor: V,
554    ) -> Result<V::Value, Self::Error>
555    where
556        V: serde::de::Visitor<'de>,
557    {
558        self.deserialize_map(visitor)
559    }
560
561    fn deserialize_enum<V>(
562        self,
563        _name: &'static str,
564        _variants: &'static [&'static str],
565        _visitor: V,
566    ) -> Result<V::Value, Self::Error>
567    where
568        V: serde::de::Visitor<'de>,
569    {
570        Err(SerError::invalid_type(self.input, "enum"))
571    }
572    fn deserialize_identifier<V>(self, visitor: V) -> Result<V::Value, Self::Error>
573    where
574        V: serde::de::Visitor<'de>,
575    {
576        self.deserialize_str(visitor)
577    }
578    fn deserialize_ignored_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
579    where
580        V: serde::de::Visitor<'de>,
581    {
582        visitor.visit_unit()
583    }
584}
585
586struct ObjectDeserializer<'de> {
587    iter: Box<dyn Iterator<Item = (KStringCow<'de>, &'de (dyn ValueView + 'de))> + 'de>,
588    value: Option<&'de (dyn ValueView + 'de)>,
589}
590
591impl<'de> ObjectDeserializer<'de> {
592    fn new(input: &'de dyn ObjectView) -> Self {
593        Self {
594            iter: input.iter(),
595            value: None,
596        }
597    }
598}
599
600impl<'de> serde::de::MapAccess<'de> for ObjectDeserializer<'de> {
601    type Error = SerError;
602
603    fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>, Self::Error>
604    where
605        K: serde::de::DeserializeSeed<'de>,
606    {
607        match self.iter.next() {
608            Some((k, v)) => {
609                self.value = Some(v);
610                seed.deserialize(k.as_str().into_deserializer()).map(Some)
611            }
612            None => Ok(None),
613        }
614    }
615
616    fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value, Self::Error>
617    where
618        V: serde::de::DeserializeSeed<'de>,
619    {
620        match self.value {
621            Some(v) => seed.deserialize(&mut ValueDeserializer::from_value(v)),
622            None => {
623                panic!("no more values in next_value_seed, internal error in ValueDeserializer")
624            }
625        }
626    }
627}
628
629struct ArrayDeserializer<'de> {
630    iter: Box<dyn Iterator<Item = &'de dyn ValueView> + 'de>,
631}
632
633impl<'de> ArrayDeserializer<'de> {
634    fn new(input: &'de dyn ArrayView) -> Self {
635        Self {
636            iter: input.values(),
637        }
638    }
639}
640
641impl<'de> serde::de::SeqAccess<'de> for ArrayDeserializer<'de> {
642    type Error = SerError;
643
644    fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, SerError>
645    where
646        T: serde::de::DeserializeSeed<'de>,
647    {
648        match self.iter.next() {
649            Some(v) => seed
650                .deserialize(&mut ValueDeserializer::from_value(v))
651                .map(Some),
652            None => Ok(None),
653        }
654    }
655}
656
657#[cfg(test)]
658mod test {
659    use std::f64;
660
661    use snapbox::assert_data_eq;
662    use snapbox::prelude::*;
663    use snapbox::str;
664
665    #[test]
666    pub fn serialize_num() {
667        let actual = crate::model::Value::scalar(1f64);
668        let actual = serde_yaml::to_string(&actual).unwrap();
669        assert_data_eq!(
670            actual.trim(),
671            str![[r#"
672---
6731.0
674"#]]
675            .raw()
676        );
677
678        let actual = crate::model::Value::scalar(-100f64);
679        let actual = serde_yaml::to_string(&actual).unwrap();
680        assert_data_eq!(
681            actual.trim(),
682            str![[r#"
683---
684-100.0
685"#]]
686            .raw()
687        );
688
689        let actual = crate::model::Value::scalar(3.14e_10f64);
690        let actual = serde_yaml::to_string(&actual).unwrap();
691        assert_data_eq!(
692            actual.trim(),
693            str![[r#"
694---
69531400000000.0
696"#]]
697            .raw()
698        );
699
700        let actual = crate::model::Value::scalar(f64::NAN);
701        let actual = serde_yaml::to_string(&actual).unwrap();
702        assert_data_eq!(
703            actual.trim(),
704            str![[r#"
705---
706.nan
707"#]]
708            .raw()
709        );
710
711        let actual = crate::model::Value::scalar(f64::INFINITY);
712        let actual = serde_yaml::to_string(&actual).unwrap();
713        assert_data_eq!(
714            actual.trim(),
715            str![[r#"
716---
717.inf
718"#]]
719            .raw()
720        );
721    }
722
723    #[test]
724    pub fn deserialize_num() {
725        let actual: crate::model::Value = serde_yaml::from_str("---\n1").unwrap();
726        assert_eq!(actual, crate::model::Value::scalar(1f64));
727
728        let actual: crate::model::Value = serde_yaml::from_str("---\n-100").unwrap();
729        assert_eq!(actual, crate::model::Value::scalar(-100f64));
730
731        let actual: crate::model::Value = serde_yaml::from_str("---\n31399999488").unwrap();
732        assert_eq!(actual, crate::model::Value::scalar(31399999488.0f64));
733
734        // Skipping NaN and inf
735    }
736
737    #[test]
738    pub fn serialize_bool() {
739        let actual = crate::model::Value::scalar(true);
740        let actual = serde_yaml::to_string(&actual).unwrap();
741        assert_data_eq!(
742            actual.trim(),
743            str![[r#"
744---
745true
746"#]]
747            .raw()
748        );
749
750        let actual = crate::model::Value::scalar(false);
751        let actual = serde_yaml::to_string(&actual).unwrap();
752        assert_data_eq!(
753            actual.trim(),
754            str![[r#"
755---
756false
757"#]]
758            .raw()
759        );
760    }
761
762    #[test]
763    pub fn deserialize_bool() {
764        let actual: crate::model::Value = serde_yaml::from_str("---\ntrue").unwrap();
765        assert_eq!(actual, crate::model::Value::scalar(true));
766
767        let actual: crate::model::Value = serde_yaml::from_str("---\nfalse").unwrap();
768        assert_eq!(actual, crate::model::Value::scalar(false));
769    }
770
771    #[test]
772    pub fn serialize_nil() {
773        let actual = crate::model::Value::Nil;
774        let actual = serde_yaml::to_string(&actual).unwrap();
775        assert_data_eq!(
776            actual.trim(),
777            str![[r#"
778---
779~
780"#]]
781            .raw()
782        );
783    }
784
785    #[test]
786    pub fn deserialize_nil() {
787        let actual: crate::model::Value = serde_yaml::from_str("---\n~").unwrap();
788        assert_eq!(actual, crate::model::Value::Nil);
789
790        let actual: crate::model::Value = serde_yaml::from_str("---\n- ").unwrap();
791        assert_eq!(
792            actual,
793            crate::model::Value::Array(vec![crate::model::Value::Nil])
794        );
795    }
796
797    #[test]
798    pub fn serialize_str() {
799        let actual = crate::model::Value::scalar("Hello");
800        let actual = serde_yaml::to_string(&actual).unwrap();
801        assert_data_eq!(
802            actual.trim(),
803            str![[r#"
804---
805Hello
806"#]]
807            .raw()
808        );
809
810        let actual = crate::model::Value::scalar("10");
811        let actual = serde_yaml::to_string(&actual).unwrap();
812        assert_data_eq!(
813            actual.trim(),
814            str![[r#"
815---
816"10"
817"#]]
818            .raw()
819        );
820
821        let actual = crate::model::Value::scalar("false");
822        let actual = serde_yaml::to_string(&actual).unwrap();
823        assert_data_eq!(
824            actual.trim(),
825            str![[r#"
826---
827"false"
828"#]]
829            .raw()
830        );
831    }
832
833    #[test]
834    pub fn deserialize_str() {
835        let actual: crate::model::Value = serde_yaml::from_str("---\nHello").unwrap();
836        assert_eq!(actual, crate::model::Value::scalar("Hello"));
837
838        let actual: crate::model::Value = serde_yaml::from_str("\"10\"\n").unwrap();
839        assert_eq!(actual, crate::model::Value::scalar("10"));
840
841        let actual: crate::model::Value = serde_yaml::from_str("---\n\"false\"").unwrap();
842        assert_eq!(actual, crate::model::Value::scalar("false"));
843    }
844
845    #[test]
846    pub fn serialize_array() {
847        let actual = vec![
848            crate::model::Value::scalar(1f64),
849            crate::model::Value::scalar(true),
850            crate::model::Value::scalar("true"),
851        ];
852        let actual = crate::model::Value::Array(actual);
853        let actual = serde_yaml::to_string(&actual).unwrap();
854        assert_data_eq!(
855            actual.trim(),
856            str![[r#"
857---
858- 1.0
859- true
860- "true"
861"#]]
862            .raw()
863        );
864    }
865
866    #[test]
867    pub fn deserialize_array() {
868        let actual: crate::model::Value =
869            serde_yaml::from_str("---\n- 1\n- true\n- \"true\"").unwrap();
870        let expected = vec![
871            crate::model::Value::scalar(1f64),
872            crate::model::Value::scalar(true),
873            crate::model::Value::scalar("true"),
874        ];
875        let expected = crate::model::Value::Array(expected);
876        assert_eq!(actual, expected);
877    }
878
879    #[test]
880    pub fn serialize_object() {
881        // Skipping due to HashMap ordering issues
882    }
883
884    #[test]
885    pub fn deserialize_object() {
886        let actual: crate::model::Value =
887            serde_yaml::from_str("---\nNum: 1\nBool: true\nStr: \"true\"").unwrap();
888        let expected: crate::model::Object = [
889            ("Num".into(), crate::model::Value::scalar(1f64)),
890            ("Bool".into(), crate::model::Value::scalar(true)),
891            ("Str".into(), crate::model::Value::scalar("true")),
892        ]
893        .iter()
894        .cloned()
895        .collect();
896        let expected = crate::model::Value::Object(expected);
897        assert_eq!(actual, expected);
898    }
899}
liquid_core/model/value/ser.rs

liquid_core/model/value/
ser.rs
