minifind 0.7.4

minimal find reimplementation
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

use anyhow::{Context, Error};
use globset::{GlobBuilder, GlobSet, GlobSetBuilder};

/// Builds a `GlobSet` from a list of glob patterns.
///
/// # Arguments
///
/// * `patterns` - An optional reference to a vector of glob patterns.
///
/// # Returns
///
/// A Result containing the constructed `GlobSet` or an Error if the construction fails.
pub fn build_glob_set(
    patterns: Option<&[String]>,
    case_insensitive: bool,
) -> Result<GlobSet, Error> {
    let mut builder = GlobSetBuilder::new();

    for p in patterns.into_iter().flatten() {
        builder.add(
            GlobBuilder::new(p)
                .case_insensitive(case_insensitive)
                .build()
                .context("Unable to parse and build glob pattern")?,
        );
    }

    builder.build().context("Unable to build globbing set")
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_build_glob_set_none() {
        let gs = build_glob_set(None, false).unwrap();
        assert!(!gs.is_match("anything"));
    }

    #[test]
    fn test_build_glob_set_empty_vec() {
        let patterns: Vec<String> = vec![];
        let gs = build_glob_set(Some(&patterns), false).unwrap();
        assert!(!gs.is_match("anything"));
    }

    #[test]
    fn test_build_glob_set_single_pattern() {
        let patterns = vec!["*.rs".to_string()];
        let gs = build_glob_set(Some(&patterns), false).unwrap();
        assert!(gs.is_match("main.rs"));
        assert!(!gs.is_match("main.py"));
    }

    #[test]
    fn test_build_glob_set_multiple_patterns() {
        let patterns = vec!["*.rs".to_string(), "*.toml".to_string()];
        let gs = build_glob_set(Some(&patterns), false).unwrap();
        assert!(gs.is_match("main.rs"));
        assert!(gs.is_match("Cargo.toml"));
        assert!(!gs.is_match("main.py"));
    }

    #[test]
    fn test_build_glob_set_case_sensitive() {
        let patterns = vec!["*.RS".to_string()];
        let gs = build_glob_set(Some(&patterns), false).unwrap();
        assert!(!gs.is_match("main.rs"));
        assert!(gs.is_match("main.RS"));
    }

    #[test]
    fn test_build_glob_set_case_insensitive() {
        let patterns = vec!["*.RS".to_string()];
        let gs = build_glob_set(Some(&patterns), true).unwrap();
        assert!(gs.is_match("main.rs"));
        assert!(gs.is_match("main.RS"));
    }

    #[test]
    fn test_build_glob_set_invalid_pattern() {
        // Unclosed bracket is an invalid glob pattern
        let patterns = vec!["[invalid".to_string()];
        assert!(build_glob_set(Some(&patterns), false).is_err());
    }

    #[test]
    fn test_build_glob_set_wildcard() {
        let patterns = vec!["*".to_string()];
        let gs = build_glob_set(Some(&patterns), false).unwrap();
        assert!(gs.is_match("anything"));
        assert!(gs.is_match("file.txt"));
    }

    #[test]
    fn test_build_glob_set_question_mark() {
        let patterns = vec!["?.rs".to_string()];
        let gs = build_glob_set(Some(&patterns), false).unwrap();
        assert!(gs.is_match("a.rs"));
        assert!(!gs.is_match("ab.rs"));
    }

    #[test]
    fn test_build_glob_set_double_star() {
        let patterns = vec!["**/*.rs".to_string()];
        let gs = build_glob_set(Some(&patterns), false).unwrap();
        assert!(gs.is_match("src/main.rs"));
        assert!(gs.is_match("a/b/c.rs"));
        assert!(!gs.is_match("src/main.py"));
    }
}