loose_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: ?Sized>(
142        self,
143        _name: &'static str,
144        value: &T,
145    ) -> Result<Value, SerError>
146    where
147        T: Serialize,
148    {
149        value.serialize(ValueSerializer)
150    }
151
152    fn serialize_newtype_variant<T: ?Sized>(
153        self,
154        _name: &'static str,
155        _variant_index: u32,
156        variant: &'static str,
157        value: &T,
158    ) -> Result<Value, SerError>
159    where
160        T: Serialize,
161    {
162        let mut values = Object::new();
163        values.insert(
164            KString::from_static(variant),
165            value.serialize(ValueSerializer)?,
166        );
167        Ok(Value::Object(values))
168    }
169
170    #[inline]
171    fn serialize_none(self) -> Result<Value, SerError> {
172        self.serialize_unit()
173    }
174
175    #[inline]
176    fn serialize_some<T: ?Sized>(self, value: &T) -> Result<Value, SerError>
177    where
178        T: Serialize,
179    {
180        value.serialize(ValueSerializer)
181    }
182
183    fn serialize_seq(self, len: Option<usize>) -> Result<Self::SerializeSeq, SerError> {
184        Ok(SerializeVec {
185            vec: Vec::with_capacity(len.unwrap_or(0)),
186        })
187    }
188
189    fn serialize_tuple(self, len: usize) -> Result<Self::SerializeTuple, SerError> {
190        self.serialize_seq(Some(len))
191    }
192
193    fn serialize_tuple_struct(
194        self,
195        _name: &'static str,
196        len: usize,
197    ) -> Result<Self::SerializeTupleStruct, SerError> {
198        Ok(SerializeVec {
199            vec: Vec::with_capacity(len),
200        })
201    }
202
203    fn serialize_tuple_variant(
204        self,
205        _name: &'static str,
206        _variant_index: u32,
207        variant: &'static str,
208        len: usize,
209    ) -> Result<Self::SerializeTupleVariant, SerError> {
210        Ok(SerializeTupleVariant {
211            name: KString::from_static(variant),
212            vec: Vec::with_capacity(len),
213            other: std::marker::PhantomData,
214        })
215    }
216
217    fn serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap, SerError> {
218        Ok(SerializeMap::Map {
219            map: Object::new(),
220            next_key: None,
221            other: std::marker::PhantomData,
222        })
223    }
224
225    fn serialize_struct(
226        self,
227        _name: &'static str,
228        len: usize,
229    ) -> Result<Self::SerializeStruct, SerError> {
230        self.serialize_map(Some(len))
231    }
232
233    fn serialize_struct_variant(
234        self,
235        _name: &'static str,
236        _variant_index: u32,
237        variant: &'static str,
238        _len: usize,
239    ) -> Result<Self::SerializeStructVariant, SerError> {
240        Ok(SerializeStructVariant {
241            name: KString::from_static(variant),
242            map: Object::new(),
243            other: std::marker::PhantomData,
244        })
245    }
246}
247
248pub(crate) struct SerializeVec {
249    vec: Vec<Value>,
250}
251
252impl serde::ser::SerializeSeq for SerializeVec {
253    type Ok = Value;
254    type Error = SerError;
255
256    fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<(), SerError>
257    where
258        T: Serialize,
259    {
260        self.vec.push(value.serialize(ValueSerializer)?);
261        Ok(())
262    }
263
264    fn end(self) -> Result<Value, SerError> {
265        Ok(Value::Array(self.vec))
266    }
267}
268
269impl serde::ser::SerializeTuple for SerializeVec {
270    type Ok = Value;
271    type Error = SerError;
272
273    fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<(), SerError>
274    where
275        T: Serialize,
276    {
277        serde::ser::SerializeSeq::serialize_element(self, value)
278    }
279
280    fn end(self) -> Result<Value, SerError> {
281        serde::ser::SerializeSeq::end(self)
282    }
283}
284
285impl serde::ser::SerializeTupleStruct for SerializeVec {
286    type Ok = Value;
287    type Error = SerError;
288
289    fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<(), SerError>
290    where
291        T: Serialize,
292    {
293        serde::ser::SerializeSeq::serialize_element(self, value)
294    }
295
296    fn end(self) -> Result<Value, SerError> {
297        serde::ser::SerializeSeq::end(self)
298    }
299}
300
301#[allow(missing_debug_implementations)]
302pub(crate) struct ValueDeserializer<'de> {
303    input: &'de (dyn ValueView + 'de),
304}
305
306impl<'de> ValueDeserializer<'de> {
307    fn from_value(input: &'de (dyn ValueView + 'de)) -> Self {
308        Self { input }
309    }
310}
311
312impl<'de, 'a> serde::Deserializer<'de> for &'a mut ValueDeserializer<'de> {
313    type Error = SerError;
314
315    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
316    where
317        V: serde::de::Visitor<'de>,
318    {
319        if let Some(scalar) = self.input.as_scalar() {
320            if scalar.to_integer().is_some() {
321                self.deserialize_i64(visitor)
322            } else if scalar.to_float().is_some() {
323                self.deserialize_f64(visitor)
324            } else if scalar.to_bool().is_some() {
325                self.deserialize_bool(visitor)
326            } else {
327                self.deserialize_str(visitor)
328            }
329        } else if self.input.is_array() {
330            self.deserialize_seq(visitor)
331        } else if self.input.is_object() {
332            self.deserialize_map(visitor)
333        } else if self.input.is_state() || self.input.is_nil() {
334            self.deserialize_unit(visitor)
335        } else {
336            Err(SerError::unknown_type(self.input))
337        }
338    }
339
340    fn deserialize_bool<V>(self, visitor: V) -> Result<V::Value, Self::Error>
341    where
342        V: serde::de::Visitor<'de>,
343    {
344        let scalar = self
345            .input
346            .as_scalar()
347            .ok_or_else(|| SerError::invalid_type(self.input, "bool"))?;
348        let v = scalar
349            .to_bool()
350            .ok_or_else(|| SerError::invalid_type(self.input, "bool"))?;
351        visitor.visit_bool(v)
352    }
353
354    fn deserialize_i8<V>(self, visitor: V) -> Result<V::Value, Self::Error>
355    where
356        V: serde::de::Visitor<'de>,
357    {
358        self.deserialize_i64(visitor)
359    }
360    fn deserialize_i16<V>(self, visitor: V) -> Result<V::Value, Self::Error>
361    where
362        V: serde::de::Visitor<'de>,
363    {
364        self.deserialize_i64(visitor)
365    }
366    fn deserialize_i32<V>(self, visitor: V) -> Result<V::Value, Self::Error>
367    where
368        V: serde::de::Visitor<'de>,
369    {
370        self.deserialize_i64(visitor)
371    }
372    fn deserialize_i64<V>(self, visitor: V) -> Result<V::Value, Self::Error>
373    where
374        V: serde::de::Visitor<'de>,
375    {
376        let scalar = self
377            .input
378            .as_scalar()
379            .ok_or_else(|| SerError::invalid_type(self.input, "integer"))?;
380        let v = scalar
381            .to_integer()
382            .ok_or_else(|| SerError::invalid_type(self.input, "integer"))?;
383        visitor.visit_i64(v)
384    }
385    fn deserialize_u8<V>(self, visitor: V) -> Result<V::Value, Self::Error>
386    where
387        V: serde::de::Visitor<'de>,
388    {
389        self.deserialize_i64(visitor)
390    }
391    fn deserialize_u16<V>(self, visitor: V) -> Result<V::Value, Self::Error>
392    where
393        V: serde::de::Visitor<'de>,
394    {
395        self.deserialize_i64(visitor)
396    }
397    fn deserialize_u32<V>(self, visitor: V) -> Result<V::Value, Self::Error>
398    where
399        V: serde::de::Visitor<'de>,
400    {
401        self.deserialize_i64(visitor)
402    }
403    fn deserialize_u64<V>(self, visitor: V) -> Result<V::Value, Self::Error>
404    where
405        V: serde::de::Visitor<'de>,
406    {
407        self.deserialize_i64(visitor)
408    }
409
410    fn deserialize_f32<V>(self, visitor: V) -> Result<V::Value, Self::Error>
411    where
412        V: serde::de::Visitor<'de>,
413    {
414        self.deserialize_f64(visitor)
415    }
416    fn deserialize_f64<V>(self, visitor: V) -> Result<V::Value, Self::Error>
417    where
418        V: serde::de::Visitor<'de>,
419    {
420        let scalar = self
421            .input
422            .as_scalar()
423            .ok_or_else(|| SerError::invalid_type(self.input, "float"))?;
424        let v = scalar
425            .to_float()
426            .ok_or_else(|| SerError::invalid_type(self.input, "float"))?;
427        visitor.visit_f64(v)
428    }
429
430    fn deserialize_char<V>(self, visitor: V) -> Result<V::Value, Self::Error>
431    where
432        V: serde::de::Visitor<'de>,
433    {
434        let s = self.input.to_kstr();
435        if let Some(c) = s.as_str().chars().next() {
436            visitor.visit_char(c)
437        } else {
438            Err(SerError::invalid_type(self.input, "char"))
439        }
440    }
441    fn deserialize_str<V>(self, visitor: V) -> Result<V::Value, Self::Error>
442    where
443        V: serde::de::Visitor<'de>,
444    {
445        let scalar = self
446            .input
447            .as_scalar()
448            .ok_or_else(|| SerError::invalid_type(self.input, "string"))?;
449        match scalar.into_cow_str() {
450            std::borrow::Cow::Borrowed(s) => visitor.visit_borrowed_str(s),
451            std::borrow::Cow::Owned(s) => visitor.visit_string(s),
452        }
453    }
454    fn deserialize_string<V>(self, visitor: V) -> Result<V::Value, Self::Error>
455    where
456        V: serde::de::Visitor<'de>,
457    {
458        self.deserialize_str(visitor)
459    }
460    fn deserialize_bytes<V>(self, _visitor: V) -> Result<V::Value, Self::Error>
461    where
462        V: serde::de::Visitor<'de>,
463    {
464        Err(SerError::invalid_type(self.input, "bytes"))
465    }
466    fn deserialize_byte_buf<V>(self, _visitor: V) -> Result<V::Value, Self::Error>
467    where
468        V: serde::de::Visitor<'de>,
469    {
470        Err(SerError::invalid_type(self.input, "bytes"))
471    }
472
473    fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Self::Error>
474    where
475        V: serde::de::Visitor<'de>,
476    {
477        if self.input.is_state() || self.input.is_nil() {
478            visitor.visit_none()
479        } else {
480            visitor.visit_some(self)
481        }
482    }
483    fn deserialize_unit<V>(self, visitor: V) -> Result<V::Value, Self::Error>
484    where
485        V: serde::de::Visitor<'de>,
486    {
487        if self.input.is_state() || self.input.is_nil() {
488            visitor.visit_unit()
489        } else {
490            Err(SerError::invalid_type(self.input, "nil"))
491        }
492    }
493    fn deserialize_unit_struct<V>(
494        self,
495        _name: &'static str,
496        visitor: V,
497    ) -> Result<V::Value, Self::Error>
498    where
499        V: serde::de::Visitor<'de>,
500    {
501        self.deserialize_unit(visitor)
502    }
503
504    fn deserialize_newtype_struct<V>(
505        self,
506        _name: &'static str,
507        visitor: V,
508    ) -> Result<V::Value, Self::Error>
509    where
510        V: serde::de::Visitor<'de>,
511    {
512        visitor.visit_newtype_struct(self)
513    }
514
515    fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value, Self::Error>
516    where
517        V: serde::de::Visitor<'de>,
518    {
519        let input = self
520            .input
521            .as_array()
522            .ok_or_else(|| SerError::invalid_type(self.input, "array"))?;
523        visitor.visit_seq(ArrayDeserializer::new(input))
524    }
525    fn deserialize_tuple<V>(self, _len: usize, visitor: V) -> Result<V::Value, Self::Error>
526    where
527        V: serde::de::Visitor<'de>,
528    {
529        self.deserialize_seq(visitor)
530    }
531    fn deserialize_tuple_struct<V>(
532        self,
533        _name: &'static str,
534        _len: usize,
535        visitor: V,
536    ) -> Result<V::Value, Self::Error>
537    where
538        V: serde::de::Visitor<'de>,
539    {
540        self.deserialize_seq(visitor)
541    }
542
543    fn deserialize_map<V>(self, visitor: V) -> Result<V::Value, Self::Error>
544    where
545        V: serde::de::Visitor<'de>,
546    {
547        let input = self
548            .input
549            .as_object()
550            .ok_or_else(|| SerError::invalid_type(self.input, "object"))?;
551        visitor.visit_map(ObjectDeserializer::new(input))
552    }
553    fn deserialize_struct<V>(
554        self,
555        _name: &'static str,
556        _fields: &'static [&'static str],
557        visitor: V,
558    ) -> Result<V::Value, Self::Error>
559    where
560        V: serde::de::Visitor<'de>,
561    {
562        self.deserialize_map(visitor)
563    }
564
565    fn deserialize_enum<V>(
566        self,
567        _name: &'static str,
568        _variants: &'static [&'static str],
569        _visitor: V,
570    ) -> Result<V::Value, Self::Error>
571    where
572        V: serde::de::Visitor<'de>,
573    {
574        Err(SerError::invalid_type(self.input, "enum"))
575    }
576    fn deserialize_identifier<V>(self, visitor: V) -> Result<V::Value, Self::Error>
577    where
578        V: serde::de::Visitor<'de>,
579    {
580        self.deserialize_str(visitor)
581    }
582    fn deserialize_ignored_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
583    where
584        V: serde::de::Visitor<'de>,
585    {
586        visitor.visit_unit()
587    }
588}
589
590struct ObjectDeserializer<'de> {
591    iter: Box<dyn Iterator<Item = (KStringCow<'de>, &'de (dyn ValueView + 'de))> + 'de>,
592    value: Option<&'de (dyn ValueView + 'de)>,
593}
594
595impl<'de> ObjectDeserializer<'de> {
596    fn new(input: &'de dyn ObjectView) -> Self {
597        Self {
598            iter: input.iter(),
599            value: None,
600        }
601    }
602}
603
604impl<'de> serde::de::MapAccess<'de> for ObjectDeserializer<'de> {
605    type Error = SerError;
606
607    fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>, Self::Error>
608    where
609        K: serde::de::DeserializeSeed<'de>,
610    {
611        match self.iter.next() {
612            Some((k, v)) => {
613                self.value = Some(v);
614                seed.deserialize(k.as_str().into_deserializer()).map(Some)
615            }
616            None => Ok(None),
617        }
618    }
619
620    fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value, Self::Error>
621    where
622        V: serde::de::DeserializeSeed<'de>,
623    {
624        match self.value {
625            Some(v) => seed.deserialize(&mut ValueDeserializer::from_value(v)),
626            None => {
627                panic!("no more values in next_value_seed, internal error in ValueDeserializer")
628            }
629        }
630    }
631}
632
633struct ArrayDeserializer<'de> {
634    iter: Box<dyn Iterator<Item = &'de dyn ValueView> + 'de>,
635}
636
637impl<'de> ArrayDeserializer<'de> {
638    fn new(input: &'de dyn ArrayView) -> Self {
639        Self {
640            iter: input.values(),
641        }
642    }
643}
644
645impl<'de> serde::de::SeqAccess<'de> for ArrayDeserializer<'de> {
646    type Error = SerError;
647
648    fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, SerError>
649    where
650        T: serde::de::DeserializeSeed<'de>,
651    {
652        match self.iter.next() {
653            Some(v) => seed
654                .deserialize(&mut ValueDeserializer::from_value(v))
655                .map(Some),
656            None => Ok(None),
657        }
658    }
659}
660
661#[cfg(test)]
662mod test {
663    use std::f64;
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        snapbox::assert_eq(actual.trim(), "---\n1.0");
670
671        let actual = crate::model::Value::scalar(-100f64);
672        let actual = serde_yaml::to_string(&actual).unwrap();
673        snapbox::assert_eq(actual.trim(), "---\n-100.0");
674
675        let actual = crate::model::Value::scalar(3.14e_10f64);
676        let actual = serde_yaml::to_string(&actual).unwrap();
677        snapbox::assert_eq(actual.trim(), "---\n31400000000.0");
678
679        let actual = crate::model::Value::scalar(f64::NAN);
680        let actual = serde_yaml::to_string(&actual).unwrap();
681        snapbox::assert_eq(actual.trim(), "---\n.nan");
682
683        let actual = crate::model::Value::scalar(f64::INFINITY);
684        let actual = serde_yaml::to_string(&actual).unwrap();
685        snapbox::assert_eq(actual.trim(), "---\n.inf");
686    }
687
688    #[test]
689    pub fn deserialize_num() {
690        let actual: crate::model::Value = serde_yaml::from_str("---\n1").unwrap();
691        assert_eq!(actual, crate::model::Value::scalar(1f64));
692
693        let actual: crate::model::Value = serde_yaml::from_str("---\n-100").unwrap();
694        assert_eq!(actual, crate::model::Value::scalar(-100f64));
695
696        let actual: crate::model::Value = serde_yaml::from_str("---\n31399999488").unwrap();
697        assert_eq!(actual, crate::model::Value::scalar(31399999488.0f64));
698
699        // Skipping NaN and inf
700    }
701
702    #[test]
703    pub fn serialize_bool() {
704        let actual = crate::model::Value::scalar(true);
705        let actual = serde_yaml::to_string(&actual).unwrap();
706        snapbox::assert_eq(actual.trim(), "---\ntrue");
707
708        let actual = crate::model::Value::scalar(false);
709        let actual = serde_yaml::to_string(&actual).unwrap();
710        snapbox::assert_eq(actual.trim(), "---\nfalse");
711    }
712
713    #[test]
714    pub fn deserialize_bool() {
715        let actual: crate::model::Value = serde_yaml::from_str("---\ntrue").unwrap();
716        assert_eq!(actual, crate::model::Value::scalar(true));
717
718        let actual: crate::model::Value = serde_yaml::from_str("---\nfalse").unwrap();
719        assert_eq!(actual, crate::model::Value::scalar(false));
720    }
721
722    #[test]
723    pub fn serialize_nil() {
724        let actual = crate::model::Value::Nil;
725        let actual = serde_yaml::to_string(&actual).unwrap();
726        snapbox::assert_eq(actual.trim(), "---\n~");
727    }
728
729    #[test]
730    pub fn deserialize_nil() {
731        let actual: crate::model::Value = serde_yaml::from_str("---\n~").unwrap();
732        assert_eq!(actual, crate::model::Value::Nil);
733
734        let actual: crate::model::Value = serde_yaml::from_str("---\n- ").unwrap();
735        assert_eq!(
736            actual,
737            crate::model::Value::Array(vec![crate::model::Value::Nil])
738        );
739    }
740
741    #[test]
742    pub fn serialize_str() {
743        let actual = crate::model::Value::scalar("Hello");
744        let actual = serde_yaml::to_string(&actual).unwrap();
745        snapbox::assert_eq(actual.trim(), "---\nHello");
746
747        let actual = crate::model::Value::scalar("10");
748        let actual = serde_yaml::to_string(&actual).unwrap();
749        snapbox::assert_eq(actual.trim(), "---\n\"10\"");
750
751        let actual = crate::model::Value::scalar("false");
752        let actual = serde_yaml::to_string(&actual).unwrap();
753        snapbox::assert_eq(actual.trim(), "---\n\"false\"");
754    }
755
756    #[test]
757    pub fn deserialize_str() {
758        let actual: crate::model::Value = serde_yaml::from_str("---\nHello").unwrap();
759        assert_eq!(actual, crate::model::Value::scalar("Hello"));
760
761        let actual: crate::model::Value = serde_yaml::from_str("\"10\"\n").unwrap();
762        assert_eq!(actual, crate::model::Value::scalar("10"));
763
764        let actual: crate::model::Value = serde_yaml::from_str("---\n\"false\"").unwrap();
765        assert_eq!(actual, crate::model::Value::scalar("false"));
766    }
767
768    #[test]
769    pub fn serialize_array() {
770        let actual = vec![
771            crate::model::Value::scalar(1f64),
772            crate::model::Value::scalar(true),
773            crate::model::Value::scalar("true"),
774        ];
775        let actual = crate::model::Value::Array(actual);
776        let actual = serde_yaml::to_string(&actual).unwrap();
777        snapbox::assert_eq(actual.trim(), "---\n- 1.0\n- true\n- \"true\"");
778    }
779
780    #[test]
781    pub fn deserialize_array() {
782        let actual: crate::model::Value =
783            serde_yaml::from_str("---\n- 1\n- true\n- \"true\"").unwrap();
784        let expected = vec![
785            crate::model::Value::scalar(1f64),
786            crate::model::Value::scalar(true),
787            crate::model::Value::scalar("true"),
788        ];
789        let expected = crate::model::Value::Array(expected);
790        assert_eq!(actual, expected);
791    }
792
793    #[test]
794    pub fn serialize_object() {
795        // Skipping due to HashMap ordering issues
796    }
797
798    #[test]
799    pub fn deserialize_object() {
800        let actual: crate::model::Value =
801            serde_yaml::from_str("---\nNum: 1\nBool: true\nStr: \"true\"").unwrap();
802        let expected: crate::model::Object = [
803            ("Num".into(), crate::model::Value::scalar(1f64)),
804            ("Bool".into(), crate::model::Value::scalar(true)),
805            ("Str".into(), crate::model::Value::scalar("true")),
806        ]
807        .iter()
808        .cloned()
809        .collect();
810        let expected = crate::model::Value::Object(expected);
811        assert_eq!(actual, expected);
812    }
813}
loose_liquid_core/model/value/ser.rs

loose_liquid_core/model/value/
ser.rs
