serde_plain 1.0.2

A restricted plain text serializer for serde
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91

#[macro_use]
extern crate serde_derive;

use serde_plain::derive_fromstr_from_deserialize;

use std::str::FromStr;

#[derive(Deserialize, PartialEq, Eq, Debug)]
#[serde(rename_all = "snake_case")]
pub enum Test {
    FooBarBaz,
    BlahBlah,
}

#[derive(Deserialize, PartialEq, Eq, Debug)]
#[serde(rename_all = "snake_case")]
pub enum FooType {
    FooA,
    FooB,
}
#[derive(Deserialize, PartialEq, Eq, Debug)]
#[serde(rename_all = "snake_case")]
pub enum BarType {
    BarA,
    BarB,
}

#[derive(Deserialize, PartialEq, Eq, Debug)]
#[serde(untagged)]
pub enum TestUntagged {
    Foo(FooType),
    Bar(BarType),
    Other(String),
}

derive_fromstr_from_deserialize!(TestUntagged);

#[derive(Deserialize, PartialEq, Eq, Debug)]
pub struct NewInt(pub i32);

impl FromStr for Test {
    type Err = serde_plain::Error;
    fn from_str(value: &str) -> Result<Test, serde_plain::Error> {
        serde_plain::from_str(value)
    }
}

#[test]
fn test_basics() {
    assert_eq!(serde_plain::from_str::<&str>("aha").unwrap(), "aha");
    assert_eq!(serde_plain::from_str::<i32>("42").unwrap(), 42);
    assert_eq!(serde_plain::from_str::<bool>("true").unwrap(), true);
    assert_eq!(serde_plain::from_str::<bool>("false").unwrap(), false);
    assert_eq!(serde_plain::from_str::<()>("").unwrap(), ());
    assert_eq!(serde_plain::from_str::<Option<()>>("").unwrap(), None);
    assert_eq!(
        serde_plain::from_str::<Option<String>>("42").unwrap(),
        Some("42".into())
    );
    assert_eq!(
        serde_plain::from_str::<Option<&str>>("42").unwrap(),
        Some("42")
    );
    assert_eq!(
        serde_plain::from_str::<Test>("blah_blah").unwrap(),
        Test::BlahBlah
    );
    assert_eq!(serde_plain::from_str::<NewInt>("42").unwrap(), NewInt(42));
    serde_plain::from_str::<serde::de::IgnoredAny>("blah_blah")
        .expect("doesn't fail on #[serde(skip)] fields");
}

#[test]
fn test_untagged_enum() {
    let pairs = [
        ("foo_a", TestUntagged::Foo(FooType::FooA)),
        ("foo_b", TestUntagged::Foo(FooType::FooB)),
        ("bar_a", TestUntagged::Bar(BarType::BarA)),
        ("bar_b", TestUntagged::Bar(BarType::BarB)),
        ("other", TestUntagged::Other("other".to_string())),
    ];

    for (string, expected) in pairs.iter() {
        assert_eq!(string.parse::<TestUntagged>().unwrap(), *expected);
    }
}

#[test]
fn test_from_str() {
    assert_eq!("foo_bar_baz".parse::<Test>().unwrap(), Test::FooBarBaz);
}