pval 0.1.1

A Rust library for password validation with customizable criteria.
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
143
144
145
146
147
148
149

/// `Pval` is a struct that holds the password validation criteria.
pub struct Pval {
    min_length: usize,
    max_length: usize,
    require_uppercase: bool,
    require_lowercase: bool,
    require_digit: bool,
    require_special: bool,
}

impl Pval {
    /// Creates a new `Pval` instance with default values.
    pub fn new() -> Self {
        Self {
            min_length: 0,
            max_length: usize::MAX,
            require_uppercase: false,
            require_lowercase: false,
            require_digit: false,
            require_special: false,
        }
    }

    /// Sets the minimum length requirement for the password.
    ///
    /// # Arguments
    ///
    /// * `min_length` - A usize that sets the minimum length.
    pub fn min_length(mut self, min_length: usize) -> Self {
        self.min_length = min_length;
        self
    }

    /// Sets the maximum length requirement for the password.
    ///
    /// # Arguments
    ///
    /// * `max_length` - A usize that sets the maximum length.
    pub fn max_length(mut self, max_length: usize) -> Self {
        self.max_length = max_length;
        self
    }

    /// Sets whether the password must contain at least one uppercase letter.
    ///
    /// # Arguments
    ///
    /// * `require` - A bool that sets whether the password must contain at least one uppercase letter.
    pub fn require_uppercase(mut self, require: bool) -> Self {
        self.require_uppercase = require;
        self
    }

    /// Sets whether the password must contain at least one lowercase letter.
    ///
    /// # Arguments
    ///
    /// * `require` - A bool that sets whether the password must contain at least one lowercase letter.
    pub fn require_lowercase(mut self, require: bool) -> Self {
        self.require_lowercase = require;
        self
    }

    /// Sets whether the password must contain at least one digit.
    ///
    /// # Arguments
    ///
    /// * `require` - A bool that sets whether the password must contain at least one digit.
    pub fn require_digit(mut self, require: bool) -> Self {
        self.require_digit = require;
        self
    }

    /// Sets whether the password must contain at least one special character.
    ///
    /// Special characters are defined as any character that is not a letter or digit.
    ///
    /// # Arguments
    ///
    /// * `require` - A bool that sets whether the password must contain at least one special character.
    pub fn require_special(mut self, require: bool) -> Self {
        self.require_special = require;
        self
    }

    /// Builds the `Pval` instance with the specified criteria.
    pub fn build(self) -> Self {
        self
    }

    /// Validates a password against the criteria.
    ///
    /// # Arguments
    ///
    /// * `password` - A string slice that holds the password to validate.
    ///
    /// # Returns
    ///
    /// * `Ok(())` if the password is valid.
    pub fn validate(&self, password: &str) -> Result<(), String> {
        if password.len() < self.min_length {
            return Err(format!(
                "Password is too short. Minimum length is {}.",
                self.min_length
            ));
        }
        if password.len() > self.max_length {
            return Err(format!(
                "Password is too long. Maximum length is {}.",
                self.max_length
            ));
        }

        let mut has_uppercase: bool = false;
        let mut has_lowercase: bool = false;
        let mut has_digit: bool = false;
        let mut has_special: bool = false;

        for c in password.chars() {
            if c.is_uppercase() {
                has_uppercase = true;
            } else if c.is_lowercase() {
                has_lowercase = true;
            } else if c.is_digit(10) {
                has_digit = true;
            } else if !c.is_alphanumeric() {
                has_special = true;
            }
        }

        if self.require_uppercase && !has_uppercase {
            return Err("Password must contain at least one uppercase letter (A-Z).".to_string());
        }
        if self.require_lowercase && !has_lowercase {
            return Err("Password must contain at least one lowercase letter (a-z).".to_string());
        }
        if self.require_digit && !has_digit {
            return Err("Password must contain at least one digit (0-9).".to_string());
        }
        if self.require_special && !has_special {
            return Err(
                "Password must contain at least one special character (e.g., !@#$%^&*)."
                    .to_string(),
            );
        }

        Ok(())
    }
}