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

json_five/
de.rs
