This is an archive of the discontinued Mercurial Phabricator instance.

Differential D11818

rhg: refactor to use IgnoreFnType alias more widely
ClosedPublic

Authored by aalekseyev on Nov 29 2021, 9:09 AM.

Details

Reviewers
Alphare
Group Reviewers
hg-reviewers
Commits
rHG2009e3c64a53: rhg: refactor to use IgnoreFnType alias more widely

Diff Detail

Repository
rHG Mercurial
Branch
default
Lint
No Linters Available
Unit
No Unit Test Coverage

Revision Contents
Changeset List

PathPackages
Mrust/hg-core/src/matchers.rs (22 lines)

Diff 31186

rust/hg-core/src/matchers.rs

files::find_dirs, files::find_dirs,
hg_path::{HgPath, HgPathBuf}, hg_path::{HgPath, HgPathBuf},
Escaped, Escaped,
}, },
DirsMultiset, DirstateMapError, FastHashMap, IgnorePattern, PatternError, DirsMultiset, DirstateMapError, FastHashMap, IgnorePattern, PatternError,
PatternSyntax, PatternSyntax,
}; };
use crate::dirstate::status::IgnoreFnType;
use crate::filepatterns::normalize_path_bytes; use crate::filepatterns::normalize_path_bytes;
use std::borrow::ToOwned; use std::borrow::ToOwned;
use std::collections::HashSet; use std::collections::HashSet;
use std::fmt::{Display, Error, Formatter}; use std::fmt::{Display, Error, Formatter};
use std::iter::FromIterator; use std::iter::FromIterator;
use std::ops::Deref; use std::ops::Deref;
use std::path::{Path, PathBuf}; use std::path::{Path, PathBuf};
/// /// /// ///
/// assert_eq!(matcher.matches(HgPath::new(b"testing")), false); /// assert_eq!(matcher.matches(HgPath::new(b"testing")), false);
/// assert_eq!(matcher.matches(HgPath::new(b"this should work")), true); /// assert_eq!(matcher.matches(HgPath::new(b"this should work")), true);
/// assert_eq!(matcher.matches(HgPath::new(b"this also")), true); /// assert_eq!(matcher.matches(HgPath::new(b"this also")), true);
/// assert_eq!(matcher.matches(HgPath::new(b"but not this")), false); /// assert_eq!(matcher.matches(HgPath::new(b"but not this")), false);
/// ``` /// ```
pub struct IncludeMatcher<'a> { pub struct IncludeMatcher<'a> {
patterns: Vec<u8>, patterns: Vec<u8>,
match_fn: Box<dyn for<'r> Fn(&'r HgPath) -> bool + 'a + Sync>, match_fn: IgnoreFnType<'a>,
/// Whether all the patterns match a prefix (i.e. recursively) /// Whether all the patterns match a prefix (i.e. recursively)
prefix: bool, prefix: bool,
roots: HashSet<HgPathBuf>, roots: HashSet<HgPathBuf>,
dirs: HashSet<HgPathBuf>, dirs: HashSet<HgPathBuf>,
parents: HashSet<HgPathBuf>, parents: HashSet<HgPathBuf>,
} }
impl<'a> Matcher for IncludeMatcher<'a> { impl<'a> Matcher for IncludeMatcher<'a> {
.build() .build()
.map_err(|e| PatternError::UnsupportedSyntax(e.to_string()))?; .map_err(|e| PatternError::UnsupportedSyntax(e.to_string()))?;
Ok(move |path: &HgPath| re.is_match(path.as_bytes())) Ok(move |path: &HgPath| re.is_match(path.as_bytes()))
} }
/// Returns the regex pattern and a function that matches an `HgPath` against /// Returns the regex pattern and a function that matches an `HgPath` against
/// said regex formed by the given ignore patterns. /// said regex formed by the given ignore patterns.
fn build_regex_match( fn build_regex_match<'a, 'b>(
ignore_patterns: &[IgnorePattern], ignore_patterns: &'a [IgnorePattern],
) -> PatternResult<(Vec<u8>, Box<dyn Fn(&HgPath) -> bool + Sync>)> { ) -> PatternResult<(Vec<u8>, IgnoreFnType<'b>)> {
let mut regexps = vec![]; let mut regexps = vec![];
let mut exact_set = HashSet::new(); let mut exact_set = HashSet::new();
for pattern in ignore_patterns { for pattern in ignore_patterns {
if let Some(re) = build_single_regex(pattern)? { if let Some(re) = build_single_regex(pattern)? {
regexps.push(re); regexps.push(re);
} else { } else {
let exact = normalize_path_bytes(&pattern.pattern); let exact = normalize_path_bytes(&pattern.pattern);
exact_set.insert(HgPathBuf::from_bytes(&exact)); exact_set.insert(HgPathBuf::from_bytes(&exact));
} }
} }
let full_regex = regexps.join(&b'|'); let full_regex = regexps.join(&b'|');
// An empty pattern would cause the regex engine to incorrectly match the // An empty pattern would cause the regex engine to incorrectly match the
// (empty) root directory // (empty) root directory
let func = if !(regexps.is_empty()) { let func = if !(regexps.is_empty()) {
let matcher = re_matcher(&full_regex)?; let matcher = re_matcher(&full_regex)?;
let func = move |filename: &HgPath| { let func = move |filename: &HgPath| {
exact_set.contains(filename) || matcher(filename) exact_set.contains(filename) || matcher(filename)
}; };
Box::new(func) as Box<dyn Fn(&HgPath) -> bool + Sync> Box::new(func) as IgnoreFnType
} else { } else {
let func = move |filename: &HgPath| exact_set.contains(filename); let func = move |filename: &HgPath| exact_set.contains(filename);
Box::new(func) as Box<dyn Fn(&HgPath) -> bool + Sync> Box::new(func) as IgnoreFnType
}; };
Ok((full_regex, func)) Ok((full_regex, func))
} }
/// Returns roots and directories corresponding to each pattern. /// Returns roots and directories corresponding to each pattern.
/// ///
/// This calculates the roots and directories exactly matching the patterns and /// This calculates the roots and directories exactly matching the patterns and
parents, parents,
}) })
} }
/// Returns a function that checks whether a given file (in the general sense) /// Returns a function that checks whether a given file (in the general sense)
/// should be matched. /// should be matched.
fn build_match<'a, 'b>( fn build_match<'a, 'b>(
ignore_patterns: Vec<IgnorePattern>, ignore_patterns: Vec<IgnorePattern>,
) -> PatternResult<(Vec<u8>, Box<dyn Fn(&HgPath) -> bool + 'b + Sync>)> { ) -> PatternResult<(Vec<u8>, IgnoreFnType<'b>)> {
let mut match_funcs: Vec<Box<dyn Fn(&HgPath) -> bool + Sync>> = vec![]; let mut match_funcs: Vec<IgnoreFnType<'b>> = vec![];
// For debugging and printing // For debugging and printing
let mut patterns = vec![]; let mut patterns = vec![];
let (subincludes, ignore_patterns) = filter_subincludes(ignore_patterns)?; let (subincludes, ignore_patterns) = filter_subincludes(ignore_patterns)?;
if !subincludes.is_empty() { if !subincludes.is_empty() {
// Build prefix-based matcher functions for subincludes // Build prefix-based matcher functions for subincludes
let mut submatchers = FastHashMap::default(); let mut submatchers = FastHashMap::default();
/// Parses all "ignore" files with their recursive includes and returns a /// Parses all "ignore" files with their recursive includes and returns a
/// function that checks whether a given file (in the general sense) should be /// function that checks whether a given file (in the general sense) should be
/// ignored. /// ignored.
pub fn get_ignore_function<'a>( pub fn get_ignore_function<'a>(
mut all_pattern_files: Vec<PathBuf>, mut all_pattern_files: Vec<PathBuf>,
root_dir: &Path, root_dir: &Path,
inspect_pattern_bytes: &mut impl FnMut(&[u8]), inspect_pattern_bytes: &mut impl FnMut(&[u8]),
) -> PatternResult<( ) -> PatternResult<(IgnoreFnType<'a>, Vec<PatternFileWarning>)> {
Box<dyn for<'r> Fn(&'r HgPath) -> bool + Sync + 'a>,
Vec<PatternFileWarning>,
)> {
let mut all_patterns = vec![]; let mut all_patterns = vec![];
let mut all_warnings = vec![]; let mut all_warnings = vec![];
// Sort to make the ordering of calls to `inspect_pattern_bytes` // Sort to make the ordering of calls to `inspect_pattern_bytes`
// deterministic even if the ordering of `all_pattern_files` is not (such // deterministic even if the ordering of `all_pattern_files` is not (such
// as when a iteration order of a Python dict or Rust HashMap is involved). // as when a iteration order of a Python dict or Rust HashMap is involved).
// Sort by "string" representation instead of the default by component // Sort by "string" representation instead of the default by component
// (with a Rust-specific definition of a component) // (with a Rust-specific definition of a component)