			Path	Packages
M			rust/hg-core/src/matchers.rs (382 lines)

Diff	ID	Description	Created	Lint	Unit
Base		Base
Diff 1	19404		Jan 17 2020, 6:00 AM	★	★
Diff 2	19420		Jan 17 2020, 11:53 AM	★	★
Diff 3	19941		Feb 6 2020, 10:15 AM	★	★
Diff 4	20043		Feb 10 2020, 11:29 AM	★	★
Diff 5	20163		Feb 11 2020, 6:13 AM	★	★
Diff 6	20495		Mar 5 2020, 3:33 AM	★	★
Diff 7	20715	rHGc697638e0e9140f0798b35f4bbe01923d69b2145	Jan 17 2020, 5:53 AM	★	★

Status	Author	Revision
Closed	Alphare	D8253 hg-core: add function timing information
Closed	Alphare	D8252 rust: add logging utils
Closed	Alphare	D8251 rust-status: traverse working directory in parallel
Closed	Alphare	D8250 rust-status: wrap `stat_dmap_entries` to ease profiling
Closed	Alphare	D8249 rust-status: refactor handling of unknown files
Closed	Alphare	D8215 rust-status: move to recursive traversal to prepare for parallel traversal
Closed	Alphare	D8213 rust-pathauditor: use interior mutability for use in multi-threaded contexts
Closed	Alphare	D8212 rust-pathauditor: actually populate the `audited_dirs` cache
Closed	Alphare	D8211 rust-pathauditor: actually split Windows shortname aliases at `~`
Closed	Alphare	D8226 debuginstall: add entry about re2 Rust bindings when applicable
Closed	Alphare	D8225 rust-cpython: add `debug` module to expose debug information to Python
Closed	Alphare	D7931 rust-status: use bare hg status fastpath from Python
Closed	Alphare	D7930 rust-status: update rust-cpython bridge to account for the changes in core
Closed	Alphare	D7929 rust-status: add bare `hg status` support in hg-core
Closed	Alphare	D7928 rust-status: add function for sequential traversal of the working directory
Closed	Alphare	D8088 rust-status: add missing variants to `Dispatch` enum
Closed	Alphare	D8087 rust-status: rename `StatusResult` to `DirstateStatus`
Closed	Alphare	D8086 rust-status: refactor options into a `StatusOptions` struct
Closed	Alphare	D7927 rust-status: add util for listing a directory
Closed	Alphare	D7926 rust-dependencies: update rayon
Closed	Alphare	D7925 rust-matchers: add `IgnoreMatcher`
Closed	Alphare	D7924 rust-matchers: add `build_regex_match` function
Closed	Alphare	D7923 rust-matchers: add functions to get roots, dirs and parents from patterns
Closed	Alphare	D7922 rust-matchers: add function to generate a regex matcher function
Closed	Alphare	D8224 rust-format: cleanup ancestors.rs to make rustfmt happy

Diff 20715

rust/hg-core/src/matchers.rs

	// matchers.rs			// matchers.rs
	//			//
	// Copyright 2019 Raphaël Gomès <rgomes@octobus.net>			// Copyright 2019 Raphaël Gomès <rgomes@octobus.net>
	//			//
	// This software may be used and distributed according to the terms of the			// This software may be used and distributed according to the terms of the
	// GNU General Public License version 2 or any later version.			// GNU General Public License version 2 or any later version.

	//! Structs and types for matching files and directories.			//! Structs and types for matching files and directories.

	#[cfg(feature = "with-re2")]			#[cfg(feature = "with-re2")]
	use crate::re2::Re2;			use crate::re2::Re2;
	use crate::{			use crate::{
	filepatterns::{build_single_regex, PatternResult},			dirstate::dirs_multiset::DirsChildrenMultiset,
	utils::hg_path::{HgPath, HgPathBuf},			filepatterns::{
	DirsMultiset, DirstateMapError, IgnorePattern, PatternError,			build_single_regex, filter_subincludes, get_patterns_from_file,
				PatternFileWarning, PatternResult, SubInclude,
				},
				utils::{
				files::find_dirs,
				hg_path::{HgPath, HgPathBuf},
				Escaped,
				},
				DirsMultiset, DirstateMapError, FastHashMap, IgnorePattern, PatternError,
	PatternSyntax,			PatternSyntax,
	};			};

	use std::collections::HashSet;			use std::collections::HashSet;
				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;

	#[derive(Debug, PartialEq)]			#[derive(Debug, PartialEq)]
	pub enum VisitChildrenSet<'a> {			pub enum VisitChildrenSet<'a> {
	/// Don't visit anything			/// Don't visit anything
	Empty,			Empty,
	/// Only visit this directory			/// Only visit this directory
	This,			This,
	/// Visit this directory and these subdirectories			/// Visit this directory and these subdirectories
	fn matches_everything(&self) -> bool {			fn matches_everything(&self) -> bool {
	false			false
	}			}
	fn is_exact(&self) -> bool {			fn is_exact(&self) -> bool {
	true			true
	}			}
	}			}

				/// Matches files that are included in the ignore rules.
				#[cfg_attr(
				feature = "with-re2",
				doc = r##"
				```
				use hg::{
				matchers::{IncludeMatcher, Matcher},
				IgnorePattern,
				PatternSyntax,
				utils::hg_path::HgPath
				};
				use std::path::Path;
				///
				let ignore_patterns =
				vec![IgnorePattern::new(PatternSyntax::RootGlob, b"this*", Path::new(""))];
				let (matcher, _) = IncludeMatcher::new(ignore_patterns, "").unwrap();
				///
				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 also")), true);
				assert_eq!(matcher.matches(HgPath::new(b"but not this")), false);
				```
				"##
				)]
				pub struct IncludeMatcher<'a> {
				patterns: Vec<u8>,
				match_fn: Box<dyn for<'r> Fn(&'r HgPath) -> bool + 'a + Sync>,
				/// Whether all the patterns match a prefix (i.e. recursively)
				prefix: bool,
				roots: HashSet<HgPathBuf>,
				dirs: HashSet<HgPathBuf>,
				parents: HashSet<HgPathBuf>,
				}

				impl<'a> Matcher for IncludeMatcher<'a> {
				fn file_set(&self) -> Option<&HashSet<&HgPath>> {
				None
				}

				fn exact_match(&self, _filename: impl AsRef<HgPath>) -> bool {
				false
				}

				fn matches(&self, filename: impl AsRef<HgPath>) -> bool {
				(self.match_fn)(filename.as_ref())
				}

				fn visit_children_set(
				&self,
				directory: impl AsRef<HgPath>,
				) -> VisitChildrenSet {
				let dir = directory.as_ref();
				if self.prefix && self.roots.contains(dir) {
				return VisitChildrenSet::Recursive;
				}
				if self.roots.contains(HgPath::new(b""))
				\|\| self.roots.contains(dir)
				\|\| self.dirs.contains(dir)
				\|\| find_dirs(dir).any(\|parent_dir\| self.roots.contains(parent_dir))
				{
				return VisitChildrenSet::This;
				}

				if self.parents.contains(directory.as_ref()) {
				let multiset = self.get_all_parents_children();
				if let Some(children) = multiset.get(dir) {
				return VisitChildrenSet::Set(children.to_owned());
				}
				}
				VisitChildrenSet::Empty
				}

				fn matches_everything(&self) -> bool {
				false
				}

				fn is_exact(&self) -> bool {
				false
				}
				}

	#[cfg(feature = "with-re2")]			#[cfg(feature = "with-re2")]
	/// Returns a function that matches an `HgPath` against the given regex			/// Returns a function that matches an `HgPath` against the given regex
	/// pattern.			/// pattern.
	///			///
	/// This can fail when the pattern is invalid or not supported by the			/// This can fail when the pattern is invalid or not supported by the
	/// underlying engine `Re2`, for instance anything with back-references.			/// underlying engine `Re2`, for instance anything with back-references.
	fn re_matcher(			fn re_matcher(
	pattern: &[u8],			pattern: &[u8],

	Ok(RootsDirsAndParents {			Ok(RootsDirsAndParents {
	roots: HashSet::from_iter(roots),			roots: HashSet::from_iter(roots),
	dirs: HashSet::from_iter(dirs),			dirs: HashSet::from_iter(dirs),
	parents,			parents,
	})			})
	}			}

				/// Returns a function that checks whether a given file (in the general sense)
				/// should be matched.
				fn build_match<'a, 'b>(
				ignore_patterns: &'a [IgnorePattern],
				root_dir: impl AsRef<Path>,
				) -> PatternResult<(
				Vec<u8>,
				Box<dyn Fn(&HgPath) -> bool + 'b + Sync>,
				Vec<PatternFileWarning>,
				)> {
				let mut match_funcs: Vec<Box<dyn Fn(&HgPath) -> bool + Sync>> = vec![];
				// For debugging and printing
				let mut patterns = vec![];
				let mut all_warnings = vec![];

				let (subincludes, ignore_patterns) =
				filter_subincludes(ignore_patterns, root_dir)?;

				if !subincludes.is_empty() {
				// Build prefix-based matcher functions for subincludes
				let mut submatchers = FastHashMap::default();
				let mut prefixes = vec![];

				for SubInclude { prefix, root, path } in subincludes.into_iter() {
				let (match_fn, warnings) = get_ignore_function(&[path], root)?;
				all_warnings.extend(warnings);
				prefixes.push(prefix.to_owned());
				submatchers.insert(prefix.to_owned(), match_fn);
				}

				let match_subinclude = move \|filename: &HgPath\| {
				for prefix in prefixes.iter() {
				if let Some(rel) = filename.relative_to(prefix) {
				if (submatchers.get(prefix).unwrap())(rel) {
				return true;
				}
				}
				}
				false
				};

				match_funcs.push(Box::new(match_subinclude));
				}

				if !ignore_patterns.is_empty() {
				// Either do dumb matching if all patterns are rootfiles, or match
				// with a regex.
				if ignore_patterns
				.iter()
				.all(\|k\| k.syntax == PatternSyntax::RootFiles)
				{
				let dirs: HashSet<_> = ignore_patterns
				.iter()
				.map(\|k\| k.pattern.to_owned())
				.collect();
				let mut dirs_vec: Vec<_> = dirs.iter().cloned().collect();

				let match_func = move \|path: &HgPath\| -> bool {
				let path = path.as_bytes();
				let i = path.iter().rfind(\|a\| **a == b'/');
				let dir = if let Some(i) = i {
				&path[..*i as usize]
				} else {
				b"."
				};
				dirs.contains(dir.deref())
				};
				match_funcs.push(Box::new(match_func));

				patterns.extend(b"rootfilesin: ");
				dirs_vec.sort();
				patterns.extend(dirs_vec.escaped_bytes());
				} else {
				let (new_re, match_func) = build_regex_match(&ignore_patterns)?;
				patterns = new_re;
				match_funcs.push(match_func)
				}
				}

				Ok(if match_funcs.len() == 1 {
				(patterns, match_funcs.remove(0), all_warnings)
				} else {
				(
				patterns,
				Box::new(move \|f: &HgPath\| -> bool {
				match_funcs.iter().any(\|match_func\| match_func(f))
				}),
				all_warnings,
				)
				})
				}

				/// Parses all "ignore" files with their recursive includes and returns a
				/// function that checks whether a given file (in the general sense) should be
				/// ignored.
				pub fn get_ignore_function<'a>(
				all_pattern_files: &[impl AsRef<Path>],
				root_dir: impl AsRef<Path>,
				) -> PatternResult<(
				impl for<'r> Fn(&'r HgPath) -> bool + Sync,
				Vec<PatternFileWarning>,
				)> {
				let mut all_patterns = vec![];
				let mut all_warnings = vec![];

				for pattern_file in all_pattern_files.into_iter() {
				let (patterns, warnings) =
				get_patterns_from_file(pattern_file, &root_dir)?;

				all_patterns.extend(patterns);
				all_warnings.extend(warnings);
				}
				let (matcher, warnings) = IncludeMatcher::new(all_patterns, root_dir)?;
				all_warnings.extend(warnings);
				Ok((move \|path: &HgPath\| matcher.matches(path), all_warnings))
				}

				impl<'a> IncludeMatcher<'a> {
				pub fn new(
				ignore_patterns: Vec<IgnorePattern>,
				root_dir: impl AsRef<Path>,
				) -> PatternResult<(Self, Vec<PatternFileWarning>)> {
				let (patterns, match_fn, warnings) =
				build_match(&ignore_patterns, root_dir)?;
				let RootsDirsAndParents {
				roots,
				dirs,
				parents,
				} = roots_dirs_and_parents(&ignore_patterns)?;

				let prefix = ignore_patterns.iter().any(\|k\| match k.syntax {
				PatternSyntax::Path \| PatternSyntax::RelPath => true,
				_ => false,
				});

				Ok((
				Self {
				patterns,
				match_fn,
				prefix,
				roots,
				dirs,
				parents,
				},
				warnings,
				))
				}

				fn get_all_parents_children(&self) -> DirsChildrenMultiset {
				// TODO cache
				let thing = self
				.dirs
				.iter()
				.chain(self.roots.iter())
				.chain(self.parents.iter());
				DirsChildrenMultiset::new(thing, Some(&self.parents))
				}
				}

				impl<'a> Display for IncludeMatcher<'a> {
				fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error> {
				write!(
				f,
				"IncludeMatcher(includes='{}')",
				String::from_utf8_lossy(&self.patterns.escaped_bytes())
				)
				}
				}

	#[cfg(test)]			#[cfg(test)]
	mod tests {			mod tests {
	use super::*;			use super::*;
	use pretty_assertions::assert_eq;			use pretty_assertions::assert_eq;
	use std::path::Path;			use std::path::Path;

	#[test]			#[test]
	fn test_roots_and_dirs() {			fn test_roots_and_dirs() {
	matcher.visit_children_set(HgPath::new(b"a/b/c/d/e")),			matcher.visit_children_set(HgPath::new(b"a/b/c/d/e")),
	VisitChildrenSet::Empty			VisitChildrenSet::Empty
	);			);
	assert_eq!(			assert_eq!(
	matcher.visit_children_set(HgPath::new(b"folder")),			matcher.visit_children_set(HgPath::new(b"folder")),
	VisitChildrenSet::Empty			VisitChildrenSet::Empty
	);			);
	}			}

				#[cfg(feature = "with-re2")]
				#[test]
				fn test_includematcher() {
				// VisitchildrensetPrefix
				let (matcher, _) = IncludeMatcher::new(
				vec![IgnorePattern::new(
				PatternSyntax::RelPath,
				b"dir/subdir",
				Path::new(""),
				)],
				"",
				)
				.unwrap();

				let mut set = HashSet::new();
				set.insert(HgPath::new(b"dir"));
				assert_eq!(
				matcher.visit_children_set(HgPath::new(b"")),
				VisitChildrenSet::Set(set)
				);

				let mut set = HashSet::new();
				set.insert(HgPath::new(b"subdir"));
				assert_eq!(
				matcher.visit_children_set(HgPath::new(b"dir")),
				VisitChildrenSet::Set(set)
				);
				assert_eq!(
				matcher.visit_children_set(HgPath::new(b"dir/subdir")),
				VisitChildrenSet::Recursive
				);
				// OPT: This should probably be 'all' if its parent is?
				assert_eq!(
				matcher.visit_children_set(HgPath::new(b"dir/subdir/x")),
				VisitChildrenSet::This
				);
				assert_eq!(
				matcher.visit_children_set(HgPath::new(b"folder")),
				VisitChildrenSet::Empty
				);

				// VisitchildrensetRootfilesin
				let (matcher, _) = IncludeMatcher::new(
				vec![IgnorePattern::new(
				PatternSyntax::RootFiles,
				b"dir/subdir",
				Path::new(""),
				)],
				"",
				)
				.unwrap();

				let mut set = HashSet::new();
				set.insert(HgPath::new(b"dir"));
				assert_eq!(
				matcher.visit_children_set(HgPath::new(b"")),
				VisitChildrenSet::Set(set)
				);

				let mut set = HashSet::new();
				set.insert(HgPath::new(b"subdir"));
				assert_eq!(
				matcher.visit_children_set(HgPath::new(b"dir")),
				VisitChildrenSet::Set(set)
				);

				assert_eq!(
				matcher.visit_children_set(HgPath::new(b"dir/subdir")),
				VisitChildrenSet::This
				);
				assert_eq!(
				matcher.visit_children_set(HgPath::new(b"dir/subdir/x")),
				VisitChildrenSet::Empty
				);
				assert_eq!(
				matcher.visit_children_set(HgPath::new(b"folder")),
				VisitChildrenSet::Empty
				);

				// VisitchildrensetGlob
				let (matcher, _) = IncludeMatcher::new(
				vec![IgnorePattern::new(
				PatternSyntax::Glob,
				b"dir/z*",
				Path::new(""),
				)],
				"",
				)
				.unwrap();

				let mut set = HashSet::new();
				set.insert(HgPath::new(b"dir"));
				assert_eq!(
				matcher.visit_children_set(HgPath::new(b"")),
				VisitChildrenSet::Set(set)
				);
				assert_eq!(
				matcher.visit_children_set(HgPath::new(b"folder")),
				VisitChildrenSet::Empty
				);
				assert_eq!(
				matcher.visit_children_set(HgPath::new(b"dir")),
				VisitChildrenSet::This
				);
				// OPT: these should probably be set().
				assert_eq!(
				matcher.visit_children_set(HgPath::new(b"dir/subdir")),
				VisitChildrenSet::This
				);
				assert_eq!(
				matcher.visit_children_set(HgPath::new(b"dir/subdir/x")),
				VisitChildrenSet::This
				);
				}
	}			}

This is an archive of the discontinued Mercurial Phabricator instance.

rust-matchers: add `IgnoreMatcher`
ClosedPublic

Details

Diff Detail

Event Timeline

Revision Contents
Changeset List

Diff 20715

rust/hg-core/src/matchers.rs

This is an archive of the discontinued Mercurial Phabricator instance.

rust-matchers: add `IgnoreMatcher`ClosedPublic

Details

Diff Detail

Event Timeline

Revision ContentsChangeset List

Diff 20715

rust/hg-core/src/matchers.rs

rust-matchers: add `IgnoreMatcher`
ClosedPublic

Revision Contents
Changeset List