feat: open::Options now allow controlling where gitattributes files are loaded from.

That way it's possible to, for example, isolate all operations that rely on the `gitattribute`
system, like checkouts or additions to the index.

Author: Byron

gix/src/config/cache/access.rs

@@ -1,4 +1,6 @@
 #![allow(clippy::result_large_err)]
+use gix_attributes::Source;
+use gix_glob::pattern::Case;
 use std::{borrow::Cow, path::PathBuf, time::Duration};
 
 use gix_lock::acquire::Fail;
@@ -154,33 +156,30 @@ impl Cache {
                 .unwrap_or(default))
         }
 
-        fn assemble_attribute_globals(
-            me: &Cache,
-            _git_dir: &std::path::Path,
-        ) -> Result<gix_attributes::Search, checkout_options::Error> {
-            let _attributes_file = match me
-                .trusted_file_path("core", None, Core::ATTRIBUTES_FILE.name)
-                .transpose()?
-            {
-                Some(attributes) => Some(attributes.into_owned()),
-                None => me.xdg_config_path("attributes").ok().flatten(),
-            };
-            // TODO: implement gix_attributes::Search::from_git_dir(), similar to what's done for `Ignore`.
-            Ok(Default::default())
-        }
-
         let thread_limit = self.apply_leniency(
             self.resolved
                 .integer_filter_by_key("checkout.workers", &mut self.filter_config_section.clone())
                 .map(|value| Checkout::WORKERS.try_from_workers(value)),
         )?;
+        let capabilities = gix_worktree::fs::Capabilities {
+            precompose_unicode: boolean(self, "core.precomposeUnicode", &Core::PRECOMPOSE_UNICODE, false)?,
+            ignore_case: boolean(self, "core.ignoreCase", &Core::IGNORE_CASE, false)?,
+            executable_bit: boolean(self, "core.fileMode", &Core::FILE_MODE, true)?,
+            symlink: boolean(self, "core.symlinks", &Core::SYMLINKS, true)?,
+        };
+        let case = if capabilities.ignore_case {
+            Case::Fold
+        } else {
+            Case::Sensitive
+        };
         Ok(gix_worktree::index::checkout::Options {
-            fs: gix_worktree::fs::Capabilities {
-                precompose_unicode: boolean(self, "core.precomposeUnicode", &Core::PRECOMPOSE_UNICODE, false)?,
-                ignore_case: boolean(self, "core.ignoreCase", &Core::IGNORE_CASE, false)?,
-                executable_bit: boolean(self, "core.fileMode", &Core::FILE_MODE, true)?,
-                symlink: boolean(self, "core.symlinks", &Core::SYMLINKS, true)?,
-            },
+            attributes: self.assemble_attribute_globals(
+                git_dir,
+                case,
+                gix_worktree::fs::cache::state::attributes::Source::AttributeListThenWorktree,
+                self.attributes,
+            )?,
+            fs: capabilities,
             thread_limit,
             destination_is_initially_empty: false,
             overwrite_existing: false,
@@ -193,23 +192,64 @@ impl Cache {
                         .map(|v| Core::CHECK_STAT.try_into_checkstat(v)),
                 )?
                 .unwrap_or(true),
-            attribute_globals: assemble_attribute_globals(self, git_dir)?,
         })
     }
+
+    // TODO: at least one test, maybe related to core.attributesFile configuration.
+    fn assemble_attribute_globals(
+        &self,
+        git_dir: &std::path::Path,
+        case: gix_glob::pattern::Case,
+        source: gix_worktree::fs::cache::state::attributes::Source,
+        attributes: crate::permissions::Attributes,
+    ) -> Result<gix_worktree::fs::cache::state::Attributes, config::attribute_stack::Error> {
+        let configured_or_user_attributes = match self
+            .trusted_file_path("core", None, Core::ATTRIBUTES_FILE.name)
+            .transpose()?
+        {
+            Some(attributes) => Some(attributes),
+            None => {
+                if attributes.git {
+                    self.xdg_config_path("attributes").ok().flatten().map(Cow::Owned)
+                } else {
+                    None
+                }
+            }
+        };
+        let attribute_files = [gix_attributes::Source::GitInstallation, gix_attributes::Source::System]
+            .into_iter()
+            .filter(|source| match source {
+                Source::GitInstallation => attributes.git_binary,
+                Source::System => attributes.system,
+                Source::Git | Source::Local => unreachable!("we don't offer turning this off right now"),
+            })
+            .filter_map(|source| source.storage_location(&mut Self::make_source_env(self.environment)))
+            .chain(configured_or_user_attributes);
+        let info_attributes_path = git_dir.join("info").join("attributes");
+        let mut buf = Vec::new();
+        Ok(gix_worktree::fs::cache::state::Attributes::new(
+            gix_attributes::Search::new_globals(attribute_files, &mut buf)?,
+            Default::default(),
+            Some(info_attributes_path),
+            case,
+            source,
+        ))
+    }
+
     pub(crate) fn xdg_config_path(
         &self,
         resource_file_name: &str,
     ) -> Result<Option<PathBuf>, gix_sec::permission::Error<PathBuf>> {
         std::env::var_os("XDG_CONFIG_HOME")
-            .map(|path| (PathBuf::from(path), &self.xdg_config_home_env))
+            .map(|path| (PathBuf::from(path), &self.environment.xdg_config_home))
             .or_else(|| {
                 gix_path::env::home_dir().map(|mut p| {
                     (
                         {
                             p.push(".config");
                             p
                         },
-                        &self.home_env,
+                        &self.environment.home,
                     )
                 })
             })
@@ -225,6 +265,6 @@ impl Cache {
     /// We never fail for here even if the permission is set to deny as we `gix-config` will fail later
     /// if it actually wants to use the home directory - we don't want to fail prematurely.
     pub(crate) fn home_dir(&self) -> Option<PathBuf> {
-        gix_path::env::home_dir().and_then(|path| self.home_env.check_opt(path))
+        gix_path::env::home_dir().and_then(|path| self.environment.home.check_opt(path))
     }
 }

gix/src/config/cache/init.rs

@@ -1,5 +1,6 @@
 #![allow(clippy::result_large_err)]
 use std::borrow::Cow;
+use std::ffi::OsString;
 
 use gix_sec::Permission;
 
@@ -32,15 +33,16 @@ impl Cache {
         filter_config_section: fn(&gix_config::file::Metadata) -> bool,
         git_install_dir: Option<&std::path::Path>,
         home: Option<&std::path::Path>,
-        repository::permissions::Environment {
+        environment @ repository::permissions::Environment {
             git_prefix,
-            home: home_env,
-            xdg_config_home: xdg_config_home_env,
             ssh_prefix: _,
+            xdg_config_home: _,
+            home: _,
             http_transport,
             identity,
             objects,
         }: repository::permissions::Environment,
+        attributes: repository::permissions::Attributes,
         repository::permissions::Config {
             git_binary: use_installation,
             system: use_system,
@@ -69,8 +71,6 @@ impl Cache {
         };
 
         let config = {
-            let home_env = &home_env;
-            let xdg_config_home_env = &xdg_config_home_env;
             let git_prefix = &git_prefix;
             let metas = [
                 gix_config::source::Kind::GitInstallation,
@@ -88,15 +88,7 @@ impl Cache {
                     _ => {}
                 }
                 source
-                    .storage_location(&mut |name| {
-                        match name {
-                            git_ if git_.starts_with("GIT_") => Some(git_prefix),
-                            "XDG_CONFIG_HOME" => Some(xdg_config_home_env),
-                            "HOME" => Some(home_env),
-                            _ => None,
-                        }
-                        .and_then(|perm| perm.check_opt(name).and_then(gix_path::env::var))
-                    })
+                    .storage_location(&mut Self::make_source_env(environment))
                     .map(|p| (source, p.into_owned()))
             })
             .map(|(source, path)| gix_config::file::Metadata {
@@ -175,9 +167,9 @@ impl Cache {
             ignore_case,
             hex_len,
             filter_config_section,
-            xdg_config_home_env,
-            home_env,
+            environment,
             lenient_config,
+            attributes,
             user_agent: Default::default(),
             personas: Default::default(),
             url_rewrite: Default::default(),
@@ -240,6 +232,31 @@ impl Cache {
 
         Ok(())
     }
+
+    pub(crate) fn make_source_env(
+        crate::permissions::Environment {
+            xdg_config_home,
+            git_prefix,
+            home,
+            ..
+        }: crate::permissions::Environment,
+    ) -> impl FnMut(&str) -> Option<OsString> {
+        move |name| {
+            match name {
+                git_ if git_.starts_with("GIT_") => Some(git_prefix),
+                "XDG_CONFIG_HOME" => Some(xdg_config_home),
+                "HOME" => {
+                    return if home.is_allowed() {
+                        gix_path::env::home_dir().map(Into::into)
+                    } else {
+                        None
+                    }
+                }
+                _ => None,
+            }
+            .and_then(|perm| perm.check_opt(name).and_then(gix_path::env::var))
+        }
+    }
 }
 
 impl crate::Repository {

gix/src/config/mod.rs

@@ -113,6 +113,19 @@ pub mod checkout_options {
         ConfigBoolean(#[from] super::boolean::Error),
         #[error(transparent)]
         CheckoutWorkers(#[from] super::checkout::workers::Error),
+        #[error(transparent)]
+        Attributes(#[from] super::attribute_stack::Error),
+    }
+}
+
+///
+pub mod attribute_stack {
+    /// The error produced when setting up the attribute stack to query `gitattributes`.
+    #[derive(Debug, thiserror::Error)]
+    #[allow(missing_docs)]
+    pub enum Error {
+        #[error("An attribute file could not be read")]
+        Io(#[from] std::io::Error),
         #[error("Failed to interpolate the attribute file configured at `core.attributesFile`")]
         AttributesFileInterpolation(#[from] gix_config::path::interpolate::Error),
     }
@@ -449,9 +462,7 @@ pub(crate) struct Cache {
     /// If true, we should default what's possible if something is misconfigured, on case by case basis, to be more resilient.
     /// Also available in options! Keep in sync!
     pub lenient_config: bool,
-    /// Define how we can use values obtained with `xdg_config(…)` and its `XDG_CONFIG_HOME` variable.
-    xdg_config_home_env: gix_sec::Permission,
-    /// Define how we can use values obtained with `xdg_config(…)`. and its `HOME` variable.
-    home_env: gix_sec::Permission,
+    attributes: crate::permissions::Attributes,
+    environment: crate::permissions::Environment,
     // TODO: make core.precomposeUnicode available as well.
 }

gix/src/open/repository.rs

@@ -146,7 +146,12 @@ impl ThreadSafeRepository {
             lenient_config,
             bail_if_untrusted,
             open_path_as_is: _,
-            permissions: Permissions { ref env, config },
+            permissions:
+                Permissions {
+                    ref env,
+                    config,
+                    attributes,
+                },
             ref api_config_overrides,
             ref cli_config_overrides,
             ref current_dir,
@@ -190,7 +195,8 @@ impl ThreadSafeRepository {
             filter_config_section,
             git_install_dir.as_deref(),
             home.as_deref(),
-            env.clone(),
+            *env,
+            attributes,
             config,
             lenient_config,
             api_config_overrides,

gix/src/permissions.rs

@@ -1 +1 @@
-pub use crate::repository::permissions::{Config, Environment};
+pub use crate::repository::permissions::{Attributes, Config, Environment};