First steps of attribute cache initialization.

This is done to fully understand how attribute initialization works
with the current architecture, while taking care of its particular
difference compared to the handling of exclude patterns.

Author: Byron

gix-worktree/src/fs/cache/state/attributes.rs

@@ -0,0 +1,51 @@
+use crate::fs::cache::state::{AttributeMatchGroup, Attributes};
+use gix_glob::pattern::Case;
+use std::path::PathBuf;
+
+/// Decide where to read `.gitattributes` files from.
+#[derive(Default, Debug, Clone, Copy)]
+pub enum Source {
+    /// Retrieve attribute files from an attribute list, see
+    /// [State::attribute_list_from_index()][crate::fs::cache::State::attribute_list_from_index()].
+    ///
+    /// The attribute list is typically produced from an index. If a tree should be the source, build an attribute list
+    /// from a tree instead.
+    #[default]
+    AttributeList,
+    /// Read from an attribute list and if not present, read from the worktree.
+    AttributeListThenWorktree,
+    /// Read from the worktree and if not present, read from the attribute list.
+    WorktreeThenAttributeList,
+}
+
+/// Initialization
+impl Attributes {
+    /// Create a new instance from an attribute match group that represents `globals` and `overrides`.
+    /// `globals` contribute first and consist of all globally available, static files.
+    pub fn new(
+        globals: AttributeMatchGroup,
+        overrides: AttributeMatchGroup,
+        info_attributes: Option<PathBuf>,
+        case: Case,
+        source: Source,
+    ) -> Self {
+        let stack = AttributeMatchGroup::default();
+        Attributes {
+            globals,
+            stack,
+            overrides,
+            info_attributes,
+            case,
+            source,
+        }
+    }
+}
+
+/// Builder
+impl Attributes {
+    /// Set the case to use when matching attributes to paths.
+    pub fn with_case(mut self, case: gix_glob::pattern::Case) -> Self {
+        self.case = case;
+        self
+    }
+}

gix-worktree/src/fs/cache/state.rs renamed to gix-worktree/src/fs/cache/state/ignore.rs

@@ -1,23 +1,9 @@
-use std::path::Path;
-
+use crate::fs::cache::state::IgnoreMatchGroup;
+use crate::fs::PathOidMapping;
 use bstr::{BStr, BString, ByteSlice};
 use gix_glob::pattern::Case;
 use gix_hash::oid;
-
-use crate::fs::{cache::State, PathOidMapping};
-
-type AttributeMatchGroup = gix_attributes::Search;
-type IgnoreMatchGroup = gix_ignore::Search;
-
-/// 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,
-}
+use std::path::Path;
 
 /// State related to the exclusion of files.
 #[derive(Default, Clone)]
@@ -35,7 +21,7 @@ pub struct Ignore {
     /// (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,
+    pub(crate) 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,
@@ -199,118 +185,3 @@ impl Ignore {
         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")
-            }
-        }
-    }
-}

gix-worktree/src/fs/cache/state/mod.rs

@@ -0,0 +1,136 @@
+use bstr::ByteSlice;
+use gix_glob::pattern::Case;
+use std::path::PathBuf;
+
+use crate::fs::{cache::State, PathOidMapping};
+
+type AttributeMatchGroup = gix_attributes::Search;
+type IgnoreMatchGroup = gix_ignore::Search;
+
+/// State related to attributes associated with files in the repository.
+#[derive(Default, Clone)]
+#[allow(unused)]
+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,
+    /// Attribute assignments passed as additions or adjustments to everything else,
+    /// typically passed on the command-line.
+    overrides: 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>,
+    /// 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,
+    /// Where to read `.gitattributes` data from.
+    source: attributes::Source,
+}
+
+///
+pub mod attributes;
+mod ignore;
+pub use ignore::Ignore;
+
+/// Initialization
+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)
+    }
+}
+
+/// Utilities
+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 attribute_list_from_index(
+        &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")
+            }
+        }
+    }
+}

gix-worktree/src/index/checkout.rs

@@ -1,4 +1,5 @@
 #![allow(missing_docs)]
+
 use bstr::BString;
 
 #[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
@@ -58,8 +59,8 @@ pub struct Options {
     ///
     /// 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::Search,
+    /// A stack of attributes to use with the filesystem cache to use as driver for filters.
+    pub attributes: crate::fs::cache::state::Attributes,
 }
 
 impl Default for Options {
@@ -72,7 +73,7 @@ impl Default for Options {
             trust_ctime: true,
             check_stat: true,
             overwrite_existing: false,
-            attribute_globals: Default::default(),
+            attributes: Default::default(),
         }
     }
 }

gix-worktree/src/index/mod.rs

@@ -59,8 +59,8 @@ where
         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 state = fs::cache::State::for_checkout(options.overwrite_existing, options.attributes.clone().with_case(case));
+    let attribute_files = state.attribute_list_from_index(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),

gix-worktree/tests/worktree/fs/cache/ignore.rs

@@ -106,7 +106,7 @@ fn check_against_baseline() -> crate::Result {
         ),
     );
     let paths_storage = index.take_path_backing();
-    let attribute_files_in_index = state.build_attribute_list(&index, &paths_storage, case);
+    let attribute_files_in_index = state.attribute_list_from_index(&index, &paths_storage, case);
     assert_eq!(
         attribute_files_in_index,
         vec![(