This is an archive of the discontinued Mercurial Phabricator instance.

Differential D10834

rust: Parse "subinclude"d files along the way, not later
ClosedPublic

Authored by SimonSapin on Jun 4 2021, 5:02 AM.

Details

Reviewers
Alphare
Group Reviewers
hg-reviewers
Commits
rHGf6bb181c75f8: rust: Parse "subinclude"d files along the way, not later
Summary

When parsing a .hgignore file and encountering an include: line,
the included file is parsed recursively right then in a depth-first fashion.

With subinclude: however included files were parsed (recursively) much later.
This changes it to be expanded during parsing, like .hgignore.

The motivation for this is an upcoming changeset that needs to detect changes
in which files are ignored or not. The plan is to hash all ignore files while
they are being read, and store that hash in the dirstate (in v2 format).
In order to allow a potential alternative implementations to read that format,
the algorithm to compute that hash must be documented. Having a well-defined
depth-first ordering for the tree of (sub-)included files makes that easier.

Diff Detail

Repository
rHG Mercurial
Lint
Automatic diff as part of commit; lint not applicable.
Unit
Automatic diff as part of commit; unit tests not applicable.

Event Timeline

SimonSapin created this revision.Jun 4 2021, 5:02 AM
baymax updated this revision to Diff 28436.Jun 4 2021, 7:23 AM

✅ refresh by Heptapod after a successful CI run (🐙 💚)

Alphare accepted this revision as: Alphare.Jun 4 2021, 8:45 AM
Alphare added a subscriber: Alphare.

Note that I had the idea for this change and discussed it with Simon. I'm only accepting because the code looks right, but if another reviewer wants to approve it, that'd be great also.
As an aside, this also makes a potential hgignore crate easier to make.

SimonSapin added a commit: rHGf6bb181c75f8: rust: Parse "subinclude"d files along the way, not later.Jun 7 2021, 3:44 AM
This revision was not accepted when it landed; it landed in state Needs Review.
Closed by commit rHGf6bb181c75f8: rust: Parse "subinclude"d files along the way, not later (authored by SimonSapin). · Explain Why
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

Diff 28467

rust/hg-core/src/filepatterns.rs

/// These are matched in order /// These are matched in order
const GLOB_REPLACEMENTS: &[(&[u8], &[u8])] = const GLOB_REPLACEMENTS: &[(&[u8], &[u8])] =
&[(b"*/", b"(?:.*/)?"), (b"*", b".*"), (b"", b"[^/]*")]; &[(b"*/", b"(?:.*/)?"), (b"*", b".*"), (b"", b"[^/]*")];
/// Appended to the regexp of globs /// Appended to the regexp of globs
const GLOB_SUFFIX: &[u8; 7] = b"(?:/|$)"; const GLOB_SUFFIX: &[u8; 7] = b"(?:/|$)";
#[derive(Debug, Copy, Clone, PartialEq, Eq)] #[derive(Debug, Clone, PartialEq, Eq)]
pub enum PatternSyntax { pub enum PatternSyntax {
/// A regular expression /// A regular expression
Regexp, Regexp,
/// Glob that matches at the front of the path /// Glob that matches at the front of the path
RootGlob, RootGlob,
/// Glob that matches at any suffix of the path (still anchored at /// Glob that matches at any suffix of the path (still anchored at
/// slashes) /// slashes)
Glob, Glob,
/// a path relative to repository root, which is matched recursively /// a path relative to repository root, which is matched recursively
Path, Path,
/// A path relative to cwd /// A path relative to cwd
RelPath, RelPath,
/// an unrooted glob (*.rs matches Rust files in all dirs) /// an unrooted glob (*.rs matches Rust files in all dirs)
RelGlob, RelGlob,
/// A regexp that needn't match the start of a name /// A regexp that needn't match the start of a name
RelRegexp, RelRegexp,
/// A path relative to repository root, which is matched non-recursively /// A path relative to repository root, which is matched non-recursively
/// (will not match subdirectories) /// (will not match subdirectories)
RootFiles, RootFiles,
/// A file of patterns to read and include /// A file of patterns to read and include
Include, Include,
/// A file of patterns to match against files under the same directory /// A file of patterns to match against files under the same directory
SubInclude, SubInclude,
/// 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>),
} }
/// Transforms a glob pattern into a regex /// Transforms a glob pattern into a regex
fn glob_to_re(pat: &[u8]) -> Vec<u8> { fn glob_to_re(pat: &[u8]) -> Vec<u8> {
let mut input = pat; let mut input = pat;
let mut res: Vec<u8> = vec![]; let mut res: Vec<u8> = vec![];
let mut group_depth = 0; let mut group_depth = 0;
[b".*", rest, GLOB_SUFFIX].concat() [b".*", rest, GLOB_SUFFIX].concat()
} else { } else {
[b"(?:.*/)?", glob_re.as_slice(), GLOB_SUFFIX].concat() [b"(?:.*/)?", glob_re.as_slice(), GLOB_SUFFIX].concat()
} }
} }
PatternSyntax::Glob | PatternSyntax::RootGlob => { PatternSyntax::Glob | PatternSyntax::RootGlob => {
[glob_to_re(pattern).as_slice(), GLOB_SUFFIX].concat() [glob_to_re(pattern).as_slice(), GLOB_SUFFIX].concat()
} }
PatternSyntax::Include | PatternSyntax::SubInclude => unreachable!(), PatternSyntax::Include
| PatternSyntax::SubInclude
| PatternSyntax::ExpandedSubInclude(_) => unreachable!(),
} }
} }
const GLOB_SPECIAL_CHARACTERS: [u8; 7] = const GLOB_SPECIAL_CHARACTERS: [u8; 7] =
[b'*', b'?', b'[', b']', b'{', b'}', b'\\']; [b'*', b'?', b'[', b']', b'{', b'}', b'\\'];
/// TODO support other platforms /// TODO support other platforms
#[cfg(unix)] #[cfg(unix)]
source: source.to_owned(), source: source.to_owned(),
} }
} }
} }
pub type PatternResult<T> = Result<T, PatternError>; pub type PatternResult<T> = Result<T, PatternError>;
/// Wrapper for `read_pattern_file` that also recursively expands `include:` /// Wrapper for `read_pattern_file` that also recursively expands `include:`
/// patterns. /// and `subinclude:` patterns.
/// ///
/// `subinclude:` is not treated as a special pattern here: unraveling them /// The former are expanded in place, while `PatternSyntax::ExpandedSubInclude`
/// needs to occur in the "ignore" phase. /// is used for the latter to form a tree of patterns.
pub fn get_patterns_from_file( pub fn get_patterns_from_file(
pattern_file: &Path, pattern_file: &Path,
root_dir: &Path, root_dir: &Path,
) -> PatternResult<(Vec<IgnorePattern>, Vec<PatternFileWarning>)> { ) -> PatternResult<(Vec<IgnorePattern>, Vec<PatternFileWarning>)> {
let (patterns, mut warnings) = read_pattern_file(pattern_file, true)?; let (patterns, mut warnings) = read_pattern_file(pattern_file, true)?;
let patterns = patterns let patterns = patterns
.into_iter() .into_iter()
.flat_map(|entry| -> PatternResult<_> { .flat_map(|entry| -> PatternResult<_> {
let IgnorePattern { Ok(match &entry.syntax {
syntax, pattern, ..
} = &entry;
Ok(match syntax {
PatternSyntax::Include => { PatternSyntax::Include => {
let inner_include = let inner_include =
root_dir.join(get_path_from_bytes(&pattern)); root_dir.join(get_path_from_bytes(&entry.pattern));
let (inner_pats, inner_warnings) = let (inner_pats, inner_warnings) =
get_patterns_from_file(&inner_include, root_dir)?; get_patterns_from_file(&inner_include, root_dir)?;
warnings.extend(inner_warnings); warnings.extend(inner_warnings);
inner_pats inner_pats
} }
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
}]
}
_ => vec![entry], _ => vec![entry],
}) })
}) })
.flatten() .flatten()
.collect(); .collect();
Ok((patterns, warnings)) Ok((patterns, warnings))
} }
/// Holds all the information needed to handle a `subinclude:` pattern. /// Holds all the information needed to handle a `subinclude:` pattern.
#[derive(Debug, PartialEq, Eq, Clone)]
pub struct SubInclude { pub struct SubInclude {
/// Will be used for repository (hg) paths that start with this prefix. /// Will be used for repository (hg) paths that start with this prefix.
/// It is relative to the current working directory, so comparing against /// It is relative to the current working directory, so comparing against
/// repository paths is painless. /// repository paths is painless.
pub prefix: HgPathBuf, pub prefix: HgPathBuf,
/// The file itself, containing the patterns /// The file itself, containing the patterns
pub path: PathBuf, pub path: PathBuf,
/// Folder in the filesystem where this it applies /// Folder in the filesystem where this it applies
pub root: PathBuf, pub root: PathBuf,
pub included_patterns: Vec<IgnorePattern>,
} }
impl SubInclude { impl SubInclude {
pub fn new( pub fn new(
root_dir: &Path, root_dir: &Path,
pattern: &[u8], pattern: &[u8],
source: &Path, source: &Path,
) -> Result<SubInclude, HgPathError> { ) -> Result<SubInclude, HgPathError> {
prefix: path_to_hg_path_buf(prefix).and_then(|mut p| { prefix: path_to_hg_path_buf(prefix).and_then(|mut p| {
if !p.is_empty() { if !p.is_empty() {
p.push(b'/'); p.push(b'/');
} }
Ok(p) Ok(p)
})?, })?,
path: path.to_owned(), path: path.to_owned(),
root: new_root.to_owned(), root: new_root.to_owned(),
included_patterns: Vec::new(),
}) })
} }
} }
/// Separate and pre-process subincludes from other patterns for the "ignore" /// Separate and pre-process subincludes from other patterns for the "ignore"
/// phase. /// phase.
pub fn filter_subincludes<'a>( pub fn filter_subincludes(
ignore_patterns: &'a [IgnorePattern], ignore_patterns: Vec<IgnorePattern>,
root_dir: &Path, ) -> Result<(Vec<Box<SubInclude>>, Vec<IgnorePattern>), HgPathError> {
) -> Result<(Vec<SubInclude>, Vec<&'a IgnorePattern>), HgPathError> {
let mut subincludes = vec![]; let mut subincludes = vec![];
let mut others = vec![]; let mut others = vec![];
for ignore_pattern in ignore_patterns.iter() { for pattern in ignore_patterns {
let IgnorePattern { if let PatternSyntax::ExpandedSubInclude(sub_include) = pattern.syntax
syntax, {
pattern, subincludes.push(sub_include);
source,
} = ignore_pattern;
if *syntax == PatternSyntax::SubInclude {
subincludes.push(SubInclude::new(root_dir, pattern, &source)?);
} else { } else {
others.push(ignore_pattern) others.push(pattern)
} }
} }
Ok((subincludes, others)) Ok((subincludes, others))
} }
#[cfg(test)] #[cfg(test)]
mod tests { mod tests {
use super::*; use super::*;

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.
use crate::{ use crate::{
dirstate::dirs_multiset::DirsChildrenMultiset, dirstate::dirs_multiset::DirsChildrenMultiset,
filepatterns::{ filepatterns::{
build_single_regex, filter_subincludes, get_patterns_from_file, build_single_regex, filter_subincludes, get_patterns_from_file,
PatternFileWarning, PatternResult, SubInclude, PatternFileWarning, PatternResult,
}, },
utils::{ utils::{
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,
/// IgnorePattern, /// IgnorePattern,
/// PatternSyntax, /// PatternSyntax,
/// utils::hg_path::HgPath /// utils::hg_path::HgPath
/// }; /// };
/// use std::path::Path; /// use std::path::Path;
/// /// /// ///
/// let ignore_patterns = /// let ignore_patterns =
/// vec![IgnorePattern::new(PatternSyntax::RootGlob, b"this*", Path::new(""))]; /// vec![IgnorePattern::new(PatternSyntax::RootGlob, b"this*", Path::new(""))];
/// let (matcher, _) = IncludeMatcher::new(ignore_patterns, "".as_ref()).unwrap(); /// let matcher = IncludeMatcher::new(ignore_patterns).unwrap();
/// /// /// ///
/// 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>,
.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<'a>( fn build_regex_match(
ignore_patterns: &'a [&'a IgnorePattern], ignore_patterns: &[IgnorePattern],
) -> PatternResult<(Vec<u8>, Box<dyn Fn(&HgPath) -> bool + Sync>)> { ) -> PatternResult<(Vec<u8>, Box<dyn Fn(&HgPath) -> bool + Sync>)> {
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 {
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) /// 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: &'a [IgnorePattern], ignore_patterns: Vec<IgnorePattern>,
root_dir: &Path, ) -> PatternResult<(Vec<u8>, Box<dyn Fn(&HgPath) -> bool + 'b + Sync>)> {
) -> PatternResult<(
Vec<u8>,
Box<dyn Fn(&HgPath) -> bool + 'b + Sync>,
Vec<PatternFileWarning>,
)> {
let mut match_funcs: Vec<Box<dyn Fn(&HgPath) -> bool + Sync>> = vec![]; let mut match_funcs: Vec<Box<dyn Fn(&HgPath) -> bool + Sync>> = vec![];
// For debugging and printing // For debugging and printing
let mut patterns = vec![]; let mut patterns = vec![];
let mut all_warnings = vec![];
let (subincludes, ignore_patterns) = let (subincludes, ignore_patterns) = filter_subincludes(ignore_patterns)?;
filter_subincludes(ignore_patterns, root_dir)?;
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();
let mut prefixes = vec![]; let mut prefixes = vec![];
for SubInclude { prefix, root, path } in subincludes.into_iter() { for sub_include in subincludes {
let (match_fn, warnings) = let matcher = IncludeMatcher::new(sub_include.included_patterns)?;
get_ignore_function(vec![path.to_path_buf()], &root)?; let match_fn =
all_warnings.extend(warnings); Box::new(move |path: &HgPath| matcher.matches(path));
prefixes.push(prefix.to_owned()); prefixes.push(sub_include.prefix.clone());
submatchers.insert(prefix.to_owned(), match_fn); submatchers.insert(sub_include.prefix.clone(), match_fn);
} }
let match_subinclude = move |filename: &HgPath| { let match_subinclude = move |filename: &HgPath| {
for prefix in prefixes.iter() { for prefix in prefixes.iter() {
if let Some(rel) = filename.relative_to(prefix) { if let Some(rel) = filename.relative_to(prefix) {
if (submatchers[prefix])(rel) { if (submatchers[prefix])(rel) {
return true; return true;
} }
} else { } else {
let (new_re, match_func) = build_regex_match(&ignore_patterns)?; let (new_re, match_func) = build_regex_match(&ignore_patterns)?;
patterns = new_re; patterns = new_re;
match_funcs.push(match_func) match_funcs.push(match_func)
} }
} }
Ok(if match_funcs.len() == 1 { Ok(if match_funcs.len() == 1 {
(patterns, match_funcs.remove(0), all_warnings) (patterns, match_funcs.remove(0))
} else { } else {
( (
patterns, patterns,
Box::new(move |f: &HgPath| -> bool { Box::new(move |f: &HgPath| -> bool {
match_funcs.iter().any(|match_func| match_func(f)) match_funcs.iter().any(|match_func| match_func(f))
}), }),
all_warnings,
) )
}) })
} }
/// 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>(
all_pattern_files: Vec<PathBuf>, all_pattern_files: Vec<PathBuf>,
root_dir: &Path, root_dir: &Path,
) -> PatternResult<( ) -> PatternResult<(
Box<dyn for<'r> Fn(&'r HgPath) -> bool + Sync + 'a>, Box<dyn for<'r> Fn(&'r HgPath) -> bool + Sync + 'a>,
Vec<PatternFileWarning>, Vec<PatternFileWarning>,
)> { )> {
let mut all_patterns = vec![]; let mut all_patterns = vec![];
let mut all_warnings = vec![]; let mut all_warnings = vec![];
for pattern_file in &all_pattern_files { for pattern_file in &all_pattern_files {
let (patterns, warnings) = let (patterns, warnings) =
get_patterns_from_file(pattern_file, root_dir)?; get_patterns_from_file(pattern_file, root_dir)?;
all_patterns.extend(patterns.to_owned()); all_patterns.extend(patterns.to_owned());
all_warnings.extend(warnings); all_warnings.extend(warnings);
} }
let (matcher, warnings) = IncludeMatcher::new(all_patterns, root_dir)?; let matcher = IncludeMatcher::new(all_patterns)?;
all_warnings.extend(warnings);
Ok(( Ok((
Box::new(move |path: &HgPath| matcher.matches(path)), Box::new(move |path: &HgPath| matcher.matches(path)),
all_warnings, all_warnings,
)) ))
} }
impl<'a> IncludeMatcher<'a> { impl<'a> IncludeMatcher<'a> {
pub fn new( pub fn new(ignore_patterns: Vec<IgnorePattern>) -> PatternResult<Self> {
ignore_patterns: Vec<IgnorePattern>,
root_dir: &Path,
) -> PatternResult<(Self, Vec<PatternFileWarning>)> {
let (patterns, match_fn, warnings) =
build_match(&ignore_patterns, root_dir)?;
let RootsDirsAndParents { let RootsDirsAndParents {
roots, roots,
dirs, dirs,
parents, parents,
} = roots_dirs_and_parents(&ignore_patterns)?; } = roots_dirs_and_parents(&ignore_patterns)?;
let prefix = ignore_patterns.iter().any(|k| match k.syntax { let prefix = ignore_patterns.iter().any(|k| match k.syntax {
PatternSyntax::Path | PatternSyntax::RelPath => true, PatternSyntax::Path | PatternSyntax::RelPath => true,
_ => false, _ => false,
}); });
let (patterns, match_fn) = build_match(ignore_patterns)?;
Ok(( Ok(Self {
Self {
patterns, patterns,
match_fn, match_fn,
prefix, prefix,
roots, roots,
dirs, dirs,
parents, parents,
}, })
warnings,
))
} }
fn get_all_parents_children(&self) -> DirsChildrenMultiset { fn get_all_parents_children(&self) -> DirsChildrenMultiset {
// TODO cache // TODO cache
let thing = self let thing = self
.dirs .dirs
.iter() .iter()
.chain(self.roots.iter()) .chain(self.roots.iter())
matcher.visit_children_set(HgPath::new(b"folder")), matcher.visit_children_set(HgPath::new(b"folder")),
VisitChildrenSet::Empty VisitChildrenSet::Empty
); );
} }
#[test] #[test]
fn test_includematcher() { fn test_includematcher() {
// VisitchildrensetPrefix // VisitchildrensetPrefix
let (matcher, _) = IncludeMatcher::new( let matcher = IncludeMatcher::new(vec![IgnorePattern::new(
vec![IgnorePattern::new(
PatternSyntax::RelPath, PatternSyntax::RelPath,
b"dir/subdir", b"dir/subdir",
Path::new(""), Path::new(""),
)], )])
"".as_ref(),
)
.unwrap(); .unwrap();
let mut set = HashSet::new(); let mut set = HashSet::new();
set.insert(HgPath::new(b"dir")); set.insert(HgPath::new(b"dir"));
assert_eq!( assert_eq!(
matcher.visit_children_set(HgPath::new(b"")), matcher.visit_children_set(HgPath::new(b"")),
VisitChildrenSet::Set(set) VisitChildrenSet::Set(set)
); );
VisitChildrenSet::This VisitChildrenSet::This
); );
assert_eq!( assert_eq!(
matcher.visit_children_set(HgPath::new(b"folder")), matcher.visit_children_set(HgPath::new(b"folder")),
VisitChildrenSet::Empty VisitChildrenSet::Empty
); );
// VisitchildrensetRootfilesin // VisitchildrensetRootfilesin
let (matcher, _) = IncludeMatcher::new( let matcher = IncludeMatcher::new(vec![IgnorePattern::new(
vec![IgnorePattern::new(
PatternSyntax::RootFiles, PatternSyntax::RootFiles,
b"dir/subdir", b"dir/subdir",
Path::new(""), Path::new(""),
)], )])
"".as_ref(),
)
.unwrap(); .unwrap();
let mut set = HashSet::new(); let mut set = HashSet::new();
set.insert(HgPath::new(b"dir")); set.insert(HgPath::new(b"dir"));
assert_eq!( assert_eq!(
matcher.visit_children_set(HgPath::new(b"")), matcher.visit_children_set(HgPath::new(b"")),
VisitChildrenSet::Set(set) VisitChildrenSet::Set(set)
); );
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
); );
// VisitchildrensetGlob // VisitchildrensetGlob
let (matcher, _) = IncludeMatcher::new( let matcher = IncludeMatcher::new(vec![IgnorePattern::new(
vec![IgnorePattern::new(
PatternSyntax::Glob, PatternSyntax::Glob,
b"dir/z*", b"dir/z*",
Path::new(""), Path::new(""),
)], )])
"".as_ref(),
)
.unwrap(); .unwrap();
let mut set = HashSet::new(); let mut set = HashSet::new();
set.insert(HgPath::new(b"dir")); set.insert(HgPath::new(b"dir"));
assert_eq!( assert_eq!(
matcher.visit_children_set(HgPath::new(b"")), matcher.visit_children_set(HgPath::new(b"")),
VisitChildrenSet::Set(set) VisitChildrenSet::Set(set)
); );

rust/hg-cpython/src/dirstate/status.rs

let source = k.get_item(py, 2)?.extract::<PyBytes>(py)?; let source = k.get_item(py, 2)?.extract::<PyBytes>(py)?;
let source = get_path_from_bytes(source.data(py)); let source = get_path_from_bytes(source.data(py));
let new = IgnorePattern::new(syntax, pattern, source); let new = IgnorePattern::new(syntax, pattern, source);
Ok(new) Ok(new)
}) })
.collect(); .collect();
let ignore_patterns = ignore_patterns?; let ignore_patterns = ignore_patterns?;
let mut all_warnings = vec![];
let (matcher, warnings) = let matcher = IncludeMatcher::new(ignore_patterns)
IncludeMatcher::new(ignore_patterns, &root_dir)
.map_err(|e| handle_fallback(py, e.into()))?; .map_err(|e| handle_fallback(py, e.into()))?;
all_warnings.extend(warnings);
let (status_res, warnings) = dmap let (status_res, warnings) = dmap
.status( .status(
&matcher, &matcher,
root_dir.to_path_buf(), root_dir.to_path_buf(),
ignore_files, ignore_files,
StatusOptions { StatusOptions {
check_exec, check_exec,
last_normal_time, last_normal_time,
list_clean, list_clean,
list_ignored, list_ignored,
list_unknown, list_unknown,
collect_traversed_dirs, collect_traversed_dirs,
}, },
) )
.map_err(|e| handle_fallback(py, e))?; .map_err(|e| handle_fallback(py, e))?;
all_warnings.extend(warnings); build_response(py, status_res, warnings)
build_response(py, status_res, all_warnings)
} }
e => Err(PyErr::new::<ValueError, _>( e => Err(PyErr::new::<ValueError, _>(
py, py,
format!("Unsupported matcher {}", e), format!("Unsupported matcher {}", e),
)), )),
} }
} }