estring 0.3.0

A simple way to parse a string using type annotations
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

use crate::core::{EString, ParseFragment, ToEString};

impl<T> ToEString for Option<T>
where
    T: ToEString,
{
    fn to_estring(&self) -> EString {
        match self {
            Some(inner) => inner.to_estring(),
            None => EString::new(),
        }
    }
}

impl<T> ParseFragment for Option<T>
where
    T: ParseFragment,
{
    fn parse_frag(es: EString) -> crate::Result<Self> {
        if es.is_empty() {
            Ok(None)
        } else {
            es.parse().map(Some)
        }
    }
}

#[cfg(feature = "aggs")]
impl<T> crate::core::Aggregatable for Option<T>
where
    T: crate::core::Aggregatable,
{
    type Item = T::Item;

    fn items(self) -> Vec<Self::Item> {
        self.map(T::items).unwrap_or_default()
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::structs::Pair;

    #[test]
    fn should_parse_empty_string_as_none() {
        let estr = EString::new();
        match estr.parse::<Option<i32>>() {
            Ok(res) => assert_eq!(res, None),
            _ => unreachable!(),
        }
    }

    #[test]
    fn should_parse_number_as_some() {
        let estr = EString::from("99");
        match estr.parse::<Option<i32>>() {
            Ok(res) => assert_eq!(res, Some(99)),
            _ => unreachable!(),
        }
    }

    #[test]
    fn should_parse_pair() {
        let estr = EString::from("1+2");
        match estr.parse::<Option<Pair<i32, '+', i32>>>() {
            Ok(res) => assert_eq!(res, Some(Pair(1, 2))),
            _ => unreachable!(),
        }
    }

    #[test]
    fn should_format_option() {
        assert_eq!(None::<i32>.to_estring(), EString::new());
        assert_eq!(Some(99).to_estring(), EString(String::from("99")));
    }
}