rede_parser 0.2.2

Parser in charge of modeling Rede's files
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
92
93
94
95
96
97
98
99
100
101
102
103

//! This module holds a subset of TOML types to limit supported types of the scema

use std::vec::IntoIter;

use serde::Deserialize;

/// Subset with the four primitive types
#[derive(Clone, Debug, Deserialize, PartialEq)]
#[serde(untagged)]
pub(crate) enum Primitive {
    Bool(bool),
    Int(i64),
    Float(f64),
    Str(String),
}

/// Subset with the four primitive types and the array of those
#[derive(Clone, Debug, Deserialize, PartialEq)]
#[serde(untagged)]
pub(crate) enum PrimitiveArray {
    Single(Primitive),
    Multiple(Vec<Primitive>),
}

impl From<Primitive> for String {
    fn from(value: Primitive) -> Self {
        match value {
            Primitive::Str(s) => s,
            Primitive::Bool(b) => b.to_string(),
            Primitive::Float(f) => f.to_string(),
            Primitive::Int(i) => i.to_string(),
        }
    }
}

impl From<PrimitiveArray> for String {
    fn from(value: PrimitiveArray) -> Self {
        match value {
            PrimitiveArray::Single(p) => p.into(),
            PrimitiveArray::Multiple(a) => a
                .into_iter()
                .map(String::from)
                .collect::<Vec<String>>()
                .join(","),
        }
    }
}

impl IntoIterator for PrimitiveArray {
    type Item = Primitive;
    type IntoIter = IntoIter<Primitive>;

    fn into_iter(self) -> Self::IntoIter {
        match self {
            PrimitiveArray::Single(v) => vec![v],
            PrimitiveArray::Multiple(vec) => vec,
        }
        .into_iter()
    }
}

#[cfg(test)]
mod test {
    use std::collections::HashMap;

    use super::*;

    #[derive(Deserialize)]
    struct Parent<T>(HashMap<String, T>);
    type Pri = Parent<Primitive>;
    type PriArr = Parent<PrimitiveArray>;

    #[test]
    fn primitive() {
        assert_eq!(parse_pri(r#"primitive="string""#), "string");
        assert_eq!(parse_pri("primitive=10"), "10");
        assert_eq!(parse_pri("primitive=5.1"), "5.1");
        assert_eq!(parse_pri("primitive=true"), "true");
        assert!(toml::from_str::<Pri>("a=1970-01-01").is_err());
    }

    #[test]
    fn primitive_array() {
        assert_eq!(parse_pri_arr(r#"primitive="string""#), "string");
        assert_eq!(parse_pri_arr("primitive=10"), "10");
        assert_eq!(parse_pri_arr("primitive=5.1"), "5.1");
        assert_eq!(parse_pri_arr("primitive=true"), "true");
        assert_eq!(parse_pri_arr(r#"primitive=[1,"two"]"#), "1,two");
        assert!(toml::from_str::<PriArr>("a=1970-01-01").is_err());
    }

    fn parse_pri(str: &str) -> String {
        toml::from_str::<Pri>(str).unwrap().0["primitive"]
            .clone()
            .into()
    }

    fn parse_pri_arr(str: &str) -> String {
        toml::from_str::<PriArr>(str).unwrap().0["primitive"]
            .clone()
            .into()
    }
}