valida 1.1.2

Modular validation system for Rust with support for nested structures and localization.
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

use std::rc::Rc;
use std::sync::Arc;

// ┌────────────────────────────────────────────┐
// │           Основний trait ValueRef          │
// └────────────────────────────────────────────┘
pub trait ValueRef {
    type Target;
    fn value(&self) -> Option<&Self::Target>;
}

// ┌────────────────────────────────────────────┐
// │        Імплементації для числових типів    │
// └────────────────────────────────────────────┘
macro_rules! impl_value_ref_for_numbers {
    ($($t:ty),*) => {
        $(
            impl ValueRef for $t {
                type Target = $t;
                fn value(&self) -> Option<&Self::Target> {
                    Some(self)
                }
            }
        )*
    };
}

impl_value_ref_for_numbers!(i8, i16, i32, i64, u8, u16, u32, u64, f32, f64);

// ┌────────────────────────────────────────────┐
// │          Делегуючі обгортки                │
// └────────────────────────────────────────────┘
impl<T: ValueRef> ValueRef for &T {
    type Target = T::Target;
    fn value(&self) -> Option<&Self::Target> {
        (**self).value()
    }
}

impl<T: ValueRef> ValueRef for Option<T> {
    type Target = T::Target;
    fn value(&self) -> Option<&Self::Target> {
        self.as_ref().and_then(|v| v.value())
    }
}

impl<T: ValueRef> ValueRef for Box<T> {
    type Target = T::Target;
    fn value(&self) -> Option<&Self::Target> {
        (**self).value()
    }
}

impl<T: ValueRef> ValueRef for Rc<T> {
    type Target = T::Target;
    fn value(&self) -> Option<&Self::Target> {
        (**self).value()
    }
}

impl<T: ValueRef> ValueRef for Arc<T> {
    type Target = T::Target;
    fn value(&self) -> Option<&Self::Target> {
        (**self).value()
    }
}

// ┌────────────────────────────────────────────┐
// │                 Тести 🧪                    │
// └────────────────────────────────────────────┘
#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn value_for_primitives() {
        let v: i32 = 42;
        assert_eq!(v.value(), Some(&42));

        let f: f64 = 3.14;
        assert_eq!(f.value(), Some(&3.14));
    }

    #[test]
    fn value_for_reference() {
        let v = &100u16;
        assert_eq!(v.value(), Some(&100));
    }

    #[test]
    fn value_for_option_some() {
        let v = Some(88i64);
        assert_eq!(v.value(), Some(&88));
    }

    #[test]
    fn value_for_option_none() {
        let v: Option<i64> = None;
        assert_eq!(v.value(), None);
    }

    #[test]
    fn value_for_boxed() {
        let v = Box::new(256u32);
        assert_eq!(v.value(), Some(&256));
    }

    #[test]
    fn value_for_rc() {
        let v = Rc::new(77u8);
        assert_eq!(v.value(), Some(&77));
    }

    #[test]
    fn value_for_arc() {
        let v = Arc::new(std::f64::consts::PI);
        assert_eq!(v.value(), Some(&std::f64::consts::PI));
    }
}