catfive 0.2.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
130
131
132
133
134
135
136
137
138
139
140
141
142

use crate::error::{ValidationError, ValidationErrors};
use crate::string::StringValidator;
use crate::traits::Validator;
use std::collections::{BTreeMap, HashMap};

/// Trait abstracting key-value form data access.
pub trait FormData {
    /// Retrieves the string value for a given form field key.
    fn get_value(&self, key: &str) -> Option<&str>;
}

impl FormData for HashMap<String, String> {
    fn get_value(&self, key: &str) -> Option<&str> {
        self.get(key).map(|v| v.as_str())
    }
}

impl FormData for HashMap<&str, &str> {
    fn get_value(&self, key: &str) -> Option<&str> {
        self.get(key).copied()
    }
}

impl FormData for HashMap<String, Vec<String>> {
    fn get_value(&self, key: &str) -> Option<&str> {
        self.get(key).and_then(|v| v.first()).map(|s| s.as_str())
    }
}

impl FormData for HashMap<&str, Vec<&str>> {
    fn get_value(&self, key: &str) -> Option<&str> {
        self.get(key).and_then(|v| v.first()).copied()
    }
}

impl FormData for BTreeMap<String, String> {
    fn get_value(&self, key: &str) -> Option<&str> {
        self.get(key).map(|v| v.as_str())
    }
}

impl FormData for BTreeMap<&str, &str> {
    fn get_value(&self, key: &str) -> Option<&str> {
        self.get(key).copied()
    }
}

impl FormData for [(&str, &str)] {
    fn get_value(&self, key: &str) -> Option<&str> {
        self.iter().find(|(k, _)| *k == key).map(|(_, v)| *v)
    }
}

impl FormData for Vec<(&str, &str)> {
    fn get_value(&self, key: &str) -> Option<&str> {
        self.as_slice().get_value(key)
    }
}

#[derive(Clone)]
struct FormRule {
    name: String,
    validator: StringValidator,
    required: bool,
    required_message: String,
}

/// Fluent schema validator for form payloads (key-value data).
#[derive(Clone, Default)]
pub struct FormValidator {
    rules: Vec<FormRule>,
}

impl FormValidator {
    /// Creates a new empty form validator.
    pub fn new() -> Self {
        Self { rules: Vec::new() }
    }

    /// Adds a required field rule with default error message ("This field is required").
    pub fn field(self, name: impl Into<String>, validator: StringValidator) -> Self {
        self.field_msg(name, validator, "This field is required")
    }

    /// Adds a required field rule with a custom error message.
    pub fn field_msg(
        mut self,
        name: impl Into<String>,
        validator: StringValidator,
        required_msg: impl Into<String>,
    ) -> Self {
        self.rules.push(FormRule {
            name: name.into(),
            validator,
            required: true,
            required_message: required_msg.into(),
        });
        self
    }

    /// Adds an optional field rule to the form validator.
    ///
    /// If the field is not present or is empty, validation succeeds.
    /// If present and non-empty, the validator rules are executed.
    pub fn optional_field(mut self, name: impl Into<String>, validator: StringValidator) -> Self {
        self.rules.push(FormRule {
            name: name.into(),
            validator,
            required: false,
            required_message: String::new(),
        });
        self
    }

    /// Validates a form data payload, collecting all errors across all fields.
    pub fn validate<F: FormData + ?Sized>(&self, data: &F) -> Result<(), ValidationErrors> {
        let mut errors = ValidationErrors::new();

        for rule in &self.rules {
            match data.get_value(&rule.name) {
                Some(val) if !val.is_empty() => {
                    let field_errors = rule.validator.validate_all(val);
                    errors.add_many(&rule.name, field_errors);
                }
                Some(_) | None => {
                    if rule.required {
                        errors.add(
                            &rule.name,
                            ValidationError::new("required", rule.required_message.clone()),
                        );
                    }
                }
            }
        }

        if errors.is_empty() {
            Ok(())
        } else {
            Err(errors)
        }
    }
}