json_five/
de.rs

1use serde::de::{self, DeserializeSeed, Deserialize, Deserializer, MapAccess, SeqAccess, VariantAccess, Visitor};
2use std::fmt;
3use crate::parser::{JSONValue, JSONKeyValuePair, UnaryOperator, from_str as model_from_str};
4use crate::utils::unescape;
5#[derive(Debug)]
6pub enum SerdeJSON5Error {
7    Custom(String),
8}
9
10impl fmt::Display for SerdeJSON5Error {
11    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
12        match self {
13            SerdeJSON5Error::Custom(msg) => write!(f, "{}", msg),
14        }
15    }
16}
17
18impl std::error::Error for SerdeJSON5Error {}
19
20impl de::Error for SerdeJSON5Error {
21    fn custom<T: fmt::Display>(msg: T) -> Self {
22        SerdeJSON5Error::Custom(msg.to_string())
23    }
24}
25
26/// A small helper that wraps our `JSONValue` and implements
27/// `serde::Deserializer`.
28pub struct JSONValueDeserializer<'a> {
29    input: &'a JSONValue<'a>,
30}
31
32
33
34impl<'de, 'a> Deserializer<'de> for JSONValueDeserializer<'a> {
35    type Error = SerdeJSON5Error;
36
37    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
38    where
39        V: Visitor<'de>,
40    {
41        match self.input {
42            JSONValue::Null => visitor.visit_unit(),
43            JSONValue::Bool(b) => visitor.visit_bool(*b),
44            JSONValue::DoubleQuotedString(s) | JSONValue::SingleQuotedString(s) => {
45                visitor.visit_str(unescape(s).unwrap().as_str())
46            }
47            JSONValue::Identifier(s) => visitor.visit_str(unescape(s).unwrap().as_str()),
48            JSONValue::JSONObject { key_value_pairs } => {
49                // Treat as a map
50                let mut map_deserializer = JSONMapAccess {
51                    pairs: key_value_pairs,
52                    index: 0,
53                };
54                visitor.visit_map(&mut map_deserializer)
55            }
56            JSONValue::JSONArray { values } => {
57                let mut seq_deserializer = JSONSeqAccess {
58                    values,
59                    index: 0,
60                };
61                visitor.visit_seq(&mut seq_deserializer)
62            }
63            JSONValue::Integer(s) => {
64                // Attempt to parse as i64, or fallback to bigger integer handling as needed
65                if let Ok(i) = s.parse::<i64>() {
66                    visitor.visit_i64(i)
67                } else {
68                    // if it doesn't parse to i64, try as u64 or fallback to string
69                    if let Ok(u) = s.parse::<u64>() {
70                        visitor.visit_u64(u)
71                    } else {
72                        // fallback: treat as a string or produce an error
73                        Err(de::Error::custom(format!("Invalid integer {}", s)))
74                    }
75                }
76            }
77            JSONValue::Float(s) | JSONValue::Exponent(s) => {
78                // For floats (including exponent):
79                if let Ok(f) = s.parse::<f64>() {
80                    visitor.visit_f64(f)
81                } else {
82                    Err(de::Error::custom(format!("Invalid float {}", s)))
83                }
84            }
85            JSONValue::Infinity => visitor.visit_f64(f64::INFINITY),
86            JSONValue::NaN => visitor.visit_f64(f64::NAN),
87            JSONValue::Hexadecimal(s) => {
88                // Optionally convert to integer, or treat as string
89                match u64::from_str_radix(s.trim_start_matches("0x"), 16) {
90                    Ok(hex) => {
91                        visitor.visit_u64(hex)
92                    }
93                    Err(e) => {
94                        Err(de::Error::custom(format!("Invalid hex {}", e)))
95                    }
96                }
97            }
98            JSONValue::Unary { operator, value } => {
99                let sign = match operator {
100                    UnaryOperator::Plus => 1.0,
101                    UnaryOperator::Minus => -1.0,
102                };
103                let inner_de = JSONValueDeserializer { input: &**value };
104                let number: f64 = Deserialize::deserialize(inner_de)?;
105                visitor.visit_f64(sign * number)
106            }
107        }
108    }
109
110    // --- The following methods “forward” to deserialize_any by default. ---
111    // --- For efficiency/clarity, you can implement them specifically.  ---
112
113    fn deserialize_bool<V>(self, visitor: V) -> Result<V::Value, Self::Error>
114    where
115        V: Visitor<'de>,
116    {
117        self.deserialize_any(visitor)
118    }
119
120    fn deserialize_i8<V>(self, visitor: V) -> Result<V::Value, Self::Error>
121    where
122        V: Visitor<'de>
123    {
124        self.deserialize_any(visitor)
125    }
126
127    fn deserialize_i16<V>(self, visitor: V) -> Result<V::Value, Self::Error>
128    where
129        V: Visitor<'de>
130    {
131        self.deserialize_any(visitor)
132    }
133
134    fn deserialize_i32<V>(self, visitor: V) -> Result<V::Value, Self::Error>
135    where
136        V: Visitor<'de>
137    {
138        self.deserialize_any(visitor)
139    }
140
141    fn deserialize_i64<V>(self, visitor: V) -> Result<V::Value, Self::Error>
142    where
143        V: Visitor<'de>,
144    {
145        // Example: if we have an integer string, parse to i64
146        match self.input {
147            JSONValue::Integer(s) => {
148                let i = s.parse::<i64>().map_err(de::Error::custom)?;
149                visitor.visit_i64(i)
150            }
151            _ => self.deserialize_any(visitor),
152        }
153    }
154
155    fn deserialize_u8<V>(self, visitor: V) -> Result<V::Value, Self::Error>
156    where
157        V: Visitor<'de>
158    {
159        self.deserialize_any(visitor)
160    }
161
162    fn deserialize_u16<V>(self, visitor: V) -> Result<V::Value, Self::Error>
163    where
164        V: Visitor<'de>
165    {
166        self.deserialize_any(visitor)
167    }
168
169    fn deserialize_u32<V>(self, visitor: V) -> Result<V::Value, Self::Error>
170    where
171        V: Visitor<'de>
172    {
173        self.deserialize_any(visitor)
174    }
175
176    fn deserialize_u64<V>(self, visitor: V) -> Result<V::Value, Self::Error>
177    where
178        V: Visitor<'de>
179    {
180        self.deserialize_any(visitor)
181    }
182
183    fn deserialize_f32<V>(self, visitor: V) -> Result<V::Value, Self::Error>
184    where
185        V: Visitor<'de>
186    {
187        self.deserialize_any(visitor)
188    }
189
190    fn deserialize_f64<V>(self, visitor: V) -> Result<V::Value, Self::Error>
191    where
192        V: Visitor<'de>,
193    {
194        match self.input {
195            JSONValue::Float(s) | JSONValue::Exponent(s) => {
196                let f = s.parse::<f64>().map_err(de::Error::custom)?;
197                visitor.visit_f64(f)
198            }
199            JSONValue::Infinity => visitor.visit_f64(f64::INFINITY),
200            JSONValue::NaN => visitor.visit_f64(f64::NAN),
201            _ => self.deserialize_any(visitor),
202        }
203    }
204
205    fn deserialize_char<V>(self, visitor: V) -> Result<V::Value, Self::Error>
206    where
207        V: Visitor<'de>
208    {
209        self.deserialize_any(visitor)
210    }
211
212    fn deserialize_str<V>(self, visitor: V) -> Result<V::Value, Self::Error>
213    where
214        V: Visitor<'de>
215    {
216        self.deserialize_any(visitor)
217    }
218
219    fn deserialize_string<V>(self, visitor: V) -> Result<V::Value, Self::Error>
220    where
221        V: Visitor<'de>
222    {
223        self.deserialize_any(visitor)
224    }
225
226    fn deserialize_bytes<V>(self, visitor: V) -> Result<V::Value, Self::Error>
227    where
228        V: Visitor<'de>
229    {
230        self.deserialize_any(visitor)
231    }
232
233    fn deserialize_byte_buf<V>(self, visitor: V) -> Result<V::Value, Self::Error>
234    where
235        V: Visitor<'de>
236    {
237        self.deserialize_any(visitor)
238    }
239
240    // The rest are standard boilerplate.
241    fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Self::Error>
242    where
243        V: Visitor<'de>,
244    {
245        match self.input {
246            JSONValue::Null => visitor.visit_none(),
247            _ => visitor.visit_some(self),
248        }
249    }
250
251    fn deserialize_unit<V>(self, visitor: V) -> Result<V::Value, Self::Error>
252    where
253        V: Visitor<'de>,
254    {
255        if let JSONValue::Null = self.input {
256            visitor.visit_unit()
257        } else {
258            self.deserialize_any(visitor)
259        }
260    }
261
262    fn deserialize_unit_struct<V>(
263        self,
264        _name: &'static str,
265        visitor: V,
266    ) -> Result<V::Value, Self::Error>
267    where
268        V: Visitor<'de>,
269    {
270        self.deserialize_unit(visitor)
271    }
272
273    fn deserialize_newtype_struct<V>(
274        self,
275        _name: &'static str,
276        visitor: V,
277    ) -> Result<V::Value, Self::Error>
278    where
279        V: Visitor<'de>,
280    {
281        visitor.visit_newtype_struct(self)
282    }
283
284    fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value, Self::Error>
285    where
286        V: Visitor<'de>,
287    {
288        match self.input {
289            JSONValue::JSONArray { values } => {
290                let mut seq = JSONSeqAccess {
291                    values,
292                    index: 0,
293                };
294                visitor.visit_seq(&mut seq)
295            }
296            _ => self.deserialize_any(visitor),
297        }
298    }
299
300    fn deserialize_tuple<V>(
301        self,
302        _len: usize,
303        visitor: V,
304    ) -> Result<V::Value, Self::Error>
305    where
306        V: Visitor<'de>,
307    {
308        self.deserialize_seq(visitor)
309    }
310
311    fn deserialize_tuple_struct<V>(
312        self,
313        _name: &'static str,
314        _len: usize,
315        visitor: V,
316    ) -> Result<V::Value, Self::Error>
317    where
318        V: Visitor<'de>,
319    {
320        self.deserialize_seq(visitor)
321    }
322
323    fn deserialize_map<V>(self, visitor: V) -> Result<V::Value, Self::Error>
324    where
325        V: Visitor<'de>,
326    {
327        match self.input {
328            JSONValue::JSONObject { key_value_pairs } => {
329                let mut map = JSONMapAccess {
330                    pairs: key_value_pairs,
331                    index: 0,
332                };
333                visitor.visit_map(&mut map)
334            }
335            _ => self.deserialize_any(visitor),
336        }
337    }
338
339    fn deserialize_struct<V>(
340        self,
341        _name: &'static str,
342        _fields: &'static [&'static str],
343        visitor: V,
344    ) -> Result<V::Value, Self::Error>
345    where
346        V: Visitor<'de>,
347    {
348        self.deserialize_map(visitor)
349    }
350
351    fn deserialize_enum<V>(
352        self,
353        _name: &'static str,
354        _variants: &'static [&'static str],
355        visitor: V,
356    ) -> Result<V::Value, Self::Error>
357    where
358        V: Visitor<'de>,
359    {
360        // If you do not need enum support, you can skip or error out here.
361        // Otherwise interpret your JSONValue in a way that corresponds to an enum
362        // in user code.
363        use serde::de::IntoDeserializer;
364        match self.input {
365            JSONValue::Identifier(ident) | JSONValue::SingleQuotedString(ident) | JSONValue::DoubleQuotedString(ident) => {
366                // We'll treat the entire enum as a single variant with no payload:
367                visitor.visit_enum(ident.into_deserializer())
368            }
369            JSONValue::JSONObject { key_value_pairs } if !key_value_pairs.is_empty() => {
370                // Possibly the first key is your variant, the value is the data.
371                // Example pattern for `Tag: { /* contents */ }` style
372                let kv = &key_value_pairs[0];
373                match kv.key {
374                    JSONValue::Identifier(variant) | JSONValue::SingleQuotedString(variant) | JSONValue::DoubleQuotedString(variant) => {
375                        visitor.visit_enum(EnumDeserializer {variant, content: &kv.value})
376                    }
377                    _ => Err(de::Error::custom("Invalid enum representation"))
378                }
379            }
380            _ => Err(de::Error::custom("Unsupported enum representation")),
381        }
382    }
383
384    fn deserialize_identifier<V>(self, visitor: V) -> Result<V::Value, Self::Error>
385    where
386        V: Visitor<'de>,
387    {
388        match self.input {
389            JSONValue::Identifier(s)
390            | JSONValue::DoubleQuotedString(s)
391            | JSONValue::SingleQuotedString(s) => visitor.visit_str(unescape(s).unwrap().as_str()),
392            _ => self.deserialize_any(visitor),
393        }
394    }
395
396    fn deserialize_ignored_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
397    where
398        V: Visitor<'de>,
399    {
400        visitor.visit_unit()
401    }
402}
403
404/// Minimal SeqAccess implementation for arrays
405struct JSONSeqAccess<'a> {
406    values: &'a [JSONValue<'a>],
407    index: usize,
408}
409
410impl<'de, 'a> SeqAccess<'de> for JSONSeqAccess<'a> {
411    type Error = SerdeJSON5Error;
412
413    fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, SerdeJSON5Error>
414    where
415        T: DeserializeSeed<'de>,
416    {
417        if self.index < self.values.len() {
418            let deserializer = JSONValueDeserializer {
419                input: &self.values[self.index],
420            };
421            self.index += 1;
422            seed.deserialize(deserializer).map(Some)
423        } else {
424            Ok(None)
425        }
426    }
427}
428
429/// Minimal MapAccess implementation for objects
430struct JSONMapAccess<'a> {
431    pairs: &'a [JSONKeyValuePair<'a>],
432    index: usize,
433}
434
435impl<'de, 'a> MapAccess<'de> for JSONMapAccess<'a> {
436    type Error = SerdeJSON5Error;
437
438    fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>, SerdeJSON5Error>
439    where
440        K: DeserializeSeed<'de>,
441    {
442        if self.index < self.pairs.len() {
443            let deserializer = JSONValueDeserializer {
444                input: &self.pairs[self.index].key,
445            };
446            seed.deserialize(deserializer).map(Some)
447        } else {
448            Ok(None)
449        }
450    }
451
452    fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value, SerdeJSON5Error>
453    where
454        V: DeserializeSeed<'de>,
455    {
456        let deserializer = JSONValueDeserializer {
457            input: &self.pairs[self.index].value,
458        };
459        self.index += 1;
460        seed.deserialize(deserializer)
461    }
462}
463
464/// If you need to handle complex enum representations:
465struct EnumDeserializer<'a> {
466    variant: &'a str,
467    content: &'a JSONValue<'a>,
468}
469
470impl<'de, 'a> de::EnumAccess<'de> for EnumDeserializer<'a> {
471    type Error = SerdeJSON5Error;
472    type Variant = JSONValueDeserializer<'a>;
473
474    fn variant_seed<V>(self, seed: V) -> Result<(V::Value, Self::Variant), SerdeJSON5Error>
475    where
476        V: DeserializeSeed<'de>,
477    {
478        use serde::de::IntoDeserializer;
479        let val = seed.deserialize(self.variant.into_deserializer())?;
480        Ok((val, JSONValueDeserializer { input: self.content }))
481    }
482}
483
484impl<'de, 'a> VariantAccess<'de> for JSONValueDeserializer<'a> {
485    type Error = SerdeJSON5Error;
486
487    fn unit_variant(self) -> Result<(), Self::Error> {
488        // If the variant is expected to have no value, do nothing:
489        match self.input {
490            JSONValue::Null => {Ok(())}
491            _ => {
492                Err(de::Error::custom("Unit variants must be null"))
493            }
494        }
495
496    }
497
498    fn newtype_variant_seed<T>(self, seed: T) -> Result<T::Value, Self::Error>
499    where
500        T: de::DeserializeSeed<'de>,
501    {
502        // If the variant is a "newtype" (e.g. `MyEnum::Variant(SomeData)`),
503        // call deserialize on *this* deserializer to parse it.
504        seed.deserialize(self)
505    }
506
507    fn tuple_variant<V>(
508        self,
509        _len: usize,
510        visitor: V,
511    ) -> Result<V::Value, Self::Error>
512    where
513        V: Visitor<'de>,
514    {
515        // If the variant is a tuple, we can delegate to `deserialize_seq`.
516        self.deserialize_seq(visitor)
517    }
518
519    fn struct_variant<V>(
520        self,
521        _fields: &'static [&'static str],
522        visitor: V,
523    ) -> Result<V::Value, Self::Error>
524    where
525        V: Visitor<'de>,
526    {
527        // If the variant is a struct, we can delegate to `deserialize_map`.
528        self.deserialize_map(visitor)
529    }
530}
531
532/// Deserialize str to your values/structs/etc. compatible with the serde data model
533///
534///
535/// # Examples
536///
537/// ```rust
538/// use json_five::from_str;
539/// use serde::Deserialize;
540/// #[derive(Debug, PartialEq, Deserialize)]
541/// struct MyData {
542///     name: String,
543///     count: i64,
544///     maybe: Option<f64>,
545/// }
546///
547/// fn main() {
548///     let source = r#"
549///     // A possible JSON5 input
550///     {
551///       name: 'Hello',
552///       count: 42,
553///       maybe: null
554///     }
555/// "#;
556///
557///     let parsed = from_str::<MyData>(source).unwrap();
558///     let expected = MyData {name: "Hello".to_string(), count: 42, maybe: None};
559///     assert_eq!(parsed, expected);
560/// }
561/// ```
562///
563/// For convenience in dealing with arbitrary valid JSON5 documents, you may use `serde_json`'s [`Value` enum](https://docs.rs/serde_json/latest/serde_json/enum.Value.html).
564/// with this crate. This may be something implemented or vendored into `json-five` in the future.
565///
566pub fn from_str<'de, T>(s: &'de str) -> Result<T, SerdeJSON5Error>
567where
568    T: Deserialize<'de>,
569{
570    // 1) Parse the string into your JSONText
571    let parsed = model_from_str(s).map_err(|err| SerdeJSON5Error::Custom(err.to_string()))?;
572
573    // 2) Wrap the JSONValue in our deserializer
574    let deserializer = JSONValueDeserializer {
575        input: &parsed.value,
576    };
577
578    // 3) Deserialize into the caller’s type T
579    T::deserialize(deserializer)
580}
581
582#[cfg(test)]
583mod test {
584    use std::collections::HashMap;
585    use serde::Deserialize;
586    use super::*;
587    #[derive(Debug, Deserialize)]
588    struct MyData {
589        name: String,
590        count: i64,
591        maybe: Option<f64>,
592    }
593    #[test]
594    fn main() {
595        let source = r#"
596        // A possible JSON5 input
597        {
598          name: 'Hello',
599          count: 42,
600          maybe: NaN
601        }
602    "#;
603
604        match from_str::<MyData>(source) {
605            Ok(data) => {
606                println!("Parsed data: {:?}", data);
607                println!("{}{}{:?}", data.name, data.count, data.maybe)
608            }
609            Err(e) => {
610                println!("Error: {:?}", e);
611            }
612        }
613    }
614
615    #[test]
616    fn test_hashmap() {
617        let source = r#"
618        // A possible JSON5 input
619        {
620          name: 'Hello',
621          count: '42',
622          maybe: null
623        }
624    "#;
625
626        let res: HashMap<String, Option<String>> = from_str(source).unwrap();
627        let expected = HashMap::from([
628            (String::from("name"), Some(String::from("Hello"))),
629            (String::from("count"), Some(String::from("42"))),
630            (String::from("maybe"), None),
631        ]);
632        assert_eq!(res, expected)
633
634    }
635
636
637}
638
639#[cfg(test)]
640mod json5_compat_tests {
641    use super::*; // Bring in your `from_str` parser.
642    use std::collections::BTreeMap; // Or HashMap, if preferred.
643    use serde::{Deserialize, Serialize};
644
645    /// A minimal JSON5-like "value" type for testing.
646    /// Adjust as needed for your parser’s feature set.
647    #[derive(Debug, PartialEq, Deserialize)]
648    #[serde(untagged)]
649    enum MyValue {
650        Null,
651        Bool(bool),
652        Number(f64),
653        String(String),
654        Array(Vec<MyValue>),
655        Object(BTreeMap<String, MyValue>),
656    }
657
658    /// Helper to parse a string with your JSON5 parser under test.
659    fn parse_test(input: &str) -> MyValue {
660        match from_str::<MyValue>(input) {
661            Ok(v) => v,
662            Err(e) => panic!("Error parsing input: {:?}", e),
663        }
664    }
665
666    // ------------------------------------------------------------------------
667    // Objects
668    // ------------------------------------------------------------------------
669
670    #[test]
671    fn object_empty() {
672        let v = parse_test(r#"{}"#);
673        match v {
674            MyValue::Object(map) => assert!(map.is_empty()),
675            _ => panic!("Expected an empty object"),
676        }
677    }
678
679    #[test]
680    fn object_double_quoted_key() {
681        let v = parse_test(r#"{"a":1}"#);
682        match v {
683            MyValue::Object(map) => {
684                assert_eq!(map.get("a"), Some(&MyValue::Number(1.0)));
685            }
686            _ => panic!("Expected an object with key 'a' = 1"),
687        }
688    }
689
690    #[test]
691    fn object_single_quoted_key() {
692        let v = parse_test(r#"{'a':1}"#);
693        match v {
694            MyValue::Object(map) => {
695                assert_eq!(map.get("a"), Some(&MyValue::Number(1.0)));
696            }
697            _ => panic!("Expected an object with key 'a' = 1"),
698        }
699    }
700
701    #[test]
702    fn object_unquoted_key() {
703        let v = parse_test(r#"{a:1}"#);
704        match v {
705            MyValue::Object(map) => {
706                assert_eq!(map.get("a"), Some(&MyValue::Number(1.0)));
707            }
708            _ => panic!("Expected an object with key 'a' = 1"),
709        }
710    }
711
712    #[test]
713    fn object_special_keys() {
714        let v = parse_test(r#"{$_:1,_$:2,a\u200C:3}"#);
715        dbg!(&v);
716        match v {
717            MyValue::Object(map) => {
718                assert_eq!(map.get("$_"), Some(&MyValue::Number(1.0)));
719                assert_eq!(map.get("_$"), Some(&MyValue::Number(2.0)));
720                assert_eq!(map.get("a\u{200C}"), Some(&MyValue::Number(3.0)));
721            }
722            _ => panic!("Expected an object with special keys $_, _$, and a\u{200C}"),
723        }
724    }
725
726    #[test]
727    fn object_unicode_key() {
728        let v = parse_test(r#"{ùńîċõďë:9}"#);
729        match v {
730            MyValue::Object(map) => {
731                assert_eq!(map.get("ùńîċõďë"), Some(&MyValue::Number(9.0)));
732            }
733            _ => panic!("Expected an object with unicode key 'ùńîċõďë' = 9"),
734        }
735    }
736
737
738    #[test]
739    fn object_unicode_key_quoted() {
740        let v = parse_test(r#"{"ùńîċõďë":9}"#);
741        match v {
742            MyValue::Object(map) => {
743                assert_eq!(map.get("ùńîċõďë"), Some(&MyValue::Number(9.0)));
744            }
745            _ => panic!("Expected an object with unicode key 'ùńîċõďë' = 9"),
746        }
747    }
748
749    #[test]
750    fn object_escaped_keys() {
751        let v = parse_test(r#"{\u0061\u0062:1,\u0024\u005F:2,\u005F\u0024:3}"#);
752        dbg!(&v);
753        match v {
754            MyValue::Object(map) => {
755                // \u0061\u0062 -> "ab"
756                assert_eq!(map.get("ab"), Some(&MyValue::Number(1.0)));
757                // \u0024\u005F -> "$_"
758                assert_eq!(map.get("$_"), Some(&MyValue::Number(2.0)));
759                // \u005F\u0024 -> "_$"
760                assert_eq!(map.get("_$"), Some(&MyValue::Number(3.0)));
761            }
762            _ => panic!("Expected escaped keys"),
763        }
764    }
765
766    #[test]
767    fn object_proto_name() {
768        let v = parse_test(r#"{"__proto__":1}"#);
769        match v {
770            MyValue::Object(map) => {
771                // In Rust, it's just a normal key:
772                assert_eq!(map.get("__proto__"), Some(&MyValue::Number(1.0)));
773            }
774            _ => panic!("Expected object with '__proto__' key"),
775        }
776    }
777
778    #[test]
779    fn object_multiple_properties() {
780        let v = parse_test(r#"{abc:1,def:2}"#);
781        match v {
782            MyValue::Object(map) => {
783                assert_eq!(map.get("abc"), Some(&MyValue::Number(1.0)));
784                assert_eq!(map.get("def"), Some(&MyValue::Number(2.0)));
785            }
786            _ => panic!("Expected object with {{abc:1,def:2}}"),
787        }
788    }
789
790    #[test]
791    fn object_nested() {
792        let v = parse_test(r#"{a:{b:2}}"#);
793        match v {
794            MyValue::Object(outer) => {
795                match outer.get("a") {
796                    Some(MyValue::Object(inner)) => {
797                        assert_eq!(inner.get("b"), Some(&MyValue::Number(2.0)));
798                    }
799                    _ => panic!("Expected a nested object {{b:2}}"),
800                }
801            }
802            _ => panic!("Expected object with key 'a'"),
803        }
804    }
805
806    // ------------------------------------------------------------------------
807    // Arrays
808    // ------------------------------------------------------------------------
809
810    #[test]
811    fn array_empty() {
812        let v = parse_test(r#"[]"#);
813        match v {
814            MyValue::Array(arr) => {
815                assert!(arr.is_empty());
816            }
817            _ => panic!("Expected an empty array"),
818        }
819    }
820
821    #[test]
822    fn array_single_value() {
823        let v = parse_test(r#"[1]"#);
824        match v {
825            MyValue::Array(arr) => {
826                assert_eq!(arr.len(), 1);
827                assert_eq!(arr[0], MyValue::Number(1.0));
828            }
829            _ => panic!("Expected [1]"),
830        }
831    }
832
833    #[test]
834    fn array_multiple_values() {
835        let v = parse_test(r#"[1,2]"#);
836        match v {
837            MyValue::Array(arr) => {
838                assert_eq!(arr, vec![MyValue::Number(1.0), MyValue::Number(2.0)]);
839            }
840            _ => panic!("Expected [1,2]"),
841        }
842    }
843
844    #[test]
845    fn array_nested() {
846        let v = parse_test(r#"[1,[2,3]]"#);
847        match v {
848            MyValue::Array(arr) => {
849                assert_eq!(arr.len(), 2);
850                assert_eq!(arr[0], MyValue::Number(1.0));
851                match &arr[1] {
852                    MyValue::Array(inner) => {
853                        assert_eq!(inner, &vec![MyValue::Number(2.0), MyValue::Number(3.0)]);
854                    }
855                    _ => panic!("Expected a nested array [2,3]"),
856                }
857            }
858            _ => panic!("Expected an array with nested array"),
859        }
860    }
861
862
863    #[test]
864    fn parse_null() {
865        let v = parse_test(r#"null"#);
866        assert_eq!(v, MyValue::Null);
867    }
868
869    #[test]
870    fn parse_true() {
871        let v = parse_test(r#"true"#);
872        assert_eq!(v, MyValue::Bool(true));
873    }
874
875    #[test]
876    fn parse_false() {
877        let v = parse_test(r#"false"#);
878        assert_eq!(v, MyValue::Bool(false));
879    }
880
881
882    #[test]
883    fn numbers_leading_zeroes() {
884        let v = parse_test(r#"[0,0.,0e0,]"#);
885        match v {
886            MyValue::Array(arr) => {
887                // All are 0.
888                assert_eq!(arr, vec![
889                    MyValue::Number(0.0),
890                    MyValue::Number(0.0),
891                    MyValue::Number(0.0),
892                ]);
893            }
894            _ => panic!("Expected array of zeros"),
895        }
896    }
897
898    #[test]
899    fn numbers_trailing_zeroes() {
900        let v = parse_test(r#"[.0]"#);
901        match v {
902            MyValue::Array(arr) => {
903                // All are 0.
904                assert_eq!(arr, vec![
905                    MyValue::Number(0.0),
906                ]);
907            }
908            _ => panic!("Expected array of zeros"),
909        }
910    }
911    #[test]
912    fn numbers_integers() {
913        let v = parse_test(r#"[1,23,456,7890]"#);
914        match v {
915            MyValue::Array(arr) => {
916                assert_eq!(arr, vec![
917                    MyValue::Number(1.0),
918                    MyValue::Number(23.0),
919                    MyValue::Number(456.0),
920                    MyValue::Number(7890.0),
921                ]);
922            }
923            _ => panic!("Expected integer array"),
924        }
925    }
926
927    #[test]
928    fn numbers_signed() {
929        let v = parse_test(r#"[-1,+2,-.1,-0]"#);
930        match v {
931            MyValue::Array(arr) => {
932                // Some tricky floating-point checks:
933                assert_eq!(arr[0], MyValue::Number(-1.0));
934                assert_eq!(arr[1], MyValue::Number(2.0));
935                assert_eq!(arr[2], MyValue::Number(-0.1));
936                // -0 is 0.0 in float equality:
937                let minus_zero = match arr[3] {
938                    MyValue::Number(f) => f,
939                    _ => panic!("Expected a number for -0"),
940                };
941                assert_eq!(minus_zero, 0.0);
942            }
943            _ => panic!("Expected array of signed numbers"),
944        }
945    }
946
947    #[test]
948    fn numbers_leading_decimal() {
949        let v = parse_test(r#"[.1,.23]"#);
950        match v {
951            MyValue::Array(arr) => {
952                assert_eq!(arr, vec![MyValue::Number(0.1), MyValue::Number(0.23)]);
953            }
954            _ => panic!("Expected array of leading-decimal numbers"),
955        }
956    }
957
958    #[test]
959    fn numbers_fractional() {
960        let v = parse_test(r#"[1.0,1.23]"#);
961        match v {
962            MyValue::Array(arr) => {
963                assert_eq!(arr, vec![MyValue::Number(1.0), MyValue::Number(1.23)]);
964            }
965            _ => panic!("Expected array with fractional numbers"),
966        }
967    }
968
969    #[test]
970    fn numbers_exponents() {
971        let v = parse_test(r#"[1e0,1e1,1e01,1.e0,1.1e0,1e-1,1e+1]"#);
972        match v {
973            MyValue::Array(arr) => {
974                let expected = vec![
975                    MyValue::Number(1.0),
976                    MyValue::Number(10.0),
977                    MyValue::Number(10.0),
978                    MyValue::Number(1.0),
979                    MyValue::Number(1.1),
980                    MyValue::Number(0.1),
981                    MyValue::Number(10.0),
982                ];
983                assert_eq!(arr, expected);
984            }
985            _ => panic!("Expected array of exponent numbers"),
986        }
987    }
988
989    #[test]
990    fn numbers_hexadecimal() {
991        let v = parse_test(r#"[0x1,0x10,0xff,0xFF]"#);
992        match v {
993            MyValue::Array(arr) => {
994                let expected = vec![
995                    MyValue::Number(1.0),
996                    MyValue::Number(16.0),
997                    MyValue::Number(255.0),
998                    MyValue::Number(255.0),
999                ];
1000                assert_eq!(arr, expected);
1001            }
1002            _ => panic!("Expected array of hex numbers"),
1003        }
1004    }
1005
1006    #[test]
1007    fn numbers_infinity() {
1008        let v = parse_test(r#"[Infinity,-Infinity]"#);
1009        match v {
1010            MyValue::Array(arr) => {
1011                match arr.as_slice() {
1012                    [MyValue::Number(a), MyValue::Number(b)] => {
1013                        assert!(a.is_infinite() && a.is_sign_positive());
1014                        assert!(b.is_infinite() && b.is_sign_negative());
1015                    }
1016                    _ => panic!("Expected [Infinity, -Infinity]"),
1017                }
1018            }
1019            _ => panic!("Expected array"),
1020        }
1021    }
1022
1023    #[test]
1024    fn numbers_nan() {
1025        let v = parse_test(r#"NaN"#);
1026        match v {
1027            MyValue::Number(f) => assert!(f.is_nan()),
1028            _ => panic!("Expected NaN"),
1029        }
1030    }
1031
1032    #[test]
1033    fn numbers_negative_nan() {
1034        let v = parse_test(r#"-NaN"#);
1035        match v {
1036            MyValue::Number(f) => assert!(f.is_nan()),
1037            _ => panic!("Expected -NaN"),
1038        }
1039    }
1040
1041    #[test]
1042    fn numbers_single() {
1043        let v = parse_test(r#"1"#);
1044        assert_eq!(v, MyValue::Number(1.0));
1045    }
1046
1047    #[test]
1048    fn numbers_signed_explicit() {
1049        let v = parse_test(r#"+1.23e100"#);
1050        match v {
1051            MyValue::Number(f) => {
1052                assert_eq!(f, 1.23e100);
1053            }
1054            _ => panic!("Expected +1.23e100 as a number"),
1055        }
1056    }
1057
1058    #[test]
1059    fn numbers_bare_hex() {
1060        let v = parse_test(r#"0x1"#);
1061        assert_eq!(v, MyValue::Number(1.0));
1062    }
1063
1064    #[test]
1065    #[should_panic]
1066    fn numbers_bare_long_hex() {
1067        let v = parse_test(r#"-0x0123456789abcdefABCDEF"#);
1068        match v {
1069            MyValue::Number(f) => {
1070                // Very large; f might be approximate in float form. We just check it's a number.
1071                assert!(f.is_sign_negative());
1072            }
1073            _ => panic!("Expected a negative large hex as a float number"),
1074        }
1075    }
1076
1077
1078    #[test]
1079    fn strings_double_quoted() {
1080        let v = parse_test(r#""abc""#);
1081        assert_eq!(v, MyValue::String("abc".to_owned()));
1082    }
1083
1084    #[test]
1085    fn strings_single_quoted() {
1086        let v = parse_test(r#"'abc'"#);
1087        assert_eq!(v, MyValue::String("abc".to_owned()));
1088    }
1089
1090    #[test]
1091    fn strings_quotes_in_strings() {
1092        let v = parse_test(r#"['"',"'"]"#);
1093        match v {
1094            MyValue::Array(arr) => {
1095                assert_eq!(arr, vec![
1096                    MyValue::String("\"".to_owned()),
1097                    MyValue::String("'".to_owned()),
1098                ]);
1099            }
1100            _ => panic!("Expected an array with double-quote and single-quote strings"),
1101        }
1102    }
1103
1104    #[test]
1105    fn strings_escaped_chars() {
1106        // The JavaScript test includes many escapes plus line continuations.
1107        let input = "'\\a\\b\\f\\n\\r\\t\\v\\0\\x0f\\u01fF\\\n\\\r\n\\\r\\\u{2028}\\\u{2029}\\'\\\"'";
1108        println!("{:?}", input);
1109        let v = parse_test(input);
1110        let expected = String::from("\x07\x08\x0C\n\r\t\x0B\0\x0f\u{01fF}\n\r\n\r\u{2028}\u{2029}'\"");
1111        match v {
1112            MyValue::String(s) => {
1113                assert_eq!(s, expected)
1114            }
1115            _ => panic!("Expected an escaped string"),
1116        }
1117    }
1118
1119    #[test]
1120    fn strings_line_paragraph_separators() {
1121        let v = parse_test(r#"'\u2028\u2029'"#);
1122        match v {
1123            MyValue::String(s) => {
1124                assert_eq!(s, "\u{2028}\u{2029}");
1125            }
1126            _ => panic!("Expected string with line/paragraph separators"),
1127        }
1128    }
1129
1130
1131    #[test]
1132    fn comments_single_line() {
1133        let input = r#"{// comment
1134        }"#;
1135        let v = parse_test(input);
1136        match v {
1137            MyValue::Object(map) => assert!(map.is_empty()),
1138            _ => panic!("Expected empty object"),
1139        }
1140    }
1141
1142    #[test]
1143    fn comments_single_line_at_end() {
1144        let input = r#"{}// comment"#;
1145        let v = parse_test(input);
1146        match v {
1147            MyValue::Object(map) => assert!(map.is_empty()),
1148            _ => panic!("Expected empty object"),
1149        }
1150    }
1151
1152    #[test]
1153    fn comments_multi_line() {
1154        let input = r#"{/* comment
1155        ** */}"#;
1156        let v = parse_test(input);
1157        match v {
1158            MyValue::Object(map) => assert!(map.is_empty()),
1159            _ => panic!("Expected empty object"),
1160        }
1161    }
1162
1163    #[test]
1164    fn whitespace() {
1165        // Includes tabs, vertical tabs, form feeds, non-breaking spaces, etc.
1166        let input = "{\t\u{000B}\u{000C} \u{00A0}\u{FEFF}\n\r\u{2028}\u{2029}\u{2003}}";
1167        let v = parse_test(input);
1168        match v {
1169            MyValue::Object(map) => assert!(map.is_empty()),
1170            _ => panic!("Expected empty object after whitespace"),
1171        }
1172    }
1173
1174    #[test]
1175    fn test_gh_11() {
1176        use crate::from_str;
1177        #[derive(Debug, Clone, serde::Deserialize, Serialize, PartialEq)]
1178        #[serde(rename_all="snake_case")]
1179        enum SomeEnum{
1180            VariantA(String),
1181            VariantB,
1182        }
1183
1184        #[derive(Debug, Clone, serde::Deserialize, Serialize)]
1185        struct SomeStruct {
1186            some_enum: SomeEnum
1187        }
1188
1189
1190        let json5 = r#"{some_enum: "variant_b" }"#;
1191        let parsed: SomeStruct = from_str(json5).unwrap();
1192        assert_eq!(parsed.some_enum, SomeEnum::VariantB);
1193
1194        let json5 = r#"{some_enum: {"variant_b": null} }"#;
1195        let parsed: SomeStruct = from_str(json5).unwrap();
1196        assert_eq!(parsed.some_enum, SomeEnum::VariantB);
1197
1198
1199        let json5 = r#"{some_enum: { "variant_b": {} }}"#;
1200        let maybe_res: Result<SomeStruct, _> = from_str(json5);
1201        let err = maybe_res.unwrap_err();
1202    }
1203}
json_five/de.rs

json_five/
de.rs
