php_literal_parser/
serde_impl.rs

1use serde::de::{
2    self, DeserializeSeed, EnumAccess, IntoDeserializer, MapAccess, SeqAccess, VariantAccess,
3    Visitor,
4};
5use serde::Deserialize;
6
7use crate::error::{ArrayKeyError, ArrayKeyErrorKind, ExpectToken, ResultExt, TrailingError};
8use crate::lexer::{SpannedToken, Token};
9use crate::num::ParseIntError;
10use crate::parser::{ArraySyntax, Parser};
11use crate::{Key, ParseError};
12use std::collections::VecDeque;
13use std::convert::TryFrom;
14
15type Result<T> = std::result::Result<T, ParseError>;
16
17pub struct Deserializer<'de> {
18    parser: Parser<'de>,
19    peeked: VecDeque<SpannedToken<'de>>,
20}
21
22impl<'de> Deserializer<'de> {
23    pub fn from_str(input: &'de str) -> Self {
24        Deserializer {
25            parser: Parser::new(input),
26            peeked: Default::default(),
27        }
28    }
29
30    pub fn source(&self) -> &'de str {
31        self.parser.source()
32    }
33}
34
35/// Parse a php literal
36///
37/// ## Example
38///
39/// ```rust
40/// use php_literal_parser::{from_str, Value, Key};
41/// # use std::fmt::Debug;
42/// # use std::error::Error;
43///
44/// # fn main() -> Result<(), Box<dyn Error>> {
45/// let map = from_str::<Value>(r#"["foo" => true, "nested" => ['foo' => false]]"#)?;
46///
47/// assert_eq!(map["foo"], true);
48/// assert_eq!(map["nested"]["foo"], false);
49/// # Ok(())
50/// # }
51/// ```
52///
53pub fn from_str<'a, T>(s: &'a str) -> Result<T>
54where
55    T: Deserialize<'a>,
56{
57    let mut deserializer = Deserializer::from_str(s);
58    let t = T::deserialize(&mut deserializer)?;
59    match deserializer.next_token() {
60        None
61        | Some(SpannedToken {
62            token: Token::SemiColon,
63            ..
64        }) => Ok(t),
65        Some(token) => Err(TrailingError::new(s, token.span.start..token.span.start).into()),
66    }
67}
68
69impl<'de> Deserializer<'de> {
70    fn next_token(&mut self) -> Option<SpannedToken<'de>> {
71        self.peeked.pop_front().or_else(|| self.parser.next_token())
72    }
73
74    fn peek_token(&mut self) -> Option<&SpannedToken<'de>> {
75        if self.peeked.is_empty() {
76            let next = self.next_token()?;
77            self.peeked.push_back(next)
78        }
79        self.peeked.front()
80    }
81
82    fn eat_token(&mut self) {
83        let _ = self.next_token();
84    }
85
86    fn parse_bool(&mut self) -> Result<bool> {
87        let token = self
88            .next_token()
89            .expect_token(&[Token::Bool], self.source())?;
90        self.parser.parse_bool_token(token)
91    }
92
93    fn push_peeked(&mut self, peeked: SpannedToken<'de>) {
94        self.peeked.push_back(peeked)
95    }
96
97    fn parse_unsigned<T>(&mut self) -> Result<T>
98    where
99        T: TryFrom<i64>,
100    {
101        let token = self
102            .next_token()
103            .expect_token(&[Token::Integer], self.source())?;
104        let span = token.span.clone();
105        let int = self.parser.parse_int_token(token)?;
106        if int < 0 {
107            Err(ParseIntError::UnexpectedNegative).with_span(span, self.source())
108        } else {
109            Ok(T::try_from(int)
110                .or_else(|_| Err(ParseIntError::Overflow).with_span(span, self.source()))?)
111        }
112    }
113
114    fn parse_signed<T>(&mut self) -> Result<T>
115    where
116        T: TryFrom<i64>,
117    {
118        let token = self
119            .next_token()
120            .expect_token(&[Token::Integer], self.source())?;
121        let span = token.span.clone();
122        T::try_from(self.parser.parse_int_token(token)?)
123            .or_else(|_| Err(ParseIntError::Overflow).with_span(span, self.source()))
124    }
125
126    fn parse_float(&mut self) -> Result<f64> {
127        let token = self
128            .next_token()
129            .expect_token(&[Token::Float], self.source())?;
130        self.parser.parse_float_token(token)
131    }
132
133    fn parse_string(&mut self) -> Result<String> {
134        let token = self
135            .next_token()
136            .expect_token(&[Token::LiteralString], self.source())?;
137        self.parser.parse_string_token(token)
138    }
139}
140
141impl<'de, 'a> de::Deserializer<'de> for &'a mut Deserializer<'de> {
142    type Error = ParseError;
143
144    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value>
145    where
146        V: Visitor<'de>,
147    {
148        let source = self.source();
149        let peek = self.peek_token().expect_token(
150            &[
151                Token::Null,
152                Token::Bool,
153                Token::LiteralString,
154                Token::Integer,
155                Token::Float,
156                Token::Array,
157                Token::SquareOpen,
158            ],
159            source,
160        )?;
161        match peek.token {
162            Token::Null => self.deserialize_unit(visitor),
163            Token::Bool => self.deserialize_bool(visitor),
164            Token::LiteralString => self.deserialize_string(visitor),
165            Token::Integer => self.deserialize_i64(visitor),
166            Token::Float => self.deserialize_f64(visitor),
167            Token::Array | Token::SquareOpen => self.deserialize_map(visitor),
168            _ => unreachable!(),
169        }
170    }
171
172    fn deserialize_bool<V>(self, visitor: V) -> Result<V::Value>
173    where
174        V: Visitor<'de>,
175    {
176        visitor.visit_bool(self.parse_bool()?)
177    }
178
179    // The `parse_signed` function is generic over the integer type `T` so here
180    // it is invoked with `T=i8`. The next 8 methods are similar.
181    fn deserialize_i8<V>(self, visitor: V) -> Result<V::Value>
182    where
183        V: Visitor<'de>,
184    {
185        visitor.visit_i8(self.parse_signed()?)
186    }
187
188    fn deserialize_i16<V>(self, visitor: V) -> Result<V::Value>
189    where
190        V: Visitor<'de>,
191    {
192        visitor.visit_i16(self.parse_signed()?)
193    }
194
195    fn deserialize_i32<V>(self, visitor: V) -> Result<V::Value>
196    where
197        V: Visitor<'de>,
198    {
199        visitor.visit_i32(self.parse_signed()?)
200    }
201
202    fn deserialize_i64<V>(self, visitor: V) -> Result<V::Value>
203    where
204        V: Visitor<'de>,
205    {
206        visitor.visit_i64(self.parse_signed()?)
207    }
208
209    fn deserialize_u8<V>(self, visitor: V) -> Result<V::Value>
210    where
211        V: Visitor<'de>,
212    {
213        visitor.visit_u8(self.parse_unsigned()?)
214    }
215
216    fn deserialize_u16<V>(self, visitor: V) -> Result<V::Value>
217    where
218        V: Visitor<'de>,
219    {
220        visitor.visit_u16(self.parse_unsigned()?)
221    }
222
223    fn deserialize_u32<V>(self, visitor: V) -> Result<V::Value>
224    where
225        V: Visitor<'de>,
226    {
227        visitor.visit_u32(self.parse_unsigned()?)
228    }
229
230    fn deserialize_u64<V>(self, visitor: V) -> Result<V::Value>
231    where
232        V: Visitor<'de>,
233    {
234        visitor.visit_u64(self.parse_unsigned()?)
235    }
236
237    fn deserialize_f32<V>(self, visitor: V) -> Result<V::Value>
238    where
239        V: Visitor<'de>,
240    {
241        visitor.visit_f32(self.parse_float()? as f32)
242    }
243
244    fn deserialize_f64<V>(self, visitor: V) -> Result<V::Value>
245    where
246        V: Visitor<'de>,
247    {
248        visitor.visit_f64(self.parse_float()?)
249    }
250
251    // The `Serializer` implementation on the previous page serialized chars as
252    // single-character strings so handle that representation here.
253    fn deserialize_char<V>(self, _visitor: V) -> Result<V::Value>
254    where
255        V: Visitor<'de>,
256    {
257        // Parse a string, check that it is one character, call `visit_char`.
258        unimplemented!()
259    }
260
261    // Refer to the "Understanding deserializer lifetimes" page for information
262    // about the three deserialization flavors of strings in Serde.
263    fn deserialize_str<V>(self, visitor: V) -> Result<V::Value>
264    where
265        V: Visitor<'de>,
266    {
267        let str = self.parse_string()?;
268        visitor.visit_str(str.as_str())
269    }
270
271    fn deserialize_string<V>(self, visitor: V) -> Result<V::Value>
272    where
273        V: Visitor<'de>,
274    {
275        visitor.visit_string(self.parse_string()?)
276    }
277
278    // The `Serializer` implementation on the previous page serialized byte
279    // arrays as JSON arrays of bytes. Handle that representation here.
280    fn deserialize_bytes<V>(self, _visitor: V) -> Result<V::Value>
281    where
282        V: Visitor<'de>,
283    {
284        todo!()
285    }
286
287    fn deserialize_byte_buf<V>(self, _visitor: V) -> Result<V::Value>
288    where
289        V: Visitor<'de>,
290    {
291        todo!()
292        // visitor.visit_string(self.parse_string()?.to_vec())
293    }
294
295    // An absent optional is represented as the JSON `null` and a present
296    // optional is represented as just the contained value.
297    //
298    // As commented in `Serializer` implementation, this is a lossy
299    // representation. For example the values `Some(())` and `None` both
300    // serialize as just `null`. Unfortunately this is typically what people
301    // expect when working with JSON. Other formats are encouraged to behave
302    // more intelligently if possible.
303    fn deserialize_option<V>(self, visitor: V) -> Result<V::Value>
304    where
305        V: Visitor<'de>,
306    {
307        let source = self.source();
308        let token = self.peek_token().expect_token(
309            &[
310                Token::Null,
311                Token::Bool,
312                Token::LiteralString,
313                Token::Integer,
314                Token::Float,
315                Token::Array,
316                Token::SquareOpen,
317            ],
318            source,
319        )?;
320        if token.token == Token::Null {
321            let _ = self.next_token();
322            visitor.visit_none()
323        } else {
324            visitor.visit_some(self)
325        }
326    }
327
328    fn deserialize_unit<V>(self, visitor: V) -> Result<V::Value>
329    where
330        V: Visitor<'de>,
331    {
332        self.next_token()
333            .expect_token(&[Token::Null], self.source())?;
334        visitor.visit_unit()
335    }
336
337    fn deserialize_unit_struct<V>(self, _name: &'static str, visitor: V) -> Result<V::Value>
338    where
339        V: Visitor<'de>,
340    {
341        self.deserialize_unit(visitor)
342    }
343
344    fn deserialize_newtype_struct<V>(self, _name: &'static str, visitor: V) -> Result<V::Value>
345    where
346        V: Visitor<'de>,
347    {
348        visitor.visit_newtype_struct(self)
349    }
350
351    fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value>
352    where
353        V: Visitor<'de>,
354    {
355        let token = self
356            .next_token()
357            .expect_token(&[Token::Array, Token::SquareOpen], self.source())?;
358        let syntax = match token.token {
359            Token::Array => {
360                self.next_token()
361                    .expect_token(&[Token::BracketOpen], self.source())?;
362                ArraySyntax::Long
363            }
364            Token::SquareOpen => ArraySyntax::Short,
365            _ => unreachable!(),
366        };
367
368        let value = visitor.visit_seq(ArrayWalker::new(self, syntax))?;
369        Ok(value)
370    }
371
372    fn deserialize_tuple<V>(self, _len: usize, visitor: V) -> Result<V::Value>
373    where
374        V: Visitor<'de>,
375    {
376        self.deserialize_seq(visitor)
377    }
378
379    fn deserialize_tuple_struct<V>(
380        self,
381        _name: &'static str,
382        _len: usize,
383        visitor: V,
384    ) -> Result<V::Value>
385    where
386        V: Visitor<'de>,
387    {
388        self.deserialize_seq(visitor)
389    }
390
391    fn deserialize_map<V>(self, visitor: V) -> Result<V::Value>
392    where
393        V: Visitor<'de>,
394    {
395        let token = self
396            .next_token()
397            .expect_token(&[Token::Array, Token::SquareOpen], self.source())?;
398        let syntax = match token.token {
399            Token::Array => {
400                self.next_token()
401                    .expect_token(&[Token::BracketOpen], self.source())?;
402                ArraySyntax::Long
403            }
404            Token::SquareOpen => ArraySyntax::Short,
405            _ => unreachable!(),
406        };
407
408        let value = visitor.visit_map(ArrayWalker::new(self, syntax))?;
409        Ok(value)
410    }
411
412    fn deserialize_struct<V>(
413        self,
414        _name: &'static str,
415        _fields: &'static [&'static str],
416        visitor: V,
417    ) -> Result<V::Value>
418    where
419        V: Visitor<'de>,
420    {
421        self.deserialize_map(visitor)
422    }
423
424    fn deserialize_enum<V>(
425        self,
426        _name: &'static str,
427        _variants: &'static [&'static str],
428        visitor: V,
429    ) -> Result<V::Value>
430    where
431        V: Visitor<'de>,
432    {
433        let source = self.source();
434        let token = self.peek_token().expect_token(
435            &[Token::LiteralString, Token::Array, Token::SquareOpen],
436            source,
437        )?;
438        match token.token {
439            Token::LiteralString => visitor.visit_enum(self.parse_string()?.into_deserializer()),
440            Token::Array | Token::SquareOpen => {
441                self.eat_token();
442                let syntax = if token.token == Token::Array {
443                    self.next_token()
444                        .expect_token(&[Token::BracketOpen], self.source())?;
445                    ArraySyntax::Long
446                } else {
447                    ArraySyntax::Short
448                };
449
450                let value = visitor.visit_enum(Enum::new(self))?;
451                self.next_token()
452                    .expect_token(&[syntax.close_bracket()], self.source())?;
453                Ok(value)
454            }
455            _ => unreachable!(),
456        }
457    }
458
459    fn deserialize_identifier<V>(self, visitor: V) -> Result<V::Value>
460    where
461        V: Visitor<'de>,
462    {
463        self.deserialize_str(visitor)
464    }
465
466    fn deserialize_ignored_any<V>(self, visitor: V) -> Result<V::Value>
467    where
468        V: Visitor<'de>,
469    {
470        self.deserialize_any(visitor)
471    }
472}
473
474struct ArrayWalker<'source, 'a> {
475    de: &'a mut Deserializer<'source>,
476    next_int_key: i64,
477    syntax: ArraySyntax,
478    done: bool,
479}
480
481impl<'source, 'a> ArrayWalker<'source, 'a> {
482    pub fn new(de: &'a mut Deserializer<'source>, syntax: ArraySyntax) -> Self {
483        ArrayWalker {
484            de,
485            next_int_key: 0,
486            syntax,
487            done: false,
488        }
489    }
490
491    fn source(&self) -> &'source str {
492        self.de.source()
493    }
494}
495
496impl<'de, 'a> SeqAccess<'de> for ArrayWalker<'de, 'a> {
497    type Error = ParseError;
498
499    fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>>
500    where
501        T: DeserializeSeed<'de>,
502    {
503        if self.done {
504            return Ok(None);
505        }
506
507        let token = self.de.next_token().expect_token(
508            &[
509                Token::Bool,
510                Token::Integer,
511                Token::Float,
512                Token::LiteralString,
513                Token::Null,
514                Token::Array,
515                Token::SquareOpen,
516                self.syntax.close_bracket(),
517            ],
518            self.source(),
519        )?;
520
521        if token.token == self.syntax.close_bracket() {
522            self.done = true;
523            return Ok(None);
524        }
525
526        let next = self.de.next_token().expect_token(
527            &[self.syntax.close_bracket(), Token::Comma, Token::Arrow],
528            self.source(),
529        )?;
530
531        let value_token = match next.token {
532            Token::Comma => token,
533            Token::Arrow => {
534                let span = token.span.clone();
535                let key = self.de.parser.parse_array_key(token)?;
536                match key {
537                    Key::Int(key) if key == self.next_int_key => Ok(()),
538                    Key::Int(_) => Err(ParseError::UnexpectedArrayKey(ArrayKeyError::new(
539                        ArrayKeyErrorKind::NonConsecutive,
540                        self.source(),
541                        span,
542                    ))),
543                    _ => Err(ParseError::UnexpectedArrayKey(ArrayKeyError::new(
544                        ArrayKeyErrorKind::IntegerExpected,
545                        self.source(),
546                        span,
547                    ))),
548                }?;
549                self.next_int_key += 1;
550                let value = self.de.next_token().expect_token(
551                    &[
552                        Token::Bool,
553                        Token::Integer,
554                        Token::Float,
555                        Token::LiteralString,
556                        Token::Null,
557                        Token::Array,
558                        Token::SquareOpen,
559                    ],
560                    self.source(),
561                )?;
562                let next = self
563                    .de
564                    .next_token()
565                    .expect_token(&[Token::Comma, self.syntax.close_bracket()], self.source())?;
566                if next.token == self.syntax.close_bracket() {
567                    self.done = true;
568                }
569                value
570            }
571            peeked_token if peeked_token == self.syntax.close_bracket() => {
572                self.done = true;
573                token
574            }
575            _ => unreachable!(),
576        };
577
578        // Deserialize an array element.
579        self.de.push_peeked(value_token);
580        seed.deserialize(&mut *self.de).map(Some)
581    }
582}
583
584impl<'de, 'a> MapAccess<'de> for ArrayWalker<'de, 'a> {
585    type Error = ParseError;
586
587    fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>>
588    where
589        K: DeserializeSeed<'de>,
590    {
591        if self.done {
592            return Ok(None);
593        }
594
595        let token = self.de.next_token().expect_token(
596            &[
597                Token::Bool,
598                Token::Integer,
599                Token::Float,
600                Token::LiteralString,
601                Token::Null,
602                self.syntax.close_bracket(),
603                // below is only when this token is a value with implicit key, not a when the token is a key
604                Token::Array,
605                Token::SquareOpen,
606            ],
607            self.source(),
608        )?;
609
610        if token.token == self.syntax.close_bracket() {
611            self.done = true;
612            return Ok(None);
613        }
614
615        let next = self.de.next_token().ok_or_else(|| {
616            Option::<SpannedToken>::None
617                .expect_token(
618                    &[Token::Arrow, Token::Comma, self.syntax.close_bracket()],
619                    self.source(),
620                )
621                .unwrap_err()
622        })?;
623
624        match next.token {
625            Token::Arrow => {
626                // now we know it's a map key, the expected token is a bit more strict
627                let token = token.expect_token(
628                    &[
629                        Token::Bool,
630                        Token::Integer,
631                        Token::Float,
632                        Token::LiteralString,
633                        Token::Null,
634                        self.syntax.close_bracket(),
635                    ],
636                    self.source(),
637                )?;
638                // Deserialize a map key.
639                if let Key::Int(int_key) = self.de.parser.parse_array_key(token.clone())? {
640                    self.next_int_key = int_key + 1;
641                }
642                self.de.push_peeked(token);
643                seed.deserialize(&mut *self.de).map(Some)
644            }
645            _ => {
646                // implicit key
647                let key = self.next_int_key;
648                self.next_int_key += 1;
649                self.de.push_peeked(token);
650                self.de.push_peeked(next);
651                seed.deserialize(format!("{}", key).into_deserializer())
652                    .map(Some)
653            }
654        }
655    }
656
657    fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value>
658    where
659        V: DeserializeSeed<'de>,
660    {
661        let source = self.source();
662        self.de.peek_token().expect_token(
663            &[
664                Token::Bool,
665                Token::Integer,
666                Token::Float,
667                Token::LiteralString,
668                Token::Null,
669                Token::Array,
670                Token::SquareOpen,
671            ],
672            source,
673        )?;
674
675        // Deserialize a map key.
676        let value = seed.deserialize(&mut *self.de)?;
677
678        let next = self
679            .de
680            .next_token()
681            .expect_token(&[Token::Comma, self.syntax.close_bracket()], self.source())?;
682
683        if next.token == self.syntax.close_bracket() {
684            self.done = true;
685        }
686        Ok(value)
687    }
688}
689
690struct Enum<'a, 'de: 'a> {
691    de: &'a mut Deserializer<'de>,
692}
693
694impl<'a, 'de> Enum<'a, 'de> {
695    fn new(de: &'a mut Deserializer<'de>) -> Self {
696        Enum { de }
697    }
698
699    fn source(&self) -> &'de str {
700        self.de.source()
701    }
702}
703
704// `EnumAccess` is provided to the `Visitor` to give it the ability to determine
705// which variant of the enum is supposed to be deserialized.
706//
707// Note that all enum deserialization methods in Serde refer exclusively to the
708// "externally tagged" enum representation.
709impl<'de, 'a> EnumAccess<'de> for Enum<'a, 'de> {
710    type Error = ParseError;
711    type Variant = Self;
712
713    fn variant_seed<V>(self, seed: V) -> Result<(V::Value, Self::Variant)>
714    where
715        V: DeserializeSeed<'de>,
716    {
717        let val = seed.deserialize(&mut *self.de)?;
718        self.de
719            .next_token()
720            .expect_token(&[Token::Arrow], self.source())?;
721        Ok((val, self))
722    }
723}
724
725// `VariantAccess` is provided to the `Visitor` to give it the ability to see
726// the content of the single variant that it decided to deserialize.
727impl<'de, 'a> VariantAccess<'de> for Enum<'a, 'de> {
728    type Error = ParseError;
729
730    fn unit_variant(self) -> Result<()> {
731        self.de
732            .next_token()
733            .expect_token(&[Token::LiteralString], self.source())?;
734        Ok(())
735    }
736
737    fn newtype_variant_seed<T>(self, seed: T) -> Result<T::Value>
738    where
739        T: DeserializeSeed<'de>,
740    {
741        seed.deserialize(self.de)
742    }
743
744    fn tuple_variant<V>(self, _len: usize, visitor: V) -> Result<V::Value>
745    where
746        V: Visitor<'de>,
747    {
748        de::Deserializer::deserialize_seq(self.de, visitor)
749    }
750
751    fn struct_variant<V>(self, _fields: &'static [&'static str], visitor: V) -> Result<V::Value>
752    where
753        V: Visitor<'de>,
754    {
755        de::Deserializer::deserialize_map(self.de, visitor)
756    }
757}
758
759////////////////////////////////////////////////////////////////////////////////
760
761#[cfg(test)]
762mod tests {
763    use serde_derive::Deserialize;
764
765    fn from_str<'a, T>(source: &'a str) -> super::Result<T>
766    where
767        T: serde::Deserialize<'a>,
768    {
769        match super::from_str(source) {
770            Ok(res) => Ok(res),
771            Err(err) => {
772                eprintln!("{}", err);
773                Err(err)
774            }
775        }
776    }
777
778    #[test]
779    fn test_vec() {
780        let j = r#"["a","b"]"#;
781        let expected: Vec<String> = vec!["a".to_string(), "b".to_string()];
782        assert_eq!(expected, from_str::<Vec<String>>(j).unwrap());
783    }
784
785    #[test]
786    fn test_vec_explicit_keys() {
787        let j = r#"[0=>"a", 1=>"b"]"#;
788        let expected: Vec<String> = vec!["a".to_string(), "b".to_string()];
789        assert_eq!(expected, from_str::<Vec<String>>(j).unwrap());
790    }
791
792    #[test]
793    fn test_struct() {
794        #[derive(Deserialize, PartialEq, Debug)]
795        struct Test {
796            int: u32,
797            seq: Vec<String>,
798        }
799
800        let j = r#"["int"=>1,"seq"=>["a","b"]]"#;
801        let expected = Test {
802            int: 1,
803            seq: vec!["a".to_owned(), "b".to_owned()],
804        };
805        assert_eq!(expected, from_str(j).unwrap());
806    }
807
808    #[test]
809    fn test_struct_nested() {
810        #[derive(Deserialize, PartialEq, Debug)]
811        struct Inner {
812            a: f32,
813            b: bool,
814        }
815
816        #[derive(Deserialize, PartialEq, Debug)]
817        struct Test {
818            int: u32,
819            nested: Inner,
820        }
821
822        let j = r#"["int"=>1,"nested"=>["a" => 1.0, "b" => false]]"#;
823        let expected = Test {
824            int: 1,
825            nested: Inner { a: 1.0, b: false },
826        };
827        assert_eq!(expected, from_str(j).unwrap());
828    }
829
830    #[test]
831    fn test_enum() {
832        #[derive(Deserialize, PartialEq, Debug)]
833        enum E {
834            Unit,
835            Newtype1(u32),
836            Newtype2(u32),
837            Tuple(u32, u32),
838            Struct { a: u32 },
839        }
840
841        let j = r#""Unit""#;
842        let expected = E::Unit;
843        assert_eq!(expected, from_str(j).unwrap());
844
845        let j = r#"["Newtype1"=>1]"#;
846        let expected = E::Newtype1(1);
847        assert_eq!(expected, from_str(j).unwrap());
848
849        let j = r#"["Newtype2"=>1]"#;
850        let expected = E::Newtype2(1);
851        assert_eq!(expected, from_str(j).unwrap());
852
853        let j = r#"["Tuple"=>[1,2]]"#;
854        let expected = E::Tuple(1, 2);
855        assert_eq!(expected, from_str(j).unwrap());
856
857        let j = r#"["Struct"=>["a"=>1]]"#;
858        let expected = E::Struct { a: 1 };
859        assert_eq!(expected, from_str(j).unwrap());
860    }
861}
php_literal_parser/serde_impl.rs

php_literal_parser/
serde_impl.rs
