1use std::path::Path;
2use std::path::PathBuf;
3
4use anyhow::Context as _;
5use anyhow::Result;
6use anyhow::ensure;
7use globset::GlobBuilder;
8use globset::GlobSet;
9use globset::GlobSetBuilder;
10
11
12#[derive(Debug, Default)]
13pub struct Exclusions {
14 patterns: GlobSet,
15}
16
17impl Exclusions {
18 pub fn new(patterns: &[String]) -> Result<Self> {
19 let mut compiled = GlobSetBuilder::new();
20 for pattern in patterns {
21 ensure!(!pattern.is_empty(), "Invalid exclusion pattern {pattern:?}: patterns must not be empty");
22 ensure!(!pattern.starts_with('!'), "Invalid exclusion pattern {pattern:?}: negation is not supported");
23 let nonportable = pattern.chars().any(|character| {
24 character.is_control() || matches!(character, '\\' | ':' | '<' | '>' | '"' | '|')
25 });
26 ensure!(!nonportable, "Invalid exclusion pattern {pattern:?}: use portable relative paths with '/' separators");
27 ensure!(
28 pattern.split('/').all(|component| !matches!(component, "" | "." | "..")),
29 "Invalid exclusion pattern {pattern:?}: paths must be relative with nonempty components and no '.' or '..'; \
30 use 'directory/**' for directories"
31 );
32 let glob = GlobBuilder::new(pattern).literal_separator(true).backslash_escape(false).case_insensitive(false).build();
33 compiled.add(glob.with_context(|| format!("Invalid exclusion pattern {pattern:?}"))?);
34 }
35 Ok(Self { patterns: compiled.build().context("Could not compile file exclusion patterns")? })
36 }
37
38 #[must_use]
39 pub(super) fn matches(&self, path: &Path) -> bool {
40 if self.patterns.is_empty() {
41 return false;
42 }
43 let path: PathBuf = path.components().collect();
44 self.patterns.is_match(path)
45 }
46}
47
48#[cfg(test)]
49mod tests {
50 use std::path::PathBuf;
51
52 use assertables::assert_contains;
53 use claims::assert_err;
54 use claims::assert_ok;
55 use pretty_assertions::assert_eq;
56 use rstest::rstest;
57
58 use super::Exclusions;
59 use crate::SourcePath;
60
61 #[must_use]
62 #[track_caller]
63 fn validated_source_path_test_fixture(path: PathBuf) -> PathBuf {
64 let source_path = SourcePath::new(path);
65 let source_path = assert_ok!(source_path, "Exclusion test fixture must have a valid relative source path");
66 source_path.into_path()
67 }
68
69 #[must_use]
70 #[track_caller]
71 fn portable_source_path_test_fixture(path: &str) -> PathBuf {
72 validated_source_path_test_fixture(path.split('/').collect())
73 }
74
75 #[rstest]
76 #[case("src/file.rs", "src/file.rs", true)]
77 #[case("src/file.rs", "src/file.rs.bak", false)]
78 #[case("src/file.rs", "nested/src/file.rs", false)]
79 #[case("src/file.rs", "src/FILE.rs", false)]
80 #[case("src", "src", true)]
81 #[case("src", "src/file.rs", false)]
82 #[case("*.rs", "file.rs", true)]
83 #[case("*.rs", ".hidden.rs", true)]
84 #[case("*.rs", "src/file.rs", false)]
85 #[case("src/*.rs", "src/file.rs", true)]
86 #[case("src/*.rs", "src/nested/file.rs", false)]
87 #[case("src/*.rs", "src/file.RS", false)]
88 #[case("src/*/file.rs", "src/nested/file.rs", true)]
89 #[case("src/*/file.rs", "src/file.rs", false)]
90 #[case("src/*/file.rs", "src/nested/deeper/file.rs", false)]
91 #[case("**/*.rs", "file.rs", true)]
92 #[case("**/*.rs", "src/nested/file.rs", true)]
93 #[case("src/**/file.rs", "src/file.rs", true)]
94 #[case("src/**/file.rs", "src/nested/deeper/file.rs", true)]
95 #[case("src/generated/**", "src/generated/file.rs", true)]
96 #[case("src/generated/**", "src/generated/nested/file.rs", true)]
97 #[case("src/generated/**", "src/generated", false)]
98 #[case("src/generated/**", "src/generated_other/file.rs", false)]
99 #[case("src/generated/**", "nested/src/generated/file.rs", false)]
100 #[case("SRC/**", "src/file.rs", false)]
101 #[case("src/?.rs", "src/a.rs", true)]
102 #[case("src/?.rs", "src/ab.rs", false)]
103 #[case("src/[ab].rs", "src/a.rs", true)]
104 #[case("src/{first,second}.rs", "src/second.rs", true)]
105 #[case("src/some name.rs", "src/some name.rs", true)]
106 #[case("src/\u{e9}*.rs", "src/\u{e9}tude.rs", true)]
107 #[case("src/..hidden.rs", "src/..hidden.rs", true)]
108 fn test_glob_semantics(#[case] pattern: &str, #[case] path: &str, #[case] expected: bool) {
109 let file = portable_source_path_test_fixture(path);
110 let system_under_test = Exclusions::new(&[pattern.to_owned()]);
111 let system_under_test = assert_ok!(system_under_test, "Portable exclusion glob must compile: {pattern:?}");
112
113 let matched = system_under_test.matches(&file);
114
115 assert_eq!(expected, matched, "Pattern {pattern:?} matched path {path:?} incorrectly");
116 }
117
118 #[rstest]
119 #[case("src/generated/file.rs", true)]
120 #[case("src/nested/file.generated.rs", true)]
121 #[case("root.rs", true)]
122 #[case("src/root.rs", false)]
123 #[case("src/main.rs", false)]
124 fn test_combined_patterns(#[case] path: &str, #[case] expected: bool) {
125 let file = portable_source_path_test_fixture(path);
126 let patterns = ["src/generated/**", "**/*.generated.rs", "root.rs", "src/generated/**"].map(str::to_owned);
127 let system_under_test = Exclusions::new(&patterns);
128 let system_under_test = assert_ok!(system_under_test, "Overlapping and duplicate exclusion patterns must compile");
129
130 let matched = system_under_test.matches(&file);
131 let matched_again = system_under_test.matches(&file);
132
133 assert_eq!(expected, matched, "Combined patterns matched path {path:?} incorrectly");
134 assert_eq!(matched, matched_again, "Compiled exclusions must be reusable");
135 }
136
137 #[rstest]
138 fn test_empty_exclusions(#[values(false, true)] compiled: bool) {
139 let file = portable_source_path_test_fixture("src/file.rs");
140 let system_under_test = if compiled {
141 let exclusions = Exclusions::new(&[]);
142 assert_ok!(exclusions, "An empty pattern list must compile")
143 } else {
144 Exclusions::default()
145 };
146
147 let matched = system_under_test.matches(&file);
148
149 assert!(!matched, "Empty exclusions must not match any file");
150 }
151
152 #[rstest]
153 #[case("")]
154 #[case("/")]
155 #[case("/src/**")]
156 #[case("//server/share/**")]
157 #[case(".")]
158 #[case("./src/**")]
159 #[case("src/./file.rs")]
160 #[case("..")]
161 #[case("../**")]
162 #[case("src/../**")]
163 #[case("src/..")]
164 #[case("src//*.rs")]
165 #[case("src/")]
166 #[case("src\\**")]
167 #[case("C:/src/**")]
168 #[case("C:src/**")]
169 #[case("\\src\\**")]
170 #[case("\\\\server\\share\\**")]
171 #[case("\\\\?\\C:\\src\\**")]
172 #[case("src/file:stream")]
173 #[case("src/<file>.rs")]
174 #[case("src/\"file\".rs")]
175 #[case("src/file|other.rs")]
176 #[case("src/file\0.rs")]
177 #[case("src/file\n.rs")]
178 #[case("!src/**")]
179 #[case("[")]
180 #[case("src/[z-a].rs")]
181 #[case("{src,tests")]
182 fn test_pattern_validation(#[case] pattern: &str) {
183 let patterns = ["valid/**".to_owned(), pattern.to_owned()];
184
185 let system_under_test = Exclusions::new(&patterns);
186
187 let error = assert_err!(system_under_test, "Invalid exclusion pattern was accepted: {pattern:?}");
188 let diagnostic = error.to_string();
189 let expected = format!("{pattern:?}");
190 assert_contains!(diagnostic, &expected, "Validation must identify the invalid pattern: {diagnostic}");
191 }
192
193 #[rstest]
194 #[case("src/file.rs")]
195 #[case("src//file.rs")]
196 #[case("src/./file.rs")]
197 #[case("src//file.rs/")]
198 fn test_validated_source_path_spelling(#[case] path: &str) {
199 let expected_path = PathBuf::from(path);
200 let file = validated_source_path_test_fixture(expected_path.clone());
201 let system_under_test = Exclusions::new(&["src/file.rs".to_owned()]);
202 let system_under_test = assert_ok!(system_under_test, "An exact project-relative file exclusion must compile");
203
204 let matched = system_under_test.matches(&file);
205
206 assert!(matched, "Equivalent validated source path spelling did not match: {path:?}");
207 assert_eq!(expected_path.as_os_str(), file.as_os_str(), "Matching must not change stored path spelling");
208 }
209
210 #[cfg(unix)]
211 #[rstest]
212 #[case("src/*.rs", true)]
213 #[case("src/f\u{fffd}.rs", false)]
214 fn test_non_utf8_source_paths(#[case] pattern: &str, #[case] expected: bool) {
215 use std::ffi::OsString;
216 use std::os::unix::ffi::OsStringExt as _;
217 use std::path::Path;
218
219 let name = OsString::from_vec(vec![b'f', 0xff, b'.', b'r', b's']);
220 let file = validated_source_path_test_fixture(Path::new("src").join(name));
221 let system_under_test = Exclusions::new(&[pattern.to_owned()]);
222 let system_under_test = assert_ok!(system_under_test, "Non-UTF-8 source paths must not affect glob compilation");
223
224 let matched = system_under_test.matches(&file);
225
226 assert_eq!(expected, matched, "Matching must preserve non-UTF-8 source path bytes");
227 }
228}