lowdash 0.5.3

A Lodash inspired utility library to manipulate array and object 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
143

use crate::common;

/// Generates a random string of a specified size using the provided charset.
///
/// # Arguments
///
/// * `size` - The length of the generated string. Must be greater than 0.
/// * `charset` - A slice of characters to use for generating the string. Must not be empty.
///
/// # Panics
///
/// * If `size` is less than or equal to 0.
/// * If `charset` is empty.
///
/// # Examples
///
/// ```rust
/// use lowdash::common::ALPHANUMERIC_CHARSET;
/// use lowdash::random_string;
///
/// let charset = ALPHANUMERIC_CHARSET;
/// let random_str = random_string(10, charset);
/// assert_eq!(random_str.len(), 10);
/// for c in random_str.chars() {
///     assert!(charset.contains(&c));
/// }
/// ```
pub fn random_string(size: usize, charset: &[char]) -> String {
    if size == 0 {
        panic!("common::random_string: Size parameter must be greater than 0");
    }
    if charset.is_empty() {
        panic!("common::random_string: Charset parameter must not be empty");
    }

    // Calculate the number of bits required to represent the charset
    let charset_len = charset.len();
    let letter_id_bits = common::ceil_log2(charset_len);
    let letter_id_mask = (1 << letter_id_bits) - 1;
    let letter_id_max = 63 / letter_id_bits;

    let mut result = String::with_capacity(size);
    let mut bits_remaining = 0;
    let mut cache: u64 = 0;

    for _ in 0..size {
        if bits_remaining == 0 {
            cache = common::random_u64();
            bits_remaining = letter_id_max;
        }

        let idx = (cache & letter_id_mask as u64) as usize;
        cache >>= letter_id_bits;
        bits_remaining -= 1;

        if idx < charset_len {
            result.push(charset[idx]);
        } else {
            // If the index is out of range, retry with a new random number
            let new_cache = common::random_u64();
            let new_idx = (new_cache & letter_id_mask as u64) as usize;
            if new_idx < charset_len {
                result.push(charset[new_idx]);
            } else {
                // Fallback to the first character if all else fails
                result.push(charset[0]);
            }
        }
    }

    result
}

#[cfg(test)]
mod tests {
    use crate::common;

    use super::*;

    #[test]
    fn test_random_string_length() {
        let charset = common::ALPHANUMERIC_CHARSET;
        let size = 12;
        let random_str = random_string(size, charset);
        assert_eq!(random_str.len(), size);
    }

    #[test]
    fn test_random_string_characters() {
        let charset = common::ALPHANUMERIC_CHARSET;
        let size = 20;
        let random_str = random_string(size, charset);
        for c in random_str.chars() {
            assert!(charset.contains(&c));
        }
    }

    #[test]
    #[should_panic(expected = "common::random_string: Size parameter must be greater than 0")]
    fn test_random_string_size_zero() {
        let charset = common::ALPHANUMERIC_CHARSET;
        let _ = random_string(0, charset);
    }

    #[test]
    #[should_panic(expected = "common::random_string: Charset parameter must not be empty")]
    fn test_random_string_empty_charset() {
        let charset: &[char] = &[];
        let _ = random_string(10, charset);
    }

    #[test]
    fn test_random_string_variety() {
        let charset = common::ALPHANUMERIC_CHARSET;
        let size = 15;
        let random_str1 = random_string(size, charset);
        let random_str2 = random_string(size, charset);
        assert_ne!(
            random_str1, random_str2,
            "Two random strings should not be identical"
        );
    }

    #[test]
    fn test_random_string_with_special_characters() {
        let charset = common::SPECIAL_CHARSET;
        let size = 10;
        let random_str = random_string(size, charset);
        for c in random_str.chars() {
            assert!(charset.contains(&c));
        }
    }

    #[test]
    fn test_random_string_full_charset() {
        let charset = common::ALL_CHARSET;
        let size = 25;
        let random_str = random_string(size, charset);
        for c in random_str.chars() {
            assert!(charset.contains(&c));
        }
    }
}