use crate::error::Error;
use crate::syntax::dialect::Dialect;
use crate::syntax::matcher::{match_path, match_segment};
use crate::syntax::parse::{Anchor, parse};
use crate::syntax::{CaseSensitivity, CodePoint, Pattern, PatternSegment};
#[cfg(test)]
mod tests;
#[derive(Clone, Debug)]
pub struct CompiledPattern {
pub pattern: Pattern,
pub anchor: Anchor,
pub dialect: Dialect,
pub case: CaseSensitivity,
}
#[derive(Clone, Debug, Default)]
pub struct PatternSet {
patterns: Vec<CompiledPattern>,
}
impl PatternSet {
pub fn new() -> Self {
Self::default()
}
pub fn from_compiled(patterns: Vec<CompiledPattern>) -> Self {
Self { patterns }
}
pub fn add(
&mut self,
input: &str,
dialect: Dialect,
case: Option<CaseSensitivity>,
) -> Result<usize, Error> {
let parsed = parse(input, dialect)?;
let idx = self.patterns.len();
self.patterns.push(CompiledPattern {
pattern: parsed.pattern,
anchor: parsed.anchor,
dialect,
case: case.unwrap_or_else(|| dialect.default_case()),
});
Ok(idx)
}
pub fn len(&self) -> usize {
self.patterns.len()
}
pub fn is_empty(&self) -> bool {
self.patterns.is_empty()
}
pub fn get(&self, index: usize) -> Option<&CompiledPattern> {
self.patterns.get(index)
}
pub fn matches(&self, path: &[&[CodePoint]]) -> Vec<usize> {
self.patterns
.iter()
.enumerate()
.filter(|(_, p)| match_path(&p.pattern.segments, path, p.case))
.map(|(i, _)| i)
.collect()
}
pub fn should_descend(&self, dir: &[&[CodePoint]]) -> bool {
self.patterns
.iter()
.any(|p| descend_viable(&p.pattern.segments, dir, p.case))
}
pub fn should_descend_where(
&self,
dir: &[&[CodePoint]],
applies: impl Fn(usize) -> bool,
) -> bool {
self.patterns
.iter()
.enumerate()
.filter(|(i, _)| applies(*i))
.any(|(_, p)| descend_viable(&p.pattern.segments, dir, p.case))
}
}
fn descend_viable(pat: &[PatternSegment], dir: &[&[CodePoint]], case: CaseSensitivity) -> bool {
let mut pat = pat;
let mut dir = dir;
loop {
match pat.split_first() {
None => return false,
Some((PatternSegment::DoubleStar, _)) => return true,
Some((PatternSegment::Match(seg), rest)) => match dir.split_first() {
Some((head, tail)) => {
if match_segment(seg, head, case) {
pat = rest;
dir = tail;
} else {
return false;
}
}
None => return true,
},
}
}
}