catfive 0.1.0

Category-5 fluent, zero-dependency schema and form validation for Rust.
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

use std::fmt::Display;
use crate::error::ValidationError;
use crate::traits::Validator;

type NumberRule<T> = Box<dyn Fn(&T) -> Option<ValidationError> + Send + Sync>;

/// Fluent validator for numeric values.
pub struct NumberValidator<T> {
    rules: Vec<NumberRule<T>>,
}

impl<T> Default for NumberValidator<T> {
    fn default() -> Self {
        Self { rules: Vec::new() }
    }
}

impl<T> NumberValidator<T>
where
    T: PartialOrd + Copy + Display + Send + Sync + 'static,
{
    /// Creates a new empty numeric validator.
    pub fn new() -> Self {
        Self::default()
    }

    /// Enforces a minimum numeric value.
    pub fn min(mut self, minimum: T) -> Self {
        self.rules.push(Box::new(move |val| {
            if *val < minimum {
                Some(ValidationError::new(
                    "min_value",
                    format!("Must be at least {}, got {}", minimum, val),
                ))
            } else {
                None
            }
        }));
        self
    }

    /// Enforces a maximum numeric value.
    pub fn max(mut self, maximum: T) -> Self {
        self.rules.push(Box::new(move |val| {
            if *val > maximum {
                Some(ValidationError::new(
                    "max_value",
                    format!("Must not exceed {}, got {}", maximum, val),
                ))
            } else {
                None
            }
        }));
        self
    }

    /// Enforces that the value is within a given range (inclusive).
    pub fn range(mut self, min_val: T, max_val: T) -> Self {
        self.rules.push(Box::new(move |val| {
            if *val < min_val || *val > max_val {
                Some(ValidationError::new(
                    "range",
                    format!("Must be between {} and {}, got {}", min_val, max_val, val),
                ))
            } else {
                None
            }
        }));
        self
    }

    /// Adds a custom user-defined validation closure for numeric types.
    pub fn custom<F>(mut self, validator: F) -> Self
    where
        F: Fn(&T) -> Result<(), ValidationError> + Send + Sync + 'static,
    {
        self.rules.push(Box::new(move |val| validator(val).err()));
        self
    }
}

impl<T> NumberValidator<T>
where
    T: PartialOrd + Default + Copy + Display + Send + Sync + 'static,
{
    /// Enforces that the numeric value is strictly positive (> 0).
    pub fn positive(mut self) -> Self {
        let zero = T::default();
        self.rules.push(Box::new(move |val| {
            if *val <= zero {
                Some(ValidationError::new(
                    "positive",
                    format!("Must be greater than 0, got {}", val),
                ))
            } else {
                None
            }
        }));
        self
    }

    /// Enforces that the numeric value is strictly negative (< 0).
    pub fn negative(mut self) -> Self {
        let zero = T::default();
        self.rules.push(Box::new(move |val| {
            if *val >= zero {
                Some(ValidationError::new(
                    "negative",
                    format!("Must be less than 0, got {}", val),
                ))
            } else {
                None
            }
        }));
        self
    }
}

impl<T: Send + Sync> Validator<T> for NumberValidator<T> {
    fn validate_all(&self, value: &T) -> Vec<ValidationError> {
        let mut errors = Vec::new();
        for rule in &self.rules {
            if let Some(err) = rule(value) {
                errors.push(err);
            }
        }
        errors
    }
}