rusdantic-core 0.1.0

Core validation traits, error types, and built-in rules for Rusdantic
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

//! Built-in validation rules for Rusdantic.
//!
//! Each rule module provides a validation function that the derive macro's
//! generated code calls at runtime. All functions follow a consistent pattern:
//! they take the value to validate, constraint parameters, the field path,
//! and a mutable reference to a `ValidationErrors` collection.
//!
//! This design allows error accumulation (collect-all) rather than
//! fail-fast behavior.

pub mod contains;
pub mod email;
pub mod length;
pub mod pattern;
pub mod range;
pub mod required;
pub mod url;

// Re-export all validation functions at the rules module level
// so generated code can use `::rusdantic_core::rules::validate_length(...)`.
pub use contains::validate_contains;
pub use email::validate_email;
pub use length::validate_length;
pub use pattern::validate_pattern;
pub use range::validate_range;
pub use required::validate_required;
pub use url::validate_url;

/// Trait for types that have a measurable length.
/// Used by the length validator to work with both strings and collections.
pub trait HasLength {
    /// Return the length of this value (character count for strings,
    /// element count for collections).
    fn rusdantic_length(&self) -> usize;

    /// Return the unit name for error messages ("characters" for strings,
    /// "items" for collections).
    fn rusdantic_length_unit(&self) -> &'static str {
        "items"
    }
}

impl HasLength for String {
    fn rusdantic_length(&self) -> usize {
        self.chars().count()
    }

    fn rusdantic_length_unit(&self) -> &'static str {
        "characters"
    }
}

impl HasLength for &str {
    fn rusdantic_length(&self) -> usize {
        self.chars().count()
    }

    fn rusdantic_length_unit(&self) -> &'static str {
        "characters"
    }
}

impl<T> HasLength for Vec<T> {
    fn rusdantic_length(&self) -> usize {
        self.len()
    }
}

impl<T: std::hash::Hash + Eq> HasLength for std::collections::HashSet<T> {
    fn rusdantic_length(&self) -> usize {
        self.len()
    }
}

impl<T: Ord> HasLength for std::collections::BTreeSet<T> {
    fn rusdantic_length(&self) -> usize {
        self.len()
    }
}

impl<K: std::hash::Hash + Eq, V> HasLength for std::collections::HashMap<K, V> {
    fn rusdantic_length(&self) -> usize {
        self.len()
    }
}

impl<K: Ord, V> HasLength for std::collections::BTreeMap<K, V> {
    fn rusdantic_length(&self) -> usize {
        self.len()
    }
}

impl<T> HasLength for std::collections::VecDeque<T> {
    fn rusdantic_length(&self) -> usize {
        self.len()
    }
}

impl<T> HasLength for std::collections::LinkedList<T> {
    fn rusdantic_length(&self) -> usize {
        self.len()
    }
}

/// Trait for types that can be checked against a string pattern.
/// Used by email, url, pattern, and contains validators.
pub trait AsStr {
    /// Return this value as a string slice for pattern matching.
    fn as_str_ref(&self) -> &str;
}

impl AsStr for String {
    fn as_str_ref(&self) -> &str {
        self.as_str()
    }
}

impl AsStr for &str {
    fn as_str_ref(&self) -> &str {
        self
    }
}

impl AsStr for std::borrow::Cow<'_, str> {
    fn as_str_ref(&self) -> &str {
        self.as_ref()
    }
}