Skip to main content

source_mesh_core/graph/
exclusions.rs

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 claims::assert_err;
53    use claims::assert_ok;
54    use pretty_assertions::assert_eq;
55    use rstest::rstest;
56
57    use super::Exclusions;
58    use crate::SourcePath;
59
60    #[must_use]
61    #[track_caller]
62    fn validated_source_path_test_fixture(path: PathBuf) -> PathBuf {
63        let source_path = SourcePath::new(path);
64        let source_path = assert_ok!(source_path, "Exclusion test fixture must have a valid relative source path");
65        source_path.into_path()
66    }
67
68    #[must_use]
69    #[track_caller]
70    fn portable_source_path_test_fixture(path: &str) -> PathBuf {
71        validated_source_path_test_fixture(path.split('/').collect())
72    }
73
74    #[rstest]
75    #[case("src/file.rs", "src/file.rs", true)]
76    #[case("src/file.rs", "src/file.rs.bak", false)]
77    #[case("src/file.rs", "nested/src/file.rs", false)]
78    #[case("src/file.rs", "src/FILE.rs", false)]
79    #[case("src", "src", true)]
80    #[case("src", "src/file.rs", false)]
81    #[case("*.rs", "file.rs", true)]
82    #[case("*.rs", ".hidden.rs", true)]
83    #[case("*.rs", "src/file.rs", false)]
84    #[case("src/*.rs", "src/file.rs", true)]
85    #[case("src/*.rs", "src/nested/file.rs", false)]
86    #[case("src/*.rs", "src/file.RS", false)]
87    #[case("src/*/file.rs", "src/nested/file.rs", true)]
88    #[case("src/*/file.rs", "src/file.rs", false)]
89    #[case("src/*/file.rs", "src/nested/deeper/file.rs", false)]
90    #[case("**/*.rs", "file.rs", true)]
91    #[case("**/*.rs", "src/nested/file.rs", true)]
92    #[case("src/**/file.rs", "src/file.rs", true)]
93    #[case("src/**/file.rs", "src/nested/deeper/file.rs", true)]
94    #[case("src/generated/**", "src/generated/file.rs", true)]
95    #[case("src/generated/**", "src/generated/nested/file.rs", true)]
96    #[case("src/generated/**", "src/generated", false)]
97    #[case("src/generated/**", "src/generated_other/file.rs", false)]
98    #[case("src/generated/**", "nested/src/generated/file.rs", false)]
99    #[case("SRC/**", "src/file.rs", false)]
100    #[case("src/?.rs", "src/a.rs", true)]
101    #[case("src/?.rs", "src/ab.rs", false)]
102    #[case("src/[ab].rs", "src/a.rs", true)]
103    #[case("src/{first,second}.rs", "src/second.rs", true)]
104    #[case("src/some name.rs", "src/some name.rs", true)]
105    #[case("src/\u{e9}*.rs", "src/\u{e9}tude.rs", true)]
106    #[case("src/..hidden.rs", "src/..hidden.rs", true)]
107    fn test_glob_semantics(#[case] pattern: &str, #[case] path: &str, #[case] expected: bool) {
108        let file = portable_source_path_test_fixture(path);
109        let system_under_test = Exclusions::new(&[pattern.to_owned()]);
110        let system_under_test = assert_ok!(system_under_test, "Portable exclusion glob must compile: {pattern:?}");
111
112        let matched = system_under_test.matches(&file);
113
114        assert_eq!(expected, matched, "Pattern {pattern:?} matched path {path:?} incorrectly");
115    }
116
117    #[rstest]
118    #[case("src/generated/file.rs", true)]
119    #[case("src/nested/file.generated.rs", true)]
120    #[case("root.rs", true)]
121    #[case("src/root.rs", false)]
122    #[case("src/main.rs", false)]
123    fn test_combined_patterns(#[case] path: &str, #[case] expected: bool) {
124        let file = portable_source_path_test_fixture(path);
125        let patterns = ["src/generated/**", "**/*.generated.rs", "root.rs", "src/generated/**"].map(str::to_owned);
126        let system_under_test = Exclusions::new(&patterns);
127        let system_under_test = assert_ok!(system_under_test, "Overlapping and duplicate exclusion patterns must compile");
128
129        let matched = system_under_test.matches(&file);
130        let matched_again = system_under_test.matches(&file);
131
132        assert_eq!(expected, matched, "Combined patterns matched path {path:?} incorrectly");
133        assert_eq!(matched, matched_again, "Compiled exclusions must be reusable");
134    }
135
136    #[rstest]
137    fn test_empty_exclusions(#[values(false, true)] compiled: bool) {
138        let file = portable_source_path_test_fixture("src/file.rs");
139        let system_under_test = if compiled {
140            let exclusions = Exclusions::new(&[]);
141            assert_ok!(exclusions, "An empty pattern list must compile")
142        } else {
143            Exclusions::default()
144        };
145
146        let matched = system_under_test.matches(&file);
147
148        assert!(!matched, "Empty exclusions must not match any file");
149    }
150
151    #[rstest]
152    #[case("")]
153    #[case("/")]
154    #[case("/src/**")]
155    #[case("//server/share/**")]
156    #[case(".")]
157    #[case("./src/**")]
158    #[case("src/./file.rs")]
159    #[case("..")]
160    #[case("../**")]
161    #[case("src/../**")]
162    #[case("src/..")]
163    #[case("src//*.rs")]
164    #[case("src/")]
165    #[case("src\\**")]
166    #[case("C:/src/**")]
167    #[case("C:src/**")]
168    #[case("\\src\\**")]
169    #[case("\\\\server\\share\\**")]
170    #[case("\\\\?\\C:\\src\\**")]
171    #[case("src/file:stream")]
172    #[case("src/<file>.rs")]
173    #[case("src/\"file\".rs")]
174    #[case("src/file|other.rs")]
175    #[case("src/file\0.rs")]
176    #[case("src/file\n.rs")]
177    #[case("!src/**")]
178    #[case("[")]
179    #[case("src/[z-a].rs")]
180    #[case("{src,tests")]
181    fn test_pattern_validation(#[case] pattern: &str) {
182        let patterns = ["valid/**".to_owned(), pattern.to_owned()];
183
184        let system_under_test = Exclusions::new(&patterns);
185
186        let error = assert_err!(system_under_test, "Invalid exclusion pattern was accepted: {pattern:?}");
187        let diagnostic = error.to_string();
188        let expected = format!("{pattern:?}");
189        assert!(diagnostic.contains(&expected), "Validation must identify the invalid pattern: {diagnostic}");
190    }
191
192    #[rstest]
193    #[case("src/file.rs")]
194    #[case("src//file.rs")]
195    #[case("src/./file.rs")]
196    #[case("src//file.rs/")]
197    fn test_validated_source_path_spelling(#[case] path: &str) {
198        let expected_path = PathBuf::from(path);
199        let file = validated_source_path_test_fixture(expected_path.clone());
200        let system_under_test = Exclusions::new(&["src/file.rs".to_owned()]);
201        let system_under_test = assert_ok!(system_under_test, "An exact project-relative file exclusion must compile");
202
203        let matched = system_under_test.matches(&file);
204
205        assert!(matched, "Equivalent validated source path spelling did not match: {path:?}");
206        assert_eq!(expected_path.as_os_str(), file.as_os_str(), "Matching must not change stored path spelling");
207    }
208
209    #[cfg(unix)]
210    #[rstest]
211    #[case("src/*.rs", true)]
212    #[case("src/f\u{fffd}.rs", false)]
213    fn test_non_utf8_source_paths(#[case] pattern: &str, #[case] expected: bool) {
214        use std::ffi::OsString;
215        use std::os::unix::ffi::OsStringExt as _;
216        use std::path::Path;
217
218        let name = OsString::from_vec(vec![b'f', 0xff, b'.', b'r', b's']);
219        let file = validated_source_path_test_fixture(Path::new("src").join(name));
220        let system_under_test = Exclusions::new(&[pattern.to_owned()]);
221        let system_under_test = assert_ok!(system_under_test, "Non-UTF-8 source paths must not affect glob compilation");
222
223        let matched = system_under_test.matches(&file);
224
225        assert_eq!(expected, matched, "Matching must preserve non-UTF-8 source path bytes");
226    }
227}