filepatterns.rs
688 lines
| 21.2 KiB
| application/rls-services+xml
|
RustLexer
|
r42996 | // filepatterns.rs | ||
// | ||||
// Copyright 2019 Raphaël Gomès <rgomes@octobus.net> | ||||
// | ||||
// This software may be used and distributed according to the terms of the | ||||
// GNU General Public License version 2 or any later version. | ||||
//! Handling of Mercurial-specific patterns. | ||||
|
r44785 | use crate::{ | ||
utils::{ | ||||
files::{canonical_path, get_bytes_from_path, get_path_from_bytes}, | ||||
hg_path::{path_to_hg_path_buf, HgPathBuf, HgPathError}, | ||||
SliceExt, | ||||
}, | ||||
FastHashMap, PatternError, | ||||
}; | ||||
|
r42828 | use lazy_static::lazy_static; | ||
|
r42859 | use regex::bytes::{NoExpand, Regex}; | ||
|
r42514 | use std::fs::File; | ||
use std::io::Read; | ||||
|
r44785 | use std::ops::Deref; | ||
|
r43227 | use std::path::{Path, PathBuf}; | ||
|
r42514 | use std::vec::Vec; | ||
lazy_static! { | ||||
|
r42683 | static ref RE_ESCAPE: Vec<Vec<u8>> = { | ||
|
r42514 | let mut v: Vec<Vec<u8>> = (0..=255).map(|byte| vec![byte]).collect(); | ||
let to_escape = b"()[]{}?*+-|^$\\.&~# \t\n\r\x0b\x0c"; | ||||
for byte in to_escape { | ||||
v[*byte as usize].insert(0, b'\\'); | ||||
} | ||||
v | ||||
}; | ||||
} | ||||
/// These are matched in order | ||||
const GLOB_REPLACEMENTS: &[(&[u8], &[u8])] = | ||||
&[(b"*/", b"(?:.*/)?"), (b"*", b".*"), (b"", b"[^/]*")]; | ||||
|
r44784 | /// Appended to the regexp of globs | ||
const GLOB_SUFFIX: &[u8; 7] = b"(?:/|$)"; | ||||
|
r48170 | #[derive(Debug, Clone, PartialEq, Eq)] | ||
|
r42514 | pub enum PatternSyntax { | ||
|
r44784 | /// A regular expression | ||
|
r42514 | Regexp, | ||
/// Glob that matches at the front of the path | ||||
RootGlob, | ||||
|
r43109 | /// Glob that matches at any suffix of the path (still anchored at | ||
/// slashes) | ||||
|
r42514 | Glob, | ||
|
r44784 | /// a path relative to repository root, which is matched recursively | ||
|
r42514 | Path, | ||
|
r44784 | /// A path relative to cwd | ||
|
r42514 | RelPath, | ||
|
r44784 | /// an unrooted glob (*.rs matches Rust files in all dirs) | ||
|
r42514 | RelGlob, | ||
|
r44784 | /// A regexp that needn't match the start of a name | ||
|
r42514 | RelRegexp, | ||
|
r44784 | /// A path relative to repository root, which is matched non-recursively | ||
/// (will not match subdirectories) | ||||
|
r42514 | RootFiles, | ||
|
r44785 | /// A file of patterns to read and include | ||
Include, | ||||
/// A file of patterns to match against files under the same directory | ||||
SubInclude, | ||||
|
r48170 | /// SubInclude with the result of parsing the included file | ||
/// | ||||
/// Note: there is no ExpandedInclude because that expansion can be done | ||||
/// in place by replacing the Include pattern by the included patterns. | ||||
/// SubInclude requires more handling. | ||||
/// | ||||
/// Note: `Box` is used to minimize size impact on other enum variants | ||||
ExpandedSubInclude(Box<SubInclude>), | ||||
|
r42514 | } | ||
/// Transforms a glob pattern into a regex | ||||
fn glob_to_re(pat: &[u8]) -> Vec<u8> { | ||||
let mut input = pat; | ||||
let mut res: Vec<u8> = vec![]; | ||||
let mut group_depth = 0; | ||||
while let Some((c, rest)) = input.split_first() { | ||||
input = rest; | ||||
match c { | ||||
b'*' => { | ||||
for (source, repl) in GLOB_REPLACEMENTS { | ||||
|
r43129 | if let Some(rest) = input.drop_prefix(source) { | ||
input = rest; | ||||
|
r42514 | res.extend(*repl); | ||
break; | ||||
} | ||||
} | ||||
} | ||||
b'?' => res.extend(b"."), | ||||
b'[' => { | ||||
match input.iter().skip(1).position(|b| *b == b']') { | ||||
None => res.extend(b"\\["), | ||||
Some(end) => { | ||||
// Account for the one we skipped | ||||
let end = end + 1; | ||||
res.extend(b"["); | ||||
for (i, b) in input[..end].iter().enumerate() { | ||||
if *b == b'!' && i == 0 { | ||||
res.extend(b"^") | ||||
} else if *b == b'^' && i == 0 { | ||||
res.extend(b"\\^") | ||||
} else if *b == b'\\' { | ||||
res.extend(b"\\\\") | ||||
} else { | ||||
res.push(*b) | ||||
} | ||||
} | ||||
res.extend(b"]"); | ||||
input = &input[end + 1..]; | ||||
} | ||||
} | ||||
} | ||||
b'{' => { | ||||
group_depth += 1; | ||||
res.extend(b"(?:") | ||||
} | ||||
b'}' if group_depth > 0 => { | ||||
group_depth -= 1; | ||||
res.extend(b")"); | ||||
} | ||||
b',' if group_depth > 0 => res.extend(b"|"), | ||||
b'\\' => { | ||||
let c = { | ||||
if let Some((c, rest)) = input.split_first() { | ||||
input = rest; | ||||
c | ||||
} else { | ||||
c | ||||
} | ||||
}; | ||||
|
r42683 | res.extend(&RE_ESCAPE[*c as usize]) | ||
|
r42514 | } | ||
|
r42683 | _ => res.extend(&RE_ESCAPE[*c as usize]), | ||
|
r42514 | } | ||
} | ||||
res | ||||
} | ||||
fn escape_pattern(pattern: &[u8]) -> Vec<u8> { | ||||
pattern | ||||
.iter() | ||||
|
r42683 | .flat_map(|c| RE_ESCAPE[*c as usize].clone()) | ||
|
r42514 | .collect() | ||
} | ||||
|
r44784 | pub fn parse_pattern_syntax( | ||
kind: &[u8], | ||||
) -> Result<PatternSyntax, PatternError> { | ||||
|
r42514 | match kind { | ||
|
r44784 | b"re:" => Ok(PatternSyntax::Regexp), | ||
b"path:" => Ok(PatternSyntax::Path), | ||||
b"relpath:" => Ok(PatternSyntax::RelPath), | ||||
b"rootfilesin:" => Ok(PatternSyntax::RootFiles), | ||||
b"relglob:" => Ok(PatternSyntax::RelGlob), | ||||
b"relre:" => Ok(PatternSyntax::RelRegexp), | ||||
b"glob:" => Ok(PatternSyntax::Glob), | ||||
b"rootglob:" => Ok(PatternSyntax::RootGlob), | ||||
|
r44785 | b"include:" => Ok(PatternSyntax::Include), | ||
b"subinclude:" => Ok(PatternSyntax::SubInclude), | ||||
|
r42514 | _ => Err(PatternError::UnsupportedSyntax( | ||
String::from_utf8_lossy(kind).to_string(), | ||||
)), | ||||
} | ||||
} | ||||
/// Builds the regex that corresponds to the given pattern. | ||||
/// If within a `syntax: regexp` context, returns the pattern, | ||||
/// otherwise, returns the corresponding regex. | ||||
|
r44784 | fn _build_single_regex(entry: &IgnorePattern) -> Vec<u8> { | ||
let IgnorePattern { | ||||
syntax, pattern, .. | ||||
} = entry; | ||||
|
r42514 | if pattern.is_empty() { | ||
return vec![]; | ||||
} | ||||
match syntax { | ||||
|
r45347 | PatternSyntax::Regexp => pattern.to_owned(), | ||
|
r42514 | PatternSyntax::RelRegexp => { | ||
|
r45084 | // The `regex` crate accepts `**` while `re2` and Python's `re` | ||
// do not. Checking for `*` correctly triggers the same error all | ||||
// engines. | ||||
|
r45348 | if pattern[0] == b'^' | ||
|| pattern[0] == b'*' | ||||
|| pattern.starts_with(b".*") | ||||
{ | ||||
|
r42514 | return pattern.to_owned(); | ||
} | ||||
|
r44784 | [&b".*"[..], pattern].concat() | ||
|
r42514 | } | ||
PatternSyntax::Path | PatternSyntax::RelPath => { | ||||
if pattern == b"." { | ||||
return vec![]; | ||||
} | ||||
|
r43133 | [escape_pattern(pattern).as_slice(), b"(?:/|$)"].concat() | ||
|
r42514 | } | ||
PatternSyntax::RootFiles => { | ||||
let mut res = if pattern == b"." { | ||||
|
r45347 | vec![] | ||
|
r42514 | } else { | ||
// Pattern is a directory name. | ||||
|
r45347 | [escape_pattern(pattern).as_slice(), b"/"].concat() | ||
|
r42514 | }; | ||
// Anything after the pattern must be a non-directory. | ||||
res.extend(b"[^/]+$"); | ||||
res | ||||
} | ||||
|
r43132 | PatternSyntax::RelGlob => { | ||
let glob_re = glob_to_re(pattern); | ||||
if let Some(rest) = glob_re.drop_prefix(b"[^/]*") { | ||||
|
r44784 | [b".*", rest, GLOB_SUFFIX].concat() | ||
|
r43132 | } else { | ||
|
r45084 | [b"(?:.*/)?", glob_re.as_slice(), GLOB_SUFFIX].concat() | ||
|
r42514 | } | ||
|
r43132 | } | ||
PatternSyntax::Glob | PatternSyntax::RootGlob => { | ||||
|
r45347 | [glob_to_re(pattern).as_slice(), GLOB_SUFFIX].concat() | ||
|
r42514 | } | ||
|
r48170 | PatternSyntax::Include | ||
| PatternSyntax::SubInclude | ||||
| PatternSyntax::ExpandedSubInclude(_) => unreachable!(), | ||||
|
r42514 | } | ||
} | ||||
const GLOB_SPECIAL_CHARACTERS: [u8; 7] = | ||||
[b'*', b'?', b'[', b']', b'{', b'}', b'\\']; | ||||
|
r44784 | /// TODO support other platforms | ||
#[cfg(unix)] | ||||
pub fn normalize_path_bytes(bytes: &[u8]) -> Vec<u8> { | ||||
if bytes.is_empty() { | ||||
return b".".to_vec(); | ||||
} | ||||
let sep = b'/'; | ||||
let mut initial_slashes = bytes.iter().take_while(|b| **b == sep).count(); | ||||
if initial_slashes > 2 { | ||||
// POSIX allows one or two initial slashes, but treats three or more | ||||
// as single slash. | ||||
initial_slashes = 1; | ||||
} | ||||
let components = bytes | ||||
.split(|b| *b == sep) | ||||
.filter(|c| !(c.is_empty() || c == b".")) | ||||
.fold(vec![], |mut acc, component| { | ||||
if component != b".." | ||||
|| (initial_slashes == 0 && acc.is_empty()) | ||||
|| (!acc.is_empty() && acc[acc.len() - 1] == b"..") | ||||
{ | ||||
acc.push(component) | ||||
} else if !acc.is_empty() { | ||||
acc.pop(); | ||||
} | ||||
acc | ||||
}); | ||||
let mut new_bytes = components.join(&sep); | ||||
if initial_slashes > 0 { | ||||
let mut buf: Vec<_> = (0..initial_slashes).map(|_| sep).collect(); | ||||
buf.extend(new_bytes); | ||||
new_bytes = buf; | ||||
} | ||||
if new_bytes.is_empty() { | ||||
b".".to_vec() | ||||
} else { | ||||
new_bytes | ||||
} | ||||
} | ||||
|
r42514 | /// Wrapper function to `_build_single_regex` that short-circuits 'exact' globs | ||
/// that don't need to be transformed into a regex. | ||||
pub fn build_single_regex( | ||||
|
r44784 | entry: &IgnorePattern, | ||
|
r45311 | ) -> Result<Option<Vec<u8>>, PatternError> { | ||
|
r44784 | let IgnorePattern { | ||
pattern, syntax, .. | ||||
} = entry; | ||||
let pattern = match syntax { | ||||
PatternSyntax::RootGlob | ||||
| PatternSyntax::Path | ||||
| PatternSyntax::RelGlob | ||||
| PatternSyntax::RootFiles => normalize_path_bytes(&pattern), | ||||
|
r44785 | PatternSyntax::Include | PatternSyntax::SubInclude => { | ||
return Err(PatternError::NonRegexPattern(entry.clone())) | ||||
} | ||||
|
r44784 | _ => pattern.to_owned(), | ||
}; | ||||
if *syntax == PatternSyntax::RootGlob | ||||
&& !pattern.iter().any(|b| GLOB_SPECIAL_CHARACTERS.contains(b)) | ||||
|
r42514 | { | ||
|
r45311 | Ok(None) | ||
|
r42514 | } else { | ||
|
r44784 | let mut entry = entry.clone(); | ||
entry.pattern = pattern; | ||||
|
r45311 | Ok(Some(_build_single_regex(&entry))) | ||
|
r42514 | } | ||
} | ||||
lazy_static! { | ||||
|
r44278 | static ref SYNTAXES: FastHashMap<&'static [u8], &'static [u8]> = { | ||
let mut m = FastHashMap::default(); | ||||
|
r42514 | |||
|
r42630 | m.insert(b"re".as_ref(), b"relre:".as_ref()); | ||
m.insert(b"regexp".as_ref(), b"relre:".as_ref()); | ||||
m.insert(b"glob".as_ref(), b"relglob:".as_ref()); | ||||
m.insert(b"rootglob".as_ref(), b"rootglob:".as_ref()); | ||||
|
r44784 | m.insert(b"include".as_ref(), b"include:".as_ref()); | ||
m.insert(b"subinclude".as_ref(), b"subinclude:".as_ref()); | ||||
|
r42514 | m | ||
}; | ||||
} | ||||
|
r44784 | #[derive(Debug)] | ||
pub enum PatternFileWarning { | ||||
/// (file path, syntax bytes) | ||||
InvalidSyntax(PathBuf, Vec<u8>), | ||||
/// File path | ||||
NoSuchFile(PathBuf), | ||||
} | ||||
|
r42514 | |||
|
r48169 | pub fn parse_pattern_file_contents( | ||
|
r42630 | lines: &[u8], | ||
|
r48169 | file_path: &Path, | ||
|
r42514 | warn: bool, | ||
|
r44784 | ) -> Result<(Vec<IgnorePattern>, Vec<PatternFileWarning>), PatternError> { | ||
|
r42514 | let comment_regex = Regex::new(r"((?:^|[^\\])(?:\\\\)*)#.*").unwrap(); | ||
|
r45500 | |||
#[allow(clippy::trivial_regex)] | ||||
|
r42859 | let comment_escape_regex = Regex::new(r"\\#").unwrap(); | ||
|
r44784 | let mut inputs: Vec<IgnorePattern> = vec![]; | ||
let mut warnings: Vec<PatternFileWarning> = vec![]; | ||||
|
r42514 | |||
|
r42630 | let mut current_syntax = b"relre:".as_ref(); | ||
|
r42514 | |||
|
r42630 | for (line_number, mut line) in lines.split(|c| *c == b'\n').enumerate() { | ||
|
r42514 | let line_number = line_number + 1; | ||
|
r42859 | let line_buf; | ||
|
r42858 | if line.contains(&b'#') { | ||
|
r42630 | if let Some(cap) = comment_regex.captures(line) { | ||
line = &line[..cap.get(1).unwrap().end()] | ||||
|
r42514 | } | ||
|
r42859 | line_buf = comment_escape_regex.replace_all(line, NoExpand(b"#")); | ||
line = &line_buf; | ||||
|
r42514 | } | ||
let mut line = line.trim_end(); | ||||
if line.is_empty() { | ||||
continue; | ||||
} | ||||
|
r43129 | if let Some(syntax) = line.drop_prefix(b"syntax:") { | ||
let syntax = syntax.trim(); | ||||
|
r42514 | |||
if let Some(rel_syntax) = SYNTAXES.get(syntax) { | ||||
current_syntax = rel_syntax; | ||||
} else if warn { | ||||
|
r44784 | warnings.push(PatternFileWarning::InvalidSyntax( | ||
|
r48169 | file_path.to_owned(), | ||
|
r44784 | syntax.to_owned(), | ||
)); | ||||
|
r42514 | } | ||
continue; | ||||
} | ||||
|
r42630 | let mut line_syntax: &[u8] = ¤t_syntax; | ||
|
r42514 | |||
for (s, rels) in SYNTAXES.iter() { | ||||
|
r43129 | if let Some(rest) = line.drop_prefix(rels) { | ||
|
r42514 | line_syntax = rels; | ||
|
r43129 | line = rest; | ||
|
r42514 | break; | ||
|
r43129 | } | ||
if let Some(rest) = line.drop_prefix(&[s, &b":"[..]].concat()) { | ||||
|
r42514 | line_syntax = rels; | ||
|
r43129 | line = rest; | ||
|
r42514 | break; | ||
} | ||||
} | ||||
|
r44784 | inputs.push(IgnorePattern::new( | ||
parse_pattern_syntax(&line_syntax).map_err(|e| match e { | ||||
PatternError::UnsupportedSyntax(syntax) => { | ||||
PatternError::UnsupportedSyntaxInFile( | ||||
syntax, | ||||
|
r48169 | file_path.to_string_lossy().into(), | ||
|
r44784 | line_number, | ||
) | ||||
} | ||||
_ => e, | ||||
})?, | ||||
&line, | ||||
|
r48169 | file_path, | ||
|
r42514 | )); | ||
} | ||||
|
r44784 | Ok((inputs, warnings)) | ||
|
r42514 | } | ||
|
r48169 | pub fn read_pattern_file( | ||
file_path: &Path, | ||||
|
r42514 | warn: bool, | ||
|
r44784 | ) -> Result<(Vec<IgnorePattern>, Vec<PatternFileWarning>), PatternError> { | ||
|
r48169 | let mut f = match File::open(file_path) { | ||
|
r44784 | Ok(f) => Ok(f), | ||
Err(e) => match e.kind() { | ||||
std::io::ErrorKind::NotFound => { | ||||
return Ok(( | ||||
vec![], | ||||
|
r48169 | vec![PatternFileWarning::NoSuchFile(file_path.to_owned())], | ||
|
r44784 | )) | ||
} | ||||
_ => Err(e), | ||||
}, | ||||
}?; | ||||
|
r42630 | let mut contents = Vec::new(); | ||
|
r42514 | |||
|
r42630 | f.read_to_end(&mut contents)?; | ||
|
r42514 | |||
|
r44784 | Ok(parse_pattern_file_contents(&contents, file_path, warn)?) | ||
} | ||||
/// Represents an entry in an "ignore" file. | ||||
#[derive(Debug, Eq, PartialEq, Clone)] | ||||
pub struct IgnorePattern { | ||||
pub syntax: PatternSyntax, | ||||
pub pattern: Vec<u8>, | ||||
pub source: PathBuf, | ||||
|
r42514 | } | ||
|
r44784 | impl IgnorePattern { | ||
|
r48169 | pub fn new(syntax: PatternSyntax, pattern: &[u8], source: &Path) -> Self { | ||
|
r44784 | Self { | ||
syntax, | ||||
pattern: pattern.to_owned(), | ||||
|
r48169 | source: source.to_owned(), | ||
|
r44784 | } | ||
} | ||||
} | ||||
pub type PatternResult<T> = Result<T, PatternError>; | ||||
|
r44785 | /// Wrapper for `read_pattern_file` that also recursively expands `include:` | ||
|
r48170 | /// and `subinclude:` patterns. | ||
|
r44785 | /// | ||
|
r48170 | /// The former are expanded in place, while `PatternSyntax::ExpandedSubInclude` | ||
/// is used for the latter to form a tree of patterns. | ||||
|
r44785 | pub fn get_patterns_from_file( | ||
|
r48169 | pattern_file: &Path, | ||
root_dir: &Path, | ||||
|
r44785 | ) -> PatternResult<(Vec<IgnorePattern>, Vec<PatternFileWarning>)> { | ||
|
r48169 | let (patterns, mut warnings) = read_pattern_file(pattern_file, true)?; | ||
|
r44785 | let patterns = patterns | ||
.into_iter() | ||||
.flat_map(|entry| -> PatternResult<_> { | ||||
|
r48170 | Ok(match &entry.syntax { | ||
|
r44785 | PatternSyntax::Include => { | ||
let inner_include = | ||||
|
r48170 | root_dir.join(get_path_from_bytes(&entry.pattern)); | ||
|
r48169 | let (inner_pats, inner_warnings) = | ||
get_patterns_from_file(&inner_include, root_dir)?; | ||||
|
r44785 | warnings.extend(inner_warnings); | ||
inner_pats | ||||
} | ||||
|
r48170 | PatternSyntax::SubInclude => { | ||
let mut sub_include = SubInclude::new( | ||||
&root_dir, | ||||
&entry.pattern, | ||||
&entry.source, | ||||
)?; | ||||
let (inner_patterns, inner_warnings) = | ||||
get_patterns_from_file( | ||||
&sub_include.path, | ||||
&sub_include.root, | ||||
)?; | ||||
sub_include.included_patterns = inner_patterns; | ||||
warnings.extend(inner_warnings); | ||||
vec![IgnorePattern { | ||||
syntax: PatternSyntax::ExpandedSubInclude(Box::new( | ||||
sub_include, | ||||
)), | ||||
..entry | ||||
}] | ||||
} | ||||
|
r44785 | _ => vec![entry], | ||
}) | ||||
}) | ||||
.flatten() | ||||
.collect(); | ||||
Ok((patterns, warnings)) | ||||
} | ||||
/// Holds all the information needed to handle a `subinclude:` pattern. | ||||
|
r48170 | #[derive(Debug, PartialEq, Eq, Clone)] | ||
|
r44785 | pub struct SubInclude { | ||
/// Will be used for repository (hg) paths that start with this prefix. | ||||
/// It is relative to the current working directory, so comparing against | ||||
/// repository paths is painless. | ||||
pub prefix: HgPathBuf, | ||||
/// The file itself, containing the patterns | ||||
pub path: PathBuf, | ||||
/// Folder in the filesystem where this it applies | ||||
pub root: PathBuf, | ||||
|
r48170 | |||
pub included_patterns: Vec<IgnorePattern>, | ||||
|
r44785 | } | ||
impl SubInclude { | ||||
pub fn new( | ||||
|
r48169 | root_dir: &Path, | ||
|
r44785 | pattern: &[u8], | ||
|
r48169 | source: &Path, | ||
|
r44785 | ) -> Result<SubInclude, HgPathError> { | ||
let normalized_source = | ||||
normalize_path_bytes(&get_bytes_from_path(source)); | ||||
let source_root = get_path_from_bytes(&normalized_source); | ||||
|
r45500 | let source_root = | ||
source_root.parent().unwrap_or_else(|| source_root.deref()); | ||||
|
r44785 | |||
let path = source_root.join(get_path_from_bytes(pattern)); | ||||
|
r45500 | let new_root = path.parent().unwrap_or_else(|| path.deref()); | ||
|
r44785 | |||
|
r48169 | let prefix = canonical_path(root_dir, root_dir, new_root)?; | ||
|
r44785 | |||
Ok(Self { | ||||
prefix: path_to_hg_path_buf(prefix).and_then(|mut p| { | ||||
if !p.is_empty() { | ||||
p.push(b'/'); | ||||
} | ||||
Ok(p) | ||||
})?, | ||||
path: path.to_owned(), | ||||
root: new_root.to_owned(), | ||||
|
r48170 | included_patterns: Vec::new(), | ||
|
r44785 | }) | ||
} | ||||
} | ||||
/// Separate and pre-process subincludes from other patterns for the "ignore" | ||||
/// phase. | ||||
|
r48170 | pub fn filter_subincludes( | ||
ignore_patterns: Vec<IgnorePattern>, | ||||
) -> Result<(Vec<Box<SubInclude>>, Vec<IgnorePattern>), HgPathError> { | ||||
|
r44785 | let mut subincludes = vec![]; | ||
let mut others = vec![]; | ||||
|
r48170 | for pattern in ignore_patterns { | ||
if let PatternSyntax::ExpandedSubInclude(sub_include) = pattern.syntax | ||||
{ | ||||
subincludes.push(sub_include); | ||||
|
r44785 | } else { | ||
|
r48170 | others.push(pattern) | ||
|
r44785 | } | ||
} | ||||
Ok((subincludes, others)) | ||||
} | ||||
|
r42514 | #[cfg(test)] | ||
mod tests { | ||||
use super::*; | ||||
|
r44784 | use pretty_assertions::assert_eq; | ||
|
r42514 | |||
#[test] | ||||
fn escape_pattern_test() { | ||||
|
r44784 | let untouched = | ||
br#"!"%',/0123456789:;<=>@ABCDEFGHIJKLMNOPQRSTUVWXYZ_`abcdefghijklmnopqrstuvwxyz"#; | ||||
|
r42514 | assert_eq!(escape_pattern(untouched), untouched.to_vec()); | ||
// All escape codes | ||||
assert_eq!( | ||||
escape_pattern(br#"()[]{}?*+-|^$\\.&~# \t\n\r\v\f"#), | ||||
br#"\(\)\[\]\{\}\?\*\+\-\|\^\$\\\\\.\&\~\#\ \\t\\n\\r\\v\\f"# | ||||
.to_vec() | ||||
); | ||||
} | ||||
#[test] | ||||
fn glob_test() { | ||||
assert_eq!(glob_to_re(br#"?"#), br#"."#); | ||||
assert_eq!(glob_to_re(br#"*"#), br#"[^/]*"#); | ||||
assert_eq!(glob_to_re(br#"**"#), br#".*"#); | ||||
assert_eq!(glob_to_re(br#"**/a"#), br#"(?:.*/)?a"#); | ||||
assert_eq!(glob_to_re(br#"a/**/b"#), br#"a/(?:.*/)?b"#); | ||||
assert_eq!(glob_to_re(br#"[a*?!^][^b][!c]"#), br#"[a*?!^][\^b][^c]"#); | ||||
assert_eq!(glob_to_re(br#"{a,b}"#), br#"(?:a|b)"#); | ||||
assert_eq!(glob_to_re(br#".\*\?"#), br#"\.\*\?"#); | ||||
} | ||||
#[test] | ||||
fn test_parse_pattern_file_contents() { | ||||
|
r42630 | let lines = b"syntax: glob\n*.elc"; | ||
|
r42514 | |||
assert_eq!( | ||||
|
r43227 | parse_pattern_file_contents(lines, Path::new("file_path"), false) | ||
|
r44784 | .unwrap() | ||
|
r43227 | .0, | ||
|
r44784 | vec![IgnorePattern::new( | ||
PatternSyntax::RelGlob, | ||||
b"*.elc", | ||||
Path::new("file_path") | ||||
)], | ||||
|
r42514 | ); | ||
|
r42630 | let lines = b"syntax: include\nsyntax: glob"; | ||
|
r42514 | |||
assert_eq!( | ||||
|
r43227 | parse_pattern_file_contents(lines, Path::new("file_path"), false) | ||
|
r44784 | .unwrap() | ||
|
r43227 | .0, | ||
|
r42514 | vec![] | ||
); | ||||
|
r42630 | let lines = b"glob:**.o"; | ||
assert_eq!( | ||||
|
r43227 | parse_pattern_file_contents(lines, Path::new("file_path"), false) | ||
|
r44784 | .unwrap() | ||
|
r43227 | .0, | ||
|
r44784 | vec![IgnorePattern::new( | ||
PatternSyntax::RelGlob, | ||||
b"**.o", | ||||
Path::new("file_path") | ||||
)] | ||||
); | ||||
} | ||||
#[test] | ||||
fn test_build_single_regex() { | ||||
assert_eq!( | ||||
build_single_regex(&IgnorePattern::new( | ||||
PatternSyntax::RelGlob, | ||||
b"rust/target/", | ||||
Path::new("") | ||||
)) | ||||
.unwrap(), | ||||
|
r45311 | Some(br"(?:.*/)?rust/target(?:/|$)".to_vec()), | ||
|
r42630 | ); | ||
|
r45349 | assert_eq!( | ||
build_single_regex(&IgnorePattern::new( | ||||
PatternSyntax::Regexp, | ||||
br"rust/target/\d+", | ||||
Path::new("") | ||||
)) | ||||
.unwrap(), | ||||
Some(br"rust/target/\d+".to_vec()), | ||||
); | ||||
|
r42514 | } | ||
|
r42631 | |||
#[test] | ||||
fn test_build_single_regex_shortcut() { | ||||
assert_eq!( | ||||
|
r44784 | build_single_regex(&IgnorePattern::new( | ||
PatternSyntax::RootGlob, | ||||
b"", | ||||
Path::new("") | ||||
)) | ||||
.unwrap(), | ||||
|
r45311 | None, | ||
|
r42631 | ); | ||
assert_eq!( | ||||
|
r44784 | build_single_regex(&IgnorePattern::new( | ||
PatternSyntax::RootGlob, | ||||
b"whatever", | ||||
Path::new("") | ||||
)) | ||||
.unwrap(), | ||||
|
r45311 | None, | ||
|
r42631 | ); | ||
assert_eq!( | ||||
|
r44784 | build_single_regex(&IgnorePattern::new( | ||
PatternSyntax::RootGlob, | ||||
b"*.o", | ||||
Path::new("") | ||||
)) | ||||
.unwrap(), | ||||
|
r45347 | Some(br"[^/]*\.o(?:/|$)".to_vec()), | ||
|
r42631 | ); | ||
} | ||||
|
r42514 | } | ||