use crate::matcher::{Matcher, MatcherBuilder};
use crate::utils;
use crate::ContentPath;
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Precedence {
Lowest,
Low,
Medium,
High,
Highest,
}
impl Precedence {
fn rank(self) -> u8 {
match self {
Self::Lowest => 0,
Self::Low => 1,
Self::Medium => 2,
Self::High => 3,
Self::Highest => 4,
}
}
}
enum FilterRule {
IncludeExtensions(Matcher<bool>),
ExcludeExtensions(Matcher<bool>),
IncludeFileNames(Matcher<bool>),
ExcludeFileNames(Matcher<bool>),
Include(fn(&ContentPath, u64) -> bool),
Exclude(fn(&ContentPath, u64) -> bool),
}
pub struct Filter {
rules: Vec<FilterRule>,
default_result: bool,
check_extensions: bool,
check_file_names: bool,
temp_ext: Vec<u8>,
temp_filename: Vec<u8>,
}
impl Filter {
pub(crate) fn should_process(&mut self, path: &ContentPath, size: u64) -> bool {
let file_name = if self.check_file_names {
let res = utils::get_file_name(path.as_bytes());
if utils::contains_uppercase(res) {
utils::copy_lowercase(res, &mut self.temp_filename)
} else {
res
}
} else {
b""
};
let ext = if self.check_extensions {
let res = utils::get_extension(file_name);
if utils::contains_uppercase(res) {
utils::copy_lowercase(res, &mut self.temp_ext)
} else {
res
}
} else {
b""
};
for rule in &self.rules {
match rule {
FilterRule::IncludeExtensions(matcher) | FilterRule::ExcludeExtensions(matcher) => {
if let Some(res) = matcher.matches_exactly(ext) {
return res;
}
}
FilterRule::IncludeFileNames(matcher) | FilterRule::ExcludeFileNames(matcher) => {
if let Some(res) = matcher.matches_exactly(file_name) {
return res;
}
}
FilterRule::Include(cb) => {
if cb(path, size) {
return true;
}
}
FilterRule::Exclude(cb) => {
if cb(path, size) {
return false;
}
}
};
}
self.default_result
}
}
pub struct FilterBuilder {
rules: Vec<(Precedence, FilterRule)>,
default_result: bool,
}
impl FilterBuilder {
pub fn new() -> Self {
Self {
rules: Vec::with_capacity(4),
default_result: true,
}
}
pub fn include_extensions(mut self, prec: Precedence, extensions: &[&'static str]) -> Self {
let mut matcher_builder = MatcherBuilder::new();
for extension in extensions {
matcher_builder.add(true, utils::ascii_lower_static(extension));
}
self.rules.push((prec, FilterRule::IncludeExtensions(matcher_builder.build())));
self
}
pub fn exclude_extensions(mut self, prec: Precedence, extensions: &[&'static str]) -> Self {
let mut matcher_builder = MatcherBuilder::new();
for extension in extensions {
matcher_builder.add(false, utils::ascii_lower_static(extension));
}
self.rules.push((prec, FilterRule::ExcludeExtensions(matcher_builder.build())));
self
}
pub fn include_file_names(mut self, prec: Precedence, file_names: &[&'static str]) -> Self {
let mut matcher_builder = MatcherBuilder::new();
for file_name in file_names {
matcher_builder.add(true, utils::ascii_lower_static(file_name));
}
self.rules.push((prec, FilterRule::IncludeFileNames(matcher_builder.build())));
self
}
pub fn exclude_file_names(mut self, prec: Precedence, file_names: &[&'static str]) -> Self {
let mut matcher_builder = MatcherBuilder::new();
for file_name in file_names {
matcher_builder.add(false, utils::ascii_lower_static(file_name));
}
self.rules.push((prec, FilterRule::ExcludeFileNames(matcher_builder.build())));
self
}
pub fn include(mut self, prec: Precedence, callback: fn(&ContentPath, u64) -> bool) -> Self {
self.rules.push((prec, FilterRule::Include(callback)));
self
}
pub fn exclude(mut self, prec: Precedence, callback: fn(&ContentPath, u64) -> bool) -> Self {
self.rules.push((prec, FilterRule::Exclude(callback)));
self
}
pub fn deny_the_rest(mut self) -> ReadyFilterBuilder {
self.default_result = false;
ReadyFilterBuilder { builder: self }
}
pub fn allow_the_rest(mut self) -> ReadyFilterBuilder {
self.default_result = true;
ReadyFilterBuilder { builder: self }
}
}
impl Default for FilterBuilder {
fn default() -> Self {
Self::new()
}
}
pub struct ReadyFilterBuilder {
builder: FilterBuilder,
}
impl ReadyFilterBuilder {
pub fn build(self) -> Filter {
let check_extensions = self
.builder
.rules
.iter()
.any(|(_, rule)| matches!(rule, FilterRule::IncludeExtensions(_) | FilterRule::ExcludeExtensions(_)));
let check_file_names = self
.builder
.rules
.iter()
.any(|(_, rule)| matches!(rule, FilterRule::IncludeFileNames(_) | FilterRule::ExcludeFileNames(_)));
let mut ranked = self.builder.rules;
ranked.sort_by_key(|b| std::cmp::Reverse(b.0.rank()));
let rules = ranked.into_iter().map(|(_, rule)| rule).collect();
Filter {
rules,
default_result: self.builder.default_result,
check_extensions,
check_file_names: check_file_names || check_extensions, temp_ext: Vec::with_capacity(16),
temp_filename: Vec::with_capacity(64),
}
}
}