( )⚙ 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
Lint
Automatic diff as part of commit; lint not applicable.
Unit
Automatic diff as part of commit; unit tests not applicable.

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
248

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

309

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 (152 lines)

Diff 20713

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). It does not return other directories
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.
/// 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)
}
/// Paths extracted from patterns
#[derive(Debug, PartialEq)]
struct RootsDirsAndParents {
/// Directories to match recursively
pub roots: HashSet<HgPathBuf>,
/// Directories to match non-recursively
pub dirs: HashSet<HgPathBuf>,
/// Implicitly required directories to go to items in either roots or dirs
pub parents: HashSet<HgPathBuf>,
kevincoxUnsubmitted
Done

Please describe the return value.

kevincox: Please describe the return value.
}
/// Extract roots, dirs and parents from patterns.
fn roots_dirs_and_parents(
ignore_patterns: &[IgnorePattern],
) -> PatternResult<RootsDirsAndParents> {
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(RootsDirsAndParents {
roots: HashSet::from_iter(roots),
dirs: 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(),
RootsDirsAndParents {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();