#![forbid(unsafe_code)]
#[derive(Debug, Clone, Default, PartialEq, Eq)]
pub struct FilterSet {
pub includes: Vec<String>,
pub excludes: Vec<String>,
}
impl FilterSet {
#[must_use]
pub fn is_active(&self) -> bool {
!self.includes.is_empty() || !self.excludes.is_empty()
}
#[must_use]
pub fn passes(&self, path: &str) -> bool {
if !self.is_active() {
return true;
}
let basename = path.rsplit('/').next().unwrap_or(path);
let matched =
|patterns: &[String]| patterns.iter().any(|p| pattern_matches(p, path, basename));
if matched(&self.includes) {
return true;
}
if matched(&self.excludes) {
return false;
}
true
}
}
fn pattern_matches(pattern: &str, path: &str, basename: &str) -> bool {
let anchored = pattern.starts_with('/');
let pattern = pattern.trim_start_matches('/').trim_end_matches('/');
let pattern = pattern.strip_prefix("**/").unwrap_or(pattern);
if pattern.is_empty() {
return false;
}
if pattern.contains('/') {
let pat = pattern.as_bytes();
if anchored {
prefix_matches(pat, path.as_bytes())
} else if has_wildcards(pat) {
let bytes = path.as_bytes();
(0..=bytes.len()).any(|start| glob(pat, &bytes[start..]))
} else {
path.as_bytes().windows(pat.len()).any(|w| w == pat)
}
} else if anchored {
prefix_matches(pattern.as_bytes(), path.as_bytes())
} else {
glob(pattern.as_bytes(), basename.as_bytes())
}
}
fn has_wildcards(pattern: &[u8]) -> bool {
pattern.iter().any(|&b| b == b'*' || b == b'?')
}
fn prefix_matches(pattern: &[u8], path: &[u8]) -> bool {
if glob(pattern, path) {
return true;
}
path.starts_with(pattern) && path.get(pattern.len()) == Some(&b'/')
}
fn glob(pattern: &[u8], text: &[u8]) -> bool {
if !has_wildcards(pattern) {
return pattern == text;
}
let (mut p, mut t) = (0usize, 0usize);
let (mut star_p, mut star_t) = (usize::MAX, 0usize);
while t < text.len() {
if p < pattern.len() && (pattern[p] == b'?' || pattern[p] == text[t]) {
p += 1;
t += 1;
} else if p < pattern.len() && pattern[p] == b'*' {
star_p = p;
star_t = t;
p += 1;
} else if star_p != usize::MAX {
p = star_p + 1;
star_t += 1;
t = star_t;
} else {
return false;
}
}
while p < pattern.len() && pattern[p] == b'*' {
p += 1;
}
p == pattern.len()
}
#[cfg(test)]
mod tests {
use super::*;
fn set(excludes: &[&str], includes: &[&str]) -> FilterSet {
FilterSet {
excludes: excludes
.iter()
.map(std::string::ToString::to_string)
.collect(),
includes: includes
.iter()
.map(std::string::ToString::to_string)
.collect(),
}
}
#[test]
fn inactive_passes_everything() {
let f = FilterSet::default();
assert!(f.passes("a/b/c.txt"));
}
#[test]
fn basename_pattern_matches_at_any_depth() {
let f = set(&["*.tmp"], &[]);
assert!(!f.passes("a.tmp"));
assert!(!f.passes("sub/b.tmp"));
assert!(f.passes("sub/b.txt"));
}
#[test]
fn question_mark_matches_single_char() {
let f = set(&["?x"], &[]);
assert!(!f.passes("ax"));
assert!(f.passes("aax"));
}
#[test]
fn anchored_pattern_is_root_only() {
let f = set(&["/build"], &[]);
assert!(!f.passes("build"));
assert!(!f.passes("build/x.rs"));
assert!(f.passes("sub/build"));
}
#[test]
fn slashed_pattern_matches_at_any_depth() {
let f = set(&["src/*.rs"], &[]);
assert!(!f.passes("src/main.rs"));
assert!(!f.passes("a/b/src/main.rs"));
assert!(f.passes("src/main.c"));
}
#[test]
fn includes_override_excludes() {
let f = set(&["*.tmp"], &["keep.tmp"]);
assert!(!f.passes("other.tmp"));
assert!(f.passes("keep.tmp"));
assert!(f.passes("other.txt"));
}
#[test]
fn wildcard_matches_across_slashes() {
let f = set(&["**/generated"], &[]);
assert!(!f.passes("generated"));
assert!(!f.passes("a/generated"));
assert!(!f.passes("a/b/generated"));
assert!(f.passes("a/b/keep"));
}
#[test]
fn glob_star_backtracking_edge_cases() {
for (pat, text) in [
("a*b", "ab"), ("a*b", "axxb"), ("*a", "ba"), ("a*", "a"), ("*a*", "ba"), ("*a*b*", "xaybz"), ("a*b*c", "abc"), ("*?", "x"), ("*a?b*", "zzaybzz"), ] {
assert!(glob(pat.as_bytes(), text.as_bytes()), "{pat} ~ {text}");
}
for (pat, text) in [
("a*c", "ab"), ("*?", ""), ("?x", "xy"), ("a*b", "ba"), ("ab", "abc"), ("ab", "aab"), ] {
assert!(!glob(pat.as_bytes(), text.as_bytes()), "{pat} !~ {text}");
}
}
}