minifind 0.9.0

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
113
114
115
116
117
118
119
120
121
122
123
124

// SPDX-FileCopyrightText: 2022 Dinko Korunic <dinko.korunic@gmail.com>
// SPDX-License-Identifier: MIT

use anyhow::{Context, Error};
use regex::bytes::{RegexSet, RegexSetBuilder};
use std::borrow::Cow;
use std::path::Path;

#[cfg(unix)]
use std::os::unix::ffi::OsStrExt;

/// Builds a byte `RegexSet` from the optional `--regex` patterns (empty set
/// matches nothing). Errors on an invalid pattern.
pub fn build_regex_set(
    patterns: Option<&[String]>,
    case_insensitive: bool,
) -> Result<RegexSet, Error> {
    RegexSetBuilder::new(patterns.into_iter().flatten())
        .case_insensitive(case_insensitive)
        .build()
        .context("Unable to parse and build regular expression set")
}

/// Converts the given path to a byte slice, lossily on non-Unix.
#[cfg(unix)]
#[inline]
pub fn path_to_bytes<P: AsRef<Path> + ?Sized>(path: &P) -> Cow<'_, [u8]> {
    Cow::Borrowed(path.as_ref().as_os_str().as_bytes())
}

#[cfg(not(unix))]
#[inline]
pub fn path_to_bytes<P: AsRef<Path> + ?Sized>(path: &P) -> Cow<'_, [u8]> {
    match path.as_ref().to_string_lossy() {
        Cow::Borrowed(s) => Cow::Borrowed(s.as_bytes()),
        Cow::Owned(s) => Cow::Owned(s.into_bytes()),
    }
}

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

    #[test]
    fn test_build_regex_set_none() {
        let rs = build_regex_set(None, false).unwrap();
        assert!(!rs.is_match(b"anything"));
    }

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

    #[test]
    fn test_build_regex_set_single_pattern() {
        let patterns = vec![r"\.rs$".to_string()];
        let rs = build_regex_set(Some(&patterns), false).unwrap();
        assert!(rs.is_match(b"/src/main.rs"));
        assert!(!rs.is_match(b"/src/main.py"));
    }

    #[test]
    fn test_build_regex_set_multiple_patterns() {
        let patterns = vec![r"\.rs$".to_string(), r"\.toml$".to_string()];
        let rs = build_regex_set(Some(&patterns), false).unwrap();
        assert!(rs.is_match(b"main.rs"));
        assert!(rs.is_match(b"Cargo.toml"));
        assert!(!rs.is_match(b"main.py"));
    }

    #[test]
    fn test_build_regex_set_case_sensitive() {
        let patterns = vec![r"\.RS$".to_string()];
        let rs = build_regex_set(Some(&patterns), false).unwrap();
        assert!(!rs.is_match(b"/src/main.rs"));
        assert!(rs.is_match(b"/src/main.RS"));
    }

    #[test]
    fn test_build_regex_set_case_insensitive() {
        let patterns = vec![r"\.RS$".to_string()];
        let rs = build_regex_set(Some(&patterns), true).unwrap();
        assert!(rs.is_match(b"/src/main.rs"));
        assert!(rs.is_match(b"/src/main.RS"));
    }

    #[test]
    fn test_build_regex_set_invalid() {
        let patterns = vec!["[invalid".to_string()];
        assert!(build_regex_set(Some(&patterns), false).is_err());
    }

    #[test]
    fn test_build_regex_set_anchored() {
        let patterns = vec![r"^/src/".to_string()];
        let rs = build_regex_set(Some(&patterns), false).unwrap();
        assert!(rs.is_match(b"/src/main.rs"));
        assert!(!rs.is_match(b"/other/main.rs"));
    }

    #[test]
    fn test_path_to_bytes_simple() {
        let path = Path::new("/some/path/file.txt");
        let bytes = path_to_bytes(path);
        assert_eq!(bytes.as_ref(), b"/some/path/file.txt");
    }

    #[test]
    fn test_path_to_bytes_with_spaces() {
        let path = Path::new("/path/with spaces/file.txt");
        let bytes = path_to_bytes(path);
        assert_eq!(bytes.as_ref(), b"/path/with spaces/file.txt");
    }

    #[test]
    fn test_path_to_bytes_root() {
        let path = Path::new("/");
        let bytes = path_to_bytes(path);
        assert_eq!(bytes.as_ref(), b"/");
    }
}