e173 0.1.0-alpha.7

A library implementing various aspects of the ESTA BSR E1.73 standard
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
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134

use crate::e173_types_no_serde;

e173_types_no_serde! {

#[derive(PartialEq)]
pub struct Version {
    major: u64,
    minor: u64,
    patch: u64,
}

}

mod serde {
    use super::Version;
    use serde::{
        de::{Unexpected, Visitor},
        Deserialize, Deserializer, Serialize,
    };

    struct VersionVisitor;

    impl<'a> VersionVisitor {
        fn validate_version_part<E>(
            &self,
            value: &str,
            parts: &mut impl Iterator<Item = &'a str>,
        ) -> Result<u64, E>
        where
            E: serde::de::Error,
        {
            let part = parts
                .next()
                .ok_or(E::invalid_value(Unexpected::Str(value), self))?;

            // Per E1.73-1 5.2, leading zeros in version number components are not allowed
            if part.starts_with('0') && part.len() > 1 {
                return Err(E::invalid_value(Unexpected::Str(value), self));
            }

            part.parse()
                .map_err(|_| E::invalid_value(Unexpected::Str(value), self))
        }
    }

    impl<'de> Visitor<'de> for VersionVisitor {
        type Value = Version;

        fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
            formatter.write_str("a string formatted as a 3-digit version number, e.g. 1.2.3")
        }

        fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
        where
            E: serde::de::Error,
        {
            let mut parts = v.split('.');

            let major = self.validate_version_part(v, &mut parts)?;
            let minor = self.validate_version_part(v, &mut parts)?;
            let patch = self.validate_version_part(v, &mut parts)?;

            if parts.next().is_none() {
                Ok(Version {
                    major,
                    minor,
                    patch,
                })
            } else {
                Err(E::invalid_value(Unexpected::Str(v), &self))
            }
        }
    }

    impl<'de> Deserialize<'de> for Version {
        fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
        where
            D: Deserializer<'de>,
        {
            deserializer.deserialize_str(VersionVisitor)
        }
    }

    impl Serialize for Version {
        fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
        where
            S: serde::Serializer,
        {
            let vers = format!("{}.{}.{}", self.major, self.minor, self.patch);
            serializer.serialize_str(&vers)
        }
    }
}

#[cfg(test)]
mod test {
    use super::*;

    macro_rules! test_correct_vers {
        ($str:literal, $maj:literal, $min:literal, $pat:literal) => {
            assert_eq!(
                serde_json::from_str::<Version>($str).unwrap(),
                Version {
                    major: $maj,
                    minor: $min,
                    patch: $pat
                }
            )
        };
    }

    #[test]
    fn test_deserialize_correct_version() {
        test_correct_vers!("\"1.0.0\"", 1, 0, 0);
        test_correct_vers!("\"0.1.0\"", 0, 1, 0);
        test_correct_vers!("\"1.2.3\"", 1, 2, 3);
        test_correct_vers!("\"10000.20000.30000\"", 10000, 20000, 30000);
    }

    #[test]
    fn test_deserialize_incorrect_version() {
        assert!(serde_json::from_str::<Version>("\"01.0.0\"").is_err());
        assert!(serde_json::from_str::<Version>("\"1.01.0\"").is_err());
        assert!(serde_json::from_str::<Version>("\"1.0.01\"").is_err());
        assert!(serde_json::from_str::<Version>("\"1.0\"").is_err());
        assert!(serde_json::from_str::<Version>("\"1.0.0.3\"").is_err());
        assert!(serde_json::from_str::<Version>("\"1.a.b\"").is_err());
        assert!(serde_json::from_str::<Version>("\"1.0.0-beta.3\"").is_err());
        assert!(serde_json::from_str::<Version>("\"1.0.0e\"").is_err());
        assert!(serde_json::from_str::<Version>("\"foo\"").is_err());
        assert!(serde_json::from_str::<Version>("\"\"").is_err());
        assert!(serde_json::from_str::<Version>("40").is_err());
    }
}