Skip to main content

tera/value/
de.rs

1use crate::Value;
2use crate::value::ValueInner;
3use crate::value::utils::DeserializationFailed;
4use serde::de::{self, Unexpected, Visitor};
5use serde::{Deserializer, forward_to_deserialize_any};
6
7#[derive(Debug)]
8pub struct ValueDeserializer {
9    value: Value,
10}
11
12impl ValueDeserializer {
13    pub fn from_value(value: Value) -> Self {
14        Self { value }
15    }
16}
17
18impl<'de> de::Deserializer<'de> for ValueDeserializer {
19    type Error = DeserializationFailed;
20
21    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
22    where
23        V: Visitor<'de>,
24    {
25        match self.value.inner {
26            ValueInner::Bool(v) => visitor.visit_bool(v),
27            ValueInner::I64(v) => visitor.visit_i64(v),
28            ValueInner::U64(v) => visitor.visit_u64(v),
29            ValueInner::I128(v) => visitor.visit_i128(*v),
30            ValueInner::U128(v) => visitor.visit_u128(*v),
31            ValueInner::F64(v) => visitor.visit_f64(v),
32            ValueInner::String(v) => visitor.visit_str(v.as_str()),
33            ValueInner::Bytes(v) => visitor.visit_bytes(&v),
34            ValueInner::Undefined | ValueInner::None => visitor.visit_unit(),
35            ValueInner::Array(v) => visitor.visit_seq(de::value::SeqDeserializer::new(
36                v.iter().map(|v| ValueDeserializer::from_value(v.clone())),
37            )),
38            ValueInner::Map(v) => {
39                visitor.visit_map(de::value::MapDeserializer::new(v.iter().map(|(k, v)| {
40                    (
41                        ValueDeserializer::from_value(k.as_value()),
42                        ValueDeserializer::from_value(v.clone()),
43                    )
44                })))
45            }
46        }
47    }
48
49    fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Self::Error>
50    where
51        V: Visitor<'de>,
52    {
53        match self.value.inner {
54            ValueInner::Undefined | ValueInner::None => visitor.visit_unit(),
55            _ => visitor.visit_some(self),
56        }
57    }
58
59    fn deserialize_enum<V>(
60        self,
61        _name: &'static str,
62        _variants: &'static [&'static str],
63        visitor: V,
64    ) -> Result<V::Value, Self::Error>
65    where
66        V: Visitor<'de>,
67    {
68        let (variant, params) = match self.value.inner {
69            ValueInner::Map(m) => {
70                let mut iter = m.iter();
71                let (variant, value) = match iter.next() {
72                    Some(v) => v,
73                    None => {
74                        return Err(de::Error::invalid_value(
75                            Unexpected::Map,
76                            &"map with a single key",
77                        ));
78                    }
79                };
80                // enums are encoded as maps with a single key:value pair
81                if iter.next().is_some() {
82                    return Err(de::Error::invalid_value(
83                        Unexpected::Map,
84                        &"map with a single key",
85                    ));
86                }
87                (variant.as_value(), Some(value.clone()))
88            }
89            ValueInner::String(_) => (self.value.clone(), None),
90            _ => {
91                return Err(de::Error::invalid_type(
92                    Unexpected::Other(self.value.name()),
93                    &"map or string",
94                ));
95            }
96        };
97        visitor.visit_enum(EnumDeserializer { variant, params })
98    }
99
100    fn deserialize_newtype_struct<V>(
101        self,
102        _name: &'static str,
103        visitor: V,
104    ) -> Result<V::Value, Self::Error>
105    where
106        V: Visitor<'de>,
107    {
108        visitor.visit_newtype_struct(self)
109    }
110
111    forward_to_deserialize_any! {
112        bool u8 u16 u32 u64 i8 i16 i32 i64 i128 u128 f32 f64 char str string unit
113        seq bytes byte_buf map unit_struct
114        tuple_struct struct tuple ignored_any identifier
115    }
116}
117
118struct EnumDeserializer {
119    variant: Value,
120    params: Option<Value>,
121}
122
123impl<'de> de::EnumAccess<'de> for EnumDeserializer {
124    type Error = DeserializationFailed;
125    type Variant = VariantDeserializer;
126
127    fn variant_seed<V: de::DeserializeSeed<'de>>(
128        self,
129        seed: V,
130    ) -> Result<(V::Value, Self::Variant), Self::Error> {
131        let value = seed.deserialize(self.variant)?;
132        Ok((
133            value,
134            VariantDeserializer {
135                params: self.params,
136            },
137        ))
138    }
139}
140
141struct VariantDeserializer {
142    params: Option<Value>,
143}
144impl<'de> de::VariantAccess<'de> for VariantDeserializer {
145    type Error = DeserializationFailed;
146
147    fn unit_variant(self) -> Result<(), Self::Error> {
148        match self.params {
149            Some(value) => de::Deserialize::deserialize(value),
150            None => Ok(()),
151        }
152    }
153
154    fn newtype_variant_seed<T: de::DeserializeSeed<'de>>(
155        self,
156        seed: T,
157    ) -> Result<T::Value, Self::Error> {
158        match self.params {
159            Some(value) => seed.deserialize(value),
160            None => Err(de::Error::invalid_type(
161                Unexpected::UnitVariant,
162                &"newtype variant",
163            )),
164        }
165    }
166
167    fn tuple_variant<V: Visitor<'de>>(
168        self,
169        _len: usize,
170        visitor: V,
171    ) -> Result<V::Value, Self::Error> {
172        match self.params.filter(|x| x.is_array()) {
173            Some(val) => ValueDeserializer::from_value(val).deserialize_any(visitor),
174            _ => Err(de::Error::invalid_type(
175                Unexpected::UnitVariant,
176                &"tuple variant",
177            )),
178        }
179    }
180
181    fn struct_variant<V: Visitor<'de>>(
182        self,
183        _fields: &'static [&'static str],
184        visitor: V,
185    ) -> Result<V::Value, Self::Error> {
186        match self.params.filter(|x| x.is_map()) {
187            Some(val) => ValueDeserializer::from_value(val).deserialize_any(visitor),
188            _ => Err(de::Error::invalid_type(
189                Unexpected::UnitVariant,
190                &"struct variant",
191            )),
192        }
193    }
194}
195
196impl<'de> de::IntoDeserializer<'de, DeserializationFailed> for ValueDeserializer {
197    type Deserializer = ValueDeserializer;
198
199    fn into_deserializer(self) -> ValueDeserializer {
200        self
201    }
202}
203
204impl<'de> de::Deserializer<'de> for Value {
205    type Error = DeserializationFailed;
206
207    fn deserialize_any<V: de::Visitor<'de>>(self, visitor: V) -> Result<V::Value, Self::Error> {
208        ValueDeserializer::from_value(self).deserialize_any(visitor)
209    }
210
211    fn deserialize_option<V: de::Visitor<'de>>(self, visitor: V) -> Result<V::Value, Self::Error> {
212        ValueDeserializer::from_value(self).deserialize_option(visitor)
213    }
214
215    fn deserialize_newtype_struct<V: de::Visitor<'de>>(
216        self,
217        name: &'static str,
218        visitor: V,
219    ) -> Result<V::Value, Self::Error> {
220        ValueDeserializer::from_value(self).deserialize_newtype_struct(name, visitor)
221    }
222
223    fn deserialize_enum<V: de::Visitor<'de>>(
224        self,
225        name: &'static str,
226        variants: &'static [&'static str],
227        visitor: V,
228    ) -> Result<V::Value, Self::Error> {
229        ValueDeserializer::from_value(self).deserialize_enum(name, variants, visitor)
230    }
231
232    forward_to_deserialize_any! {
233        bool u8 u16 u32 u64 i8 i16 i32 i64 i128 u128 f32 f64 char str string unit
234        seq bytes byte_buf map unit_struct
235        tuple_struct struct tuple ignored_any identifier
236    }
237}
238
239impl<'de> de::Deserializer<'de> for &Value {
240    type Error = DeserializationFailed;
241
242    fn deserialize_any<V: de::Visitor<'de>>(self, visitor: V) -> Result<V::Value, Self::Error> {
243        ValueDeserializer::from_value(self.clone()).deserialize_any(visitor)
244    }
245
246    fn deserialize_option<V: de::Visitor<'de>>(self, visitor: V) -> Result<V::Value, Self::Error> {
247        ValueDeserializer::from_value(self.clone()).deserialize_option(visitor)
248    }
249
250    fn deserialize_newtype_struct<V: de::Visitor<'de>>(
251        self,
252        name: &'static str,
253        visitor: V,
254    ) -> Result<V::Value, Self::Error> {
255        ValueDeserializer::from_value(self.clone()).deserialize_newtype_struct(name, visitor)
256    }
257
258    fn deserialize_enum<V: de::Visitor<'de>>(
259        self,
260        name: &'static str,
261        variants: &'static [&'static str],
262        visitor: V,
263    ) -> Result<V::Value, Self::Error> {
264        ValueDeserializer::from_value(self.clone()).deserialize_enum(name, variants, visitor)
265    }
266
267    forward_to_deserialize_any! {
268        bool u8 u16 u32 u64 i8 i16 i32 i64 i128 u128 f32 f64 char str string unit
269        seq bytes byte_buf map unit_struct
270        tuple_struct struct tuple ignored_any identifier
271    }
272}
273
274#[cfg(test)]
275mod tests {
276    use super::*;
277    use serde::Deserialize;
278    use serde::Serialize;
279
280    #[derive(Debug, Serialize, Deserialize, PartialEq)]
281    struct UserId(u64);
282
283    #[derive(Debug, Serialize, Deserialize, PartialEq)]
284    enum Kind {
285        Article,
286        Comment(String),
287        Tuple(usize, usize),
288        Other { truthy: bool },
289    }
290
291    #[derive(Debug, Serialize, Deserialize, PartialEq)]
292    struct Content {
293        text: String,
294        num_likes: u64,
295        published: bool,
296        kind: Kind,
297        kind2: Kind,
298        kind3: Kind,
299        kind4: Kind,
300        maybe: Option<u64>,
301        nothing: Option<u64>,
302        user_id: UserId,
303    }
304
305    #[test]
306    fn test_deser() {
307        let instance = Content {
308            text: "hello".to_string(),
309            num_likes: 10,
310            published: true,
311            kind: Kind::Article,
312            kind2: Kind::Comment(String::new()),
313            kind3: Kind::Tuple(1, 1),
314            kind4: Kind::Other { truthy: true },
315            maybe: Some(42),
316            nothing: None,
317            user_id: UserId(1),
318        };
319        let val = Value::from_serializable(&instance);
320        let out = Content::deserialize(&val).unwrap();
321        assert_eq!(out, instance);
322        let out = Content::deserialize(val).unwrap();
323        assert_eq!(out, instance);
324    }
325}