( )⚙ D7923 rust-matchers: add functions to get roots, dirs and parents from patterns

This is an archive of the discontinued Mercurial Phabricator instance.

Differential D7923

rust-matchers: add functions to get roots, dirs and parents from patterns
ClosedPublic

Authored by Alphare on Jan 17 2020, 5:41 AM.

Details

Reviewers
kevincox
martinvonz
Group Reviewers
hg-reviewers
Commits
rHGd4e8cfcde012: rust-matchers: add functions to get roots, dirs and parents from patterns
Summary

These functions will be used to help build the upcoming IncludeMatcher.

Diff Detail

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

Event Timeline

Alphare created this revision.Jan 17 2020, 5:41 AM
kevincox requested changes to this revision.Jan 17 2020, 11:05 AM
kevincox added inline comments.
rust/hg-core/src/matchers.rs
250

I'm confused by the "for each" since this only returns one tuple.

311

Please describe the return value.

This revision now requires changes to proceed.Jan 17 2020, 11:05 AM
Alphare marked 2 inline comments as done.Jan 17 2020, 11:37 AM
Alphare updated this revision to Diff 19418.Jan 17 2020, 11:52 AM
Alphare updated this revision to Diff 19939.Feb 6 2020, 10:15 AM
kevincox accepted this revision.Feb 10 2020, 10:22 AM
Alphare added a comment.Feb 10 2020, 10:24 AM

@kevincox
I am currently fighting a nasty rebase and will be re-sending a lot of these patches (in less than 30 minutes hopefully). Just so you don't have to re-check another time. :)

kevincox added a comment.Feb 10 2020, 10:31 AM

Thanks for the heads up. I'll try to dedup them.

Alphare updated this revision to Diff 20161.Feb 11 2020, 6:13 AM
martinvonz accepted this revision.Mar 6 2020, 1:59 AM
This revision is now accepted and ready to land.Mar 6 2020, 1:59 AM

Revision Contents
Changeset List

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

Diff 19402

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::PatternResult, utils::hg_path::HgPath, DirsMultiset, filepatterns::PatternResult,
DirstateMapError, PatternError, utils::hg_path::{HgPath, HgPathBuf},
DirsMultiset, DirstateMapError, IgnorePattern, PatternError,
PatternSyntax,
}; };
use std::collections::HashSet; use std::collections::HashSet;
use std::iter::FromIterator; use std::iter::FromIterator;
use std::ops::Deref; use std::ops::Deref;
#[derive(Debug, PartialEq)] #[derive(Debug, PartialEq)]
pub enum VisitChildrenSet<'a> { pub enum VisitChildrenSet<'a> {
/// Don't visit anything /// Don't visit anything
Ok(move |path: &HgPath| regex.is_match(path.as_bytes())) Ok(move |path: &HgPath| regex.is_match(path.as_bytes()))
} }
#[cfg(not(feature = "with-re2"))] #[cfg(not(feature = "with-re2"))]
fn re_matcher(_: &[u8]) -> PatternResult<Box<dyn Fn(&HgPath) -> bool + Sync>> { fn re_matcher(_: &[u8]) -> PatternResult<Box<dyn Fn(&HgPath) -> bool + Sync>> {
Err(PatternError::Re2NotInstalled) Err(PatternError::Re2NotInstalled)
} }
/// Returns roots and directories corresponding to each pattern.
///
/// This calculates the roots and directories exactly matching the patterns and
/// returns a tuple of (roots, dirs) for each. It does not return other
kevincoxUnsubmitted
Done

I'm confused by the "for each" since this only returns one tuple.

kevincox: I'm confused by the "for each" since this only returns one tuple.
/// directories which may also need to be considered, like the parent
/// directories.
fn roots_and_dirs(
ignore_patterns: &[IgnorePattern],
) -> (Vec<HgPathBuf>, Vec<HgPathBuf>) {
let mut roots = Vec::new();
let mut dirs = Vec::new();
for ignore_pattern in ignore_patterns {
let IgnorePattern {
syntax, pattern, ..
} = ignore_pattern;
match syntax {
PatternSyntax::RootGlob | PatternSyntax::Glob => {
let mut root = vec![];
for p in pattern.split(|c| *c == b'/') {
if p.iter().any(|c| match *c {
b'[' | b'{' | b'*' | b'?' => true,
_ => false,
}) {
break;
}
root.push(HgPathBuf::from_bytes(p));
}
let buf =
root.iter().fold(HgPathBuf::new(), |acc, r| acc.join(r));
roots.push(buf);
}
PatternSyntax::Path | PatternSyntax::RelPath => {
let pat = HgPath::new(if pattern == b"." {
&[] as &[u8]
} else {
pattern
});
roots.push(pat.to_owned());
}
PatternSyntax::RootFiles => {
let pat = if pattern == b"." {
&[] as &[u8]
} else {
pattern
};
dirs.push(HgPathBuf::from_bytes(pat));
}
_ => {
roots.push(HgPathBuf::new());
}
}
}
(roots, dirs)
}
/// Returns roots and exact directories from patterns.
///
/// `roots` are directories to match recursively, `dirs` should
/// be matched non-recursively, and `parents` are the implicitly required
/// directories to walk to items in either roots or dirs.
fn roots_dirs_and_parents(
ignore_patterns: &[IgnorePattern],
) -> PatternResult<(HashSet<HgPathBuf>, HashSet<HgPathBuf>, HashSet<HgPathBuf>)>
kevincoxUnsubmitted
Done

Please describe the return value.

kevincox: Please describe the return value.
{
let (roots, dirs) = roots_and_dirs(ignore_patterns);
let mut parents = HashSet::new();
parents.extend(
DirsMultiset::from_manifest(&dirs)
.map_err(|e| match e {
DirstateMapError::InvalidPath(e) => e,
_ => unreachable!(),
})?
.iter()
.map(|k| k.to_owned()),
);
parents.extend(
DirsMultiset::from_manifest(&roots)
.map_err(|e| match e {
DirstateMapError::InvalidPath(e) => e,
_ => unreachable!(),
})?
.iter()
.map(|k| k.to_owned()),
);
Ok((HashSet::from_iter(roots), HashSet::from_iter(dirs), parents))
}
#[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;
#[test]
fn test_roots_and_dirs() {
let pats = vec![
IgnorePattern::new(PatternSyntax::Glob, b"g/h/*", Path::new("")),
IgnorePattern::new(PatternSyntax::Glob, b"g/h", Path::new("")),
IgnorePattern::new(PatternSyntax::Glob, b"g*", Path::new("")),
];
let (roots, dirs) = roots_and_dirs(&pats);
assert_eq!(
roots,
vec!(
HgPathBuf::from_bytes(b"g/h"),
HgPathBuf::from_bytes(b"g/h"),
HgPathBuf::new()
),
);
assert_eq!(dirs, vec!());
}
#[test]
fn test_roots_dirs_and_parents() {
let pats = vec![
IgnorePattern::new(PatternSyntax::Glob, b"g/h/*", Path::new("")),
IgnorePattern::new(PatternSyntax::Glob, b"g/h", Path::new("")),
IgnorePattern::new(PatternSyntax::Glob, b"g*", Path::new("")),
];
let mut roots = HashSet::new();
roots.insert(HgPathBuf::from_bytes(b"g/h"));
roots.insert(HgPathBuf::new());
let dirs = HashSet::new();
let mut parents = HashSet::new();
parents.insert(HgPathBuf::new());
parents.insert(HgPathBuf::from_bytes(b"g"));
assert_eq!(
roots_dirs_and_parents(&pats).unwrap(),
(roots, dirs, parents)
);
}
#[test] #[test]
fn test_filematcher_visit_children_set() { fn test_filematcher_visit_children_set() {
// Visitchildrenset // Visitchildrenset
let files = vec![HgPath::new(b"dir/subdir/foo.txt")]; let files = vec![HgPath::new(b"dir/subdir/foo.txt")];
let matcher = FileMatcher::new(&files).unwrap(); let matcher = FileMatcher::new(&files).unwrap();
let mut set = HashSet::new(); let mut set = HashSet::new();