srtemplate 0.3.3

Template String blazing fast with dependencyless
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

use std::str::FromStr;

use crate::prelude::FunctionError;

pub type ValidationResult = Result<(), FunctionError>;

/// Validates that the number of arguments is at least `expected`.
///
/// # Arguments
///
/// * `args` - A slice of strings representing the arguments.
/// * `expected` - The minimum number of arguments required.
///
/// # Returns
///
/// A `ValidationResult` where:
/// - `Ok(())` indicates that the number of arguments meets the minimum requirement.
/// - `Err(FunctionError::ArgumentsIncomplete)` occurs if the number of arguments is less than the expected minimum.
///
/// # Example
///
/// ```
/// use srtemplate::prelude::validations::args_min_len;
///
/// let args = vec!["arg1".to_string(), "arg2".to_string()];
/// assert!(args_min_len(&args, 2).is_ok());
/// assert!(args_min_len(&args, 3).is_err());
/// ```
///
/// # Errors
///
/// Returns an error if the number of arguments is less than the specified minimum.
pub const fn args_min_len(args: &[String], expected: usize) -> ValidationResult {
    if expected > args.len() {
        return Err(FunctionError::ArgumentsIncomplete(args.len(), expected));
    }
    Ok(())
}

/// Validates that the number of arguments does not exceed `expected`.
///
/// # Arguments
///
/// * `args` - A slice of strings representing the arguments.
/// * `expected` - The maximum number of arguments allowed.
///
/// # Returns
///
/// A `ValidationResult` where:
/// - `Ok(())` indicates that the number of arguments is within the allowed limit.
/// - `Err(FunctionError::ArgumentsIncomplete)` occurs if the number of arguments exceeds the limit.
///
/// # Example
///
/// ```
/// use srtemplate::prelude::validations::args_max_len;
///
/// let args = vec!["arg1".to_string(), "arg2".to_string()];
/// assert!(args_max_len(&args, 2).is_ok());
/// assert!(args_max_len(&args, 1).is_err());
/// ```
///
/// # Errors
///
/// Returns an error if the number of arguments exceeds the specified maximum.
pub const fn args_max_len(args: &[String], expected: usize) -> ValidationResult {
    if args.len() > expected {
        return Err(FunctionError::ArgumentsIncomplete(args.len(), expected));
    }
    Ok(())
}

/// Validates if a string argument can be parsed into a specific type `T`.
///
/// # Arguments
///
/// * `arg` - A string representing the argument to be validated.
///
/// # Returns
///
/// A `ValidationResult` where:
/// - `Ok(())` indicates that the argument can be successfully parsed into type `T`.
/// - `Err(FunctionError::InvalidType)` occurs if parsing fails.
///
/// # Example
///
/// ```
/// use srtemplate::prelude::validations::arg_type;
///
/// let valid_arg = "42";
/// assert!(arg_type::<i32>(valid_arg.to_string()).is_ok());
///
/// let invalid_arg = "not_an_integer";
/// assert!(arg_type::<i32>(invalid_arg.to_string()).is_err());
/// ```
///
/// # Errors
///
/// Returns an error if the argument cannot be parsed into the specified type.
pub fn arg_type<T: FromStr>(arg: String) -> ValidationResult {
    if arg.parse::<T>().is_err() {
        return Err(FunctionError::InvalidType(arg));
    }
    Ok(())
}

#[cfg(test)]
mod tests {
    use crate::prelude::validations::{arg_type, args_max_len, args_min_len};

    #[test]
    fn test_arg_min_len() {
        let args = vec!["Some".to_string(), "Other".to_string(), "Again".to_string()];

        assert!(args_min_len(&args, 2).is_ok());
    }

    #[test]
    fn test_arg_min_err_len() {
        let args = vec!["Some".to_string(), "Other".to_string(), "Again".to_string()];

        assert!(args_min_len(&args, 10).is_err());
    }

    #[test]
    fn test_arg_max_len() {
        let args = vec!["Some".to_string(), "Other".to_string(), "Again".to_string()];

        assert!(args_max_len(&args, 3).is_ok());
    }

    #[test]
    fn test_arg_max_out_len() {
        let args = vec!["Some".to_string(), "Other".to_string(), "Again".to_string()];

        assert!(args_max_len(&args, 1).is_err());
    }

    #[test]
    fn test_arg_type() {
        assert!(arg_type::<u32>("54".to_string()).is_ok());
        assert!(arg_type::<f32>("3.5".to_string()).is_ok());
        assert!(arg_type::<i32>("-54".to_string()).is_ok());
        assert!(arg_type::<u32>("3.5".to_string()).is_err());
        assert!(arg_type::<u32>("-54".to_string()).is_err());
    }
}