adequate 0.1.5

A yet another validation library provides a macro inspired by Accord.
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

use std::collections::HashMap;
use std::fmt;

use serde::Serialize;
use strfmt::strfmt;

/// Message struct holds the validation error message keys and its args for
/// interpolation.
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
pub struct Message {
    pub id: &'static str,
    pub text: Option<&'static str>,
    pub args: Vec<String>,
}

/// An utility function for translation by using the optional text attribute.
///
/// ## Example
///
/// ```rust
/// # #[macro_use]
/// # extern crate adequate;
///
/// # use adequate::{Message, msgfmt};
/// # use adequate::validation::length;
///
/// # fn main() {
///     let msg = Message {
///       id: "lorem.ipsum",
///       text: Some("Lorem {0} dolor {1} amet"),
///       args: vec!["ipsum".to_string(), "sit".to_string()],
///     };
///     let out = msgfmt(&msg);
///     assert_eq!("Lorem ipsum dolor sit amet", out);
///
///     // it's used also for fmt::Display::fmt()
///     assert_eq!(msg.to_string(), out);
/// # }
pub fn msgfmt(m: &Message) -> String {
    match &m.text {
        None => m.id.to_string(),
        Some(txt) => {
            let mut args = HashMap::new();
            for (i, a) in m.args.iter().enumerate() {
                args.insert(i.to_string(), a.to_string());
            }
            // panic if given txt value doesn't match
            let out = strfmt(txt, &args).expect("message format is invalid");
            if !args.is_empty() && txt == &out {
                panic!("message does not have expected number of identifiers");
            }
            out
        }
    }
}

impl fmt::Display for Message {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        let out = msgfmt(self);
        write!(f, "{}", out)
    }
}

lazy_static! {
    pub static ref MESSAGES: [(&'static str, &'static str); 7] = [
        ("max", "validation.length.max"), // args {0}
        ("min", "validation.length.min"), // args {0}
        ("within", "validation.length.within"), // args {0}, {1}
        ("contains", "validation.contain.contains"), // args {0}
        ("contains_any", "validation.contain.contains_any"), // args {0}
        ("contains_only", "validation.contain.contains_only"), // args {0}
        ("not_contain", "validation.contain.not_contain"), // args {1}
    ];
}

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

    #[test]
    fn test_fmt_without_text() {
        let m = Message {
            id: "lorem.ipsum",
            text: None,
            args: vec!["dolor sit amet".to_string()],
        };
        assert_eq!("lorem.ipsum", format!("{}", m));
    }

    #[test]
    fn test_fmt() {
        let m = Message {
            id: "lorem.ipsum",
            text: Some("lorem ipsum {0}"),
            args: vec!["dolor sit amet".to_string()],
        };
        assert_eq!("lorem ipsum dolor sit amet".to_string(), format!("{}", m));
    }

    #[test]
    fn test_eq() {
        let a: Message = Default::default();
        assert!(a.eq(&a));

        let b = Message {
            text: Some("lorem ipsum {0}"),

            ..Default::default()
        };
        assert!(!a.eq(&b));

        let c = Message {
            id: "validation.id",

            ..Default::default()
        };
        assert!(!a.eq(&c));

        let d = Message {
            args: vec![
                "dolor".to_string(),
                "sit".to_string(),
                "amet".to_string(),
            ],

            ..Default::default()
        };
        assert!(!a.eq(&d));
    }
}