vdf_reader/
serde.rs

1use crate::entry::{string_is_array, Entry, ParseItem};
2use crate::error::{ExpectToken, NoValidTokenError, ResultExt, SerdeParseError, UnknownError};
3use crate::tokenizer::{SpannedToken, Tokenizer};
4use crate::{Token, VdfError};
5use logos::Span;
6use serde_core::de::{
7    self, DeserializeSeed, EnumAccess, MapAccess, SeqAccess, VariantAccess, Visitor,
8};
9use serde_core::Deserialize;
10use std::borrow::Cow;
11
12type Result<T, E = VdfError> = std::result::Result<T, E>;
13
14pub struct Deserializer<'de> {
15    tokenizer: Tokenizer<'de>,
16    peeked: Option<Result<SpannedToken, Span>>,
17    last_key: Cow<'de, str>,
18    last_span: Span,
19}
20
21const STRING_ITEMS: &[Token] = &[
22    Token::Item,
23    Token::QuotedItem,
24    Token::Statement,
25    Token::QuotedStatement,
26];
27
28impl<'de> Deserializer<'de> {
29    pub fn from_str(input: &'de str) -> Self {
30        Deserializer {
31            tokenizer: Tokenizer::from_str(input),
32            peeked: None,
33            last_key: "".into(),
34            last_span: 0..0,
35        }
36    }
37
38    pub fn source(&self) -> &'de str {
39        self.tokenizer.source()
40    }
41
42    pub fn next(&mut self) -> Option<Result<SpannedToken, Span>> {
43        self.peeked
44            .take()
45            .or_else(|| self.tokenizer.next())
46            .map(|r| {
47                r.map(|t| {
48                    self.last_span = t.span.clone();
49                    t
50                })
51                .map_err(|span| {
52                    self.last_span = span.clone();
53                    span
54                })
55            })
56    }
57
58    pub fn peek(&mut self) -> Option<Result<SpannedToken, Span>> {
59        if self.peeked.is_none() {
60            self.peeked = self.tokenizer.next();
61        }
62        self.peeked.clone()
63    }
64
65    fn peek_span(&mut self) -> Option<Span> {
66        self.peek().and_then(|r| r.ok()).map(|token| token.span)
67    }
68
69    pub fn push_peeked(&mut self, token: SpannedToken) {
70        self.peeked = Some(Ok(token))
71    }
72
73    fn read_str(&mut self) -> Result<(Cow<'de, str>, Span)> {
74        let token = self.next().expect_token(STRING_ITEMS, self.source())?;
75        Ok((token.string(self.source()), token.span))
76    }
77
78    fn parse<T: ParseItem>(&mut self) -> Result<T> {
79        let (str, span) = self.read_str()?;
80        T::from_str(str.as_ref())
81            .map_err(|e| SerdeParseError::new(e.ty, &e.value, span, self.source()).into())
82    }
83
84    fn set_last_key(&mut self, key: Cow<'de, str>) {
85        self.last_key = key;
86    }
87}
88
89pub fn from_str<'a, T>(s: &'a str) -> Result<T>
90where
91    T: Deserialize<'a>,
92{
93    let mut deserializer = Deserializer::from_str(s);
94    T::deserialize(&mut deserializer)
95}
96
97pub fn from_entry<'a, T>(entry: Entry) -> Result<T>
98where
99    T: Deserialize<'a>,
100{
101    T::deserialize(entry)
102}
103
104const VALUE_TOKEN: &[Token] = &[
105    Token::Item,
106    Token::QuotedItem,
107    Token::Statement,
108    Token::QuotedStatement,
109    Token::GroupStart,
110];
111
112impl<'de> de::Deserializer<'de> for &'_ mut Deserializer<'de> {
113    type Error = VdfError;
114
115    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value>
116    where
117        V: Visitor<'de>,
118    {
119        let source = self.source();
120        let token = self.next().expect_token(VALUE_TOKEN, source)?;
121        let span = token.span.clone();
122        match token.token {
123            Token::Item | Token::QuotedItem | Token::Statement | Token::QuotedStatement => {
124                let str = token.string(self.source());
125                // note: we don't check for bool as we can't distinguish those from numbers
126                if let Ok(int) = i64::from_str(str.as_ref()) {
127                    return visitor.visit_i64(int).ensure_span(span, self.source());
128                }
129                if let Ok(float) = f64::from_str(str.as_ref()) {
130                    return visitor.visit_f64(float).ensure_span(span, self.source());
131                }
132                if string_is_array(&str) {
133                    self.push_peeked(token);
134                    return self
135                        .deserialize_seq(visitor)
136                        .ensure_span(span, self.source());
137                }
138                match str {
139                    Cow::Borrowed(str) => visitor
140                        .visit_borrowed_str(str)
141                        .ensure_span(span, self.source()),
142                    Cow::Owned(str) => visitor.visit_string(str).ensure_span(span, self.source()),
143                }
144            }
145            Token::GroupStart => {
146                let res = visitor.visit_map(TableWalker::new(self, false));
147                let span = span.start..self.last_span.end;
148                res.ensure_span(span.clone(), self.source()).map_err(|e| {
149                    if e.span().map(|s| s.offset()) == Some(span.start) {
150                        e.with_source_span(span, self.source())
151                    } else {
152                        e
153                    }
154                })
155            }
156            _ => unreachable!(),
157        }
158    }
159
160    fn deserialize_bool<V>(self, visitor: V) -> Result<V::Value>
161    where
162        V: Visitor<'de>,
163    {
164        visitor.visit_bool(self.parse()?)
165    }
166
167    // The `parse_signed` function is generic over the integer type `T` so here
168    // it is invoked with `T=i8`. The next 8 methods are similar.
169    fn deserialize_i8<V>(self, visitor: V) -> Result<V::Value>
170    where
171        V: Visitor<'de>,
172    {
173        visitor.visit_i8(self.parse()?)
174    }
175
176    fn deserialize_i16<V>(self, visitor: V) -> Result<V::Value>
177    where
178        V: Visitor<'de>,
179    {
180        visitor.visit_i16(self.parse()?)
181    }
182
183    fn deserialize_i32<V>(self, visitor: V) -> Result<V::Value>
184    where
185        V: Visitor<'de>,
186    {
187        visitor.visit_i32(self.parse()?)
188    }
189
190    fn deserialize_i64<V>(self, visitor: V) -> Result<V::Value>
191    where
192        V: Visitor<'de>,
193    {
194        visitor.visit_i64(self.parse()?)
195    }
196
197    fn deserialize_u8<V>(self, visitor: V) -> Result<V::Value>
198    where
199        V: Visitor<'de>,
200    {
201        visitor.visit_u8(self.parse()?)
202    }
203
204    fn deserialize_u16<V>(self, visitor: V) -> Result<V::Value>
205    where
206        V: Visitor<'de>,
207    {
208        visitor.visit_u16(self.parse()?)
209    }
210
211    fn deserialize_u32<V>(self, visitor: V) -> Result<V::Value>
212    where
213        V: Visitor<'de>,
214    {
215        visitor.visit_u32(self.parse()?)
216    }
217
218    fn deserialize_u64<V>(self, visitor: V) -> Result<V::Value>
219    where
220        V: Visitor<'de>,
221    {
222        visitor.visit_u64(self.parse()?)
223    }
224
225    fn deserialize_f32<V>(self, visitor: V) -> Result<V::Value>
226    where
227        V: Visitor<'de>,
228    {
229        visitor.visit_f32(self.parse()?)
230    }
231
232    fn deserialize_f64<V>(self, visitor: V) -> Result<V::Value>
233    where
234        V: Visitor<'de>,
235    {
236        visitor.visit_f64(self.parse()?)
237    }
238
239    // The `Serializer` implementation on the previous page serialized chars as
240    // single-character strings so handle that representation here.
241    fn deserialize_char<V>(self, visitor: V) -> Result<V::Value>
242    where
243        V: Visitor<'de>,
244    {
245        let (str, span) = self.read_str()?;
246        let mut chars = str.chars();
247        match (chars.next(), chars.next()) {
248            (Some(_), None) => Ok(()),
249            _ => Err(SerdeParseError::new(
250                "char",
251                str.as_ref(),
252                span,
253                self.source(),
254            )),
255        }?;
256
257        visitor.visit_str(str.as_ref())
258    }
259
260    // Refer to the "Understanding deserializer lifetimes" page for information
261    // about the three deserialization flavors of strings in Serde.
262    fn deserialize_str<V>(self, visitor: V) -> Result<V::Value>
263    where
264        V: Visitor<'de>,
265    {
266        visitor.visit_str(self.read_str()?.0.as_ref())
267    }
268
269    fn deserialize_string<V>(self, visitor: V) -> Result<V::Value>
270    where
271        V: Visitor<'de>,
272    {
273        visitor.visit_string(self.read_str()?.0.into())
274    }
275
276    // The `Serializer` implementation on the previous page serialized byte
277    // arrays as JSON arrays of bytes. Handle that representation here.
278    fn deserialize_bytes<V>(self, _visitor: V) -> Result<V::Value>
279    where
280        V: Visitor<'de>,
281    {
282        todo!()
283    }
284
285    fn deserialize_byte_buf<V>(self, visitor: V) -> Result<V::Value>
286    where
287        V: Visitor<'de>,
288    {
289        visitor.visit_byte_buf(self.read_str()?.0.as_bytes().into())
290    }
291
292    // An absent optional is represented as the JSON `null` and a present
293    // optional is represented as just the contained value.
294    //
295    // As commented in `Serializer` implementation, this is a lossy
296    // representation. For example the values `Some(())` and `None` both
297    // serialize as just `null`. Unfortunately this is typically what people
298    // expect when working with JSON. Other formats are encouraged to behave
299    // more intelligently if possible.
300    fn deserialize_option<V>(self, visitor: V) -> Result<V::Value>
301    where
302        V: Visitor<'de>,
303    {
304        let token = match self.next() {
305            None => return visitor.visit_none(),
306            Some(Err(span)) => {
307                return Err(
308                    NoValidTokenError::new(VALUE_TOKEN, span.into(), self.source().into()).into(),
309                )
310            }
311            Some(Ok(token)) => token,
312        };
313        if token.span.is_empty() {
314            return visitor.visit_none();
315        }
316        self.push_peeked(token);
317        visitor.visit_some(self)
318    }
319
320    fn deserialize_unit<V>(self, visitor: V) -> Result<V::Value>
321    where
322        V: Visitor<'de>,
323    {
324        let (str, span) = self.read_str()?;
325        if !str.is_empty() {
326            return Err(SerdeParseError::new("unit", str.as_ref(), span, self.source()).into());
327        }
328        visitor.visit_unit()
329    }
330
331    fn deserialize_unit_struct<V>(self, _name: &'static str, visitor: V) -> Result<V::Value>
332    where
333        V: Visitor<'de>,
334    {
335        let (str, span) = self.read_str()?;
336        if !str.is_empty() {
337            return Err(SerdeParseError::new("unit", str.as_ref(), span, self.source()).into());
338        }
339        visitor.visit_unit()
340    }
341
342    fn deserialize_newtype_struct<V>(self, _name: &'static str, visitor: V) -> Result<V::Value>
343    where
344        V: Visitor<'de>,
345    {
346        visitor.visit_newtype_struct(self)
347    }
348
349    fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value>
350    where
351        V: Visitor<'de>,
352    {
353        let token = self.peek().expect_token(SEQ_START_ITEMS, self.source())?;
354
355        if token.token == Token::GroupStart {
356            // we allow deserializing a map of consecutive int keys as a seq
357            let _ = self.next();
358            return visitor.visit_seq(MapSeqWalker {
359                table: TableWalker::new(self, false),
360                last_key: None,
361            });
362        }
363
364        let value_str = &self.source()[token.span.clone()];
365        if (value_str.starts_with("\"[") && value_str.ends_with("]\""))
366            || (value_str.starts_with("\"{") && value_str.ends_with("}\""))
367        {
368            let _ = self.next();
369            let seq = &value_str[2..value_str.len() - 2].trim();
370            let span = token.span.start + 2..token.span.end - 2;
371            visitor.visit_seq(StringArrayWalker::new(self.source(), seq, span))
372        } else {
373            let key = self.last_key.clone();
374            visitor.visit_seq(SeqWalker::new(self, key))
375        }
376    }
377
378    fn deserialize_tuple<V>(self, _len: usize, visitor: V) -> Result<V::Value>
379    where
380        V: Visitor<'de>,
381    {
382        self.deserialize_seq(visitor)
383    }
384
385    fn deserialize_tuple_struct<V>(
386        self,
387        _name: &'static str,
388        _len: usize,
389        visitor: V,
390    ) -> Result<V::Value>
391    where
392        V: Visitor<'de>,
393    {
394        self.deserialize_seq(visitor)
395    }
396
397    fn deserialize_map<V>(self, visitor: V) -> Result<V::Value>
398    where
399        V: Visitor<'de>,
400    {
401        // as a special case we allow a map without a `{` at the start of the file to create a top level struct
402        let toplevel = match self
403            .peek()
404            .expect_token(&[Token::GroupStart], self.source())
405        {
406            Ok(_) => {
407                let _ = self.next();
408                false
409            }
410            Err(VdfError::UnexpectedToken(e)) => {
411                if self.tokenizer.count > 1 {
412                    return Err(e.into());
413                }
414                true
415            }
416            Err(e) => {
417                return Err(e);
418            }
419        };
420
421        let value = visitor.visit_map(TableWalker::new(self, toplevel))?;
422        Ok(value)
423    }
424
425    fn deserialize_struct<V>(
426        self,
427        _name: &'static str,
428        _fields: &'static [&'static str],
429        visitor: V,
430    ) -> Result<V::Value>
431    where
432        V: Visitor<'de>,
433    {
434        self.deserialize_map(visitor)
435    }
436
437    fn deserialize_enum<V>(
438        self,
439        _name: &'static str,
440        _variants: &'static [&'static str],
441        visitor: V,
442    ) -> Result<V::Value>
443    where
444        V: Visitor<'de>,
445    {
446        let variant_token = self.peek().and_then(|r| r.ok());
447        visitor
448            .visit_enum(Enum::new(self))
449            .map_err(|e| match (variant_token, &e) {
450                (Some(variant_token), VdfError::UnknownVariant(_)) => {
451                    e.with_source_span(variant_token.span.start..self.last_span.end, self.source())
452                }
453                _ => e,
454            })
455    }
456
457    fn deserialize_identifier<V>(self, visitor: V) -> Result<V::Value>
458    where
459        V: Visitor<'de>,
460    {
461        self.deserialize_str(visitor)
462    }
463
464    fn deserialize_ignored_any<V>(self, visitor: V) -> Result<V::Value>
465    where
466        V: Visitor<'de>,
467    {
468        self.deserialize_any(visitor)
469    }
470}
471
472struct TableWalker<'source, 'a> {
473    de: &'a mut Deserializer<'source>,
474    done: bool,
475    toplevel: bool,
476}
477
478const KEY_TOKEN: &[Token] = &[
479    Token::Item,
480    Token::QuotedItem,
481    Token::Statement,
482    Token::QuotedStatement,
483    Token::GroupEnd,
484];
485
486impl<'source, 'a> TableWalker<'source, 'a> {
487    pub fn new(de: &'a mut Deserializer<'source>, toplevel: bool) -> Self {
488        TableWalker {
489            de,
490            done: false,
491            toplevel,
492        }
493    }
494
495    fn source(&self) -> &'source str {
496        self.de.source()
497    }
498
499    fn key_token(&mut self, retain_group_end: bool) -> Result<Option<SpannedToken>> {
500        if self.done {
501            return Ok(None);
502        }
503
504        let expected = if self.toplevel {
505            STRING_ITEMS
506        } else {
507            KEY_TOKEN
508        };
509
510        let token = match (self.de.next(), self.toplevel) {
511            (Some(token), _) => token,
512            (None, true) => {
513                self.done = true;
514                return Ok(None);
515            }
516            (None, false) => {
517                return Err(None::<SpannedToken>
518                    .expect_token(expected, self.source())
519                    .unwrap_err())
520            }
521        };
522
523        let key = token.expect_token(expected, self.source())?;
524
525        if key.token == Token::GroupEnd {
526            self.done = true;
527            if retain_group_end {
528                self.de.push_peeked(key);
529            }
530            return Ok(None);
531        }
532        Ok(Some(key))
533    }
534}
535
536impl<'de> MapAccess<'de> for TableWalker<'de, '_> {
537    type Error = VdfError;
538
539    fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>>
540    where
541        K: DeserializeSeed<'de>,
542    {
543        let key = match self.key_token(false) {
544            Ok(Some(key)) => key,
545            Ok(None) => {
546                return Ok(None);
547            }
548            Err(e) => return Err(e),
549        };
550
551        self.de.set_last_key(key.string(self.source()));
552        self.de.push_peeked(key);
553        seed.deserialize(&mut *self.de).map(Some)
554    }
555
556    fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value>
557    where
558        V: DeserializeSeed<'de>,
559    {
560        if let Some(start_span) = self.de.peek_span() {
561            let res = seed.deserialize(&mut *self.de);
562            let span = start_span.start..self.de.last_span.end;
563            res.ensure_span(span, self.source())
564        } else {
565            seed.deserialize(&mut *self.de)
566        }
567    }
568}
569
570/// STRING_ITEMS and GroupStart
571const SEQ_START_ITEMS: &[Token] = &[
572    Token::Item,
573    Token::QuotedItem,
574    Token::Statement,
575    Token::QuotedStatement,
576    Token::GroupStart,
577];
578
579struct SeqWalker<'source, 'a> {
580    table: TableWalker<'source, 'a>,
581    key: Cow<'source, str>,
582    done: bool,
583}
584
585impl<'source, 'a> SeqWalker<'source, 'a> {
586    pub fn new(de: &'a mut Deserializer<'source>, key: Cow<'source, str>) -> Self {
587        SeqWalker {
588            done: false,
589            key,
590            table: TableWalker::new(de, false),
591        }
592    }
593
594    fn source(&self) -> &'source str {
595        self.table.source()
596    }
597}
598
599impl<'de> SeqAccess<'de> for SeqWalker<'de, '_> {
600    type Error = VdfError;
601
602    fn next_element_seed<T>(
603        &mut self,
604        seed: T,
605    ) -> std::result::Result<Option<T::Value>, Self::Error>
606    where
607        T: DeserializeSeed<'de>,
608    {
609        if self.done {
610            return Ok(None);
611        }
612
613        let value = match seed.deserialize(&mut *self.table.de) {
614            Ok(value) => Some(value),
615            Err(VdfError::NoValidToken(_)) => None,
616            Err(e) => return Err(e),
617        };
618
619        let value_span = self.table.de.last_span.clone();
620        let newline = match self.table.de.peek_span() {
621            Some(next_span) => {
622                let whitespace = &self.source()[value_span.end..next_span.start];
623                whitespace.contains('\n')
624            }
625            _ => false,
626        };
627
628        if newline {
629            let key_token = match self.table.key_token(true) {
630                Ok(Some(key)) => key,
631                Ok(None) => {
632                    self.done = true;
633                    return Ok(value);
634                }
635                Err(e) => return Err(e),
636            };
637
638            let key = key_token.string(self.source());
639            if key != self.key {
640                self.table.de.push_peeked(key_token);
641                self.done = true;
642            }
643        }
644
645        Ok(value)
646    }
647}
648
649struct StringArrayWalker<'source> {
650    source: &'source str,
651    remaining: &'source str,
652    span: Span,
653}
654
655impl<'source> StringArrayWalker<'source> {
656    fn new(source: &'source str, array: &'source str, span: Span) -> Self {
657        StringArrayWalker {
658            source,
659            remaining: array,
660            span,
661        }
662    }
663}
664
665impl<'de, 'source> SeqAccess<'de> for StringArrayWalker<'source>
666where
667    'source: 'de,
668{
669    type Error = VdfError;
670
671    fn next_element_seed<T>(
672        &mut self,
673        seed: T,
674    ) -> std::result::Result<Option<T::Value>, Self::Error>
675    where
676        T: DeserializeSeed<'de>,
677    {
678        if self.remaining.is_empty() {
679            return Ok(None);
680        }
681
682        let (item, rest) = self
683            .remaining
684            .split_once(' ')
685            .unwrap_or((self.remaining, ""));
686        let item_span = self.span.start..(self.span.start + item.len());
687        self.remaining = rest.trim();
688        self.span = (self.span.end - self.remaining.len())..self.span.end;
689
690        let mut de = Deserializer::from_str(item);
691        let val = seed
692            .deserialize(&mut de)
693            .map_err(|e| e.with_source_span(item_span, self.source))?;
694        Ok(Some(val))
695    }
696}
697
698struct MapSeqWalker<'source, 'a> {
699    table: TableWalker<'source, 'a>,
700    last_key: Option<u64>,
701}
702
703impl<'de> SeqAccess<'de> for MapSeqWalker<'de, '_> {
704    type Error = VdfError;
705
706    fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Self::Error>
707    where
708        T: DeserializeSeed<'de>,
709    {
710        let Some(key) = self.table.next_key()? else {
711            return Ok(None);
712        };
713        if let Some(last_key) = self.last_key {
714            let expected_key = last_key + 1;
715            if expected_key != key {
716                return Err(VdfError::Other(UnknownError::from(format!(
717                    "Invalid array key {key}, expected {expected_key}"
718                )))
719                .with_source_span(self.table.de.last_span.clone(), self.table.de.source()));
720            }
721        }
722
723        self.last_key = Some(key);
724
725        Ok(Some(self.table.next_value_seed(seed)?))
726    }
727}
728
729struct Enum<'a, 'de: 'a> {
730    de: &'a mut Deserializer<'de>,
731    enclosed: bool,
732}
733
734impl<'a, 'de> Enum<'a, 'de> {
735    fn new(de: &'a mut Deserializer<'de>) -> Self {
736        Enum {
737            de,
738            enclosed: false,
739        }
740    }
741}
742
743// `EnumAccess` is provided to the `Visitor` to give it the ability to determine
744// which variant of the enum is supposed to be deserialized.
745//
746// Note that all enum deserialization methods in Serde refer exclusively to the
747// "externally tagged" enum representation.
748impl<'de> EnumAccess<'de> for Enum<'_, 'de> {
749    type Error = VdfError;
750    type Variant = Self;
751
752    fn variant_seed<V>(mut self, seed: V) -> Result<(V::Value, Self::Variant)>
753    where
754        V: DeserializeSeed<'de>,
755    {
756        if self
757            .de
758            .peek()
759            .expect_token(&[Token::GroupStart], self.de.source())
760            .is_ok()
761        {
762            self.enclosed = true;
763            let _ = self.de.next();
764        }
765        let val = seed.deserialize(&mut *self.de)?;
766        Ok((val, self))
767    }
768}
769
770// `VariantAccess` is provided to the `Visitor` to give it the ability to see
771// the content of the single variant that it decided to deserialize.
772impl<'de> VariantAccess<'de> for Enum<'_, 'de> {
773    type Error = VdfError;
774
775    fn unit_variant(self) -> Result<()> {
776        Ok(())
777    }
778
779    fn newtype_variant_seed<T>(self, seed: T) -> Result<T::Value>
780    where
781        T: DeserializeSeed<'de>,
782    {
783        let val = seed.deserialize(&mut *self.de)?;
784        if self.enclosed {
785            self.de
786                .next()
787                .expect_token(&[Token::GroupEnd], self.de.source())?;
788        }
789        Ok(val)
790    }
791
792    fn tuple_variant<V>(self, _len: usize, visitor: V) -> Result<V::Value>
793    where
794        V: Visitor<'de>,
795    {
796        let val = de::Deserializer::deserialize_seq(&mut *self.de, visitor)?;
797        if self.enclosed {
798            self.de
799                .next()
800                .expect_token(&[Token::GroupEnd], self.de.source())?;
801        }
802        Ok(val)
803    }
804
805    fn struct_variant<V>(self, _fields: &'static [&'static str], visitor: V) -> Result<V::Value>
806    where
807        V: Visitor<'de>,
808    {
809        let val = de::Deserializer::deserialize_map(&mut *self.de, visitor)?;
810        if self.enclosed {
811            self.de
812                .next()
813                .expect_token(&[Token::GroupEnd], self.de.source())?;
814        }
815        Ok(val)
816    }
817}
818
819////////////////////////////////////////////////////////////////////////////////
820
821#[cfg(test)]
822mod tests {
823    use crate::VdfError;
824    use serde::Deserialize;
825
826    fn unwrap_err<T>(r: Result<T, VdfError>) -> T {
827        r.map_err(miette::Error::from).unwrap()
828    }
829
830    fn from_str<'a, T>(source: &'a str) -> super::Result<T>
831    where
832        T: serde::Deserialize<'a>,
833    {
834        match super::from_str(source) {
835            Ok(res) => Ok(res),
836            Err(err) => {
837                eprintln!("{}", err);
838                Err(err)
839            }
840        }
841    }
842
843    #[test]
844    fn test_struct() {
845        #[derive(Deserialize, PartialEq, Debug)]
846        struct Test {
847            int: u32,
848            seq: String,
849        }
850
851        let j = r#"{"int" 1 "seq" "b"}"#;
852        let expected = Test {
853            int: 1,
854            seq: "b".into(),
855        };
856        assert_eq!(expected, unwrap_err(from_str(j)));
857    }
858
859    #[test]
860    fn test_struct_toplevel() {
861        #[derive(Deserialize, PartialEq, Debug)]
862        struct Test {
863            int: u32,
864            seq: String,
865        }
866
867        let j = r#""int" 1 "seq" "b""#;
868        let expected = Test {
869            int: 1,
870            seq: "b".into(),
871        };
872        assert_eq!(expected, unwrap_err(from_str(j)));
873    }
874
875    #[test]
876    fn test_struct_nested() {
877        #[derive(Deserialize, PartialEq, Debug)]
878        struct Inner {
879            a: f32,
880            b: bool,
881        }
882
883        #[derive(Deserialize, PartialEq, Debug)]
884        struct Test {
885            int: u32,
886            nested: Inner,
887        }
888
889        let j = r#"{"int" 1 "nested" {"a" 1.0 "b" false}}"#;
890        let expected = Test {
891            int: 1,
892            nested: Inner { a: 1.0, b: false },
893        };
894        assert_eq!(expected, unwrap_err(from_str(j)));
895    }
896
897    #[test]
898    fn test_enum() {
899        #[derive(Deserialize, PartialEq, Debug)]
900        enum E {
901            Unit,
902            Newtype1(u32),
903            Newtype2(u32),
904            Struct { a: u32 },
905            Struct2 { a: u32 },
906        }
907
908        let j = r#""Unit" """#;
909        let expected = E::Unit;
910        assert_eq!(expected, unwrap_err(from_str(j)));
911
912        let j = r#""Newtype1" 1"#;
913        let expected = E::Newtype1(1);
914        assert_eq!(expected, unwrap_err(from_str(j)));
915
916        let j = r#"Newtype2 1"#;
917        let expected = E::Newtype2(1);
918        assert_eq!(expected, unwrap_err(from_str(j)));
919
920        let j = r#"Struct {"a" 1}"#;
921        let expected = E::Struct { a: 1 };
922        assert_eq!(expected, unwrap_err(from_str(j)));
923
924        let j = r#"Struct2 {"a" 1}"#;
925        let expected = E::Struct2 { a: 1 };
926        assert_eq!(expected, unwrap_err(from_str(j)));
927    }
928
929    #[test]
930    fn test_untagged_enum() {
931        #[derive(Deserialize, PartialEq, Debug)]
932        #[serde(untagged)]
933        enum E {
934            Int(u8),
935            Float(f32),
936        }
937
938        let j = r#"1.1"#;
939        assert_eq!(E::Float(1.1), unwrap_err(from_str(j)));
940    }
941
942    #[test]
943    fn test_list_in_struct() {
944        #[derive(Deserialize, PartialEq, Debug)]
945        struct Test {
946            seq: Vec<u8>,
947        }
948
949        let j = r#"{
950            seq 1
951            seq 2
952            seq 3
953        }"#;
954        let expected = Test { seq: vec![1, 2, 3] };
955        assert_eq!(expected, unwrap_err(from_str(j)));
956
957        let j = r#"{
958            seq 1 2 3
959        }"#;
960        assert_eq!(expected, unwrap_err(from_str(j)));
961    }
962}
vdf_reader/serde.rs

vdf_reader/
serde.rs
