diff options
Diffstat (limited to 'vendor/gix-worktree/src')
25 files changed, 1857 insertions, 1282 deletions
diff --git a/vendor/gix-worktree/src/cache/delegate.rs b/vendor/gix-worktree/src/cache/delegate.rs new file mode 100644 index 000000000..90a141b0d --- /dev/null +++ b/vendor/gix-worktree/src/cache/delegate.rs @@ -0,0 +1,162 @@ +use crate::cache::State; +use crate::PathIdMapping; + +/// Various aggregate numbers related to the stack delegate itself. +#[derive(Default, Clone, Copy, Debug)] +#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))] +pub struct Statistics { + /// The amount of `std::fs::create_dir` calls. + /// + /// This only happens if we are in the respective mode to create leading directories efficiently. + pub num_mkdir_calls: usize, + /// Amount of calls to push a path element. + pub push_element: usize, + /// Amount of calls to push a directory. + pub push_directory: usize, + /// Amount of calls to pop a directory. + pub pop_directory: usize, +} + +pub(crate) struct StackDelegate<'a, Find> { + pub state: &'a mut State, + pub buf: &'a mut Vec<u8>, + pub is_dir: bool, + pub id_mappings: &'a Vec<PathIdMapping>, + pub find: Find, + pub case: gix_glob::pattern::Case, + pub statistics: &'a mut super::Statistics, +} + +impl<'a, Find, E> gix_fs::stack::Delegate for StackDelegate<'a, Find> +where + Find: for<'b> FnMut(&gix_hash::oid, &'b mut Vec<u8>) -> Result<gix_object::BlobRef<'b>, E>, + E: std::error::Error + Send + Sync + 'static, +{ + fn push_directory(&mut self, stack: &gix_fs::Stack) -> std::io::Result<()> { + self.statistics.delegate.push_directory += 1; + let dir_bstr = gix_path::into_bstr(stack.current()); + let mut rela_dir = gix_glob::search::pattern::strip_base_handle_recompute_basename_pos( + gix_path::into_bstr(stack.root()).as_ref(), + dir_bstr.as_ref(), + None, + self.case, + ) + .expect("dir in root") + .0; + if rela_dir.starts_with(b"/") { + rela_dir = &rela_dir[1..]; + } + match &mut self.state { + State::CreateDirectoryAndAttributesStack { attributes, .. } => { + attributes.push_directory( + stack.root(), + stack.current(), + rela_dir, + self.buf, + self.id_mappings, + &mut self.find, + &mut self.statistics.attributes, + )?; + } + State::AttributesAndIgnoreStack { ignore, attributes } => { + attributes.push_directory( + stack.root(), + stack.current(), + rela_dir, + self.buf, + self.id_mappings, + &mut self.find, + &mut self.statistics.attributes, + )?; + ignore.push_directory( + stack.root(), + stack.current(), + rela_dir, + self.buf, + self.id_mappings, + &mut self.find, + self.case, + &mut self.statistics.ignore, + )? + } + State::IgnoreStack(ignore) => ignore.push_directory( + stack.root(), + stack.current(), + rela_dir, + self.buf, + self.id_mappings, + &mut self.find, + self.case, + &mut self.statistics.ignore, + )?, + } + Ok(()) + } + + fn push(&mut self, is_last_component: bool, stack: &gix_fs::Stack) -> std::io::Result<()> { + self.statistics.delegate.push_element += 1; + match &mut self.state { + State::CreateDirectoryAndAttributesStack { + unlink_on_collision, + attributes: _, + } => create_leading_directory( + is_last_component, + stack, + self.is_dir, + &mut self.statistics.delegate.num_mkdir_calls, + *unlink_on_collision, + )?, + State::AttributesAndIgnoreStack { .. } | State::IgnoreStack(_) => {} + } + Ok(()) + } + + fn pop_directory(&mut self) { + self.statistics.delegate.pop_directory += 1; + match &mut self.state { + State::CreateDirectoryAndAttributesStack { attributes, .. } => { + attributes.pop_directory(); + } + State::AttributesAndIgnoreStack { attributes, ignore } => { + attributes.pop_directory(); + ignore.pop_directory(); + } + State::IgnoreStack(ignore) => { + ignore.pop_directory(); + } + } + } +} + +fn create_leading_directory( + is_last_component: bool, + stack: &gix_fs::Stack, + is_dir: bool, + mkdir_calls: &mut usize, + unlink_on_collision: bool, +) -> std::io::Result<()> { + if is_last_component && !is_dir { + return Ok(()); + } + *mkdir_calls += 1; + match std::fs::create_dir(stack.current()) { + Ok(()) => Ok(()), + Err(err) if err.kind() == std::io::ErrorKind::AlreadyExists => { + let meta = stack.current().symlink_metadata()?; + if meta.is_dir() { + Ok(()) + } else if unlink_on_collision { + if meta.file_type().is_symlink() { + gix_fs::symlink::remove(stack.current())?; + } else { + std::fs::remove_file(stack.current())?; + } + *mkdir_calls += 1; + std::fs::create_dir(stack.current()) + } else { + Err(err) + } + } + Err(err) => Err(err), + } +} diff --git a/vendor/gix-worktree/src/fs/cache/mod.rs b/vendor/gix-worktree/src/cache/mod.rs index 1f7710e59..7984b2c4c 100644 --- a/vendor/gix-worktree/src/fs/cache/mod.rs +++ b/vendor/gix-worktree/src/cache/mod.rs @@ -5,7 +5,21 @@ use bstr::{BStr, ByteSlice}; use gix_hash::oid; use super::Cache; -use crate::{fs, fs::PathOidMapping}; +use crate::PathIdMapping; + +/// Various aggregate numbers collected from when the corresponding [`Cache`] was instantiated. +#[derive(Default, Clone, Copy, Debug)] +#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))] +pub struct Statistics { + /// The amount of platforms created to do further matching. + pub platforms: usize, + /// Information about the stack delegate. + pub delegate: delegate::Statistics, + /// Information about attributes + pub attributes: state::attributes::Statistics, + /// Information about the ignore stack + pub ignore: state::ignore::Statistics, +} #[derive(Clone)] pub enum State { @@ -13,10 +27,6 @@ pub enum State { CreateDirectoryAndAttributesStack { /// If there is a symlink or a file in our path, try to unlink it before creating the directory. unlink_on_collision: bool, - - /// just for testing - #[cfg(debug_assertions)] - test_mkdir_calls: usize, /// State to handle attribute information attributes: state::Attributes, }, @@ -31,66 +41,47 @@ pub enum State { IgnoreStack(state::Ignore), } -#[cfg(debug_assertions)] -impl Cache { - pub fn set_case(&mut self, case: gix_glob::pattern::Case) { - self.case = case; - } - pub fn num_mkdir_calls(&self) -> usize { - match self.state { - State::CreateDirectoryAndAttributesStack { test_mkdir_calls, .. } => test_mkdir_calls, - _ => 0, - } - } - - pub fn reset_mkdir_calls(&mut self) { - if let State::CreateDirectoryAndAttributesStack { test_mkdir_calls, .. } = &mut self.state { - *test_mkdir_calls = 0; - } - } - - pub fn unlink_on_collision(&mut self, value: bool) { - if let State::CreateDirectoryAndAttributesStack { - unlink_on_collision, .. - } = &mut self.state - { - *unlink_on_collision = value; - } - } -} - #[must_use] pub struct Platform<'a> { parent: &'a Cache, is_dir: Option<bool>, } +/// Initialization impl Cache { - /// Create a new instance with `worktree_root` being the base for all future paths we handle, assuming it to be valid which includes - /// symbolic links to be included in it as well. - /// The `case` configures attribute and exclusion query case sensitivity. + /// Create a new instance with `worktree_root` being the base for all future paths we match. + /// `state` defines the capabilities of the cache. + /// The `case` configures attribute and exclusion case sensitivity at *query time*, which should match the case that + /// `state` might be configured with. + /// `buf` is used when reading files, and `id_mappings` should have been created with [State::id_mappings_from_index()]. pub fn new( worktree_root: impl Into<PathBuf>, state: State, case: gix_glob::pattern::Case, buf: Vec<u8>, - attribute_files_in_index: Vec<PathOidMapping>, + id_mappings: Vec<PathIdMapping>, ) -> Self { let root = worktree_root.into(); Cache { - stack: fs::Stack::new(root), + stack: gix_fs::Stack::new(root), state, case, buf, - attribute_files_in_index, + id_mappings, + statistics: Statistics::default(), } } +} - /// Append the `relative` path to the root directory the cache contains and efficiently create leading directories - /// unless `is_dir` is known (`Some(…)`) then `relative` points to a directory itself in which case the entire resulting +/// Entry points for attribute query +impl Cache { + /// Append the `relative` path to the root directory of the cache and efficiently create leading directories, while assuring that no + /// symlinks are in that path. + /// Unless `is_dir` is known with `Some(…)`, then `relative` points to a directory itself in which case the entire resulting /// path is created as directory. If it's not known it is assumed to be a file. + /// `find` maybe used to lookup objects from an [id mapping][crate::cache::State::id_mappings_from_index()], with mappnigs /// - /// Provide access to cached information for that `relative` entry via the platform returned. + /// Provide access to cached information for that `relative` path via the returned platform. pub fn at_path<Find, E>( &mut self, relative: impl AsRef<Path>, @@ -101,19 +92,30 @@ impl Cache { Find: for<'a> FnMut(&oid, &'a mut Vec<u8>) -> Result<gix_object::BlobRef<'a>, E>, E: std::error::Error + Send + Sync + 'static, { - let mut delegate = platform::StackDelegate { + self.statistics.platforms += 1; + let mut delegate = StackDelegate { state: &mut self.state, buf: &mut self.buf, is_dir: is_dir.unwrap_or(false), - attribute_files_in_index: &self.attribute_files_in_index, + id_mappings: &self.id_mappings, find, + case: self.case, + statistics: &mut self.statistics, }; self.stack.make_relative_path_current(relative, &mut delegate)?; Ok(Platform { parent: self, is_dir }) } - /// **Panics** on illformed UTF8 in `relative` - // TODO: more docs + /// Obtain a platform for lookups from a repo-`relative` path, typically obtained from an index entry. `is_dir` should reflect + /// whether it's a directory or not, or left at `None` if unknown. + /// `find` maybe used to lookup objects from an [id mapping][crate::cache::State::id_mappings_from_index()]. + /// All effects are similar to [`at_path()`][Self::at_path()]. + /// + /// If `relative` ends with `/` and `is_dir` is `None`, it is automatically assumed to be a directory. + /// + /// ### Panics + /// + /// on illformed UTF8 in `relative` pub fn at_entry<'r, Find, E>( &mut self, relative: impl Into<&'r BStr>, @@ -130,10 +132,34 @@ impl Cache { self.at_path( relative_path, is_dir.or_else(|| relative.ends_with_str("/").then_some(true)), - // is_dir, find, ) } +} + +/// Mutation +impl Cache { + /// Reset the statistics after returning them. + pub fn take_statistics(&mut self) -> Statistics { + std::mem::take(&mut self.statistics) + } + + /// Return our state for applying changes. + pub fn state_mut(&mut self) -> &mut State { + &mut self.state + } +} + +/// Access +impl Cache { + /// Return the statistics we gathered thus far. + pub fn statistics(&self) -> &Statistics { + &self.statistics + } + /// Return the state for introspection. + pub fn state(&self) -> &State { + &self.state + } /// Return the base path against which all entries or paths should be relative to when querying. /// @@ -143,6 +169,10 @@ impl Cache { } } +/// +pub mod delegate; +use delegate::StackDelegate; + mod platform; /// pub mod state; diff --git a/vendor/gix-worktree/src/cache/platform.rs b/vendor/gix-worktree/src/cache/platform.rs new file mode 100644 index 000000000..f52b53205 --- /dev/null +++ b/vendor/gix-worktree/src/cache/platform.rs @@ -0,0 +1,55 @@ +use std::path::Path; + +use bstr::ByteSlice; + +use crate::cache::Platform; + +/// Access +impl<'a> Platform<'a> { + /// The full path to `relative` will be returned for use on the file system. + pub fn path(&self) -> &'a Path { + self.parent.stack.current() + } + + /// See if the currently set entry is excluded as per exclude and git-ignore files. + /// + /// # Panics + /// + /// If the cache was configured without exclude patterns. + pub fn is_excluded(&self) -> bool { + self.matching_exclude_pattern() + .map_or(false, |m| !m.pattern.is_negative()) + } + + /// Check all exclude patterns to see if the currently set path matches any of them. + /// + /// Note that this pattern might be negated, and means this path in included. + /// + /// # Panics + /// + /// If the cache was configured without exclude patterns. + pub fn matching_exclude_pattern(&self) -> Option<gix_ignore::search::Match<'_, ()>> { + let ignore = self.parent.state.ignore_or_panic(); + let relative_path = + gix_path::to_unix_separators_on_windows(gix_path::into_bstr(self.parent.stack.current_relative())); + ignore.matching_exclude_pattern(relative_path.as_bstr(), self.is_dir, self.parent.case) + } + + /// Match all attributes at the current path and store the result in `out`, returning `true` if at least one attribute was found. + /// + /// # Panics + /// + /// If the cache was configured without attributes. + pub fn matching_attributes(&self, out: &mut gix_attributes::search::Outcome) -> bool { + let attrs = self.parent.state.attributes_or_panic(); + let relative_path = + gix_path::to_unix_separators_on_windows(gix_path::into_bstr(self.parent.stack.current_relative())); + attrs.matching_attributes(relative_path.as_bstr(), self.parent.case, out) + } +} + +impl<'a> std::fmt::Debug for Platform<'a> { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + std::fmt::Debug::fmt(&self.path(), f) + } +} diff --git a/vendor/gix-worktree/src/cache/state/attributes.rs b/vendor/gix-worktree/src/cache/state/attributes.rs new file mode 100644 index 000000000..64316b35b --- /dev/null +++ b/vendor/gix-worktree/src/cache/state/attributes.rs @@ -0,0 +1,201 @@ +use std::path::{Path, PathBuf}; + +use crate::{Cache, PathIdMapping}; +use gix_glob::pattern::Case; + +use crate::cache::state::{AttributeMatchGroup, Attributes}; +use bstr::{BStr, ByteSlice}; + +/// Various aggregate numbers related [`Attributes`]. +#[derive(Default, Clone, Copy, Debug)] +#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))] +pub struct Statistics { + /// Amount of patterns buffers read from the index. + pub patterns_buffers: usize, + /// Amount of pattern files read from disk. + pub pattern_files: usize, + /// Amount of pattern files we tried to find on disk. + pub tried_pattern_files: usize, +} + +/// Decide where to read `.gitattributes` files from. +#[derive(Default, Debug, Clone, Copy)] +pub enum Source { + /// Retrieve attribute files from id mappings, see + /// [State::id_mappings_from_index()][crate::cache::State::id_mappings_from_index()]. + /// + /// These mappings are typically produced from an index. + /// If a tree should be the source, build an attribute list from a tree instead, or convert a tree to an index. + /// + /// Use this when no worktree checkout is available, like in bare repositories or when accessing blobs from other parts + /// of the history which aren't checked out. + #[default] + IdMapping, + /// Read from an id mappings and if not present, read from the worktree. + /// + /// This us typically used when *checking out* files. + IdMappingThenWorktree, + /// Read from the worktree and if not present, read them from the id mappings. + /// + /// This is typically used when *checking in* files, and it's possible for sparse worktrees not to have a `.gitattribute` file + /// checked out even though it's available in the index. + WorktreeThenIdMapping, +} + +/// Initialization +impl Attributes { + /// Create a new instance from an attribute match group that represents `globals`. It can more easily be created with + /// [AttributeMatchGroup::new_globals()]. + /// + /// * `globals` contribute first and consist of all globally available, static files. + /// * `info_attributes` is a path that should refer to `.git/info/attributes`, and it's not an error if the file doesn't exist. + /// * `case` is used to control case-sensitivity during matching. + /// * `source` specifies from where the directory-based attribute files should be loaded from. + pub fn new( + globals: AttributeMatchGroup, + info_attributes: Option<PathBuf>, + source: Source, + collection: gix_attributes::search::MetadataCollection, + ) -> Self { + Attributes { + globals, + stack: Default::default(), + info_attributes, + source, + collection, + } + } +} + +impl Attributes { + pub(crate) fn pop_directory(&mut self) { + self.stack.pop_pattern_list().expect("something to pop"); + } + + #[allow(clippy::too_many_arguments)] + pub(crate) fn push_directory<Find, E>( + &mut self, + root: &Path, + dir: &Path, + rela_dir: &BStr, + buf: &mut Vec<u8>, + id_mappings: &[PathIdMapping], + mut find: Find, + stats: &mut Statistics, + ) -> std::io::Result<()> + where + Find: for<'b> FnMut(&gix_hash::oid, &'b mut Vec<u8>) -> Result<gix_object::BlobRef<'b>, E>, + E: std::error::Error + Send + Sync + 'static, + { + let attr_path_relative = + gix_path::to_unix_separators_on_windows(gix_path::join_bstr_unix_pathsep(rela_dir, ".gitattributes")); + let attr_file_in_index = id_mappings.binary_search_by(|t| t.0.as_bstr().cmp(attr_path_relative.as_ref())); + // Git does not follow symbolic links as per documentation. + let no_follow_symlinks = false; + + let mut added = false; + match self.source { + Source::IdMapping | Source::IdMappingThenWorktree => { + if let Ok(idx) = attr_file_in_index { + let blob = find(&id_mappings[idx].1, buf) + .map_err(|err| std::io::Error::new(std::io::ErrorKind::Other, err))?; + let attr_path = gix_path::from_bstring(attr_path_relative.into_owned()); + self.stack + .add_patterns_buffer(blob.data, attr_path, Some(Path::new("")), &mut self.collection); + added = true; + stats.patterns_buffers += 1; + } + if !added && matches!(self.source, Source::IdMappingThenWorktree) { + added = self.stack.add_patterns_file( + dir.join(".gitattributes"), + no_follow_symlinks, + Some(root), + buf, + &mut self.collection, + )?; + stats.pattern_files += usize::from(added); + stats.tried_pattern_files += 1; + } + } + Source::WorktreeThenIdMapping => { + added = self.stack.add_patterns_file( + dir.join(".gitattributes"), + no_follow_symlinks, + Some(root), + buf, + &mut self.collection, + )?; + stats.pattern_files += usize::from(added); + stats.tried_pattern_files += 1; + if let Some(idx) = attr_file_in_index.ok().filter(|_| !added) { + let blob = find(&id_mappings[idx].1, buf) + .map_err(|err| std::io::Error::new(std::io::ErrorKind::Other, err))?; + let attr_path = gix_path::from_bstring(attr_path_relative.into_owned()); + self.stack + .add_patterns_buffer(blob.data, attr_path, Some(Path::new("")), &mut self.collection); + added = true; + stats.patterns_buffers += 1; + } + } + } + + // Need one stack level per component so push and pop matches, but only if this isn't the root level which is never popped. + if !added && self.info_attributes.is_none() { + self.stack + .add_patterns_buffer(&[], Path::new("<empty dummy>"), None, &mut self.collection) + } + + // When reading the root, always the first call, we can try to also read the `.git/info/attributes` file which is + // by nature never popped, and follows the root, as global. + if let Some(info_attr) = self.info_attributes.take() { + let added = self + .stack + .add_patterns_file(info_attr, true, None, buf, &mut self.collection)?; + stats.pattern_files += usize::from(added); + stats.tried_pattern_files += 1; + } + + Ok(()) + } + + pub(crate) fn matching_attributes( + &self, + relative_path: &BStr, + case: Case, + out: &mut gix_attributes::search::Outcome, + ) -> bool { + // assure `out` is ready to deal with possibly changed collections (append-only) + out.initialize(&self.collection); + + let groups = [&self.globals, &self.stack]; + let mut has_match = false; + groups.iter().rev().any(|group| { + has_match |= group.pattern_matching_relative_path(relative_path, case, out); + out.is_done() + }); + has_match + } +} + +/// Attribute matching specific methods +impl Cache { + /// Creates a new container to store match outcomes for all attribute matches. + pub fn attribute_matches(&self) -> gix_attributes::search::Outcome { + let mut out = gix_attributes::search::Outcome::default(); + out.initialize(&self.state.attributes_or_panic().collection); + out + } + + /// Creates a new container to store match outcomes for the given attributes. + pub fn selected_attribute_matches<'a>( + &self, + given: impl IntoIterator<Item = impl Into<&'a str>>, + ) -> gix_attributes::search::Outcome { + let mut out = gix_attributes::search::Outcome::default(); + out.initialize_with_selection( + &self.state.attributes_or_panic().collection, + given.into_iter().map(|n| n.into()), + ); + out + } +} diff --git a/vendor/gix-worktree/src/cache/state/ignore.rs b/vendor/gix-worktree/src/cache/state/ignore.rs new file mode 100644 index 000000000..5ff4ccd42 --- /dev/null +++ b/vendor/gix-worktree/src/cache/state/ignore.rs @@ -0,0 +1,216 @@ +use std::path::Path; + +use crate::cache::state::Ignore; +use crate::{cache::state::IgnoreMatchGroup, PathIdMapping}; +use bstr::{BStr, ByteSlice}; +use gix_glob::pattern::Case; + +/// Decide where to read `.gitignore` files from. +#[derive(Default, Debug, Clone, Copy)] +pub enum Source { + /// Retrieve ignore files from id mappings, see + /// [State::id_mappings_from_index()][crate::cache::State::id_mappings_from_index()]. + /// + /// These mappings are typically produced from an index. + /// If a tree should be the source, build an attribute list from a tree instead, or convert a tree to an index. + /// + /// Use this when no worktree checkout is available, like in bare repositories or when accessing blobs from other parts + /// of the history which aren't checked out. + IdMapping, + /// Read from the worktree and if not present, read them from the id mappings *if* these don't have the skip-worktree bit set. + #[default] + WorktreeThenIdMappingIfNotSkipped, +} + +/// Various aggregate numbers related [`Ignore`]. +#[derive(Default, Clone, Copy, Debug)] +#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))] +pub struct Statistics { + /// Amount of patterns buffers read from the index. + pub patterns_buffers: usize, + /// Amount of pattern files read from disk. + pub pattern_files: usize, + /// Amount of pattern files we tried to find on disk. + pub tried_pattern_files: usize, +} + +impl Ignore { + /// Configure gitignore file matching by providing the immutable groups being `overrides` and `globals`, while letting the directory + /// stack be dynamic. + /// + /// The `exclude_file_name_for_directories` is an optional override for the filename to use when checking per-directory + /// ignore files within the repository, defaults to`.gitignore`. + pub fn new( + overrides: IgnoreMatchGroup, + globals: IgnoreMatchGroup, + exclude_file_name_for_directories: Option<&BStr>, + source: Source, + ) -> Self { + Ignore { + overrides, + globals, + stack: Default::default(), + matched_directory_patterns_stack: Vec::with_capacity(6), + exclude_file_name_for_directories: exclude_file_name_for_directories + .map(ToOwned::to_owned) + .unwrap_or_else(|| ".gitignore".into()), + source, + } + } +} + +impl Ignore { + pub(crate) fn pop_directory(&mut self) { + self.matched_directory_patterns_stack.pop().expect("something to pop"); + self.stack.patterns.pop().expect("something to pop"); + } + /// The match groups from lowest priority to highest. + pub(crate) fn match_groups(&self) -> [&IgnoreMatchGroup; 3] { + [&self.globals, &self.stack, &self.overrides] + } + + pub(crate) fn matching_exclude_pattern( + &self, + relative_path: &BStr, + is_dir: Option<bool>, + case: Case, + ) -> Option<gix_ignore::search::Match<'_, ()>> { + let groups = self.match_groups(); + let mut dir_match = None; + if let Some((source, mapping)) = self + .matched_directory_patterns_stack + .iter() + .rev() + .filter_map(|v| *v) + .map(|(gidx, plidx, pidx)| { + let list = &groups[gidx].patterns[plidx]; + (list.source.as_deref(), &list.patterns[pidx]) + }) + .next() + { + let match_ = gix_ignore::search::Match { + pattern: &mapping.pattern, + value: &mapping.value, + sequence_number: mapping.sequence_number, + source, + }; + if mapping.pattern.is_negative() { + dir_match = Some(match_); + } else { + // Note that returning here is wrong if this pattern _was_ preceded by a negative pattern that + // didn't match the directory, but would match now. + // Git does it similarly so we do too even though it's incorrect. + // To fix this, one would probably keep track of whether there was a preceding negative pattern, and + // if so we check the path in full and only use the dir match if there was no match, similar to the negative + // case above whose fix fortunately won't change the overall result. + return match_.into(); + } + } + groups + .iter() + .rev() + .find_map(|group| group.pattern_matching_relative_path(relative_path, is_dir, case)) + .or(dir_match) + } + + /// Like `matching_exclude_pattern()` but without checking if the current directory is excluded. + /// It returns a triple-index into our data structure from which a match can be reconstructed. + pub(crate) fn matching_exclude_pattern_no_dir( + &self, + relative_path: &BStr, + is_dir: Option<bool>, + case: Case, + ) -> Option<(usize, usize, usize)> { + let groups = self.match_groups(); + groups.iter().enumerate().rev().find_map(|(gidx, group)| { + let basename_pos = relative_path.rfind(b"/").map(|p| p + 1); + group + .patterns + .iter() + .enumerate() + .rev() + .find_map(|(plidx, pl)| { + gix_ignore::search::pattern_idx_matching_relative_path( + pl, + relative_path, + basename_pos, + is_dir, + case, + ) + .map(|idx| (plidx, idx)) + }) + .map(|(plidx, pidx)| (gidx, plidx, pidx)) + }) + } + + #[allow(clippy::too_many_arguments)] + pub(crate) fn push_directory<Find, E>( + &mut self, + root: &Path, + dir: &Path, + rela_dir: &BStr, + buf: &mut Vec<u8>, + id_mappings: &[PathIdMapping], + mut find: Find, + case: Case, + stats: &mut Statistics, + ) -> std::io::Result<()> + where + Find: for<'b> FnMut(&gix_hash::oid, &'b mut Vec<u8>) -> Result<gix_object::BlobRef<'b>, E>, + E: std::error::Error + Send + Sync + 'static, + { + self.matched_directory_patterns_stack + .push(self.matching_exclude_pattern_no_dir(rela_dir, Some(true), case)); + + let ignore_path_relative = + gix_path::to_unix_separators_on_windows(gix_path::join_bstr_unix_pathsep(rela_dir, ".gitignore")); + let ignore_file_in_index = id_mappings.binary_search_by(|t| t.0.as_bstr().cmp(ignore_path_relative.as_ref())); + match self.source { + Source::IdMapping => { + match ignore_file_in_index { + Ok(idx) => { + let ignore_blob = find(&id_mappings[idx].1, buf) + .map_err(|err| std::io::Error::new(std::io::ErrorKind::Other, err))?; + let ignore_path = gix_path::from_bstring(ignore_path_relative.into_owned()); + self.stack + .add_patterns_buffer(ignore_blob.data, ignore_path, Some(Path::new(""))); + stats.patterns_buffers += 1; + } + Err(_) => { + // Need one stack level per component so push and pop matches. + self.stack.patterns.push(Default::default()) + } + } + } + Source::WorktreeThenIdMappingIfNotSkipped => { + let follow_symlinks = ignore_file_in_index.is_err(); + let added = gix_glob::search::add_patterns_file( + &mut self.stack.patterns, + dir.join(".gitignore"), + follow_symlinks, + Some(root), + buf, + )?; + stats.pattern_files += usize::from(added); + stats.tried_pattern_files += 1; + if !added { + match ignore_file_in_index { + Ok(idx) => { + let ignore_blob = find(&id_mappings[idx].1, buf) + .map_err(|err| std::io::Error::new(std::io::ErrorKind::Other, err))?; + let ignore_path = gix_path::from_bstring(ignore_path_relative.into_owned()); + self.stack + .add_patterns_buffer(ignore_blob.data, ignore_path, Some(Path::new(""))); + stats.patterns_buffers += 1; + } + Err(_) => { + // Need one stack level per component so push and pop matches. + self.stack.patterns.push(Default::default()) + } + } + } + } + } + Ok(()) + } +} diff --git a/vendor/gix-worktree/src/cache/state/mod.rs b/vendor/gix-worktree/src/cache/state/mod.rs new file mode 100644 index 000000000..ae2c6bafd --- /dev/null +++ b/vendor/gix-worktree/src/cache/state/mod.rs @@ -0,0 +1,177 @@ +use std::path::PathBuf; + +use bstr::{BString, ByteSlice}; +use gix_glob::pattern::Case; + +use crate::{cache::State, PathIdMapping}; + +type AttributeMatchGroup = gix_attributes::Search; +type IgnoreMatchGroup = gix_ignore::Search; + +/// State related to attributes associated with files in the repository. +#[derive(Default, Clone)] +pub struct Attributes { + /// Attribute patterns which aren't tied to the repository root, hence are global, they contribute first. + globals: AttributeMatchGroup, + /// Attribute patterns that match the currently set directory (in the stack). + /// + /// Note that the root-level file is always loaded, if present, followed by, the `$GIT_DIR/info/attributes`, if present, based + /// on the location of the `info_attributes` file. + stack: AttributeMatchGroup, + /// The first time we push the root, we have to load additional information from this file if it exists along with the root attributes + /// file if possible, and keep them there throughout. + info_attributes: Option<PathBuf>, + /// A lookup table to accelerate searches. + collection: gix_attributes::search::MetadataCollection, + /// Where to read `.gitattributes` data from. + source: attributes::Source, +} + +/// State related to the exclusion of files, supporting static overrides and globals, along with a stack of dynamically read +/// ignore files from disk or from the index each time the directory changes. +#[derive(Default, Clone)] +#[allow(unused)] +pub struct Ignore { + /// Ignore patterns passed as overrides to everything else, typically passed on the command-line and the first patterns to + /// be consulted. + overrides: IgnoreMatchGroup, + /// Ignore patterns that match the currently set director (in the stack), which is pushed and popped as needed. + stack: IgnoreMatchGroup, + /// Ignore patterns which aren't tied to the repository root, hence are global. They are consulted last. + globals: IgnoreMatchGroup, + /// A matching stack of pattern indices which is empty if we have just been initialized to indicate that the + /// currently set directory had a pattern matched. Note that this one could be negated. + /// (index into match groups, index into list of pattern lists, index into pattern list) + matched_directory_patterns_stack: Vec<Option<(usize, usize, usize)>>, + /// The name of the file to look for in directories. + pub(crate) exclude_file_name_for_directories: BString, + /// Where to read ignore files from + source: ignore::Source, +} + +/// +pub mod attributes; +/// +pub mod ignore; + +/// Initialization +impl State { + /// Configure a state to be suitable for checking out files, which only needs access to attribute files read from the index. + pub fn for_checkout(unlink_on_collision: bool, attributes: Attributes) -> Self { + State::CreateDirectoryAndAttributesStack { + unlink_on_collision, + attributes, + } + } + + /// Configure a state for adding files, with support for ignore files and attribute files. + pub fn for_add(attributes: Attributes, ignore: Ignore) -> Self { + State::AttributesAndIgnoreStack { attributes, ignore } + } + + /// Configure a state for status retrieval, which needs access to ignore files only. + pub fn for_status(ignore: Ignore) -> Self { + State::IgnoreStack(ignore) + } +} + +/// Utilities +impl State { + /// Returns a vec of tuples of relative index paths along with the best usable blob OID for + /// either *ignore* or *attribute* files or both. This allows files to be accessed directly from + /// the object database without the need for a worktree checkout. + /// + /// Note that this method… + /// - ignores entries which aren't blobs. + /// - ignores ignore entries which are not skip-worktree. + /// - within merges, picks 'our' stage both for *ignore* and *attribute* files. + /// + /// * `index` is where we look for suitable files by path in order to obtain their blob hash. + /// * `paths` is the indices storage backend for paths. + /// * `case` determines if the search for files should be case-sensitive or not. + pub fn id_mappings_from_index( + &self, + index: &gix_index::State, + paths: &gix_index::PathStorageRef, + ignore_source: ignore::Source, + case: Case, + ) -> Vec<PathIdMapping> { + let a1_backing; + let a2_backing; + let names = match self { + State::IgnoreStack(v) => { + a1_backing = [(v.exclude_file_name_for_directories.as_bytes().as_bstr(), true)]; + a1_backing.as_ref() + } + State::AttributesAndIgnoreStack { ignore, .. } => { + a2_backing = [ + (ignore.exclude_file_name_for_directories.as_bytes().as_bstr(), true), + (".gitattributes".into(), false), + ]; + a2_backing.as_ref() + } + State::CreateDirectoryAndAttributesStack { .. } => { + a1_backing = [(".gitattributes".into(), true)]; + a1_backing.as_ref() + } + }; + + index + .entries() + .iter() + .filter_map(move |entry| { + let path = entry.path_in(paths); + + // Stage 0 means there is no merge going on, stage 2 means it's 'our' side of the merge, but then + // there won't be a stage 0. + if entry.mode == gix_index::entry::Mode::FILE && (entry.stage() == 0 || entry.stage() == 2) { + let basename = path + .rfind_byte(b'/') + .map(|pos| path[pos + 1..].as_bstr()) + .unwrap_or(path); + let is_ignore = names.iter().find_map(|t| { + match case { + Case::Sensitive => basename == t.0, + Case::Fold => basename.eq_ignore_ascii_case(t.0), + } + .then_some(t.1) + })?; + if is_ignore { + match ignore_source { + ignore::Source::IdMapping => {} + ignore::Source::WorktreeThenIdMappingIfNotSkipped => { + // See https://github.com/git/git/blob/master/dir.c#L912:L912 + if !entry.flags.contains(gix_index::entry::Flags::SKIP_WORKTREE) { + return None; + } + } + }; + } + Some((path.to_owned(), entry.id)) + } else { + None + } + }) + .collect() + } + + pub(crate) fn ignore_or_panic(&self) -> &Ignore { + match self { + State::IgnoreStack(v) => v, + State::AttributesAndIgnoreStack { ignore, .. } => ignore, + State::CreateDirectoryAndAttributesStack { .. } => { + unreachable!("BUG: must not try to check excludes without it being setup") + } + } + } + + pub(crate) fn attributes_or_panic(&self) -> &Attributes { + match self { + State::AttributesAndIgnoreStack { attributes, .. } + | State::CreateDirectoryAndAttributesStack { attributes, .. } => attributes, + State::IgnoreStack(_) => { + unreachable!("BUG: must not try to check excludes without it being setup") + } + } + } +} diff --git a/vendor/gix-worktree/src/checkout/chunk.rs b/vendor/gix-worktree/src/checkout/chunk.rs new file mode 100644 index 000000000..9de9e424e --- /dev/null +++ b/vendor/gix-worktree/src/checkout/chunk.rs @@ -0,0 +1,182 @@ +use std::sync::atomic::{AtomicUsize, Ordering}; + +use bstr::BStr; +use gix_features::progress::Progress; +use gix_hash::oid; + +use crate::{checkout, checkout::entry, Cache}; + +mod reduce { + use std::{ + marker::PhantomData, + sync::atomic::{AtomicUsize, Ordering}, + }; + + use gix_features::progress::Progress; + + use crate::checkout; + + pub struct Reduce<'a, 'entry, P1, P2, E> { + pub files: &'a mut P1, + pub bytes: &'a mut P2, + pub num_files: &'a AtomicUsize, + pub aggregate: super::Outcome<'entry>, + pub marker: PhantomData<E>, + } + + impl<'a, 'entry, P1, P2, E> gix_features::parallel::Reduce for Reduce<'a, 'entry, P1, P2, E> + where + P1: Progress, + P2: Progress, + E: std::error::Error + Send + Sync + 'static, + { + type Input = Result<super::Outcome<'entry>, checkout::Error<E>>; + type FeedProduce = (); + type Output = super::Outcome<'entry>; + type Error = checkout::Error<E>; + + fn feed(&mut self, item: Self::Input) -> Result<Self::FeedProduce, Self::Error> { + let item = item?; + let super::Outcome { + bytes_written, + delayed, + errors, + collisions, + } = item; + self.aggregate.bytes_written += bytes_written; + self.aggregate.delayed.extend(delayed); + self.aggregate.errors.extend(errors); + self.aggregate.collisions.extend(collisions); + + self.bytes.set(self.aggregate.bytes_written as usize); + self.files.set(self.num_files.load(Ordering::Relaxed)); + + Ok(()) + } + + fn finalize(self) -> Result<Self::Output, Self::Error> { + Ok(self.aggregate) + } + } +} +pub use reduce::Reduce; + +#[derive(Default)] +pub struct Outcome<'a> { + pub collisions: Vec<checkout::Collision>, + pub errors: Vec<checkout::ErrorRecord>, + pub delayed: Vec<(&'a mut gix_index::Entry, &'a BStr)>, + pub bytes_written: u64, +} + +#[derive(Clone)] +pub struct Context<'a, Find: Clone> { + pub find: Find, + pub path_cache: Cache, + pub buf: Vec<u8>, + pub options: checkout::Options, + /// We keep these shared so that there is the chance for printing numbers that aren't looking like + /// multiple of chunk sizes. Purely cosmetic. Otherwise it's the same as `files`. + pub num_files: &'a AtomicUsize, +} + +pub fn process<'entry, Find, E>( + entries_with_paths: impl Iterator<Item = (&'entry mut gix_index::Entry, &'entry BStr)>, + files: &mut impl Progress, + bytes: &mut impl Progress, + ctx: &mut Context<'_, Find>, +) -> Result<Outcome<'entry>, checkout::Error<E>> +where + Find: for<'a> FnMut(&oid, &'a mut Vec<u8>) -> Result<gix_object::BlobRef<'a>, E> + Clone, + E: std::error::Error + Send + Sync + 'static, +{ + let mut delayed = Vec::new(); + let mut collisions = Vec::new(); + let mut errors = Vec::new(); + let mut bytes_written = 0; + + for (entry, entry_path) in entries_with_paths { + // TODO: write test for that + if entry.flags.contains(gix_index::entry::Flags::SKIP_WORKTREE) { + files.inc(); + continue; + } + + // Symlinks always have to be delayed on windows as they have to point to something that exists on creation. + // And even if not, there is a distinction between file and directory symlinks, hence we have to check what the target is + // before creating it. + // And to keep things sane, we just do the same on non-windows as well which is similar to what git does and adds some safety + // around writing through symlinks (even though we handle this). + // This also means that we prefer content in files over symlinks in case of collisions, which probably is for the better, too. + if entry.mode == gix_index::entry::Mode::SYMLINK { + delayed.push((entry, entry_path)); + continue; + } + + bytes_written += + checkout_entry_handle_result(entry, entry_path, &mut errors, &mut collisions, files, bytes, ctx)? as u64; + } + + Ok(Outcome { + bytes_written, + errors, + collisions, + delayed, + }) +} + +pub fn checkout_entry_handle_result<Find, E>( + entry: &mut gix_index::Entry, + entry_path: &BStr, + errors: &mut Vec<checkout::ErrorRecord>, + collisions: &mut Vec<checkout::Collision>, + files: &mut impl Progress, + bytes: &mut impl Progress, + Context { + find, + path_cache, + buf, + options, + num_files, + }: &mut Context<'_, Find>, +) -> Result<usize, checkout::Error<E>> +where + Find: for<'a> FnMut(&oid, &'a mut Vec<u8>) -> Result<gix_object::BlobRef<'a>, E> + Clone, + E: std::error::Error + Send + Sync + 'static, +{ + let res = entry::checkout( + entry, + entry_path, + entry::Context { find, path_cache, buf }, + options.clone(), + ); + files.inc(); + num_files.fetch_add(1, Ordering::SeqCst); + match res { + Ok(object_size) => { + bytes.inc_by(object_size); + Ok(object_size) + } + Err(checkout::Error::Io(err)) if gix_fs::symlink::is_collision_error(&err) => { + // We are here because a file existed or was blocked by a directory which shouldn't be possible unless + // we are on a file insensitive file system. + files.fail(format!("{}: collided ({:?})", entry_path, err.kind())); + collisions.push(checkout::Collision { + path: entry_path.into(), + error_kind: err.kind(), + }); + Ok(0) + } + Err(err) => { + if options.keep_going { + errors.push(checkout::ErrorRecord { + path: entry_path.into(), + error: Box::new(err), + }); + Ok(0) + } else { + Err(err) + } + } + } +} diff --git a/vendor/gix-worktree/src/index/entry.rs b/vendor/gix-worktree/src/checkout/entry.rs index 32628c4e0..524cf90f2 100644 --- a/vendor/gix-worktree/src/index/entry.rs +++ b/vendor/gix-worktree/src/checkout/entry.rs @@ -1,15 +1,15 @@ -use std::{convert::TryInto, fs::OpenOptions, io::Write, path::Path, time::Duration}; +use std::{fs::OpenOptions, io::Write, path::Path}; use bstr::BStr; use gix_hash::oid; -use gix_index::Entry; +use gix_index::{entry::Stat, Entry}; use io_close::Close; -use crate::{fs, index, os}; +use crate::Cache; pub struct Context<'a, Find> { pub find: &'a mut Find, - pub path_cache: &'a mut fs::Cache, + pub path_cache: &'a mut Cache, pub buf: &'a mut Vec<u8>, } @@ -18,8 +18,8 @@ pub fn checkout<Find, E>( entry: &mut Entry, entry_path: &BStr, Context { find, path_cache, buf }: Context<'_, Find>, - index::checkout::Options { - fs: fs::Capabilities { + crate::checkout::Options { + fs: gix_fs::Capabilities { symlink, executable_bit, .. @@ -27,13 +27,13 @@ pub fn checkout<Find, E>( destination_is_initially_empty, overwrite_existing, .. - }: index::checkout::Options, -) -> Result<usize, index::checkout::Error<E>> + }: crate::checkout::Options, +) -> Result<usize, crate::checkout::Error<E>> where Find: for<'a> FnMut(&oid, &'a mut Vec<u8>) -> Result<gix_object::BlobRef<'a>, E>, E: std::error::Error + Send + Sync + 'static, { - let dest_relative = gix_path::try_from_bstr(entry_path).map_err(|_| index::checkout::Error::IllformedUtf8 { + let dest_relative = gix_path::try_from_bstr(entry_path).map_err(|_| crate::checkout::Error::IllformedUtf8 { path: entry_path.to_owned(), })?; let is_dir = Some(entry.mode == gix_index::entry::Mode::COMMIT || entry.mode == gix_index::entry::Mode::DIR); @@ -41,7 +41,7 @@ where let object_size = match entry.mode { gix_index::entry::Mode::FILE | gix_index::entry::Mode::FILE_EXECUTABLE => { - let obj = find(&entry.id, buf).map_err(|err| index::checkout::Error::Find { + let obj = find(&entry.id, buf).map_err(|err| crate::checkout::Error::Find { err, oid: entry.id, path: dest.to_path_buf(), @@ -71,21 +71,23 @@ where } // NOTE: we don't call `file.sync_all()` here knowing that some filesystems don't handle this well. // revisit this once there is a bug to fix. - update_fstat(entry, file.metadata()?)?; + entry.stat = Stat::from_fs(&file.metadata()?)?; file.close()?; obj.data.len() } gix_index::entry::Mode::SYMLINK => { - let obj = find(&entry.id, buf).map_err(|err| index::checkout::Error::Find { + let obj = find(&entry.id, buf).map_err(|err| crate::checkout::Error::Find { err, oid: entry.id, path: dest.to_path_buf(), })?; let symlink_destination = gix_path::try_from_byte_slice(obj.data) - .map_err(|_| index::checkout::Error::IllformedUtf8 { path: obj.data.into() })?; + .map_err(|_| crate::checkout::Error::IllformedUtf8 { path: obj.data.into() })?; if symlink { - try_write_or_unlink(dest, overwrite_existing, |p| os::create_symlink(symlink_destination, p))?; + try_write_or_unlink(dest, overwrite_existing, |p| { + gix_fs::symlink::create(symlink_destination, p) + })?; } else { let mut file = try_write_or_unlink(dest, overwrite_existing, |p| { open_options(p, destination_is_initially_empty, overwrite_existing).open(dest) @@ -94,7 +96,7 @@ where file.close()?; } - update_fstat(entry, std::fs::symlink_metadata(dest)?)?; + entry.stat = Stat::from_fs(&std::fs::symlink_metadata(dest)?)?; obj.data.len() } gix_index::entry::Mode::DIR => todo!(), @@ -115,7 +117,7 @@ fn try_write_or_unlink<T>( if overwrite_existing { match op(path) { Ok(res) => Ok(res), - Err(err) if os::indicates_collision(&err) => { + Err(err) if gix_fs::symlink::is_collision_error(&err) => { try_unlink_path_recursively(path, &std::fs::symlink_metadata(path)?)?; op(path) } @@ -130,7 +132,7 @@ fn try_unlink_path_recursively(path: &Path, path_meta: &std::fs::Metadata) -> st if path_meta.is_dir() { std::fs::remove_dir_all(path) } else if path_meta.file_type().is_symlink() { - os::remove_symlink(path) + gix_fs::symlink::remove(path) } else { std::fs::remove_file(path) } @@ -162,28 +164,3 @@ fn open_options(path: &Path, destination_is_initially_empty: bool, overwrite_exi .write(true); options } - -fn update_fstat<E>(entry: &mut Entry, meta: std::fs::Metadata) -> Result<(), index::checkout::Error<E>> -where - E: std::error::Error + Send + Sync + 'static, -{ - let ctime = meta - .created() - .map_or(Ok(Duration::default()), |x| x.duration_since(std::time::UNIX_EPOCH))?; - let mtime = meta - .modified() - .map_or(Ok(Duration::default()), |x| x.duration_since(std::time::UNIX_EPOCH))?; - - let stat = &mut entry.stat; - stat.mtime.secs = mtime - .as_secs() - .try_into() - .expect("by 2038 we found a solution for this"); - stat.mtime.nsecs = mtime.subsec_nanos(); - stat.ctime.secs = ctime - .as_secs() - .try_into() - .expect("by 2038 we found a solution for this"); - stat.ctime.nsecs = ctime.subsec_nanos(); - Ok(()) -} diff --git a/vendor/gix-worktree/src/checkout/function.rs b/vendor/gix-worktree/src/checkout/function.rs new file mode 100644 index 000000000..8e69fd4d6 --- /dev/null +++ b/vendor/gix-worktree/src/checkout/function.rs @@ -0,0 +1,119 @@ +use std::sync::atomic::{AtomicBool, AtomicUsize, Ordering}; + +use gix_features::{interrupt, parallel::in_parallel, progress, progress::Progress}; +use gix_hash::oid; + +use crate::{cache, checkout::chunk, Cache}; + +/// Note that interruption still produce an `Ok(…)` value, so the caller should look at `should_interrupt` to communicate the outcome. +/// `dir` is the directory into which to checkout the `index`. +/// `git_dir` is the `.git` directory for reading additional per-repository configuration files. +#[allow(clippy::too_many_arguments)] +pub fn checkout<Find, E>( + index: &mut gix_index::State, + dir: impl Into<std::path::PathBuf>, + find: Find, + files: &mut impl Progress, + bytes: &mut impl Progress, + should_interrupt: &AtomicBool, + options: crate::checkout::Options, +) -> Result<crate::checkout::Outcome, crate::checkout::Error<E>> +where + Find: for<'a> FnMut(&oid, &'a mut Vec<u8>) -> Result<gix_object::BlobRef<'a>, E> + Send + Clone, + E: std::error::Error + Send + Sync + 'static, +{ + let paths = index.take_path_backing(); + let res = checkout_inner(index, &paths, dir, find, files, bytes, should_interrupt, options); + index.return_path_backing(paths); + res +} + +#[allow(clippy::too_many_arguments)] +fn checkout_inner<Find, E>( + index: &mut gix_index::State, + paths: &gix_index::PathStorage, + dir: impl Into<std::path::PathBuf>, + find: Find, + files: &mut impl Progress, + bytes: &mut impl Progress, + should_interrupt: &AtomicBool, + options: crate::checkout::Options, +) -> Result<crate::checkout::Outcome, crate::checkout::Error<E>> +where + Find: for<'a> FnMut(&oid, &'a mut Vec<u8>) -> Result<gix_object::BlobRef<'a>, E> + Send + Clone, + E: std::error::Error + Send + Sync + 'static, +{ + let num_files = AtomicUsize::default(); + let dir = dir.into(); + let case = if options.fs.ignore_case { + gix_glob::pattern::Case::Fold + } else { + gix_glob::pattern::Case::Sensitive + }; + let (chunk_size, thread_limit, num_threads) = gix_features::parallel::optimize_chunk_size_and_thread_limit( + 100, + index.entries().len().into(), + options.thread_limit, + None, + ); + + let state = cache::State::for_checkout(options.overwrite_existing, options.attributes.clone()); + let attribute_files = state.id_mappings_from_index(index, paths, Default::default(), case); + let mut ctx = chunk::Context { + buf: Vec::new(), + path_cache: Cache::new(dir, state, case, Vec::with_capacity(512), attribute_files), + find, + options, + num_files: &num_files, + }; + + let chunk::Outcome { + mut collisions, + mut errors, + mut bytes_written, + delayed, + } = if num_threads == 1 { + let entries_with_paths = interrupt::Iter::new(index.entries_mut_with_paths_in(paths), should_interrupt); + chunk::process(entries_with_paths, files, bytes, &mut ctx)? + } else { + let entries_with_paths = interrupt::Iter::new(index.entries_mut_with_paths_in(paths), should_interrupt); + in_parallel( + gix_features::iter::Chunks { + inner: entries_with_paths, + size: chunk_size, + }, + thread_limit, + { + let ctx = ctx.clone(); + move |_| (progress::Discard, progress::Discard, ctx.clone()) + }, + |chunk, (files, bytes, ctx)| chunk::process(chunk.into_iter(), files, bytes, ctx), + chunk::Reduce { + files, + bytes, + num_files: &num_files, + aggregate: Default::default(), + marker: Default::default(), + }, + )? + }; + + for (entry, entry_path) in delayed { + bytes_written += chunk::checkout_entry_handle_result( + entry, + entry_path, + &mut errors, + &mut collisions, + files, + bytes, + &mut ctx, + )? as u64; + } + + Ok(crate::checkout::Outcome { + files_updated: num_files.load(Ordering::Relaxed), + collisions, + errors, + bytes_written, + }) +} diff --git a/vendor/gix-worktree/src/index/checkout.rs b/vendor/gix-worktree/src/checkout/mod.rs index 6bc465375..11f39b1b2 100644 --- a/vendor/gix-worktree/src/index/checkout.rs +++ b/vendor/gix-worktree/src/checkout/mod.rs @@ -1,6 +1,7 @@ #![allow(missing_docs)] + use bstr::BString; -use gix_attributes::Attributes; +use gix_index::entry::stat; #[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)] pub struct Collision { @@ -27,10 +28,10 @@ pub struct Outcome { pub errors: Vec<ErrorRecord>, } -#[derive(Clone)] +#[derive(Clone, Default)] pub struct Options { /// capabilities of the file system - pub fs: crate::fs::Capabilities, + pub fs: gix_fs::Capabilities, /// If set, don't use more than this amount of threads. /// Otherwise, usually use as many threads as there are logical cores. /// A value of 0 is interpreted as no-limit @@ -48,35 +49,12 @@ pub struct Options { /// due to a conflict. /// The checkout operation will never fail, but count the encountered errors instead along with their paths. pub keep_going: bool, - /// If true, a files creation time is taken into consideration when checking if a file changed. - /// Can be set to false in case other tools alter the creation time in ways that interfere with our operation. - /// - /// Default true. - pub trust_ctime: bool, - /// If true, all stat fields will be used when checking for up-to-date'ness of the entry. Otherwise - /// nano-second parts of mtime and ctime,uid, gid, inode and device number _will not_ be used, leaving only - /// the whole-second part of ctime and mtime and the file size to be checked. - /// - /// Default true. - pub check_stat: bool, - /// A group of attribute patterns that are applied globally, i.e. aren't rooted within the repository itself. - pub attribute_globals: gix_attributes::MatchGroup<Attributes>, + /// Control how stat comparisons are made when checking if a file is fresh. + pub stat_options: stat::Options, + /// A stack of attributes to use with the filesystem cache to use as driver for filters. + pub attributes: crate::cache::state::Attributes, } -impl Default for Options { - fn default() -> Self { - Options { - fs: Default::default(), - thread_limit: None, - destination_is_initially_empty: false, - keep_going: false, - trust_ctime: true, - check_stat: true, - overwrite_existing: false, - attribute_globals: Default::default(), - } - } -} #[derive(Debug, thiserror::Error)] pub enum Error<E: std::error::Error + Send + Sync + 'static> { #[error("Could not convert path to UTF8: {}", .path)] @@ -93,3 +71,7 @@ pub enum Error<E: std::error::Error + Send + Sync + 'static> { path: std::path::PathBuf, }, } + +mod chunk; +mod entry; +pub(crate) mod function; diff --git a/vendor/gix-worktree/src/fs/cache/platform.rs b/vendor/gix-worktree/src/fs/cache/platform.rs deleted file mode 100644 index 90bbdbe3c..000000000 --- a/vendor/gix-worktree/src/fs/cache/platform.rs +++ /dev/null @@ -1,171 +0,0 @@ -use std::path::Path; - -use bstr::ByteSlice; -use gix_hash::oid; - -use crate::{ - fs, - fs::{ - cache::{Platform, State}, - PathOidMapping, - }, -}; - -impl<'a> Platform<'a> { - /// The full path to `relative` will be returned for use on the file system. - pub fn path(&self) -> &'a Path { - self.parent.stack.current() - } - - /// See if the currently set entry is excluded as per exclude and git-ignore files. - /// - /// # Panics - /// - /// If the cache was configured without exclude patterns. - pub fn is_excluded(&self) -> bool { - self.matching_exclude_pattern() - .map_or(false, |m| !m.pattern.is_negative()) - } - - /// Check all exclude patterns to see if the currently set path matches any of them. - /// - /// Note that this pattern might be negated, and means this path in included. - /// - /// # Panics - /// - /// If the cache was configured without exclude patterns. - pub fn matching_exclude_pattern(&self) -> Option<gix_attributes::Match<'_, ()>> { - let ignore = self.parent.state.ignore_or_panic(); - let relative_path = - gix_path::to_unix_separators_on_windows(gix_path::into_bstr(self.parent.stack.current_relative.as_path())); - ignore.matching_exclude_pattern(relative_path.as_bstr(), self.is_dir, self.parent.case) - } -} - -impl<'a> std::fmt::Debug for Platform<'a> { - fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - std::fmt::Debug::fmt(&self.path(), f) - } -} - -pub struct StackDelegate<'a, Find> { - pub state: &'a mut State, - pub buf: &'a mut Vec<u8>, - pub is_dir: bool, - pub attribute_files_in_index: &'a Vec<PathOidMapping>, - pub find: Find, -} - -impl<'a, Find, E> fs::stack::Delegate for StackDelegate<'a, Find> -where - Find: for<'b> FnMut(&oid, &'b mut Vec<u8>) -> Result<gix_object::BlobRef<'b>, E>, - E: std::error::Error + Send + Sync + 'static, -{ - fn push_directory(&mut self, stack: &fs::Stack) -> std::io::Result<()> { - match &mut self.state { - State::CreateDirectoryAndAttributesStack { attributes: _, .. } => { - // TODO: attributes - } - State::AttributesAndIgnoreStack { ignore, attributes: _ } => { - // TODO: attributes - ignore.push_directory( - &stack.root, - &stack.current, - self.buf, - self.attribute_files_in_index, - &mut self.find, - )? - } - State::IgnoreStack(ignore) => ignore.push_directory( - &stack.root, - &stack.current, - self.buf, - self.attribute_files_in_index, - &mut self.find, - )?, - } - Ok(()) - } - - fn push(&mut self, is_last_component: bool, stack: &fs::Stack) -> std::io::Result<()> { - match &mut self.state { - State::CreateDirectoryAndAttributesStack { - #[cfg(debug_assertions)] - test_mkdir_calls, - unlink_on_collision, - attributes: _, - } => { - #[cfg(debug_assertions)] - { - create_leading_directory( - is_last_component, - stack, - self.is_dir, - test_mkdir_calls, - *unlink_on_collision, - )? - } - #[cfg(not(debug_assertions))] - { - create_leading_directory(is_last_component, stack, self.is_dir, *unlink_on_collision)? - } - } - State::AttributesAndIgnoreStack { .. } | State::IgnoreStack(_) => {} - } - Ok(()) - } - - fn pop_directory(&mut self) { - match &mut self.state { - State::CreateDirectoryAndAttributesStack { attributes: _, .. } => { - // TODO: attributes - } - State::AttributesAndIgnoreStack { attributes: _, ignore } => { - // TODO: attributes - ignore.pop_directory(); - } - State::IgnoreStack(ignore) => { - ignore.pop_directory(); - } - } - } -} - -fn create_leading_directory( - is_last_component: bool, - stack: &fs::Stack, - is_dir: bool, - #[cfg(debug_assertions)] mkdir_calls: &mut usize, - unlink_on_collision: bool, -) -> std::io::Result<()> { - if is_last_component && !is_dir { - return Ok(()); - } - #[cfg(debug_assertions)] - { - *mkdir_calls += 1; - } - match std::fs::create_dir(stack.current()) { - Ok(()) => Ok(()), - Err(err) if err.kind() == std::io::ErrorKind::AlreadyExists => { - let meta = stack.current().symlink_metadata()?; - if meta.is_dir() { - Ok(()) - } else if unlink_on_collision { - if meta.file_type().is_symlink() { - crate::os::remove_symlink(stack.current())?; - } else { - std::fs::remove_file(stack.current())?; - } - #[cfg(debug_assertions)] - { - *mkdir_calls += 1; - } - std::fs::create_dir(stack.current()) - } else { - Err(err) - } - } - Err(err) => Err(err), - } -} diff --git a/vendor/gix-worktree/src/fs/cache/state.rs b/vendor/gix-worktree/src/fs/cache/state.rs deleted file mode 100644 index 1692bfa5e..000000000 --- a/vendor/gix-worktree/src/fs/cache/state.rs +++ /dev/null @@ -1,301 +0,0 @@ -use std::path::Path; - -use bstr::{BStr, BString, ByteSlice}; -use gix_glob::pattern::Case; -use gix_hash::oid; - -use crate::fs::{cache::State, PathOidMapping}; - -type AttributeMatchGroup = gix_attributes::MatchGroup<gix_attributes::Attributes>; -type IgnoreMatchGroup = gix_attributes::MatchGroup<gix_attributes::Ignore>; - -/// State related to attributes associated with files in the repository. -#[derive(Default, Clone)] -#[allow(unused)] -pub struct Attributes { - /// Attribute patterns that match the currently set directory (in the stack). - pub stack: AttributeMatchGroup, - /// Attribute patterns which aren't tied to the repository root, hence are global. They are consulted last. - pub globals: AttributeMatchGroup, -} - -/// State related to the exclusion of files. -#[derive(Default, Clone)] -#[allow(unused)] -pub struct Ignore { - /// Ignore patterns passed as overrides to everything else, typically passed on the command-line and the first patterns to - /// be consulted. - overrides: IgnoreMatchGroup, - /// Ignore patterns that match the currently set director (in the stack), which is pushed and popped as needed. - stack: IgnoreMatchGroup, - /// Ignore patterns which aren't tied to the repository root, hence are global. They are consulted last. - globals: IgnoreMatchGroup, - /// A matching stack of pattern indices which is empty if we have just been initialized to indicate that the - /// currently set directory had a pattern matched. Note that this one could be negated. - /// (index into match groups, index into list of pattern lists, index into pattern list) - matched_directory_patterns_stack: Vec<Option<(usize, usize, usize)>>, - /// The name of the file to look for in directories. - exclude_file_name_for_directories: BString, - /// The case to use when matching directories as they are pushed onto the stack. We run them against the exclude engine - /// to know if an entire path can be ignored as a parent directory is ignored. - case: Case, -} - -impl Ignore { - /// The `exclude_file_name_for_directories` is an optional override for the filename to use when checking per-directory - /// ignore files within the repository, defaults to`.gitignore`. - // TODO: more docs - pub fn new( - overrides: IgnoreMatchGroup, - globals: IgnoreMatchGroup, - exclude_file_name_for_directories: Option<&BStr>, - case: Case, - ) -> Self { - Ignore { - case, - overrides, - globals, - stack: Default::default(), - matched_directory_patterns_stack: Vec::with_capacity(6), - exclude_file_name_for_directories: exclude_file_name_for_directories - .map(ToOwned::to_owned) - .unwrap_or_else(|| ".gitignore".into()), - } - } -} - -impl Ignore { - pub(crate) fn pop_directory(&mut self) { - self.matched_directory_patterns_stack.pop().expect("something to pop"); - self.stack.patterns.pop().expect("something to pop"); - } - /// The match groups from lowest priority to highest. - pub(crate) fn match_groups(&self) -> [&IgnoreMatchGroup; 3] { - [&self.globals, &self.stack, &self.overrides] - } - - pub(crate) fn matching_exclude_pattern( - &self, - relative_path: &BStr, - is_dir: Option<bool>, - case: Case, - ) -> Option<gix_attributes::Match<'_, ()>> { - let groups = self.match_groups(); - let mut dir_match = None; - if let Some((source, mapping)) = self - .matched_directory_patterns_stack - .iter() - .rev() - .filter_map(|v| *v) - .map(|(gidx, plidx, pidx)| { - let list = &groups[gidx].patterns[plidx]; - (list.source.as_deref(), &list.patterns[pidx]) - }) - .next() - { - let match_ = gix_attributes::Match { - pattern: &mapping.pattern, - value: &mapping.value, - sequence_number: mapping.sequence_number, - source, - }; - if mapping.pattern.is_negative() { - dir_match = Some(match_); - } else { - // Note that returning here is wrong if this pattern _was_ preceded by a negative pattern that - // didn't match the directory, but would match now. - // Git does it similarly so we do too even though it's incorrect. - // To fix this, one would probably keep track of whether there was a preceding negative pattern, and - // if so we check the path in full and only use the dir match if there was no match, similar to the negative - // case above whose fix fortunately won't change the overall result. - return match_.into(); - } - } - groups - .iter() - .rev() - .find_map(|group| group.pattern_matching_relative_path(relative_path.as_bytes(), is_dir, case)) - .or(dir_match) - } - - /// Like `matching_exclude_pattern()` but without checking if the current directory is excluded. - /// It returns a triple-index into our data structure from which a match can be reconstructed. - pub(crate) fn matching_exclude_pattern_no_dir( - &self, - relative_path: &BStr, - is_dir: Option<bool>, - case: Case, - ) -> Option<(usize, usize, usize)> { - let groups = self.match_groups(); - groups.iter().enumerate().rev().find_map(|(gidx, group)| { - let basename_pos = relative_path.rfind(b"/").map(|p| p + 1); - group - .patterns - .iter() - .enumerate() - .rev() - .find_map(|(plidx, pl)| { - pl.pattern_idx_matching_relative_path(relative_path, basename_pos, is_dir, case) - .map(|idx| (plidx, idx)) - }) - .map(|(plidx, pidx)| (gidx, plidx, pidx)) - }) - } - - pub(crate) fn push_directory<Find, E>( - &mut self, - root: &Path, - dir: &Path, - buf: &mut Vec<u8>, - attribute_files_in_index: &[PathOidMapping], - mut find: Find, - ) -> std::io::Result<()> - where - Find: for<'b> FnMut(&oid, &'b mut Vec<u8>) -> Result<gix_object::BlobRef<'b>, E>, - E: std::error::Error + Send + Sync + 'static, - { - let rela_dir = dir.strip_prefix(root).expect("dir in root"); - self.matched_directory_patterns_stack - .push(self.matching_exclude_pattern_no_dir(gix_path::into_bstr(rela_dir).as_ref(), Some(true), self.case)); - - let ignore_path_relative = rela_dir.join(".gitignore"); - let ignore_path_relative = gix_path::to_unix_separators_on_windows(gix_path::into_bstr(ignore_path_relative)); - let ignore_file_in_index = - attribute_files_in_index.binary_search_by(|t| t.0.as_bstr().cmp(ignore_path_relative.as_ref())); - let follow_symlinks = ignore_file_in_index.is_err(); - if !self - .stack - .add_patterns_file(dir.join(".gitignore"), follow_symlinks, Some(root), buf)? - { - match ignore_file_in_index { - Ok(idx) => { - let ignore_blob = find(&attribute_files_in_index[idx].1, buf) - .map_err(|err| std::io::Error::new(std::io::ErrorKind::Other, err))?; - let ignore_path = gix_path::from_bstring(ignore_path_relative.into_owned()); - self.stack - .add_patterns_buffer(ignore_blob.data, ignore_path, Some(root)); - } - Err(_) => { - // Need one stack level per component so push and pop matches. - self.stack.patterns.push(Default::default()) - } - } - } - Ok(()) - } -} - -impl Attributes { - /// Create a new instance from an attribute match group that represents `globals`. - /// - /// A stack of attributes will be applied on top of it later. - pub fn new(globals: AttributeMatchGroup) -> Self { - Attributes { - globals, - stack: Default::default(), - } - } -} - -impl From<AttributeMatchGroup> for Attributes { - fn from(group: AttributeMatchGroup) -> Self { - Attributes::new(group) - } -} - -impl State { - /// Configure a state to be suitable for checking out files. - pub fn for_checkout(unlink_on_collision: bool, attributes: Attributes) -> Self { - State::CreateDirectoryAndAttributesStack { - unlink_on_collision, - #[cfg(debug_assertions)] - test_mkdir_calls: 0, - attributes, - } - } - - /// Configure a state for adding files. - pub fn for_add(attributes: Attributes, ignore: Ignore) -> Self { - State::AttributesAndIgnoreStack { attributes, ignore } - } - - /// Configure a state for status retrieval. - pub fn for_status(ignore: Ignore) -> Self { - State::IgnoreStack(ignore) - } -} - -impl State { - /// Returns a vec of tuples of relative index paths along with the best usable OID for either ignore, attribute files or both. - /// - /// - ignores entries which aren't blobs - /// - ignores ignore entries which are not skip-worktree - /// - within merges, picks 'our' stage both for ignore and attribute files. - pub fn build_attribute_list( - &self, - index: &gix_index::State, - paths: &gix_index::PathStorageRef, - case: Case, - ) -> Vec<PathOidMapping> { - let a1_backing; - let a2_backing; - let names = match self { - State::IgnoreStack(v) => { - a1_backing = [(v.exclude_file_name_for_directories.as_bytes().as_bstr(), true)]; - a1_backing.as_ref() - } - State::AttributesAndIgnoreStack { ignore, .. } => { - a2_backing = [ - (ignore.exclude_file_name_for_directories.as_bytes().as_bstr(), true), - (".gitattributes".into(), false), - ]; - a2_backing.as_ref() - } - State::CreateDirectoryAndAttributesStack { .. } => { - a1_backing = [(".gitattributes".into(), true)]; - a1_backing.as_ref() - } - }; - - index - .entries() - .iter() - .filter_map(move |entry| { - let path = entry.path_in(paths); - - // Stage 0 means there is no merge going on, stage 2 means it's 'our' side of the merge, but then - // there won't be a stage 0. - if entry.mode == gix_index::entry::Mode::FILE && (entry.stage() == 0 || entry.stage() == 2) { - let basename = path - .rfind_byte(b'/') - .map(|pos| path[pos + 1..].as_bstr()) - .unwrap_or(path); - let is_ignore = names.iter().find_map(|t| { - match case { - Case::Sensitive => basename == t.0, - Case::Fold => basename.eq_ignore_ascii_case(t.0), - } - .then_some(t.1) - })?; - // See https://github.com/git/git/blob/master/dir.c#L912:L912 - if is_ignore && !entry.flags.contains(gix_index::entry::Flags::SKIP_WORKTREE) { - return None; - } - Some((path.to_owned(), entry.id)) - } else { - None - } - }) - .collect() - } - - pub(crate) fn ignore_or_panic(&self) -> &Ignore { - match self { - State::IgnoreStack(v) => v, - State::AttributesAndIgnoreStack { ignore, .. } => ignore, - State::CreateDirectoryAndAttributesStack { .. } => { - unreachable!("BUG: must not try to check excludes without it being setup") - } - } - } -} diff --git a/vendor/gix-worktree/src/fs/capabilities.rs b/vendor/gix-worktree/src/fs/capabilities.rs deleted file mode 100644 index 64daab9ce..000000000 --- a/vendor/gix-worktree/src/fs/capabilities.rs +++ /dev/null @@ -1,122 +0,0 @@ -use std::path::Path; - -use crate::fs::Capabilities; - -#[cfg(windows)] -impl Default for Capabilities { - fn default() -> Self { - Capabilities { - precompose_unicode: false, - ignore_case: true, - executable_bit: false, - symlink: false, - } - } -} - -#[cfg(target_os = "macos")] -impl Default for Capabilities { - fn default() -> Self { - Capabilities { - precompose_unicode: true, - ignore_case: true, - executable_bit: true, - symlink: true, - } - } -} - -#[cfg(all(unix, not(target_os = "macos")))] -impl Default for Capabilities { - fn default() -> Self { - Capabilities { - precompose_unicode: false, - ignore_case: false, - executable_bit: true, - symlink: true, - } - } -} - -impl Capabilities { - /// try to determine all values in this context by probing them in the given `git_dir`, which - /// should be on the file system the git repository is located on. - /// `git_dir` is a typical git repository, expected to be populated with the typical files like `config`. - /// - /// All errors are ignored and interpreted on top of the default for the platform the binary is compiled for. - pub fn probe(git_dir: impl AsRef<Path>) -> Self { - let root = git_dir.as_ref(); - let ctx = Capabilities::default(); - Capabilities { - symlink: Self::probe_symlink(root).unwrap_or(ctx.symlink), - ignore_case: Self::probe_ignore_case(root).unwrap_or(ctx.ignore_case), - precompose_unicode: Self::probe_precompose_unicode(root).unwrap_or(ctx.precompose_unicode), - executable_bit: Self::probe_file_mode(root).unwrap_or(ctx.executable_bit), - } - } - - #[cfg(unix)] - fn probe_file_mode(root: &Path) -> std::io::Result<bool> { - use std::os::unix::fs::{MetadataExt, OpenOptionsExt}; - - // test it exactly as we typically create executable files, not using chmod. - let test_path = root.join("_test_executable_bit"); - let res = std::fs::OpenOptions::new() - .create_new(true) - .write(true) - .mode(0o777) - .open(&test_path) - .and_then(|f| f.metadata().map(|m| m.mode() & 0o100 == 0o100)); - std::fs::remove_file(test_path)?; - res - } - - #[cfg(not(unix))] - fn probe_file_mode(_root: &Path) -> std::io::Result<bool> { - Ok(false) - } - - fn probe_ignore_case(git_dir: &Path) -> std::io::Result<bool> { - std::fs::metadata(git_dir.join("cOnFiG")).map(|_| true).or_else(|err| { - if err.kind() == std::io::ErrorKind::NotFound { - Ok(false) - } else { - Err(err) - } - }) - } - - fn probe_precompose_unicode(root: &Path) -> std::io::Result<bool> { - let precomposed = "ä"; - let decomposed = "a\u{308}"; - - let precomposed = root.join(precomposed); - std::fs::OpenOptions::new() - .create_new(true) - .write(true) - .open(&precomposed)?; - let res = root.join(decomposed).symlink_metadata().map(|_| true); - std::fs::remove_file(precomposed)?; - res - } - - fn probe_symlink(root: &Path) -> std::io::Result<bool> { - let src_path = root.join("__link_src_file"); - std::fs::OpenOptions::new() - .create_new(true) - .write(true) - .open(&src_path)?; - let link_path = root.join("__file_link"); - if crate::os::create_symlink(&src_path, &link_path).is_err() { - std::fs::remove_file(&src_path)?; - return Ok(false); - } - - let res = std::fs::symlink_metadata(&link_path).map(|m| m.file_type().is_symlink()); - - let cleanup = crate::os::remove_symlink(&link_path).or_else(|_| std::fs::remove_file(&link_path)); - std::fs::remove_file(&src_path).and(cleanup)?; - - res - } -} diff --git a/vendor/gix-worktree/src/fs/mod.rs b/vendor/gix-worktree/src/fs/mod.rs deleted file mode 100644 index a58c461fe..000000000 --- a/vendor/gix-worktree/src/fs/mod.rs +++ /dev/null @@ -1,81 +0,0 @@ -use std::path::PathBuf; - -use bstr::BString; - -/// Common knowledge about the worktree that is needed across most interactions with the work tree -#[cfg_attr(feature = "serde1", derive(serde::Serialize, serde::Deserialize))] -#[derive(PartialEq, Eq, Debug, Hash, Ord, PartialOrd, Clone, Copy)] -pub struct Capabilities { - /// If true, the filesystem will store paths as decomposed unicode, i.e. `ä` becomes `"a\u{308}"`, which means that - /// we have to turn these forms back from decomposed to precomposed unicode before storing it in the index or generally - /// using it. This also applies to input received from the command-line, so callers may have to be aware of this and - /// perform conversions accordingly. - /// If false, no conversions will be performed. - pub precompose_unicode: bool, - /// If true, the filesystem ignores the case of input, which makes `A` the same file as `a`. - /// This is also called case-folding. - pub ignore_case: bool, - /// If true, we assume the the executable bit is honored as part of the files mode. If false, we assume the file system - /// ignores the executable bit, hence it will be reported as 'off' even though we just tried to set it to be on. - pub executable_bit: bool, - /// If true, the file system supports symbolic links and we should try to create them. Otherwise symbolic links will be checked - /// out as files which contain the link as text. - pub symlink: bool, -} - -/// A stack of path components with the delegation of side-effects as the currently set path changes, component by component. -#[derive(Clone)] -pub struct Stack { - /// The prefix/root for all paths we handle. - root: PathBuf, - /// the most recent known cached that we know is valid. - current: PathBuf, - /// The relative portion of `valid` that was added previously. - current_relative: PathBuf, - /// The amount of path components of 'current' beyond the roots components. - valid_components: usize, - /// If set, we assume the `current` element is a directory to affect calls to `(push|pop)_directory()`. - current_is_directory: bool, -} - -/// A cache for efficiently executing operations on directories and files which are encountered in sorted order. -/// That way, these operations can be re-used for subsequent invocations in the same directory. -/// -/// This cache can be configured to create directories efficiently, read git-ignore files and git-attribute files, -/// in any combination. -/// -/// A cache for directory creation to reduce the amount of stat calls when creating -/// directories safely, that is without following symlinks that might be on the way. -/// -/// As a special case, it offers a 'prefix' which (by itself) is assumed to exist and may contain symlinks. -/// Everything past that prefix boundary must not contain a symlink. We do this by allowing any input path. -/// -/// Another added benefit is its ability to store the path of full path of the entry to which leading directories -/// are to be created to avoid allocating memory. -/// -/// For this to work, it remembers the last 'good' path to a directory and assumes that all components of it -/// are still valid, too. -/// As directories are created, the cache will be adjusted to reflect the latest seen directory. -/// -/// The caching is only useful if consecutive calls to create a directory are using a sorted list of entries. -#[derive(Clone)] -pub struct Cache { - stack: Stack, - /// tells us what to do as we change paths. - state: cache::State, - /// A buffer used when reading attribute or ignore files or their respective objects from the object database. - buf: Vec<u8>, - /// If case folding should happen when looking up attributes or exclusions. - case: gix_glob::pattern::Case, - /// A lookup table for object ids to read from in some situations when looking up attributes or exclusions. - attribute_files_in_index: Vec<PathOidMapping>, -} - -pub(crate) type PathOidMapping = (BString, gix_hash::ObjectId); - -/// -pub mod cache; -/// -pub mod stack; - -mod capabilities; diff --git a/vendor/gix-worktree/src/fs/stack.rs b/vendor/gix-worktree/src/fs/stack.rs deleted file mode 100644 index 734a4988b..000000000 --- a/vendor/gix-worktree/src/fs/stack.rs +++ /dev/null @@ -1,123 +0,0 @@ -use std::path::{Path, PathBuf}; - -use crate::fs::Stack; - -impl Stack { - /// Returns the top-level path of the stack. - pub fn root(&self) -> &Path { - &self.root - } - - /// Returns the absolute path the currently set path. - pub fn current(&self) -> &Path { - &self.current - } - - /// Returns the currently set path relative to the [`root()`][Stack::root()]. - pub fn current_relative(&self) -> &Path { - &self.current_relative - } -} - -/// A delegate for use in a [`Stack`]. -pub trait Delegate { - /// Called whenever we push a directory on top of the stack, after the fact. - /// - /// It is also called if the currently acted on path is a directory in itself. - /// Use `stack.current()` to see the directory. - fn push_directory(&mut self, stack: &Stack) -> std::io::Result<()>; - - /// Called after any component was pushed, with the path available at `stack.current()`. - /// - /// `is_last_component` is true if the path is completely built. - fn push(&mut self, is_last_component: bool, stack: &Stack) -> std::io::Result<()>; - - /// Called right after a directory-component was popped off the stack. - /// - /// Use it to pop information off internal data structures. - fn pop_directory(&mut self); -} - -impl Stack { - /// Create a new instance with `root` being the base for all future paths we handle, assuming it to be valid which includes - /// symbolic links to be included in it as well. - pub fn new(root: impl Into<PathBuf>) -> Self { - let root = root.into(); - Stack { - current: root.clone(), - current_relative: PathBuf::with_capacity(128), - valid_components: 0, - root, - current_is_directory: true, - } - } - - /// Set the current stack to point to the `relative` path and call `push_comp()` each time a new path component is popped - /// along with the stacks state for inspection to perform an operation that produces some data. - /// - /// The full path to `relative` will be returned along with the data returned by push_comp. - /// Note that this only works correctly for the delegate's `push_directory()` and `pop_directory()` methods if - /// `relative` paths are terminal, so point to their designated file or directory. - pub fn make_relative_path_current( - &mut self, - relative: impl AsRef<Path>, - delegate: &mut impl Delegate, - ) -> std::io::Result<()> { - let relative = relative.as_ref(); - debug_assert!( - relative.is_relative(), - "only index paths are handled correctly here, must be relative" - ); - debug_assert!(!relative.to_string_lossy().is_empty(), "empty paths are not allowed"); - - if self.valid_components == 0 { - delegate.push_directory(self)?; - } - - let mut components = relative.components().peekable(); - let mut existing_components = self.current_relative.components(); - let mut matching_components = 0; - while let (Some(existing_comp), Some(new_comp)) = (existing_components.next(), components.peek()) { - if existing_comp == *new_comp { - components.next(); - matching_components += 1; - } else { - break; - } - } - - for _ in 0..self.valid_components - matching_components { - self.current.pop(); - self.current_relative.pop(); - if self.current_is_directory { - delegate.pop_directory(); - } - self.current_is_directory = true; - } - self.valid_components = matching_components; - - if !self.current_is_directory && components.peek().is_some() { - delegate.push_directory(self)?; - } - - while let Some(comp) = components.next() { - let is_last_component = components.peek().is_none(); - self.current_is_directory = !is_last_component; - self.current.push(comp); - self.current_relative.push(comp); - self.valid_components += 1; - let res = delegate.push(is_last_component, self); - if self.current_is_directory { - delegate.push_directory(self)?; - } - - if let Err(err) = res { - self.current.pop(); - self.current_relative.pop(); - self.valid_components -= 1; - return Err(err); - } - } - Ok(()) - } -} diff --git a/vendor/gix-worktree/src/index/mod.rs b/vendor/gix-worktree/src/index/mod.rs deleted file mode 100644 index 684d1cae9..000000000 --- a/vendor/gix-worktree/src/index/mod.rs +++ /dev/null @@ -1,311 +0,0 @@ -use std::sync::atomic::{AtomicBool, AtomicUsize, Ordering}; - -use gix_features::{interrupt, parallel::in_parallel, progress, progress::Progress}; -use gix_hash::oid; - -use crate::fs; - -pub mod checkout; -pub(crate) mod entry; - -/// Note that interruption still produce an `Ok(…)` value, so the caller should look at `should_interrupt` to communicate the outcome. -/// `dir` is the directory into which to checkout the `index`. -/// `git_dir` is the `.git` directory for reading additional per-repository configuration files. -#[allow(clippy::too_many_arguments)] -pub fn checkout<Find, E>( - index: &mut gix_index::State, - dir: impl Into<std::path::PathBuf>, - find: Find, - files: &mut impl Progress, - bytes: &mut impl Progress, - should_interrupt: &AtomicBool, - options: checkout::Options, -) -> Result<checkout::Outcome, checkout::Error<E>> -where - Find: for<'a> FnMut(&oid, &'a mut Vec<u8>) -> Result<gix_object::BlobRef<'a>, E> + Send + Clone, - E: std::error::Error + Send + Sync + 'static, -{ - let paths = index.take_path_backing(); - let res = checkout_inner(index, &paths, dir, find, files, bytes, should_interrupt, options); - index.return_path_backing(paths); - res -} -#[allow(clippy::too_many_arguments)] -fn checkout_inner<Find, E>( - index: &mut gix_index::State, - paths: &gix_index::PathStorage, - dir: impl Into<std::path::PathBuf>, - find: Find, - files: &mut impl Progress, - bytes: &mut impl Progress, - should_interrupt: &AtomicBool, - options: checkout::Options, -) -> Result<checkout::Outcome, checkout::Error<E>> -where - Find: for<'a> FnMut(&oid, &'a mut Vec<u8>) -> Result<gix_object::BlobRef<'a>, E> + Send + Clone, - E: std::error::Error + Send + Sync + 'static, -{ - let num_files = AtomicUsize::default(); - let dir = dir.into(); - let case = if options.fs.ignore_case { - gix_glob::pattern::Case::Fold - } else { - gix_glob::pattern::Case::Sensitive - }; - let (chunk_size, thread_limit, num_threads) = gix_features::parallel::optimize_chunk_size_and_thread_limit( - 100, - index.entries().len().into(), - options.thread_limit, - None, - ); - - let state = fs::cache::State::for_checkout(options.overwrite_existing, options.attribute_globals.clone().into()); - let attribute_files = state.build_attribute_list(index, paths, case); - let mut ctx = chunk::Context { - buf: Vec::new(), - path_cache: fs::Cache::new(dir, state, case, Vec::with_capacity(512), attribute_files), - find, - options, - num_files: &num_files, - }; - - let chunk::Outcome { - mut collisions, - mut errors, - mut bytes_written, - delayed, - } = if num_threads == 1 { - let entries_with_paths = interrupt::Iter::new(index.entries_mut_with_paths_in(paths), should_interrupt); - chunk::process(entries_with_paths, files, bytes, &mut ctx)? - } else { - let entries_with_paths = interrupt::Iter::new(index.entries_mut_with_paths_in(paths), should_interrupt); - in_parallel( - gix_features::iter::Chunks { - inner: entries_with_paths, - size: chunk_size, - }, - thread_limit, - { - let ctx = ctx.clone(); - move |_| (progress::Discard, progress::Discard, ctx.clone()) - }, - |chunk, (files, bytes, ctx)| chunk::process(chunk.into_iter(), files, bytes, ctx), - chunk::Reduce { - files, - bytes, - num_files: &num_files, - aggregate: Default::default(), - marker: Default::default(), - }, - )? - }; - - for (entry, entry_path) in delayed { - bytes_written += chunk::checkout_entry_handle_result( - entry, - entry_path, - &mut errors, - &mut collisions, - files, - bytes, - &mut ctx, - )? as u64; - } - - Ok(checkout::Outcome { - files_updated: num_files.load(Ordering::Relaxed), - collisions, - errors, - bytes_written, - }) -} - -mod chunk { - use std::sync::atomic::{AtomicUsize, Ordering}; - - use bstr::BStr; - use gix_features::progress::Progress; - use gix_hash::oid; - - use crate::{ - fs, index, - index::{checkout, entry}, - os, - }; - - mod reduce { - use std::{ - marker::PhantomData, - sync::atomic::{AtomicUsize, Ordering}, - }; - - use gix_features::progress::Progress; - - use crate::index::checkout; - - pub struct Reduce<'a, 'entry, P1, P2, E> { - pub files: &'a mut P1, - pub bytes: &'a mut P2, - pub num_files: &'a AtomicUsize, - pub aggregate: super::Outcome<'entry>, - pub marker: PhantomData<E>, - } - - impl<'a, 'entry, P1, P2, E> gix_features::parallel::Reduce for Reduce<'a, 'entry, P1, P2, E> - where - P1: Progress, - P2: Progress, - E: std::error::Error + Send + Sync + 'static, - { - type Input = Result<super::Outcome<'entry>, checkout::Error<E>>; - type FeedProduce = (); - type Output = super::Outcome<'entry>; - type Error = checkout::Error<E>; - - fn feed(&mut self, item: Self::Input) -> Result<Self::FeedProduce, Self::Error> { - let item = item?; - let super::Outcome { - bytes_written, - delayed, - errors, - collisions, - } = item; - self.aggregate.bytes_written += bytes_written; - self.aggregate.delayed.extend(delayed); - self.aggregate.errors.extend(errors); - self.aggregate.collisions.extend(collisions); - - self.bytes.set(self.aggregate.bytes_written as usize); - self.files.set(self.num_files.load(Ordering::Relaxed)); - - Ok(()) - } - - fn finalize(self) -> Result<Self::Output, Self::Error> { - Ok(self.aggregate) - } - } - } - pub use reduce::Reduce; - - #[derive(Default)] - pub struct Outcome<'a> { - pub collisions: Vec<checkout::Collision>, - pub errors: Vec<checkout::ErrorRecord>, - pub delayed: Vec<(&'a mut gix_index::Entry, &'a BStr)>, - pub bytes_written: u64, - } - - #[derive(Clone)] - pub struct Context<'a, Find: Clone> { - pub find: Find, - pub path_cache: fs::Cache, - pub buf: Vec<u8>, - pub options: checkout::Options, - /// We keep these shared so that there is the chance for printing numbers that aren't looking like - /// multiple of chunk sizes. Purely cosmetic. Otherwise it's the same as `files`. - pub num_files: &'a AtomicUsize, - } - - pub fn process<'entry, Find, E>( - entries_with_paths: impl Iterator<Item = (&'entry mut gix_index::Entry, &'entry BStr)>, - files: &mut impl Progress, - bytes: &mut impl Progress, - ctx: &mut Context<'_, Find>, - ) -> Result<Outcome<'entry>, checkout::Error<E>> - where - Find: for<'a> FnMut(&oid, &'a mut Vec<u8>) -> Result<gix_object::BlobRef<'a>, E> + Clone, - E: std::error::Error + Send + Sync + 'static, - { - let mut delayed = Vec::new(); - let mut collisions = Vec::new(); - let mut errors = Vec::new(); - let mut bytes_written = 0; - - for (entry, entry_path) in entries_with_paths { - // TODO: write test for that - if entry.flags.contains(gix_index::entry::Flags::SKIP_WORKTREE) { - files.inc(); - continue; - } - - // Symlinks always have to be delayed on windows as they have to point to something that exists on creation. - // And even if not, there is a distinction between file and directory symlinks, hence we have to check what the target is - // before creating it. - // And to keep things sane, we just do the same on non-windows as well which is similar to what git does and adds some safety - // around writing through symlinks (even though we handle this). - // This also means that we prefer content in files over symlinks in case of collisions, which probably is for the better, too. - if entry.mode == gix_index::entry::Mode::SYMLINK { - delayed.push((entry, entry_path)); - continue; - } - - bytes_written += - checkout_entry_handle_result(entry, entry_path, &mut errors, &mut collisions, files, bytes, ctx)? - as u64; - } - - Ok(Outcome { - bytes_written, - errors, - collisions, - delayed, - }) - } - - pub fn checkout_entry_handle_result<Find, E>( - entry: &mut gix_index::Entry, - entry_path: &BStr, - errors: &mut Vec<checkout::ErrorRecord>, - collisions: &mut Vec<checkout::Collision>, - files: &mut impl Progress, - bytes: &mut impl Progress, - Context { - find, - path_cache, - buf, - options, - num_files, - }: &mut Context<'_, Find>, - ) -> Result<usize, checkout::Error<E>> - where - Find: for<'a> FnMut(&oid, &'a mut Vec<u8>) -> Result<gix_object::BlobRef<'a>, E> + Clone, - E: std::error::Error + Send + Sync + 'static, - { - let res = entry::checkout( - entry, - entry_path, - entry::Context { find, path_cache, buf }, - options.clone(), - ); - files.inc(); - num_files.fetch_add(1, Ordering::SeqCst); - match res { - Ok(object_size) => { - bytes.inc_by(object_size); - Ok(object_size) - } - Err(index::checkout::Error::Io(err)) if os::indicates_collision(&err) => { - // We are here because a file existed or was blocked by a directory which shouldn't be possible unless - // we are on a file insensitive file system. - files.fail(format!("{}: collided ({:?})", entry_path, err.kind())); - collisions.push(checkout::Collision { - path: entry_path.into(), - error_kind: err.kind(), - }); - Ok(0) - } - Err(err) => { - if options.keep_going { - errors.push(checkout::ErrorRecord { - path: entry_path.into(), - error: Box::new(err), - }); - Ok(0) - } else { - Err(err) - } - } - } - } -} diff --git a/vendor/gix-worktree/src/lib.rs b/vendor/gix-worktree/src/lib.rs index 9a67e0289..2626fe508 100644 --- a/vendor/gix-worktree/src/lib.rs +++ b/vendor/gix-worktree/src/lib.rs @@ -1,3 +1,7 @@ +//! A crate with all index-centric functionality that is interacting with a worktree. +//! +//! Unless specified differently, all operations need an index file (e.g. `.git/index`) as driver. +//! //! ## Feature Flags #![cfg_attr( feature = "document-features", @@ -5,11 +9,51 @@ )] #![cfg_attr(docsrs, feature(doc_cfg, doc_auto_cfg))] #![deny(missing_docs, rust_2018_idioms, unsafe_code)] +use bstr::BString; -/// file system related utilities -pub mod fs; +/// +pub mod read; + +/// A cache for efficiently executing operations on directories and files which are encountered in sorted order. +/// That way, these operations can be re-used for subsequent invocations in the same directory. +/// +/// This cache can be configured to create directories efficiently, read git-ignore files and git-attribute files, +/// in any combination. +/// +/// A cache for directory creation to reduce the amount of stat calls when creating +/// directories safely, that is without following symlinks that might be on the way. +/// +/// As a special case, it offers a 'prefix' which (by itself) is assumed to exist and may contain symlinks. +/// Everything past that prefix boundary must not contain a symlink. We do this by allowing any input path. +/// +/// Another added benefit is its ability to store the path of full path of the entry to which leading directories +/// are to be created to avoid allocating memory. +/// +/// For this to work, it remembers the last 'good' path to a directory and assumes that all components of it +/// are still valid, too. +/// As directories are created, the cache will be adjusted to reflect the latest seen directory. +/// +/// The caching is only useful if consecutive calls to create a directory are using a sorted list of entries. +#[derive(Clone)] +pub struct Cache { + stack: gix_fs::Stack, + /// tells us what to do as we change paths. + state: cache::State, + /// A buffer used when reading attribute or ignore files or their respective objects from the object database. + buf: Vec<u8>, + /// If case folding should happen when looking up attributes or exclusions. + case: gix_glob::pattern::Case, + /// A lookup table for object ids to read from in some situations when looking up attributes or exclusions. + id_mappings: Vec<PathIdMapping>, + statistics: cache::Statistics, +} + +pub(crate) type PathIdMapping = (BString, gix_hash::ObjectId); /// -pub mod index; +pub mod cache; +pub mod checkout; +pub use checkout::function::checkout; -pub(crate) mod os; +pub mod status; +pub use status::function::status; diff --git a/vendor/gix-worktree/src/os.rs b/vendor/gix-worktree/src/os.rs deleted file mode 100644 index a297e73cd..000000000 --- a/vendor/gix-worktree/src/os.rs +++ /dev/null @@ -1,50 +0,0 @@ -use std::{io, io::ErrorKind::AlreadyExists, path::Path}; - -#[cfg(not(windows))] -pub fn create_symlink(original: &Path, link: &Path) -> io::Result<()> { - std::os::unix::fs::symlink(original, link) -} - -#[cfg(not(windows))] -pub fn remove_symlink(path: &Path) -> io::Result<()> { - std::fs::remove_file(path) -} - -// TODO: use the `symlink` crate once it can delete directory symlinks -#[cfg(windows)] -pub fn remove_symlink(path: &Path) -> io::Result<()> { - if let Ok(meta) = std::fs::metadata(path) { - if meta.is_file() { - std::fs::remove_file(path) // this removes the link itself - } else { - std::fs::remove_dir(path) // however, this sees the destination directory, which isn't the right thing actually - } - } else { - std::fs::remove_file(path).or_else(|_| std::fs::remove_dir(path)) - } -} - -#[cfg(windows)] -pub fn create_symlink(original: &Path, link: &Path) -> io::Result<()> { - use std::os::windows::fs::{symlink_dir, symlink_file}; - // TODO: figure out if links to links count as files or whatever they point at - if std::fs::metadata(link.parent().expect("dir for link").join(original))?.is_dir() { - symlink_dir(original, link) - } else { - symlink_file(original, link) - } -} - -#[cfg(not(windows))] -pub fn indicates_collision(err: &std::io::Error) -> bool { - // TODO: use ::IsDirectory as well when stabilized instead of raw_os_error(), and ::FileSystemLoop respectively - err.kind() == AlreadyExists - || err.raw_os_error() == Some(21) - || err.raw_os_error() == Some(62) // no-follow on symlnk on mac-os - || err.raw_os_error() == Some(40) // no-follow on symlnk on ubuntu -} - -#[cfg(windows)] -pub fn indicates_collision(err: &std::io::Error) -> bool { - err.kind() == AlreadyExists || err.kind() == std::io::ErrorKind::PermissionDenied -} diff --git a/vendor/gix-worktree/src/read.rs b/vendor/gix-worktree/src/read.rs new file mode 100644 index 000000000..a54fc2c76 --- /dev/null +++ b/vendor/gix-worktree/src/read.rs @@ -0,0 +1,64 @@ +//! This module allows creating git blobs from worktree files. +//! +//! For the most part a blob just contains the raw on-disk data. However symlinks need to be considered properly +//! and attributes/config options need to be considered. + +use std::{ + fs::{read_link, File}, + io::{self, Read}, + path::Path, +}; + +use gix_object::Blob; +use gix_path as path; + +// TODO: tests + +// TODO: what to do about precompose unicode and ignore_case for symlinks + +/// Create a blob from a file or symlink. +pub fn blob(path: &Path, capabilities: &gix_fs::Capabilities) -> io::Result<Blob> { + let mut data = Vec::new(); + data_to_buf(path, &mut data, capabilities)?; + Ok(Blob { data }) +} + +/// Create a blob from a file or symlink. +pub fn blob_with_meta(path: &Path, is_symlink: bool, capabilities: &gix_fs::Capabilities) -> io::Result<Blob> { + let mut data = Vec::new(); + data_to_buf_with_meta(path, &mut data, is_symlink, capabilities)?; + Ok(Blob { data }) +} + +/// Create blob data from a file or symlink. +pub fn data_to_buf<'a>(path: &Path, buf: &'a mut Vec<u8>, capabilities: &gix_fs::Capabilities) -> io::Result<&'a [u8]> { + data_to_buf_with_meta(path, buf, path.symlink_metadata()?.is_symlink(), capabilities) +} + +/// Create a blob from a file or symlink. +pub fn data_to_buf_with_meta<'a>( + path: &Path, + buf: &'a mut Vec<u8>, + is_symlink: bool, + capabilities: &gix_fs::Capabilities, +) -> io::Result<&'a [u8]> { + buf.clear(); + // symlinks are only stored as actual symlinks if the FS supports it otherwise they are just + // normal files with their content equal to the linked path (so can be read normally) + // + if is_symlink && capabilities.symlink { + // conversion to bstr can never fail because symlinks are only used + // on unix (by git) so no reason to use the try version here + let symlink_path = path::into_bstr(read_link(path)?); + buf.extend_from_slice(&symlink_path); + // TODO: there is no reason this should be a clone + // std isn't great about allowing users to avoid allocations but we could + // simply write our own wrapper around libc::readlink which reuses the + // buffer. This would require unsafe code tough (obviously) + } else { + buf.clear(); + File::open(path)?.read_to_end(buf)?; + // TODO apply filters + } + Ok(buf.as_slice()) +} diff --git a/vendor/gix-worktree/src/status/content.rs b/vendor/gix-worktree/src/status/content.rs new file mode 100644 index 000000000..d47749ef8 --- /dev/null +++ b/vendor/gix-worktree/src/status/content.rs @@ -0,0 +1,86 @@ +use gix_features::hash; +use gix_hash::ObjectId; +use gix_index as index; +use gix_object::encode::loose_header; +use index::Entry; + +/// Compares the content of two blobs in some way. +pub trait CompareBlobs { + /// Output data produced by [`compare_blobs()`][CompareBlobs::compare_blobs()]. + type Output; + + /// Providing the underlying index `entry`, allow comparing a file in the worktree of size `worktree_blob_size` + /// and allow reading its bytes using `worktree_blob`. + /// If this function returns `None` the `entry` and the `worktree_blob` are assumed to be identical. + /// Use `entry_blob` to obtain the data for the blob referred to by `entry`, allowing comparisons of the data itself. + fn compare_blobs<'a, E>( + &mut self, + entry: &'a gix_index::Entry, + worktree_blob_size: usize, + worktree_blob: impl ReadDataOnce<'a, E>, + entry_blob: impl ReadDataOnce<'a, E>, + ) -> Result<Option<Self::Output>, E>; +} + +/// Lazy borrowed access to blob data. +pub trait ReadDataOnce<'a, E> { + /// Returns the contents of this blob. + /// + /// This potentially performs IO and other expensive operations + /// and should only be called when necessary. + fn read_data(self) -> Result<&'a [u8], E>; +} + +/// Compares to blobs by comparing their size and oid, and only looks at the file if +/// the size matches, therefore it's very fast. +#[derive(Clone)] +pub struct FastEq; + +impl CompareBlobs for FastEq { + type Output = (); + + fn compare_blobs<'a, E>( + &mut self, + entry: &'a Entry, + worktree_blob_size: usize, + worktree_blob: impl ReadDataOnce<'a, E>, + _entry_blob: impl ReadDataOnce<'a, E>, + ) -> Result<Option<Self::Output>, E> { + // make sure to account for racily smudged entries here so that they don't always keep + // showing up as modified even after their contents have changed again, to a potentially + // unmodified state. That means that we want to ignore stat.size == 0 for non_empty_blobs. + if entry.stat.size as usize != worktree_blob_size && (entry.id.is_empty_blob() || entry.stat.size != 0) { + return Ok(Some(())); + } + let blob = worktree_blob.read_data()?; + let file_hash = gix_object::compute_hash(entry.id.kind(), gix_object::Kind::Blob, blob); + Ok((entry.id != file_hash).then_some(())) + } +} + +/// Compares files to blobs by *always* comparing their hashes. +/// +/// Same as [`FastEq`] but does not contain a fast path for files with mismatched files and +/// therefore always returns an OID that can be reused later. +#[derive(Clone)] +pub struct HashEq; + +impl CompareBlobs for HashEq { + type Output = ObjectId; + + fn compare_blobs<'a, E>( + &mut self, + entry: &'a Entry, + _worktree_blob_size: usize, + worktree_blob: impl ReadDataOnce<'a, E>, + _entry_blob: impl ReadDataOnce<'a, E>, + ) -> Result<Option<Self::Output>, E> { + let blob = worktree_blob.read_data()?; + let header = loose_header(gix_object::Kind::Blob, blob.len()); + let mut hasher = hash::hasher(entry.id.kind()); + hasher.update(&header); + hasher.update(blob); + let file_hash: ObjectId = hasher.digest().into(); + Ok((entry.id != file_hash).then_some(file_hash)) + } +} diff --git a/vendor/gix-worktree/src/status/function.rs b/vendor/gix-worktree/src/status/function.rs new file mode 100644 index 000000000..5e01628b4 --- /dev/null +++ b/vendor/gix-worktree/src/status/function.rs @@ -0,0 +1,331 @@ +use std::{io, marker::PhantomData, path::Path}; + +use bstr::BStr; +use filetime::FileTime; +use gix_features::parallel::{in_parallel_if, Reduce}; + +use crate::{ + read, + status::{ + content, + content::CompareBlobs, + types::{Error, Options}, + Change, VisitEntry, + }, +}; + +/// Calculates the changes that need to be applied to an `index` to match the state of the `worktree` and makes them +/// observable in `collector`, along with information produced by `compare` which gets to see blobs that may have changes. +/// `options` are used to configure the operation. +/// +/// Note that `index` is updated with the latest seen stat information from the worktree, and its timestamp is adjusted to +/// the current time for which it will be considered fresh. +/// +/// Note that this isn't technically quite what this function does as this also provides some additional information, +/// like whether a file has conflicts, and files that were added with `git add` are shown as a special +/// changes despite not technically requiring a change to the index since `git add` already added the file to the index. +pub fn status<'index, T, Find, E>( + index: &'index mut gix_index::State, + worktree: &Path, + collector: &mut impl VisitEntry<'index, ContentChange = T>, + compare: impl CompareBlobs<Output = T> + Send + Clone, + find: Find, + options: Options, +) -> Result<(), Error> +where + T: Send, + E: std::error::Error + Send + Sync + 'static, + Find: for<'a> FnMut(&gix_hash::oid, &'a mut Vec<u8>) -> Result<gix_object::BlobRef<'a>, E> + Send + Clone, +{ + // the order is absolutely critical here we use the old timestamp to detect racy index entries + // (modified at or after the last index update) during the index update we then set those + // entries size to 0 (see below) to ensure they keep showing up as racy and reset the timestamp. + let timestamp = index.timestamp(); + index.set_timestamp(FileTime::now()); + let (chunk_size, thread_limit, _) = gix_features::parallel::optimize_chunk_size_and_thread_limit( + 100, + index.entries().len().into(), + options.thread_limit, + None, + ); + let (entries, path_backing) = index.entries_mut_and_pathbacking(); + in_parallel_if( + || true, // TODO: heuristic: when is parallelization not worth it? + entries.chunks_mut(chunk_size), + thread_limit, + { + let options = &options; + move |_| { + ( + State { + buf: Vec::new(), + odb_buf: Vec::new(), + timestamp, + path_backing, + worktree, + options, + }, + compare.clone(), + find.clone(), + ) + } + }, + |entries, (state, diff, find)| { + entries + .iter_mut() + .filter_map(|entry| state.process(entry, diff, find)) + .collect() + }, + ReduceChange { + collector, + phantom: PhantomData, + }, + ) +} + +struct State<'a, 'b> { + buf: Vec<u8>, + odb_buf: Vec<u8>, + timestamp: FileTime, + // path_cache: fs::Cache TODO path cache + path_backing: &'b [u8], + worktree: &'a Path, + options: &'a Options, +} + +type StatusResult<'index, T> = Result<(&'index gix_index::Entry, &'index BStr, Option<Change<T>>, bool), Error>; + +impl<'index> State<'_, 'index> { + fn process<T, Find, E>( + &mut self, + entry: &'index mut gix_index::Entry, + diff: &mut impl CompareBlobs<Output = T>, + find: &mut Find, + ) -> Option<StatusResult<'index, T>> + where + E: std::error::Error + Send + Sync + 'static, + Find: for<'a> FnMut(&gix_hash::oid, &'a mut Vec<u8>) -> Result<gix_object::BlobRef<'a>, E> + Send + Clone, + { + let conflict = match entry.stage() { + 0 => false, + 1 => true, + _ => return None, + }; + if entry.flags.intersects( + gix_index::entry::Flags::UPTODATE + | gix_index::entry::Flags::SKIP_WORKTREE + | gix_index::entry::Flags::ASSUME_VALID + | gix_index::entry::Flags::FSMONITOR_VALID, + ) { + return None; + } + let path = entry.path_in(self.path_backing); + let status = self.compute_status(&mut *entry, path, diff, find); + Some(status.map(move |status| (&*entry, path, status, conflict))) + } + + /// # On how racy-git is handled here + /// + /// Basically the racy detection is a safety mechanism that ensures we can always just compare the stat + /// information between index and worktree and if they match we don't need to look at the content. + /// This usually just works but if a file updates quickly we could run into the following situation: + /// + /// * save file version `A` from disk into worktree (git add) + /// * file is changed so fast that the mtime doesn't change - *we only looks at seconds by default* + /// * file contents change but file-size stays the same, so `"foo" -> "bar"` has the same size but different content + /// + /// Now both `mtime` and `size`, and all other stat information, is the same but the file has actually changed. + /// This case is called *racily clean*. *The file should show up as changed but due to a data race it doesn't.* + /// This is the racy git problem. + /// + /// To solve this we do the following trick: Whenever we modify the index, which includes `git status`, we save the + /// current timestamp before the modification starts. This timestamp fundamentally represents a checkpoint of sorts. + /// We "promise" ourselves that after the modification finishes all entries modified before this timestamp have the + /// racy git problem resolved. + /// + /// So now when we modify the index we must resolve the racy git problem somehow. To do that we only need to look at + /// unchanged entries. Changed entries are not interesting since they are already showing up as changed anyway so there + /// isn't really a race-condition to worry about. This also explains why removing the `return` here doesn't have an apparent effect. + /// This entire branch here is just the optimization of "don't even look at index entries where the stat hasn't changed". + /// If we don't have this optimization the result shouldn't change, our status implementation will just be super slow :D + + /// We calculate whether this change is `racy_clean`, so if the last `timestamp` is before or the same as the `mtime` of the entry + /// which is what `new_stat.is_racy(..)` does in the branch, and only if we are sure that there is no race condition + /// do we `return` early. Since we don't `return` early we just do a full content comparison below, + /// which always yields the correct result, there is no race condition there. + /// + /// If a file showed up as racily clean and didn't change then we don't need to do anything. After this status check is + /// complete and the file won't show up as racily clean anymore, since it's mtime is now before the new timestamp. + /// However if the file did actually change then we really ran into one of those rare race conditions in that case we, + /// and git does the same, set the size of the file in the index to 0. This will always make the file show up as changed. + /// This adds the need to treat all files of size 0 in the index as changed. This is not quite right of course because 0 sized files + /// could be entirely valid and unchanged. Therefore this only applies if the oid doesn't match the oid of an empty file, + /// which is a constant. + /// + /// Adapted from [here](https://github.com/Byron/gitoxide/pull/805#discussion_r1164676777). + fn compute_status<T, Find, E>( + &mut self, + entry: &mut gix_index::Entry, + git_path: &BStr, + diff: &mut impl CompareBlobs<Output = T>, + find: &mut Find, + ) -> Result<Option<Change<T>>, Error> + where + E: std::error::Error + Send + Sync + 'static, + Find: for<'a> FnMut(&gix_hash::oid, &'a mut Vec<u8>) -> Result<gix_object::BlobRef<'a>, E> + Send + Clone, + { + // TODO fs cache + let worktree_path = gix_path::try_from_bstr(git_path).map_err(|_| Error::IllformedUtf8)?; + let worktree_path = self.worktree.join(worktree_path); + let metadata = match worktree_path.symlink_metadata() { + // TODO: check if any parent directory is a symlink + // we need to use fs::Cache for that + Ok(metadata) if metadata.is_dir() => { + // index entries are normally only for files/symlinks + // if a file turned into a directory it was removed + // the only exception here are submodules which are + // part of the index despite being directories + // + // TODO: submodules: + // if entry.mode.contains(Mode::COMMIT) && + // resolve_gitlink_ref(ce->name, "HEAD", &sub)) + return Ok(Some(Change::Removed)); + } + Ok(metadata) => metadata, + Err(err) if err.kind() == io::ErrorKind::NotFound => return Ok(Some(Change::Removed)), + Err(err) => { + return Err(err.into()); + } + }; + if entry.flags.contains(gix_index::entry::Flags::INTENT_TO_ADD) { + return Ok(Some(Change::IntentToAdd)); + } + let new_stat = gix_index::entry::Stat::from_fs(&metadata)?; + let executable_bit_changed = + match entry + .mode + .change_to_match_fs(&metadata, self.options.fs.symlink, self.options.fs.executable_bit) + { + Some(gix_index::entry::mode::Change::Type { .. }) => return Ok(Some(Change::Type)), + Some(gix_index::entry::mode::Change::ExecutableBit) => true, + None => false, + }; + + // Here we implement racy-git. See racy-git.txt in the git documentation for a detailed documentation. + // + // A file is racy if: + // 1. its `mtime` is at or after the last index timestamp and its entry stat information + // matches the on-disk file but the file contents are actually modified + // 2. it's size is 0 (set after detecting a file was racy previously) + // + // The first case is detected below by checking the timestamp if the file is marked unmodified. + // The second case is usually detected either because the on-disk file is not empty, hence + // the basic stat match fails, or by checking whether the size doesn't fit the oid. + let mut racy_clean = false; + if !executable_bit_changed + && new_stat.matches(&entry.stat, self.options.stat) + // TODO: find a test for the following line or remove it. Is this more often hit with smudge/clean filters? + && (!entry.id.is_empty_blob() || entry.stat.size == 0) + { + racy_clean = new_stat.is_racy(self.timestamp, self.options.stat); + if !racy_clean { + return Ok(None); + } + } + + let read_file = WorktreeBlob { + buf: &mut self.buf, + path: &worktree_path, + entry, + options: self.options, + }; + let read_blob = OdbBlob { + buf: &mut self.odb_buf, + id: &entry.id, + find, + }; + let content_change = diff.compare_blobs::<Error>(entry, metadata.len() as usize, read_file, read_blob)?; + // This file is racy clean! Set the size to 0 so we keep detecting this as the file is updated. + if content_change.is_some() && racy_clean { + entry.stat.size = 0; + } + if content_change.is_some() || executable_bit_changed { + Ok(Some(Change::Modification { + executable_bit_changed, + content_change, + })) + } else { + // don't diff against this file next time since we know the file is unchanged. + entry.stat = new_stat; + Ok(None) + } + } +} + +struct ReduceChange<'a, 'index, T: VisitEntry<'index>> { + collector: &'a mut T, + phantom: PhantomData<fn(&'index ())>, +} + +impl<'index, T, C: VisitEntry<'index, ContentChange = T>> Reduce for ReduceChange<'_, 'index, C> { + type Input = Vec<StatusResult<'index, T>>; + + type FeedProduce = (); + + type Output = (); + + type Error = Error; + + fn feed(&mut self, items: Self::Input) -> Result<Self::FeedProduce, Self::Error> { + for item in items { + let (entry, path, change, conflict) = item?; + self.collector.visit_entry(entry, path, change, conflict); + } + Ok(()) + } + + fn finalize(self) -> Result<Self::Output, Self::Error> { + Ok(()) + } +} + +struct WorktreeBlob<'a> { + buf: &'a mut Vec<u8>, + path: &'a Path, + entry: &'a gix_index::Entry, + options: &'a Options, +} + +struct OdbBlob<'a, Find, E> +where + E: std::error::Error + Send + Sync + 'static, + Find: FnMut(&gix_hash::oid, &'a mut Vec<u8>) -> Result<gix_object::BlobRef<'a>, E>, +{ + buf: &'a mut Vec<u8>, + id: &'a gix_hash::oid, + find: Find, +} + +impl<'a> content::ReadDataOnce<'a, Error> for WorktreeBlob<'a> { + fn read_data(self) -> Result<&'a [u8], Error> { + let res = read::data_to_buf_with_meta( + self.path, + self.buf, + self.entry.mode == gix_index::entry::Mode::SYMLINK, + &self.options.fs, + )?; + Ok(res) + } +} + +impl<'a, Find, E> content::ReadDataOnce<'a, Error> for OdbBlob<'a, Find, E> +where + E: std::error::Error + Send + Sync + 'static, + Find: FnMut(&gix_hash::oid, &'a mut Vec<u8>) -> Result<gix_object::BlobRef<'a>, E>, +{ + fn read_data(mut self) -> Result<&'a [u8], Error> { + (self.find)(self.id, self.buf) + .map(|b| b.data) + .map_err(move |err| Error::Find(Box::new(err))) + } +} diff --git a/vendor/gix-worktree/src/status/mod.rs b/vendor/gix-worktree/src/status/mod.rs new file mode 100644 index 000000000..8294a54e8 --- /dev/null +++ b/vendor/gix-worktree/src/status/mod.rs @@ -0,0 +1,11 @@ +//! Changes between an index and a worktree. +/// +mod types; +pub use types::{Change, Error, Options, VisitEntry}; + +mod recorder; +pub use recorder::Recorder; + +/// +pub mod content; +pub(crate) mod function; diff --git a/vendor/gix-worktree/src/status/recorder.rs b/vendor/gix-worktree/src/status/recorder.rs new file mode 100644 index 000000000..ea10303ae --- /dev/null +++ b/vendor/gix-worktree/src/status/recorder.rs @@ -0,0 +1,27 @@ +use bstr::BStr; +use gix_index as index; + +use crate::status::{Change, VisitEntry}; + +/// Convenience implementation of [`VisitEntry`] that collects all non-trivial changes into a `Vec`. +#[derive(Debug, Default)] +pub struct Recorder<'index, T = ()> { + /// collected changes, index entries without conflicts or changes are excluded. + pub records: Vec<(&'index BStr, Option<Change<T>>, bool)>, +} + +impl<'index, T: Send> VisitEntry<'index> for Recorder<'index, T> { + type ContentChange = T; + + fn visit_entry( + &mut self, + _entry: &'index index::Entry, + rela_path: &'index BStr, + status: Option<Change<Self::ContentChange>>, + conflict: bool, + ) { + if conflict || status.is_some() { + self.records.push((rela_path, status, conflict)) + } + } +} diff --git a/vendor/gix-worktree/src/status/types.rs b/vendor/gix-worktree/src/status/types.rs new file mode 100644 index 000000000..3d488d24e --- /dev/null +++ b/vendor/gix-worktree/src/status/types.rs @@ -0,0 +1,69 @@ +use bstr::BStr; + +/// The error returned by [`status()`][crate::status()]. +#[derive(Debug, thiserror::Error)] +#[allow(missing_docs)] +pub enum Error { + #[error("Could not convert path to UTF8")] + IllformedUtf8, + #[error("The clock was off when reading file related metadata after updating a file on disk")] + Time(#[from] std::time::SystemTimeError), + #[error("IO error while writing blob or reading file metadata or changing filetype")] + Io(#[from] std::io::Error), + #[error("Failed to obtain blob from object database")] + Find(#[source] Box<dyn std::error::Error + Send + Sync + 'static>), +} + +#[derive(Clone, Default)] +/// Options that control how the index status with a worktree is computed. +pub struct Options { + /// Capabilities of the file system which affect the status computation. + pub fs: gix_fs::Capabilities, + /// If set, don't use more than this amount of threads. + /// Otherwise, usually use as many threads as there are logical cores. + /// A value of 0 is interpreted as no-limit + pub thread_limit: Option<usize>, + /// Options that control how stat comparisons are made when checking if a file is fresh. + pub stat: gix_index::entry::stat::Options, +} + +/// How an index entry needs to be changed to obtain the destination worktree state, i.e. `entry.apply(this_change) == worktree-entry`. +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Debug)] +pub enum Change<T = ()> { + /// This corresponding file does not exist in the worktree anymore. + Removed, + /// The type of file changed compared to the worktree, i.e. a symlink s now a file. + Type, + /// This worktree file was modified in some form, like a permission change or content change or both, + /// as compared to this entry. + Modification { + /// Indicates that one of the stat changes was an executable bit change + /// which is a significant change itself. + executable_bit_changed: bool, + /// The output of the [`CompareBlobs`][crate::status::content::CompareBlobs] run on this entry. + /// If there is no content change and only the executable bit + /// changed than this is `None`. + content_change: Option<T>, + }, + /// An index entry that correspond to an untracked worktree file marked with `git add --intent-to-add`. + /// + /// This means it's not available in the object database yet or the index was created from, + /// even though now an entry exists that represents the worktree file. + IntentToAdd, +} + +/// Observe changes by comparing an index entry to the worktree or another index. +pub trait VisitEntry<'index> { + /// Data generated by comparing an entry with a file. + type ContentChange; + /// Observe the `change` of `entry` at the repository-relative `rela_path`, indicating whether + /// or not it has a `conflict`. + /// If `change` is `None`, there is no change. + fn visit_entry( + &mut self, + entry: &'index gix_index::Entry, + rela_path: &'index BStr, + change: Option<Change<Self::ContentChange>>, + conflict: bool, + ); +} diff --git a/vendor/gix-worktree/src/untracked.rs b/vendor/gix-worktree/src/untracked.rs new file mode 100644 index 000000000..6e77d7fa3 --- /dev/null +++ b/vendor/gix-worktree/src/untracked.rs @@ -0,0 +1 @@ +// TODO: untracked file detection, needs fs::Cache |