json_five/
de.rs

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

json_five/
de.rs
