This is an archive of the discontinued Mercurial Phabricator instance.

	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)

Diff	ID	Description	Created	Lint	Unit
Base		Base
Diff 1	31186		Nov 29 2021, 9:09 AM	★	★
Diff 2	31188	rHG2009e3c64a539fa965e2aa6de5b1ac3c5c6d3071	Nov 29 2021, 9:06 AM	★	★

This is an archive of the discontinued Mercurial Phabricator instance.

rhg: refactor to use IgnoreFnType alias more widelyClosedPublic

Details

Diff Detail

Event Timeline

Revision ContentsChangeset List

Diff 31188

rust/hg-core/src/matchers.rs

rhg: refactor to use IgnoreFnType alias more widely
ClosedPublic

Revision Contents
Changeset List