aki-stats 0.1.14

output the statistics of text, like a wc of linux command.
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

use num_format::{Locale, ToFormattedString};

//{{{ OptLocaleLoc
#[derive(Debug, Default, PartialEq, Clone, Copy)]
pub struct OptLocaleLoc {
    inner: Option<Locale>,
}
impl OptLocaleLoc {
    pub fn formatted_string<T>(&self, v: T) -> String
    where
        T: ToString + ToFormattedString,
    {
        if self.inner.is_none() {
            v.to_string()
        } else {
            v.to_formatted_string(&self.inner.unwrap())
        }
    }
}

impl ::std::str::FromStr for OptLocaleLoc {
    type Err = OptLocaleLocParseError;
    fn from_str(s: &str) -> Result<Self, Self::Err> {
        if s == "C" {
            Ok(Self { inner: None })
        } else {
            let r = Locale::from_name(s);
            match r {
                Ok(loc) => Ok(Self { inner: Some(loc) }),
                Err(err) => {
                    //let s = format!("can not parse '{}'", s);
                    let s = format!("'{}': {}", s, err);
                    Err(OptLocaleLocParseError::new(s))
                }
            }
        }
    }
}

impl ::std::fmt::Display for OptLocaleLoc {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        if self.inner.is_some() {
            write!(f, "{}", self.inner.unwrap().name())
        } else {
            write!(f, "C")
        }
    }
}
//}}} OptLocaleLoc

//{{{ OptLocaleLocParseError
#[derive(Debug)]
pub struct OptLocaleLocParseError {
    desc: String,
}

impl OptLocaleLocParseError {
    fn new(s: String) -> OptLocaleLocParseError {
        OptLocaleLocParseError { desc: s }
    }
}

impl ::std::fmt::Display for OptLocaleLocParseError {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        self.desc.fmt(f)
    }
}

impl ::std::error::Error for OptLocaleLocParseError {
    fn description(&self) -> &str {
        self.desc.as_str()
    }
}
//}}} OptLocaleLocParseError

#[cfg(test)]
mod tests {
    //use std::error::Error;
    use std::str::FromStr;

    use super::*;

    #[test]
    fn test_display_c() {
        let loc = OptLocaleLoc::from_str("C").unwrap();
        assert_eq!(format!("{}", loc), "C");
    }
    #[test]
    fn test_display_en() {
        let loc = OptLocaleLoc::from_str("en").unwrap();
        assert_eq!(format!("{}", loc), "en");
    }
    #[test]
    fn test_display_fr() {
        let loc = OptLocaleLoc::from_str("fr").unwrap();
        assert_eq!(format!("{}", loc), "fr");
    }
    #[test]
    fn test_from_str_invalid() {
        let _col: OptLocaleLoc = match FromStr::from_str("other") {
            Ok(_c) => _c,
            Err(e) => {
                assert_eq!(
                    e.to_string(),
                    "\'other\': Failed to parse other into a valid locale."
                );
                return;
            }
        };
        unreachable!();
    }
}