jmap_tools/json/
deserializer.rs

1/*
2 * SPDX-FileCopyrightText: 2021 Pascal Seitz <pascal.seitz@gmail.com>
3 *
4 * SPDX-License-Identifier: Apache-2.0 OR MIT
5 */
6
7use std::borrow::Cow;
8
9use crate::json::key::Key;
10use crate::json::num::N;
11use crate::{Element, Property, Value};
12use serde::Deserializer;
13use serde::de::{self, IntoDeserializer, MapAccess, SeqAccess, Visitor};
14
15impl<'de, P: Property, E: Element> IntoDeserializer<'de, de::value::Error>
16    for &'de Value<'_, P, E>
17{
18    type Deserializer = Self;
19
20    fn into_deserializer(self) -> Self::Deserializer {
21        self
22    }
23}
24
25impl<'de, P: Property, E: Element> Deserializer<'de> for &'de Value<'_, P, E> {
26    type Error = de::value::Error;
27
28    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
29    where
30        V: Visitor<'de>,
31    {
32        match self {
33            Value::Null => visitor.visit_unit(),
34            Value::Bool(b) => visitor.visit_bool(*b),
35            Value::Number(n) => match n.n {
36                N::PosInt(u) => visitor.visit_u64(u),
37                N::NegInt(i) => visitor.visit_i64(i),
38                N::Float(f) => visitor.visit_f64(f),
39            },
40            Value::Str(s) => visitor.visit_borrowed_str(s),
41            Value::Array(arr) => {
42                let seq = SeqDeserializer::new(arr);
43                visitor.visit_seq(seq)
44            }
45            Value::Object(map) => {
46                let map = MapDeserializer::new(map.as_vec().as_slice());
47                visitor.visit_map(map)
48            }
49            Value::Element(e) => match e.to_cow() {
50                Cow::Borrowed(s) => visitor.visit_borrowed_str(s),
51                Cow::Owned(s) => visitor.visit_string(s),
52            },
53        }
54    }
55
56    fn deserialize_bool<V>(self, visitor: V) -> Result<V::Value, Self::Error>
57    where
58        V: Visitor<'de>,
59    {
60        self.deserialize_any(visitor)
61    }
62
63    fn deserialize_i8<V>(self, visitor: V) -> Result<V::Value, Self::Error>
64    where
65        V: Visitor<'de>,
66    {
67        self.deserialize_any(visitor)
68    }
69
70    fn deserialize_i16<V>(self, visitor: V) -> Result<V::Value, Self::Error>
71    where
72        V: Visitor<'de>,
73    {
74        self.deserialize_any(visitor)
75    }
76
77    fn deserialize_i32<V>(self, visitor: V) -> Result<V::Value, Self::Error>
78    where
79        V: Visitor<'de>,
80    {
81        self.deserialize_any(visitor)
82    }
83
84    fn deserialize_i64<V>(self, visitor: V) -> Result<V::Value, Self::Error>
85    where
86        V: Visitor<'de>,
87    {
88        self.deserialize_any(visitor)
89    }
90
91    fn deserialize_u8<V>(self, visitor: V) -> Result<V::Value, Self::Error>
92    where
93        V: Visitor<'de>,
94    {
95        self.deserialize_any(visitor)
96    }
97
98    fn deserialize_u16<V>(self, visitor: V) -> Result<V::Value, Self::Error>
99    where
100        V: Visitor<'de>,
101    {
102        self.deserialize_any(visitor)
103    }
104
105    fn deserialize_u32<V>(self, visitor: V) -> Result<V::Value, Self::Error>
106    where
107        V: Visitor<'de>,
108    {
109        self.deserialize_any(visitor)
110    }
111
112    fn deserialize_u64<V>(self, visitor: V) -> Result<V::Value, Self::Error>
113    where
114        V: Visitor<'de>,
115    {
116        self.deserialize_any(visitor)
117    }
118
119    fn deserialize_f32<V>(self, visitor: V) -> Result<V::Value, Self::Error>
120    where
121        V: Visitor<'de>,
122    {
123        self.deserialize_any(visitor)
124    }
125
126    fn deserialize_f64<V>(self, visitor: V) -> Result<V::Value, Self::Error>
127    where
128        V: Visitor<'de>,
129    {
130        self.deserialize_any(visitor)
131    }
132
133    fn deserialize_char<V>(self, visitor: V) -> Result<V::Value, Self::Error>
134    where
135        V: Visitor<'de>,
136    {
137        self.deserialize_any(visitor)
138    }
139
140    fn deserialize_str<V>(self, visitor: V) -> Result<V::Value, Self::Error>
141    where
142        V: Visitor<'de>,
143    {
144        self.deserialize_any(visitor)
145    }
146
147    fn deserialize_string<V>(self, visitor: V) -> Result<V::Value, Self::Error>
148    where
149        V: Visitor<'de>,
150    {
151        self.deserialize_any(visitor)
152    }
153
154    fn deserialize_bytes<V>(self, visitor: V) -> Result<V::Value, Self::Error>
155    where
156        V: Visitor<'de>,
157    {
158        self.deserialize_byte_buf(visitor)
159    }
160
161    fn deserialize_byte_buf<V>(self, visitor: V) -> Result<V::Value, Self::Error>
162    where
163        V: Visitor<'de>,
164    {
165        self.deserialize_any(visitor)
166    }
167
168    fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Self::Error>
169    where
170        V: Visitor<'de>,
171    {
172        match self {
173            Value::Null => visitor.visit_none(),
174            _ => visitor.visit_some(self),
175        }
176    }
177
178    fn deserialize_unit<V>(self, visitor: V) -> Result<V::Value, Self::Error>
179    where
180        V: Visitor<'de>,
181    {
182        self.deserialize_any(visitor)
183    }
184
185    fn deserialize_newtype_struct<V>(
186        self,
187        _name: &'static str,
188        visitor: V,
189    ) -> Result<V::Value, Self::Error>
190    where
191        V: Visitor<'de>,
192    {
193        visitor.visit_newtype_struct(self)
194    }
195
196    fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value, Self::Error>
197    where
198        V: Visitor<'de>,
199    {
200        self.deserialize_any(visitor)
201    }
202
203    fn deserialize_tuple<V>(self, _len: usize, visitor: V) -> Result<V::Value, Self::Error>
204    where
205        V: Visitor<'de>,
206    {
207        self.deserialize_seq(visitor)
208    }
209
210    fn deserialize_tuple_struct<V>(
211        self,
212        _name: &'static str,
213        _len: usize,
214        visitor: V,
215    ) -> Result<V::Value, Self::Error>
216    where
217        V: Visitor<'de>,
218    {
219        self.deserialize_seq(visitor)
220    }
221
222    fn deserialize_map<V>(self, visitor: V) -> Result<V::Value, Self::Error>
223    where
224        V: Visitor<'de>,
225    {
226        self.deserialize_any(visitor)
227    }
228
229    fn deserialize_enum<V>(
230        self,
231        _name: &'static str,
232        _variants: &'static [&'static str],
233        _visitor: V,
234    ) -> Result<V::Value, Self::Error>
235    where
236        V: Visitor<'de>,
237    {
238        Err(de::Error::custom("deserialize_enum is not yet supported"))
239    }
240
241    fn deserialize_identifier<V>(self, visitor: V) -> Result<V::Value, Self::Error>
242    where
243        V: Visitor<'de>,
244    {
245        self.deserialize_string(visitor)
246    }
247
248    fn deserialize_ignored_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
249    where
250        V: Visitor<'de>,
251    {
252        visitor.visit_unit()
253    }
254
255    fn deserialize_unit_struct<V>(
256        self,
257        _name: &'static str,
258        visitor: V,
259    ) -> Result<V::Value, Self::Error>
260    where
261        V: Visitor<'de>,
262    {
263        self.deserialize_unit(visitor)
264    }
265
266    fn deserialize_struct<V>(
267        self,
268        _name: &'static str,
269        _fields: &'static [&'static str],
270        visitor: V,
271    ) -> Result<V::Value, Self::Error>
272    where
273        V: Visitor<'de>,
274    {
275        self.deserialize_any(visitor)
276    }
277}
278
279// Helper struct to deserialize sequences (arrays).
280struct SeqDeserializer<'a, 'ctx, P: Property, E: Element> {
281    iter: std::slice::Iter<'a, Value<'ctx, P, E>>,
282}
283
284impl<'a, 'ctx, P: Property, E: Element> SeqDeserializer<'a, 'ctx, P, E> {
285    fn new(slice: &'a [Value<'ctx, P, E>]) -> Self {
286        SeqDeserializer { iter: slice.iter() }
287    }
288}
289
290impl<'de, 'a: 'de, 'ctx: 'de, P: Property, E: Element> SeqAccess<'de>
291    for SeqDeserializer<'a, 'ctx, P, E>
292{
293    type Error = de::value::Error;
294
295    fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Self::Error>
296    where
297        T: de::DeserializeSeed<'de>,
298    {
299        self.iter
300            .next()
301            .map(|value| seed.deserialize(value))
302            .transpose()
303    }
304}
305
306// Helper struct to deserialize maps (objects).
307struct MapDeserializer<'a, 'ctx, P: Property, E: Element> {
308    iter: std::slice::Iter<'a, (Key<'ctx, P>, Value<'ctx, P, E>)>,
309    value: Option<&'a Value<'ctx, P, E>>,
310}
311
312impl<'a, 'ctx, P: Property, E: Element> MapDeserializer<'a, 'ctx, P, E> {
313    fn new(map: &'a [(Key<'ctx, P>, Value<'ctx, P, E>)]) -> Self {
314        MapDeserializer {
315            iter: map.iter(),
316            value: None,
317        }
318    }
319}
320
321impl<'de, 'a: 'de, 'ctx: 'de, P: Property, E: Element> MapAccess<'de>
322    for MapDeserializer<'a, 'ctx, P, E>
323{
324    type Error = de::value::Error;
325
326    fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>, Self::Error>
327    where
328        K: de::DeserializeSeed<'de>,
329    {
330        if let Some((key, value)) = self.iter.next() {
331            self.value = Some(value);
332            match key.to_string() {
333                Cow::Borrowed(key) => seed
334                    .deserialize(de::value::BorrowedStrDeserializer::new(key))
335                    .map(Some),
336                Cow::Owned(key) => seed
337                    .deserialize(de::value::StringDeserializer::new(key))
338                    .map(Some),
339            }
340        } else {
341            Ok(None)
342        }
343    }
344
345    fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value, Self::Error>
346    where
347        V: de::DeserializeSeed<'de>,
348    {
349        match self.value.take() {
350            Some(value) => seed.deserialize(value),
351            None => Err(de::Error::custom("value is missing")),
352        }
353    }
354}
355
356#[cfg(test)]
357mod tests {
358    use serde::Deserialize;
359    use serde::de::value::Error as DeError;
360    use serde::de::{IgnoredAny, IntoDeserializer};
361
362    use crate::json::num::N;
363    use crate::{Key, Null, Value};
364
365    // Basic deserialization test for null value
366    #[test]
367    fn test_deserialize_null() {
368        let value: Value<'_, Null, Null> = Value::Null;
369        let deserialized: Option<i32> = Deserialize::deserialize(&value).unwrap();
370        assert_eq!(deserialized, None);
371    }
372
373    // Test deserialization of boolean value
374    #[test]
375    fn test_deserialize_bool() {
376        let value: Value<'_, Null, Null> = Value::Bool(true);
377        let deserialized: bool = Deserialize::deserialize(&value).unwrap();
378        assert!(deserialized);
379    }
380
381    #[test]
382    fn test_into_deserializer_bool() {
383        let value: Value<'_, Null, Null> = Value::Bool(true);
384
385        // Convert Value to deserializer using IntoDeserializer
386        let deserializer = (&value).into_deserializer();
387        let deserialized: bool = Deserialize::deserialize(deserializer).unwrap();
388
389        assert!(deserialized);
390    }
391
392    // Test deserialization of integer (i64) value
393    #[test]
394    fn test_deserialize_i64() {
395        let value: Value<'_, Null, Null> = Value::Number(N::NegInt(-42).into());
396        let deserialized: i64 = Deserialize::deserialize(&value).unwrap();
397        assert_eq!(deserialized, -42);
398    }
399
400    // Test deserialization of unsigned integer (u64) value
401    #[test]
402    fn test_deserialize_u64() {
403        let value: Value<'_, Null, Null> = Value::Number(N::PosInt(42).into());
404        let deserialized: u64 = Deserialize::deserialize(&value).unwrap();
405        assert_eq!(deserialized, 42);
406    }
407
408    // Test deserialization of floating point (f64) value
409    #[test]
410    fn test_deserialize_f64() {
411        let value: Value<'_, Null, Null> = Value::Number(N::Float(42.5).into());
412        let deserialized: f64 = Deserialize::deserialize(&value).unwrap();
413        assert_eq!(deserialized, 42.5);
414    }
415
416    // Test deserialization of string value
417    #[test]
418    fn test_deserialize_str() {
419        let value: Value<'_, Null, Null> = Value::Str("Hello".into());
420        let deserialized: String = Deserialize::deserialize(&value).unwrap();
421        assert_eq!(deserialized, "Hello");
422    }
423
424    // Test deserialization of optional value when null
425    #[test]
426    fn test_deserialize_option_none() {
427        let value: Value<'_, Null, Null> = Value::Null;
428        let deserialized: Option<i64> = Deserialize::deserialize(&value).unwrap();
429        assert_eq!(deserialized, None);
430    }
431
432    // Test deserialization of optional value when present
433    #[test]
434    fn test_deserialize_option_some() {
435        let value: Value<'_, Null, Null> = Value::Number(N::PosInt(42).into());
436        let deserialized: Option<u64> = Deserialize::deserialize(&value).unwrap();
437        assert_eq!(deserialized, Some(42));
438    }
439
440    // Test deserialization of an array (sequence of values)
441    #[test]
442    fn test_deserialize_array() {
443        let value: Value<'_, Null, Null> = Value::Array(vec![
444            Value::Number(N::PosInt(1).into()),
445            Value::Number(N::PosInt(2).into()),
446            Value::Number(N::PosInt(3).into()),
447        ]);
448
449        let deserialized: Vec<u64> = Deserialize::deserialize(&value).unwrap();
450        assert_eq!(deserialized, vec![1, 2, 3]);
451    }
452
453    // Test deserialization of a map (object)
454    #[test]
455    fn test_deserialize_map() {
456        let value: Value<'_, Null, Null> = Value::Object(
457            vec![
458                (Key::Borrowed("key1"), Value::Number(N::PosInt(1).into())),
459                (Key::Borrowed("key2"), Value::Number(N::PosInt(2).into())),
460                (Key::Borrowed("key3"), Value::Number(N::PosInt(3).into())),
461            ]
462            .into(),
463        );
464
465        let deserialized: std::collections::HashMap<String, u64> =
466            Deserialize::deserialize(&value).unwrap();
467
468        let mut expected = std::collections::HashMap::new();
469        expected.insert("key1".to_string(), 1);
470        expected.insert("key2".to_string(), 2);
471        expected.insert("key3".to_string(), 3);
472
473        assert_eq!(deserialized, expected);
474    }
475
476    // Test deserialization of a tuple
477    #[test]
478    fn test_deserialize_tuple() {
479        let value: Value<'_, Null, Null> = Value::Array(vec![
480            Value::Number(N::PosInt(1).into()),
481            Value::Str("Hello".into()),
482        ]);
483
484        let deserialized: (u64, String) = Deserialize::deserialize(&value).unwrap();
485        assert_eq!(deserialized, (1, "Hello".to_string()));
486    }
487
488    // Test deserialization of a nested structure (array within an object)
489    #[test]
490    fn test_deserialize_nested() {
491        let value: Value<'_, Null, Null> = Value::Object(
492            vec![(
493                Key::Borrowed("numbers"),
494                Value::Array(vec![
495                    Value::Number(N::PosInt(1).into()),
496                    Value::Number(N::PosInt(2).into()),
497                    Value::Number(N::PosInt(3).into()),
498                ]),
499            )]
500            .into(),
501        );
502
503        #[derive(Deserialize, Debug, PartialEq)]
504        struct Nested {
505            numbers: Vec<u64>,
506        }
507
508        let deserialized: Nested = Deserialize::deserialize(&value).unwrap();
509        assert_eq!(
510            deserialized,
511            Nested {
512                numbers: vec![1, 2, 3]
513            }
514        );
515    }
516
517    // Test deserialization of a newtype struct
518    #[derive(Debug, Deserialize, PartialEq)]
519    struct NewtypeStruct(u64);
520
521    #[test]
522    fn test_deserialize_newtype_struct() {
523        let value: Value<'_, Null, Null> = Value::Number(N::PosInt(42).into());
524        let deserialized: NewtypeStruct = Deserialize::deserialize(&value).unwrap();
525        assert_eq!(deserialized, NewtypeStruct(42));
526    }
527
528    #[test]
529    fn test_deserialize_ignored_any_with_string() {
530        let value: Value<'_, Null, Null> = Value::Str("Ignored".into());
531
532        let _deserialized: IgnoredAny = Deserialize::deserialize(&value).unwrap();
533    }
534
535    // Test deserialization failure (for an unsupported type like enum)
536    #[test]
537    fn test_deserialize_enum_fails() {
538        let value: Value<'_, Null, Null> = Value::Str("EnumVariant".into());
539        let result: Result<(), DeError> = Deserialize::deserialize(&value);
540        assert!(result.is_err());
541    }
542}
jmap_tools/json/deserializer.rs

jmap_tools/json/
deserializer.rs
