This is an archive of the discontinued Mercurial Phabricator instance.

Differential D7908

rust-filepatterns: improve API and robustness for pattern files parsing
ClosedPublic

Authored by Alphare on Jan 16 2020, 5:22 AM.

Details

Reviewers
kevincox
Group Reviewers
hg-reviewers
Commits
rHGd42eea9a0494: rust-filepatterns: improve API and robustness for pattern files parsing
rHG725d79b48e07: rust-filepatterns: improve API and robustness for pattern files parsing
Summary

Within the next few patches we will be using this new API.

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 16 2020, 5:22 AM
Alphare updated this revision to Diff 19356.Jan 16 2020, 6:27 AM
kevincox added inline comments.Jan 16 2020, 10:17 AM
rust/hg-core/src/filepatterns.rs
220

It might be clearer to do bytes.iter().take_while(|b| b == sep).count()

237

Personally I think this would be more clear as a for loop.

250

Should this be part of HgPathBuf or is this normalization specific to the file pattern matching in some way?

Alphare marked an inline comment as done.Jan 16 2020, 1:41 PM
Alphare added inline comments.
rust/hg-core/src/filepatterns.rs
220

Indeed. Also added a comment to explain the reasoning.

237

I'm not sure I agree. On the basis that "Rust might optimize iterators better than for loops" I vote to keep it that way.

250

For now this is pretty specific, but it might need to be moved later when more code paths use it.

kevincox accepted this revision.Jan 16 2020, 2:15 PM
kevincox added inline comments.
rust/hg-core/src/filepatterns.rs
227

Can you move this condition into a .filter()?

237

If you think it' is clearer that's fine. But I'm curious where "Rust might optimize iterators better than for loops" comes from. I did a quick test and it looks like the for loop actually generates slightly better code https://rust.godbolt.org/z/vFAWyZ

Alphare marked 2 inline comments as done.Jan 16 2020, 3:19 PM
Alphare added inline comments.
rust/hg-core/src/filepatterns.rs
237

I might be using godbolt wrong but it looks like you are using different versions of rustc. When using 1.40 for both sides, I don't see any clear win on either side... but I'm not fluent in assembly either. As I'm sure you'll agree, this function is unlikely to show up in future profiles anyway.

kevincox added inline comments.Jan 16 2020, 3:35 PM
rust/hg-core/src/filepatterns.rs
237

Oops. My mistake. But I think we agree that readability is the top priority (until profiles say otherwise)

Alphare updated this revision to Diff 19384.Jan 16 2020, 4:50 PM
Alphare updated this revision to Diff 20038.Feb 10 2020, 10:46 AM
Alphare added a commit: rHG725d79b48e07: rust-filepatterns: improve API and robustness for pattern files parsing.Feb 10 2020, 6:29 PM
This revision was not accepted when it landed; it landed in state Needs Review.
Closed by commit rHG725d79b48e07: rust-filepatterns: improve API and robustness for pattern files parsing (authored by Alphare). · Explain Why
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

PathPackages
Mrust/hg-core/src/filepatterns.rs (264 lines)
Mrust/hg-core/src/lib.rs (46 lines)

Diff 20078

rust/hg-core/src/filepatterns.rs

// filepatterns.rs // filepatterns.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.
//! Handling of Mercurial-specific patterns. //! Handling of Mercurial-specific patterns.
use crate::{ use crate::{utils::SliceExt, FastHashMap, PatternError};
utils::SliceExt, FastHashMap, LineNumber, PatternError, PatternFileError,
};
use lazy_static::lazy_static; use lazy_static::lazy_static;
use regex::bytes::{NoExpand, Regex}; use regex::bytes::{NoExpand, Regex};
use std::fs::File; use std::fs::File;
use std::io::Read; use std::io::Read;
use std::path::{Path, PathBuf}; use std::path::{Path, PathBuf};
use std::vec::Vec; use std::vec::Vec;
lazy_static! { lazy_static! {
static ref RE_ESCAPE: Vec<Vec<u8>> = { static ref RE_ESCAPE: Vec<Vec<u8>> = {
let mut v: Vec<Vec<u8>> = (0..=255).map(|byte| vec![byte]).collect(); let mut v: Vec<Vec<u8>> = (0..=255).map(|byte| vec![byte]).collect();
let to_escape = b"()[]{}?*+-|^$\\.&~# \t\n\r\x0b\x0c"; let to_escape = b"()[]{}?*+-|^$\\.&~# \t\n\r\x0b\x0c";
for byte in to_escape { for byte in to_escape {
v[*byte as usize].insert(0, b'\\'); v[*byte as usize].insert(0, b'\\');
} }
v v
}; };
} }
/// 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
const GLOB_SUFFIX: &[u8; 7] = b"(?:/|$)";
#[derive(Debug, Copy, Clone, PartialEq, Eq)] #[derive(Debug, Copy, Clone, PartialEq, Eq)]
pub enum PatternSyntax { pub enum PatternSyntax {
/// 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
Path, Path,
/// A path relative to cwd
RelPath, RelPath,
/// an unrooted glob (*.rs matches Rust files in all dirs)
RelGlob, RelGlob,
/// A regexp that needn't match the start of a name
RelRegexp, RelRegexp,
/// A path relative to repository root, which is matched non-recursively
/// (will not match subdirectories)
RootFiles, RootFiles,
} }
/// 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;
fn escape_pattern(pattern: &[u8]) -> Vec<u8> { fn escape_pattern(pattern: &[u8]) -> Vec<u8> {
pattern pattern
.iter() .iter()
.flat_map(|c| RE_ESCAPE[*c as usize].clone()) .flat_map(|c| RE_ESCAPE[*c as usize].clone())
.collect() .collect()
} }
fn parse_pattern_syntax(kind: &[u8]) -> Result<PatternSyntax, PatternError> { pub fn parse_pattern_syntax(
kind: &[u8],
) -> Result<PatternSyntax, PatternError> {
match kind { match kind {
b"re" => Ok(PatternSyntax::Regexp), b"re:" => Ok(PatternSyntax::Regexp),
b"path" => Ok(PatternSyntax::Path), b"path:" => Ok(PatternSyntax::Path),
b"relpath" => Ok(PatternSyntax::RelPath), b"relpath:" => Ok(PatternSyntax::RelPath),
b"rootfilesin" => Ok(PatternSyntax::RootFiles), b"rootfilesin:" => Ok(PatternSyntax::RootFiles),
b"relglob" => Ok(PatternSyntax::RelGlob), b"relglob:" => Ok(PatternSyntax::RelGlob),
b"relre" => Ok(PatternSyntax::RelRegexp), b"relre:" => Ok(PatternSyntax::RelRegexp),
b"glob" => Ok(PatternSyntax::Glob), b"glob:" => Ok(PatternSyntax::Glob),
b"rootglob" => Ok(PatternSyntax::RootGlob), b"rootglob:" => Ok(PatternSyntax::RootGlob),
_ => Err(PatternError::UnsupportedSyntax( _ => Err(PatternError::UnsupportedSyntax(
String::from_utf8_lossy(kind).to_string(), String::from_utf8_lossy(kind).to_string(),
)), )),
} }
} }
/// Builds the regex that corresponds to the given pattern. /// Builds the regex that corresponds to the given pattern.
/// If within a `syntax: regexp` context, returns the pattern, /// If within a `syntax: regexp` context, returns the pattern,
/// otherwise, returns the corresponding regex. /// otherwise, returns the corresponding regex.
fn _build_single_regex( fn _build_single_regex(entry: &IgnorePattern) -> Vec<u8> {
syntax: PatternSyntax, let IgnorePattern {
pattern: &[u8], syntax, pattern, ..
globsuffix: &[u8], } = entry;
) -> Vec<u8> {
if pattern.is_empty() { if pattern.is_empty() {
return vec![]; return vec![];
} }
match syntax { match syntax {
PatternSyntax::Regexp => pattern.to_owned(), PatternSyntax::Regexp => pattern.to_owned(),
PatternSyntax::RelRegexp => { PatternSyntax::RelRegexp => {
if pattern[0] == b'^' { if pattern[0] == b'^' {
return pattern.to_owned(); return pattern.to_owned();
} }
[b".*", pattern].concat() [&b".*"[..], pattern].concat()
} }
PatternSyntax::Path | PatternSyntax::RelPath => { PatternSyntax::Path | PatternSyntax::RelPath => {
if pattern == b"." { if pattern == b"." {
return vec![]; return vec![];
} }
[escape_pattern(pattern).as_slice(), b"(?:/|$)"].concat() [escape_pattern(pattern).as_slice(), b"(?:/|$)"].concat()
} }
PatternSyntax::RootFiles => { PatternSyntax::RootFiles => {
let mut res = if pattern == b"." { let mut res = if pattern == b"." {
vec![] vec![]
} else { } else {
// Pattern is a directory name. // Pattern is a directory name.
[escape_pattern(pattern).as_slice(), b"/"].concat() [escape_pattern(pattern).as_slice(), b"/"].concat()
}; };
// Anything after the pattern must be a non-directory. // Anything after the pattern must be a non-directory.
res.extend(b"[^/]+$"); res.extend(b"[^/]+$");
res res
} }
PatternSyntax::RelGlob => { PatternSyntax::RelGlob => {
let glob_re = glob_to_re(pattern); let glob_re = glob_to_re(pattern);
if let Some(rest) = glob_re.drop_prefix(b"[^/]*") { if let Some(rest) = glob_re.drop_prefix(b"[^/]*") {
[b".*", rest, globsuffix].concat() [b".*", rest, GLOB_SUFFIX].concat()
} else { } else {
[b"(?:|.*/)", glob_re.as_slice(), globsuffix].concat() [b"(?:|.*/)", glob_re.as_slice(), GLOB_SUFFIX].concat()
} }
} }
PatternSyntax::Glob | PatternSyntax::RootGlob => { PatternSyntax::Glob | PatternSyntax::RootGlob => {
[glob_to_re(pattern).as_slice(), globsuffix].concat() [glob_to_re(pattern).as_slice(), GLOB_SUFFIX].concat()
} }
} }
} }
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
#[cfg(unix)]
pub fn normalize_path_bytes(bytes: &[u8]) -> Vec<u8> {
if bytes.is_empty() {
return b".".to_vec();
}
let sep = b'/';
let mut initial_slashes = bytes.iter().take_while(|b| **b == sep).count();
if initial_slashes > 2 {
// POSIX allows one or two initial slashes, but treats three or more
// as single slash.
initial_slashes = 1;
}
kevincoxUnsubmitted
Done

It might be clearer to do bytes.iter().take_while(|b| b == sep).count()

kevincox: It might be clearer to do `bytes.iter().take_while(|b| b == sep).count()`
AlphareAuthorUnsubmitted
Done

Indeed. Also added a comment to explain the reasoning.

Alphare: Indeed. Also added a comment to explain the reasoning.
let components = bytes
.split(|b| *b == sep)
.filter(|c| !(c.is_empty() || c == b"."))
.fold(vec![], |mut acc, component| {
if component != b".."
|| (initial_slashes == 0 && acc.is_empty())
|| (!acc.is_empty() && acc[acc.len() - 1] == b"..")
kevincoxUnsubmitted
Done

Can you move this condition into a .filter()?

kevincox: Can you move this condition into a `.filter()`?
{
acc.push(component)
} else if !acc.is_empty() {
acc.pop();
}
acc
});
let mut new_bytes = components.join(&sep);
if initial_slashes > 0 {
kevincoxUnsubmitted
Not Done

Personally I think this would be more clear as a for loop.

kevincox: Personally I think this would be more clear as a `for` loop.
AlphareAuthorUnsubmitted
Done

I'm not sure I agree. On the basis that "Rust might optimize iterators better than for loops" I vote to keep it that way.

Alphare: I'm not sure I agree. On the basis that "Rust might optimize iterators better than for loops" I…
kevincoxUnsubmitted
Not Done

If you think it' is clearer that's fine. But I'm curious where "Rust might optimize iterators better than for loops" comes from. I did a quick test and it looks like the for loop actually generates slightly better code https://rust.godbolt.org/z/vFAWyZ

kevincox: If you think it' is clearer that's fine. But I'm curious where "Rust might optimize iterators…
AlphareAuthorUnsubmitted
Done

I might be using godbolt wrong but it looks like you are using different versions of rustc. When using 1.40 for both sides, I don't see any clear win on either side... but I'm not fluent in assembly either. As I'm sure you'll agree, this function is unlikely to show up in future profiles anyway.

Alphare: I might be using godbolt wrong but it looks like you are using different versions of rustc.
kevincoxUnsubmitted
Not Done

Oops. My mistake. But I think we agree that readability is the top priority (until profiles say otherwise)

kevincox: Oops. My mistake. But I think we agree that readability is the top priority (until profiles say…
let mut buf: Vec<_> = (0..initial_slashes).map(|_| sep).collect();
buf.extend(new_bytes);
new_bytes = buf;
}
if new_bytes.is_empty() {
b".".to_vec()
} else {
new_bytes
}
}
/// Wrapper function to `_build_single_regex` that short-circuits 'exact' globs /// Wrapper function to `_build_single_regex` that short-circuits 'exact' globs
/// that don't need to be transformed into a regex. /// that don't need to be transformed into a regex.
kevincoxUnsubmitted
Not Done

Should this be part of HgPathBuf or is this normalization specific to the file pattern matching in some way?

kevincox: Should this be part of HgPathBuf or is this normalization specific to the file pattern…
AlphareAuthorUnsubmitted
Done

For now this is pretty specific, but it might need to be moved later when more code paths use it.

Alphare: For now this is pretty specific, but it might need to be moved later when more code paths use…
pub fn build_single_regex( pub fn build_single_regex(
kind: &[u8], entry: &IgnorePattern,
pat: &[u8],
globsuffix: &[u8],
) -> Result<Vec<u8>, PatternError> { ) -> Result<Vec<u8>, PatternError> {
let enum_kind = parse_pattern_syntax(kind)?; let IgnorePattern {
if enum_kind == PatternSyntax::RootGlob pattern, syntax, ..
&& !pat.iter().any(|b| GLOB_SPECIAL_CHARACTERS.contains(b)) } = entry;
let pattern = match syntax {
PatternSyntax::RootGlob
| PatternSyntax::Path
| PatternSyntax::RelGlob
| PatternSyntax::RootFiles => normalize_path_bytes(&pattern),
_ => pattern.to_owned(),
};
if *syntax == PatternSyntax::RootGlob
&& !pattern.iter().any(|b| GLOB_SPECIAL_CHARACTERS.contains(b))
{ {
let mut escaped = escape_pattern(pat); let mut escaped = escape_pattern(&pattern);
escaped.extend(b"(?:/|$)"); escaped.extend(GLOB_SUFFIX);
Ok(escaped) Ok(escaped)
} else { } else {
Ok(_build_single_regex(enum_kind, pat, globsuffix)) let mut entry = entry.clone();
entry.pattern = pattern;
Ok(_build_single_regex(&entry))
} }
} }
lazy_static! { lazy_static! {
static ref SYNTAXES: FastHashMap<&'static [u8], &'static [u8]> = { static ref SYNTAXES: FastHashMap<&'static [u8], &'static [u8]> = {
let mut m = FastHashMap::default(); let mut m = FastHashMap::default();
m.insert(b"re".as_ref(), b"relre:".as_ref()); m.insert(b"re".as_ref(), b"relre:".as_ref());
m.insert(b"regexp".as_ref(), b"relre:".as_ref()); m.insert(b"regexp".as_ref(), b"relre:".as_ref());
m.insert(b"glob".as_ref(), b"relglob:".as_ref()); m.insert(b"glob".as_ref(), b"relglob:".as_ref());
m.insert(b"rootglob".as_ref(), b"rootglob:".as_ref()); m.insert(b"rootglob".as_ref(), b"rootglob:".as_ref());
m.insert(b"include".as_ref(), b"include".as_ref()); m.insert(b"include".as_ref(), b"include:".as_ref());
m.insert(b"subinclude".as_ref(), b"subinclude".as_ref()); m.insert(b"subinclude".as_ref(), b"subinclude:".as_ref());
m m
}; };
} }
pub type PatternTuple = (Vec<u8>, LineNumber, Vec<u8>); #[derive(Debug)]
type WarningTuple = (PathBuf, Vec<u8>); pub enum PatternFileWarning {
/// (file path, syntax bytes)
InvalidSyntax(PathBuf, Vec<u8>),
/// File path
NoSuchFile(PathBuf),
}
pub fn parse_pattern_file_contents<P: AsRef<Path>>( pub fn parse_pattern_file_contents<P: AsRef<Path>>(
lines: &[u8], lines: &[u8],
file_path: P, file_path: P,
warn: bool, warn: bool,
) -> (Vec<PatternTuple>, Vec<WarningTuple>) { ) -> Result<(Vec<IgnorePattern>, Vec<PatternFileWarning>), PatternError> {
let comment_regex = Regex::new(r"((?:^|[^\\])(?:\\\\)*)#.*").unwrap(); let comment_regex = Regex::new(r"((?:^|[^\\])(?:\\\\)*)#.*").unwrap();
let comment_escape_regex = Regex::new(r"\\#").unwrap(); let comment_escape_regex = Regex::new(r"\\#").unwrap();
let mut inputs: Vec<PatternTuple> = vec![]; let mut inputs: Vec<IgnorePattern> = vec![];
let mut warnings: Vec<WarningTuple> = vec![]; let mut warnings: Vec<PatternFileWarning> = vec![];
let mut current_syntax = b"relre:".as_ref(); let mut current_syntax = b"relre:".as_ref();
for (line_number, mut line) in lines.split(|c| *c == b'\n').enumerate() { for (line_number, mut line) in lines.split(|c| *c == b'\n').enumerate() {
let line_number = line_number + 1; let line_number = line_number + 1;
let line_buf; let line_buf;
if line.contains(&b'#') { if line.contains(&b'#') {
} }
if let Some(syntax) = line.drop_prefix(b"syntax:") { if let Some(syntax) = line.drop_prefix(b"syntax:") {
let syntax = syntax.trim(); let syntax = syntax.trim();
if let Some(rel_syntax) = SYNTAXES.get(syntax) { if let Some(rel_syntax) = SYNTAXES.get(syntax) {
current_syntax = rel_syntax; current_syntax = rel_syntax;
} else if warn { } else if warn {
warnings warnings.push(PatternFileWarning::InvalidSyntax(
.push((file_path.as_ref().to_owned(), syntax.to_owned())); file_path.as_ref().to_owned(),
syntax.to_owned(),
));
} }
continue; continue;
} }
let mut line_syntax: &[u8] = &current_syntax; let mut line_syntax: &[u8] = &current_syntax;
for (s, rels) in SYNTAXES.iter() { for (s, rels) in SYNTAXES.iter() {
if let Some(rest) = line.drop_prefix(rels) { if let Some(rest) = line.drop_prefix(rels) {
line_syntax = rels; line_syntax = rels;
line = rest; line = rest;
break; break;
} }
if let Some(rest) = line.drop_prefix(&[s, &b":"[..]].concat()) { if let Some(rest) = line.drop_prefix(&[s, &b":"[..]].concat()) {
line_syntax = rels; line_syntax = rels;
line = rest; line = rest;
break; break;
} }
} }
inputs.push(( inputs.push(IgnorePattern::new(
[line_syntax, line].concat(), parse_pattern_syntax(&line_syntax).map_err(|e| match e {
PatternError::UnsupportedSyntax(syntax) => {
PatternError::UnsupportedSyntaxInFile(
syntax,
file_path.as_ref().to_string_lossy().into(),
line_number, line_number,
line.to_owned(), )
}
_ => e,
})?,
&line,
&file_path,
)); ));
} }
(inputs, warnings) Ok((inputs, warnings))
} }
pub fn read_pattern_file<P: AsRef<Path>>( pub fn read_pattern_file<P: AsRef<Path>>(
file_path: P, file_path: P,
warn: bool, warn: bool,
) -> Result<(Vec<PatternTuple>, Vec<WarningTuple>), PatternFileError> { ) -> Result<(Vec<IgnorePattern>, Vec<PatternFileWarning>), PatternError> {
let mut f = File::open(file_path.as_ref())?; let mut f = match File::open(file_path.as_ref()) {
Ok(f) => Ok(f),
Err(e) => match e.kind() {
std::io::ErrorKind::NotFound => {
return Ok((
vec![],
vec![PatternFileWarning::NoSuchFile(
file_path.as_ref().to_owned(),
)],
))
}
_ => Err(e),
},
}?;
let mut contents = Vec::new(); let mut contents = Vec::new();
f.read_to_end(&mut contents)?; f.read_to_end(&mut contents)?;
Ok(parse_pattern_file_contents(&contents, file_path, warn)) Ok(parse_pattern_file_contents(&contents, file_path, warn)?)
}
/// Represents an entry in an "ignore" file.
#[derive(Debug, Eq, PartialEq, Clone)]
pub struct IgnorePattern {
pub syntax: PatternSyntax,
pub pattern: Vec<u8>,
pub source: PathBuf,
} }
impl IgnorePattern {
pub fn new(
syntax: PatternSyntax,
pattern: &[u8],
source: impl AsRef<Path>,
) -> Self {
Self {
syntax,
pattern: pattern.to_owned(),
source: source.as_ref().to_owned(),
}
}
}
pub type PatternResult<T> = Result<T, PatternError>;
#[cfg(test)] #[cfg(test)]
mod tests { mod tests {
use super::*; use super::*;
use pretty_assertions::assert_eq;
#[test] #[test]
fn escape_pattern_test() { fn escape_pattern_test() {
let untouched = br#"!"%',/0123456789:;<=>@ABCDEFGHIJKLMNOPQRSTUVWXYZ_`abcdefghijklmnopqrstuvwxyz"#; let untouched =
br#"!"%',/0123456789:;<=>@ABCDEFGHIJKLMNOPQRSTUVWXYZ_`abcdefghijklmnopqrstuvwxyz"#;
assert_eq!(escape_pattern(untouched), untouched.to_vec()); assert_eq!(escape_pattern(untouched), untouched.to_vec());
// All escape codes // All escape codes
assert_eq!( assert_eq!(
escape_pattern(br#"()[]{}?*+-|^$\\.&~# \t\n\r\v\f"#), escape_pattern(br#"()[]{}?*+-|^$\\.&~# \t\n\r\v\f"#),
br#"\(\)\[\]\{\}\?\*\+\-\|\^\$\\\\\.\&\~\#\ \\t\\n\\r\\v\\f"# br#"\(\)\[\]\{\}\?\*\+\-\|\^\$\\\\\.\&\~\#\ \\t\\n\\r\\v\\f"#
.to_vec() .to_vec()
); );
} }
assert_eq!(glob_to_re(br#".\*\?"#), br#"\.\*\?"#); assert_eq!(glob_to_re(br#".\*\?"#), br#"\.\*\?"#);
} }
#[test] #[test]
fn test_parse_pattern_file_contents() { fn test_parse_pattern_file_contents() {
let lines = b"syntax: glob\n*.elc"; let lines = b"syntax: glob\n*.elc";
assert_eq!( assert_eq!(
vec![(b"relglob:*.elc".to_vec(), 2, b"*.elc".to_vec())],
parse_pattern_file_contents(lines, Path::new("file_path"), false) parse_pattern_file_contents(lines, Path::new("file_path"), false)
.unwrap()
.0, .0,
vec![IgnorePattern::new(
PatternSyntax::RelGlob,
b"*.elc",
Path::new("file_path")
)],
); );
let lines = b"syntax: include\nsyntax: glob"; let lines = b"syntax: include\nsyntax: glob";
assert_eq!( assert_eq!(
parse_pattern_file_contents(lines, Path::new("file_path"), false) parse_pattern_file_contents(lines, Path::new("file_path"), false)
.unwrap()
.0, .0,
vec![] vec![]
); );
let lines = b"glob:**.o"; let lines = b"glob:**.o";
assert_eq!( assert_eq!(
parse_pattern_file_contents(lines, Path::new("file_path"), false) parse_pattern_file_contents(lines, Path::new("file_path"), false)
.unwrap()
.0, .0,
vec![(b"relglob:**.o".to_vec(), 1, b"**.o".to_vec())] vec![IgnorePattern::new(
PatternSyntax::RelGlob,
b"**.o",
Path::new("file_path")
)]
);
}
#[test]
fn test_build_single_regex() {
assert_eq!(
build_single_regex(&IgnorePattern::new(
PatternSyntax::RelGlob,
b"rust/target/",
Path::new("")
))
.unwrap(),
br"(?:|.*/)rust/target(?:/|$)".to_vec(),
); );
} }
#[test] #[test]
fn test_build_single_regex_shortcut() { fn test_build_single_regex_shortcut() {
assert_eq!( assert_eq!(
br"(?:/|$)".to_vec(), build_single_regex(&IgnorePattern::new(
build_single_regex(b"rootglob", b"", b"").unwrap() PatternSyntax::RootGlob,
b"",
Path::new("")
))
.unwrap(),
br"\.(?:/|$)".to_vec(),
); );
assert_eq!( assert_eq!(
build_single_regex(&IgnorePattern::new(
PatternSyntax::RootGlob,
b"whatever",
Path::new("")
))
.unwrap(),
br"whatever(?:/|$)".to_vec(), br"whatever(?:/|$)".to_vec(),
build_single_regex(b"rootglob", b"whatever", b"").unwrap()
); );
assert_eq!( assert_eq!(
br"[^/]*\.o".to_vec(), build_single_regex(&IgnorePattern::new(
build_single_regex(b"rootglob", b"*.o", b"").unwrap() PatternSyntax::RootGlob,
b"*.o",
Path::new("")
))
.unwrap(),
br"[^/]*\.o(?:/|$)".to_vec(),
); );
} }
} }

rust/hg-core/src/lib.rs

mod filepatterns; mod filepatterns;
pub mod matchers; pub mod matchers;
pub mod revlog; pub mod revlog;
pub use revlog::*; pub use revlog::*;
pub mod utils; pub mod utils;
use crate::utils::hg_path::{HgPathBuf, HgPathError}; use crate::utils::hg_path::{HgPathBuf, HgPathError};
pub use filepatterns::{ pub use filepatterns::{
build_single_regex, read_pattern_file, PatternSyntax, PatternTuple, parse_pattern_syntax, read_pattern_file, IgnorePattern,
PatternFileWarning, PatternSyntax,
}; };
use std::collections::HashMap; use std::collections::HashMap;
use twox_hash::RandomXxHashBuilder64; use twox_hash::RandomXxHashBuilder64;
pub type LineNumber = usize; pub type LineNumber = usize;
/// Rust's default hasher is too slow because it tries to prevent collision /// Rust's default hasher is too slow because it tries to prevent collision
/// attacks. We are not concerned about those: if an ill-minded person has /// attacks. We are not concerned about those: if an ill-minded person has
impl From<DirstatePackError> for DirstateError { impl From<DirstatePackError> for DirstateError {
fn from(e: DirstatePackError) -> Self { fn from(e: DirstatePackError) -> Self {
DirstateError::Pack(e) DirstateError::Pack(e)
} }
} }
#[derive(Debug)] #[derive(Debug)]
pub enum PatternError { pub enum PatternError {
Path(HgPathError),
UnsupportedSyntax(String), UnsupportedSyntax(String),
} UnsupportedSyntaxInFile(String, String, usize),
TooLong(usize),
#[derive(Debug)]
pub enum PatternFileError {
IO(std::io::Error), IO(std::io::Error),
Pattern(PatternError, LineNumber),
} }
impl From<std::io::Error> for PatternFileError { impl ToString for PatternError {
fn from(e: std::io::Error) -> Self { fn to_string(&self) -> String {
PatternFileError::IO(e) match self {
PatternError::UnsupportedSyntax(syntax) => {
format!("Unsupported syntax {}", syntax)
}
PatternError::UnsupportedSyntaxInFile(syntax, file_path, line) => {
format!(
"{}:{}: unsupported syntax {}",
file_path, line, syntax
)
}
PatternError::TooLong(size) => {
format!("matcher pattern is too long ({} bytes)", size)
}
PatternError::IO(e) => e.to_string(),
PatternError::Path(e) => e.to_string(),
}
} }
} }
impl From<DirstateMapError> for DirstateError { impl From<DirstateMapError> for DirstateError {
fn from(e: DirstateMapError) -> Self { fn from(e: DirstateMapError) -> Self {
DirstateError::Map(e) DirstateError::Map(e)
} }
} }
impl From<std::io::Error> for DirstateError { impl From<std::io::Error> for DirstateError {
fn from(e: std::io::Error) -> Self { fn from(e: std::io::Error) -> Self {
DirstateError::IO(e) DirstateError::IO(e)
} }
} }
impl From<std::io::Error> for PatternError {
fn from(e: std::io::Error) -> Self {
PatternError::IO(e)
}
}
impl From<HgPathError> for PatternError {
fn from(e: HgPathError) -> Self {
PatternError::Path(e)
}
}