This is an archive of the discontinued Mercurial Phabricator instance.

Differential D10836

dirstate-v2: Store a hash of ignore patterns (.hgignore)
ClosedPublic

Authored by SimonSapin on Jun 7 2021, 7:23 AM.

Details

Reviewers
Alphare
Group Reviewers
hg-reviewers
Commits
rHG0ef8231e413f: dirstate-v2: Store a hash of ignore patterns (.hgignore)
Summary

Later, this help extend read_dir caching to directories that contain ignored
files (but no unknown files). Such cache must be invalidated when ignore patterns
change since a formerly-ignored file might become unknown.

This helps the default configuration of hg status where unknown files must
be listed, but ignored files are not.

Diff Detail

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

Event Timeline

SimonSapin created this revision.Jun 7 2021, 7:23 AM
Alphare accepted this revision.Jun 15 2021, 6:22 AM
This revision is now accepted and ready to land.Jun 15 2021, 6:22 AM

Revision Contents
Changeset List

Diff 28506

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

root_dir: PathBuf, root_dir: PathBuf,
ignore_files: Vec<PathBuf>, ignore_files: Vec<PathBuf>,
options: StatusOptions, options: StatusOptions,
) -> StatusResult<(Self, Vec<PatternFileWarning>)> { ) -> StatusResult<(Self, Vec<PatternFileWarning>)> {
// Needs to outlive `dir_ignore_fn` since it's captured. // Needs to outlive `dir_ignore_fn` since it's captured.
let (ignore_fn, warnings): (IgnoreFnType, _) = let (ignore_fn, warnings): (IgnoreFnType, _) =
if options.list_ignored || options.list_unknown { if options.list_ignored || options.list_unknown {
get_ignore_function(ignore_files, &root_dir)? get_ignore_function(ignore_files, &root_dir, &mut |_| {})?
} else { } else {
(Box::new(|&_| true), vec![]) (Box::new(|&_| true), vec![])
}; };
Ok(( Ok((
Self { Self {
dmap, dmap,
matcher, matcher,

rust/hg-core/src/dirstate_tree/dirstate_map.rs

pub(super) root: ChildNodes<'on_disk>, pub(super) root: ChildNodes<'on_disk>,
/// Number of nodes anywhere in the tree that have `.entry.is_some()`. /// Number of nodes anywhere in the tree that have `.entry.is_some()`.
pub(super) nodes_with_entry_count: u32, pub(super) nodes_with_entry_count: u32,
/// Number of nodes anywhere in the tree that have /// Number of nodes anywhere in the tree that have
/// `.copy_source.is_some()`. /// `.copy_source.is_some()`.
pub(super) nodes_with_copy_source_count: u32, pub(super) nodes_with_copy_source_count: u32,
/// See on_disk::Header
pub(super) ignore_patterns_hash: on_disk::IgnorePatternsHash,
} }
/// Using a plain `HgPathBuf` of the full path from the repository root as a /// Using a plain `HgPathBuf` of the full path from the repository root as a
/// map key would also work: all paths in a given map have the same parent /// map key would also work: all paths in a given map have the same parent
/// path, so comparing full paths gives the same result as comparing base /// path, so comparing full paths gives the same result as comparing base
/// names. However `HashMap` would waste time always re-hashing the same /// names. However `HashMap` would waste time always re-hashing the same
/// string prefix. /// string prefix.
pub(super) type NodeKey<'on_disk> = WithBasename<Cow<'on_disk, HgPath>>; pub(super) type NodeKey<'on_disk> = WithBasename<Cow<'on_disk, HgPath>>;
impl<'on_disk> DirstateMap<'on_disk> { impl<'on_disk> DirstateMap<'on_disk> {
pub(super) fn empty(on_disk: &'on_disk [u8]) -> Self { pub(super) fn empty(on_disk: &'on_disk [u8]) -> Self {
Self { Self {
on_disk, on_disk,
root: ChildNodes::default(), root: ChildNodes::default(),
nodes_with_entry_count: 0, nodes_with_entry_count: 0,
nodes_with_copy_source_count: 0, nodes_with_copy_source_count: 0,
ignore_patterns_hash: [0; on_disk::IGNORE_PATTERNS_HASH_LEN],
} }
} }
#[timed] #[timed]
pub fn new_v2( pub fn new_v2(
on_disk: &'on_disk [u8], on_disk: &'on_disk [u8],
) -> Result<(Self, Option<DirstateParents>), DirstateError> { ) -> Result<(Self, Option<DirstateParents>), DirstateError> {
Ok(on_disk::read(on_disk)?) Ok(on_disk::read(on_disk)?)

rust/hg-core/src/dirstate_tree/on_disk.rs

use std::convert::TryFrom; use std::convert::TryFrom;
use std::time::{Duration, SystemTime, UNIX_EPOCH}; use std::time::{Duration, SystemTime, UNIX_EPOCH};
/// Added at the start of `.hg/dirstate` when the "v2" format is used. /// Added at the start of `.hg/dirstate` when the "v2" format is used.
/// This a redundant sanity check more than an actual "magic number" since /// This a redundant sanity check more than an actual "magic number" since
/// `.hg/requires` already governs which format should be used. /// `.hg/requires` already governs which format should be used.
pub const V2_FORMAT_MARKER: &[u8; 12] = b"dirstate-v2\n"; pub const V2_FORMAT_MARKER: &[u8; 12] = b"dirstate-v2\n";
pub(super) const IGNORE_PATTERNS_HASH_LEN: usize = 20;
pub(super) type IgnorePatternsHash = [u8; IGNORE_PATTERNS_HASH_LEN];
#[derive(BytesCast)] #[derive(BytesCast)]
#[repr(C)] #[repr(C)]
struct Header { struct Header {
marker: [u8; V2_FORMAT_MARKER.len()], marker: [u8; V2_FORMAT_MARKER.len()],
/// `dirstatemap.parents()` in `mercurial/dirstate.py` relies on this /// `dirstatemap.parents()` in `mercurial/dirstate.py` relies on this
/// `parents` field being at this offset, immediately after `marker`. /// `parents` field being at this offset, immediately after `marker`.
parents: DirstateParents, parents: DirstateParents,
root: ChildNodes, root: ChildNodes,
nodes_with_entry_count: Size, nodes_with_entry_count: Size,
nodes_with_copy_source_count: Size, nodes_with_copy_source_count: Size,
/// If non-zero, a hash of ignore files that were used for some previous
/// run of the `status` algorithm.
///
/// We define:
///
/// * "Root" ignore files are `.hgignore` at the root of the repository if
/// it exists, and files from `ui.ignore.*` config. This set of files is
/// then sorted by the string representation of their path.
/// * The "expanded contents" of an ignore files is the byte string made
/// by concatenating its contents with the "expanded contents" of other
/// files included with `include:` or `subinclude:` files, in inclusion
/// order. This definition is recursive, as included files can
/// themselves include more files.
///
/// This hash is defined as the SHA-1 of the concatenation (in sorted
/// order) of the "expanded contents" of each "root" ignore file.
/// (Note that computing this does not require actually concatenating byte
/// strings into contiguous memory, instead SHA-1 hashing can be done
/// incrementally.)
ignore_patterns_hash: IgnorePatternsHash,
} }
#[derive(BytesCast)] #[derive(BytesCast)]
#[repr(C)] #[repr(C)]
pub(super) struct Node { pub(super) struct Node {
full_path: PathSlice, full_path: PathSlice,
/// In bytes from `self.full_path.start` /// In bytes from `self.full_path.start`
/// A `HgPath` of `len` bytes /// A `HgPath` of `len` bytes
type PathSlice = Slice; type PathSlice = Slice;
/// Either nothing if `start == 0`, or a `HgPath` of `len` bytes /// Either nothing if `start == 0`, or a `HgPath` of `len` bytes
type OptPathSlice = Slice; type OptPathSlice = Slice;
/// Make sure that size-affecting changes are made knowingly /// Make sure that size-affecting changes are made knowingly
fn _static_assert_size_of() { fn _static_assert_size_of() {
let _ = std::mem::transmute::<Header, [u8; 72]>; let _ = std::mem::transmute::<Header, [u8; 92]>;
let _ = std::mem::transmute::<Node, [u8; 57]>; let _ = std::mem::transmute::<Node, [u8; 57]>;
} }
/// Unexpected file format found in `.hg/dirstate` with the "v2" format. /// Unexpected file format found in `.hg/dirstate` with the "v2" format.
/// ///
/// This should only happen if Mercurial is buggy or a repository is corrupted. /// This should only happen if Mercurial is buggy or a repository is corrupted.
#[derive(Debug)] #[derive(Debug)]
pub struct DirstateV2ParseError; pub struct DirstateV2ParseError;
root: dirstate_map::ChildNodes::OnDisk(read_slice::<Node>( root: dirstate_map::ChildNodes::OnDisk(read_slice::<Node>(
on_disk, on_disk,
header.root, header.root,
)?), )?),
nodes_with_entry_count: header.nodes_with_entry_count.get(), nodes_with_entry_count: header.nodes_with_entry_count.get(),
nodes_with_copy_source_count: header nodes_with_copy_source_count: header
.nodes_with_copy_source_count .nodes_with_copy_source_count
.get(), .get(),
ignore_patterns_hash: header.ignore_patterns_hash,
}; };
let parents = Some(header.parents.clone()); let parents = Some(header.parents.clone());
Ok((dirstate_map, parents)) Ok((dirstate_map, parents))
} }
impl Node { impl Node {
pub(super) fn full_path<'on_disk>( pub(super) fn full_path<'on_disk>(
&self, &self,
let header = Header { let header = Header {
marker: *V2_FORMAT_MARKER, marker: *V2_FORMAT_MARKER,
parents: parents, parents: parents,
root, root,
nodes_with_entry_count: dirstate_map.nodes_with_entry_count.into(), nodes_with_entry_count: dirstate_map.nodes_with_entry_count.into(),
nodes_with_copy_source_count: dirstate_map nodes_with_copy_source_count: dirstate_map
.nodes_with_copy_source_count .nodes_with_copy_source_count
.into(), .into(),
ignore_patterns_hash: dirstate_map.ignore_patterns_hash,
}; };
out[..header_len].copy_from_slice(header.as_bytes()); out[..header_len].copy_from_slice(header.as_bytes());
Ok(out) Ok(out)
} }
fn write_nodes( fn write_nodes(
dirstate_map: &DirstateMap, dirstate_map: &DirstateMap,
nodes: dirstate_map::ChildNodesRef, nodes: dirstate_map::ChildNodesRef,

rust/hg-core/src/dirstate_tree/status.rs

use crate::DirstateStatus; use crate::DirstateStatus;
use crate::EntryState; use crate::EntryState;
use crate::HgPathBuf; use crate::HgPathBuf;
use crate::PatternFileWarning; use crate::PatternFileWarning;
use crate::StatusError; use crate::StatusError;
use crate::StatusOptions; use crate::StatusOptions;
use micro_timer::timed; use micro_timer::timed;
use rayon::prelude::*; use rayon::prelude::*;
use sha1::{Digest, Sha1};
use std::borrow::Cow; use std::borrow::Cow;
use std::io; use std::io;
use std::path::Path; use std::path::Path;
use std::path::PathBuf; use std::path::PathBuf;
use std::sync::Mutex; use std::sync::Mutex;
use std::time::SystemTime; use std::time::SystemTime;
/// Returns the status of the working directory compared to its parent /// Returns the status of the working directory compared to its parent
/// changeset. /// changeset.
/// ///
/// This algorithm is based on traversing the filesystem tree (`fs` in function /// This algorithm is based on traversing the filesystem tree (`fs` in function
/// and variable names) and dirstate tree at the same time. The core of this /// and variable names) and dirstate tree at the same time. The core of this
/// traversal is the recursive `traverse_fs_directory_and_dirstate` function /// traversal is the recursive `traverse_fs_directory_and_dirstate` function
/// and its use of `itertools::merge_join_by`. When reaching a path that only /// and its use of `itertools::merge_join_by`. When reaching a path that only
/// exists in one of the two trees, depending on information requested by /// exists in one of the two trees, depending on information requested by
/// `options` we may need to traverse the remaining subtree. /// `options` we may need to traverse the remaining subtree.
#[timed] #[timed]
pub fn status<'tree, 'on_disk: 'tree>( pub fn status<'tree, 'on_disk: 'tree>(
dmap: &'tree mut DirstateMap<'on_disk>, dmap: &'tree mut DirstateMap<'on_disk>,
matcher: &(dyn Matcher + Sync), matcher: &(dyn Matcher + Sync),
root_dir: PathBuf, root_dir: PathBuf,
ignore_files: Vec<PathBuf>, ignore_files: Vec<PathBuf>,
options: StatusOptions, options: StatusOptions,
) -> Result<(DirstateStatus<'on_disk>, Vec<PatternFileWarning>), StatusError> { ) -> Result<(DirstateStatus<'on_disk>, Vec<PatternFileWarning>), StatusError> {
let (ignore_fn, warnings): (IgnoreFnType, _) = let (ignore_fn, warnings, patterns_changed): (IgnoreFnType, _, _) =
if options.list_ignored || options.list_unknown { if options.list_ignored || options.list_unknown {
get_ignore_function(ignore_files, &root_dir)? let mut hasher = Sha1::new();
let (ignore_fn, warnings) = get_ignore_function(
ignore_files,
&root_dir,
&mut |pattern_bytes| hasher.update(pattern_bytes),
)?;
let new_hash = *hasher.finalize().as_ref();
let changed = new_hash != dmap.ignore_patterns_hash;
dmap.ignore_patterns_hash = new_hash;
(ignore_fn, warnings, Some(changed))
} else { } else {
(Box::new(|&_| true), vec![]) (Box::new(|&_| true), vec![], None)
}; };
let common = StatusCommon { let common = StatusCommon {
dmap, dmap,
options, options,
matcher, matcher,
ignore_fn, ignore_fn,
outcome: Default::default(), outcome: Default::default(),
cached_directory_mtimes_to_add: Default::default(), ignore_patterns_have_changed: patterns_changed,
new_cachable_directories: Default::default(),
filesystem_time_at_status_start: filesystem_now(&root_dir).ok(), filesystem_time_at_status_start: filesystem_now(&root_dir).ok(),
}; };
let is_at_repo_root = true; let is_at_repo_root = true;
let hg_path = &BorrowedPath::OnDisk(HgPath::new("")); let hg_path = &BorrowedPath::OnDisk(HgPath::new(""));
let has_ignored_ancestor = false; let has_ignored_ancestor = false;
let root_cached_mtime = None; let root_cached_mtime = None;
let root_dir_metadata = None; let root_dir_metadata = None;
// If the path we have for the repository root is a symlink, do follow it. // If the path we have for the repository root is a symlink, do follow it.
// (As opposed to symlinks within the working directory which are not // (As opposed to symlinks within the working directory which are not
// followed, using `std::fs::symlink_metadata`.) // followed, using `std::fs::symlink_metadata`.)
common.traverse_fs_directory_and_dirstate( common.traverse_fs_directory_and_dirstate(
has_ignored_ancestor, has_ignored_ancestor,
dmap.root.as_ref(), dmap.root.as_ref(),
hg_path, hg_path,
&root_dir, &root_dir,
root_dir_metadata, root_dir_metadata,
root_cached_mtime, root_cached_mtime,
is_at_repo_root, is_at_repo_root,
)?; )?;
let mut outcome = common.outcome.into_inner().unwrap(); let mut outcome = common.outcome.into_inner().unwrap();
let to_add = common.cached_directory_mtimes_to_add.into_inner().unwrap(); let new_cachable = common.new_cachable_directories.into_inner().unwrap();
outcome.dirty = !to_add.is_empty();
for (path, mtime) in &to_add { outcome.dirty = common.ignore_patterns_have_changed == Some(true)
|| !new_cachable.is_empty();
for (path, mtime) in &new_cachable {
let node = DirstateMap::get_or_insert_node( let node = DirstateMap::get_or_insert_node(
dmap.on_disk, dmap.on_disk,
&mut dmap.root, &mut dmap.root,
path, path,
WithBasename::to_cow_owned, WithBasename::to_cow_owned,
|_| {}, |_| {},
)?; )?;
match &node.data { match &node.data {
NodeData::Entry(_) => {} // Don’t overwrite an entry NodeData::Entry(_) => {} // Don’t overwrite an entry
NodeData::CachedDirectory { .. } | NodeData::None => { NodeData::CachedDirectory { .. } | NodeData::None => {
node.data = NodeData::CachedDirectory { mtime: *mtime } node.data = NodeData::CachedDirectory { mtime: *mtime }
} }
} }
} }
Ok((outcome, warnings)) Ok((outcome, warnings))
} }
/// Bag of random things needed by various parts of the algorithm. Reduces the /// Bag of random things needed by various parts of the algorithm. Reduces the
/// number of parameters passed to functions. /// number of parameters passed to functions.
struct StatusCommon<'a, 'tree, 'on_disk: 'tree> { struct StatusCommon<'a, 'tree, 'on_disk: 'tree> {
dmap: &'tree DirstateMap<'on_disk>, dmap: &'tree DirstateMap<'on_disk>,
options: StatusOptions, options: StatusOptions,
matcher: &'a (dyn Matcher + Sync), matcher: &'a (dyn Matcher + Sync),
ignore_fn: IgnoreFnType<'a>, ignore_fn: IgnoreFnType<'a>,
outcome: Mutex<DirstateStatus<'on_disk>>, outcome: Mutex<DirstateStatus<'on_disk>>,
cached_directory_mtimes_to_add: new_cachable_directories: Mutex<Vec<(Cow<'on_disk, HgPath>, Timestamp)>>,
Mutex<Vec<(Cow<'on_disk, HgPath>, Timestamp)>>,
/// Whether ignore files like `.hgignore` have changed since the previous
/// time a `status()` call wrote their hash to the dirstate. `None` means
/// we don’t know as this run doesn’t list either ignored or uknown files
/// and therefore isn’t reading `.hgignore`.
ignore_patterns_have_changed: Option<bool>,
/// The current time at the start of the `status()` algorithm, as measured /// The current time at the start of the `status()` algorithm, as measured
/// and possibly truncated by the filesystem. /// and possibly truncated by the filesystem.
filesystem_time_at_status_start: Option<SystemTime>, filesystem_time_at_status_start: Option<SystemTime>,
} }
impl<'a, 'tree, 'on_disk> StatusCommon<'a, 'tree, 'on_disk> { impl<'a, 'tree, 'on_disk> StatusCommon<'a, 'tree, 'on_disk> {
fn read_dir( fn read_dir(
// We deem this scenario (unlike the previous one) to be // We deem this scenario (unlike the previous one) to be
// unlikely enough in practice. // unlikely enough in practice.
let timestamp = directory_mtime.into(); let timestamp = directory_mtime.into();
let cached = dirstate_node.cached_directory_mtime(); let cached = dirstate_node.cached_directory_mtime();
if cached != Some(&timestamp) { if cached != Some(&timestamp) {
let hg_path = dirstate_node let hg_path = dirstate_node
.full_path_borrowed(self.dmap.on_disk)? .full_path_borrowed(self.dmap.on_disk)?
.detach_from_tree(); .detach_from_tree();
self.cached_directory_mtimes_to_add self.new_cachable_directories
.lock() .lock()
.unwrap() .unwrap()
.push((hg_path, timestamp)) .push((hg_path, timestamp))
} }
} }
} }
} }
Ok(()) Ok(())

rust/hg-core/src/filepatterns.rs

files::{canonical_path, get_bytes_from_path, get_path_from_bytes}, files::{canonical_path, get_bytes_from_path, get_path_from_bytes},
hg_path::{path_to_hg_path_buf, HgPathBuf, HgPathError}, hg_path::{path_to_hg_path_buf, HgPathBuf, HgPathError},
SliceExt, SliceExt,
}, },
FastHashMap, PatternError, FastHashMap, PatternError,
}; };
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::io::Read;
use std::ops::Deref; use std::ops::Deref;
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";
)); ));
} }
Ok((inputs, warnings)) Ok((inputs, warnings))
} }
pub fn read_pattern_file( pub fn read_pattern_file(
file_path: &Path, file_path: &Path,
warn: bool, warn: bool,
inspect_pattern_bytes: &mut impl FnMut(&[u8]),
) -> Result<(Vec<IgnorePattern>, Vec<PatternFileWarning>), PatternError> { ) -> Result<(Vec<IgnorePattern>, Vec<PatternFileWarning>), PatternError> {
let mut f = match File::open(file_path) { match std::fs::read(file_path) {
Ok(f) => Ok(f), Ok(contents) => {
Err(e) => match e.kind() { inspect_pattern_bytes(&contents);
std::io::ErrorKind::NotFound => { parse_pattern_file_contents(&contents, file_path, warn)
return Ok(( }
Err(e) if e.kind() == std::io::ErrorKind::NotFound => Ok((
vec![], vec![],
vec![PatternFileWarning::NoSuchFile(file_path.to_owned())], vec![PatternFileWarning::NoSuchFile(file_path.to_owned())],
)) )),
Err(e) => Err(e.into()),
} }
_ => Err(e),
},
}?;
let mut contents = Vec::new();
f.read_to_end(&mut contents)?;
Ok(parse_pattern_file_contents(&contents, file_path, warn)?)
} }
/// Represents an entry in an "ignore" file. /// Represents an entry in an "ignore" file.
#[derive(Debug, Eq, PartialEq, Clone)] #[derive(Debug, Eq, PartialEq, Clone)]
pub struct IgnorePattern { pub struct IgnorePattern {
pub syntax: PatternSyntax, pub syntax: PatternSyntax,
pub pattern: Vec<u8>, pub pattern: Vec<u8>,
pub source: PathBuf, pub source: PathBuf,
/// Wrapper for `read_pattern_file` that also recursively expands `include:` /// Wrapper for `read_pattern_file` that also recursively expands `include:`
/// and `subinclude:` patterns. /// and `subinclude:` patterns.
/// ///
/// The former are expanded in place, while `PatternSyntax::ExpandedSubInclude` /// The former are expanded in place, while `PatternSyntax::ExpandedSubInclude`
/// is used for the latter to form a tree of patterns. /// 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,
inspect_pattern_bytes: &mut impl FnMut(&[u8]),
) -> 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, inspect_pattern_bytes)?;
let patterns = patterns let patterns = patterns
.into_iter() .into_iter()
.flat_map(|entry| -> PatternResult<_> { .flat_map(|entry| -> PatternResult<_> {
Ok(match &entry.syntax { Ok(match &entry.syntax {
PatternSyntax::Include => { PatternSyntax::Include => {
let inner_include = let inner_include =
root_dir.join(get_path_from_bytes(&entry.pattern)); root_dir.join(get_path_from_bytes(&entry.pattern));
let (inner_pats, inner_warnings) = let (inner_pats, inner_warnings) = get_patterns_from_file(
get_patterns_from_file(&inner_include, root_dir)?; &inner_include,
root_dir,
inspect_pattern_bytes,
)?;
warnings.extend(inner_warnings); warnings.extend(inner_warnings);
inner_pats inner_pats
} }
PatternSyntax::SubInclude => { PatternSyntax::SubInclude => {
let mut sub_include = SubInclude::new( let mut sub_include = SubInclude::new(
&root_dir, &root_dir,
&entry.pattern, &entry.pattern,
&entry.source, &entry.source,
)?; )?;
let (inner_patterns, inner_warnings) = let (inner_patterns, inner_warnings) =
get_patterns_from_file( get_patterns_from_file(
&sub_include.path, &sub_include.path,
&sub_include.root, &sub_include.root,
inspect_pattern_bytes,
)?; )?;
sub_include.included_patterns = inner_patterns; sub_include.included_patterns = inner_patterns;
warnings.extend(inner_warnings); warnings.extend(inner_warnings);
vec![IgnorePattern { vec![IgnorePattern {
syntax: PatternSyntax::ExpandedSubInclude(Box::new( syntax: PatternSyntax::ExpandedSubInclude(Box::new(
sub_include, sub_include,
)), )),
..entry ..entry

rust/hg-core/src/matchers.rs

) )
}) })
} }
/// 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>, mut all_pattern_files: Vec<PathBuf>,
root_dir: &Path, root_dir: &Path,
inspect_pattern_bytes: &mut impl FnMut(&[u8]),
) -> 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![];
// Sort to make the ordering of calls to `inspect_pattern_bytes`
// deterministic even if the ordering of `all_pattern_files` is not (such
// as when a iteration order of a Python dict or Rust HashMap is involved).
// Sort by "string" representation instead of the default by component
// (with a Rust-specific definition of a component)
all_pattern_files
.sort_unstable_by(|a, b| a.as_os_str().cmp(b.as_os_str()));
for pattern_file in &all_pattern_files { for pattern_file in &all_pattern_files {
let (patterns, warnings) = let (patterns, warnings) = get_patterns_from_file(
get_patterns_from_file(pattern_file, root_dir)?; pattern_file,
root_dir,
inspect_pattern_bytes,
)?;
all_patterns.extend(patterns.to_owned()); all_patterns.extend(patterns.to_owned());
all_warnings.extend(warnings); all_warnings.extend(warnings);
} }
let matcher = IncludeMatcher::new(all_patterns)?; let matcher = IncludeMatcher::new(all_patterns)?;
Ok(( Ok((
Box::new(move |path: &HgPath| matcher.matches(path)), Box::new(move |path: &HgPath| matcher.matches(path)),
all_warnings, all_warnings,

tests/test-hgignore.t

$ rm dir1/.hgignore $ rm dir1/.hgignore
$ echo "dir1/file*" >> .hgignore $ echo "dir1/file*" >> .hgignore
$ hg debugignore "dir1\file2" $ hg debugignore "dir1\file2"
dir1/file2 is ignored dir1/file2 is ignored
(ignore rule in $TESTTMP\ignorerepo\.hgignore, line 4: 'dir1/file*') (ignore rule in $TESTTMP\ignorerepo\.hgignore, line 4: 'dir1/file*')
$ hg up -qC . $ hg up -qC .
#endif #endif
#if dirstate-v2
Check the hash of ignore patterns written in the dirstate at offset
12 + 20 + 20 + 8 + 4 + 4 + 4 = 72
$ hg status > /dev/null
$ cat .hg/testhgignore .hg/testhgignorerel .hgignore dir2/.hgignore dir1/.hgignore dir1/.hgignoretwo | $TESTDIR/f --sha1
sha1=6e315b60f15fb5dfa02be00f3e2c8f923051f5ff
>>> import binascii; print(binascii.hexlify(open(".hg/dirstate", "rb").read()[72:][:20]).decode())
6e315b60f15fb5dfa02be00f3e2c8f923051f5ff
$ echo rel > .hg/testhgignorerel
$ hg status > /dev/null
$ cat .hg/testhgignore .hg/testhgignorerel .hgignore dir2/.hgignore dir1/.hgignore dir1/.hgignoretwo | $TESTDIR/f --sha1
sha1=dea19cc7119213f24b6b582a4bae7b0cb063e34e
>>> import binascii; print(binascii.hexlify(open(".hg/dirstate", "rb").read()[72:][:20]).decode())
dea19cc7119213f24b6b582a4bae7b0cb063e34e
#endif