specler 0.21.0

A simple way to write specifications on values
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
135

use std::fmt::Display;
use crate::core::validator::validator_result::ValidatorResult;

/// # Integer trait
///
/// Provides the ability to develop generic code that covers
/// all known integer types. Without it a concrete validator
/// function would have to be duplicated for every integer
/// type.
pub trait Integer: Copy + PartialOrd + PartialEq + Display {}
impl Integer for i8 {}
impl Integer for i16 {}
impl Integer for i32 {}
impl Integer for i64 {}
impl Integer for i128 {}
impl Integer for isize {}
impl Integer for u8 {}
impl Integer for u16 {}
impl Integer for u32 {}
impl Integer for u64 {}
impl Integer for u128 {}
impl Integer for usize {}

/// Validator to check whether an input is larger or equal than a given x
pub fn larger_or_equal_than<T: Integer + 'static>(x: T) -> Box<dyn Fn(T) -> ValidatorResult> {
    Box::new(
        move |input: T| {
            if input >= x {
                ValidatorResult::valid()
            } else {
                ValidatorResult::invalid(&format!("cannot be smaller than {}", x))
            }
        }
    )
}

/// Validator to check whether an input is larger than a given x
pub fn larger_than<T: Integer + 'static>(x: T) -> Box<dyn Fn(T) -> ValidatorResult> {
    Box::new(
        move |input: T| {
            if input > x {
                ValidatorResult::valid()
            } else {
                ValidatorResult::invalid(&format!("cannot be smaller than {}", x))
            }
        }
    )
}

/// Validator to check whether an input is smaller or equal than x
pub fn smaller_or_equal_than<T: Integer + 'static>(x: T) -> Box<dyn Fn(T) -> ValidatorResult> {
    Box::new(
        move |input: T| {
            if input <= x {
                ValidatorResult::valid()
            } else {
                ValidatorResult::invalid(&format!("cannot be larger than {}", x))
            }
        }
    )
}

/// Validator to check whether an input is smaller than x
pub fn smaller_than<T: Integer + 'static>(x: T) -> Box<dyn Fn(T) -> ValidatorResult> {
    Box::new(
        move |input: T| {
            if input < x {
                ValidatorResult::valid()
            } else {
                ValidatorResult::invalid(&format!("cannot be larger than {}", x))
            }
        }
    )
}

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

    mod smaller_than {
        #[test]
        fn test_valid() {
            let result = super::smaller_than(5)(4);
            assert!(result.is_valid());
        }

        #[test]
        fn test_invalid() {
            let result = super::smaller_than(5)(5);
            assert!(!result.is_valid());
        }
    }

    mod smaller_or_equal_than {
        #[test]
        fn test_valid() {
            let result = super::smaller_or_equal_than(5)(5);
            assert!(result.is_valid());
        }

        #[test]
        fn test_invalid() {
            let result = super::smaller_or_equal_than(5)(6);
            assert!(!result.is_valid());
        }
    }

    mod larger_than {
        #[test]
        fn test_valid() {
            let result = super::larger_than(5)(6);
            assert!(result.is_valid());
        }

        #[test]
        fn test_invalid() {
            let result = super::larger_than(5)(5);
            assert!(!result.is_valid());
        }
    }

    mod larger_or_equal_than {
        #[test]
        fn test_valid() {
            let result = super::larger_or_equal_than(5)(5);
            assert!(result.is_valid());
        }

        #[test]
        fn test_invalid() {
            let result = super::larger_or_equal_than(5)(4);
            assert!(!result.is_valid());
        }
    }
}