adjust to changes in gix-attributes

Byron · Byron · commit 1755c81f64ce · 2023-04-13T22:45:41.000+02:00
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/gitoxide-core/src/repository/exclude.rs b/gitoxide-core/src/repository/exclude.rs
@@ -35,10 +35,7 @@ pub fn query(
         .worktree()
         .with_context(|| "Cannot check excludes without a current worktree")?;
     let index = worktree.index()?;
-    let mut cache = worktree.excludes(
-        &index,
-        Some(gix::attrs::MatchGroup::<gix::attrs::Ignore>::from_overrides(overrides)),
-    )?;
+    let mut cache = worktree.excludes(&index, Some(gix::ignore::Search::from_overrides(overrides)))?;
 
     let prefix = repo.prefix().expect("worktree - we have an index by now")?;
 
diff --git a/gix-worktree/Cargo.toml b/gix-worktree/Cargo.toml
@@ -24,7 +24,7 @@ required-features = ["internal-testing-to-avoid-being-run-by-cargo-test-all"]
 
 [features]
 ## Data structures implement `serde::Serialize` and `serde::Deserialize`.
-serde1 = [ "serde", "bstr/serde", "gix-index/serde1", "gix-hash/serde1", "gix-object/serde1" ]
+serde1 = [ "serde", "bstr/serde", "gix-index/serde1", "gix-hash/serde1", "gix-object/serde1", "gix-attributes/serde1", "gix-ignore/serde1" ]
 
 internal-testing-gix-features-parallel = ["gix-features/parallel"]
 internal-testing-to-avoid-being-run-by-cargo-test-all = []
@@ -37,6 +37,7 @@ gix-object = { version = "^0.28.0", path = "../gix-object" }
 gix-glob = { version = "^0.5.5", path = "../gix-glob" }
 gix-path = { version = "^0.7.3", path = "../gix-path" }
 gix-attributes = { version = "^0.10.0", path = "../gix-attributes" }
+gix-ignore = { version = "^0.1.0", path = "../gix-ignore" }
 gix-features = { version = "^0.28.0", path = "../gix-features" }
 
 serde = { version = "1.0.114", optional = true, default-features = false, features = ["derive"]}
diff --git a/gix-worktree/src/fs/cache/platform.rs b/gix-worktree/src/fs/cache/platform.rs
@@ -34,7 +34,7 @@ impl<'a> Platform<'a> {
     /// # Panics
     ///
     /// If the cache was configured without exclude patterns.
-    pub fn matching_exclude_pattern(&self) -> Option<gix_attributes::Match<'_, ()>> {
+    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.as_path()));
diff --git a/gix-worktree/src/fs/cache/state.rs b/gix-worktree/src/fs/cache/state.rs
@@ -6,8 +6,8 @@ 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>;
+type AttributeMatchGroup = gix_attributes::Search;
+type IgnoreMatchGroup = gix_ignore::Search;
 
 /// State related to attributes associated with files in the repository.
 #[derive(Default, Clone)]
@@ -44,6 +44,8 @@ pub struct Ignore {
 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`.
+    ///
+    // This is what it should be able represent: https://github.com/git/git/blob/140b9478dad5d19543c1cb4fd293ccec228f1240/dir.c#L3354
     // TODO: more docs
     pub fn new(
         overrides: IgnoreMatchGroup,
@@ -79,7 +81,7 @@ impl Ignore {
         relative_path: &BStr,
         is_dir: Option<bool>,
         case: Case,
-    ) -> Option<gix_attributes::Match<'_, ()>> {
+    ) -> Option<gix_ignore::search::Match<'_, ()>> {
         let groups = self.match_groups();
         let mut dir_match = None;
         if let Some((source, mapping)) = self
@@ -93,7 +95,7 @@ impl Ignore {
             })
             .next()
         {
-            let match_ = gix_attributes::Match {
+            let match_ = gix_ignore::search::Match {
                 pattern: &mapping.pattern,
                 value: &mapping.value,
                 sequence_number: mapping.sequence_number,
@@ -135,8 +137,14 @@ impl Ignore {
                 .enumerate()
                 .rev()
                 .find_map(|(plidx, pl)| {
-                    pl.pattern_idx_matching_relative_path(relative_path, basename_pos, is_dir, case)
-                        .map(|idx| (plidx, idx))
+                    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))
         })
@@ -163,17 +171,24 @@ impl Ignore {
         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)?
-        {
+        if !gix_glob::search::add_patterns_file(
+            &mut self.stack.patterns,
+            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));
+                    gix_glob::search::add_patterns_buffer(
+                        &mut self.stack.patterns,
+                        ignore_blob.data,
+                        ignore_path,
+                        Some(root),
+                    );
                 }
                 Err(_) => {
                     // Need one stack level per component so push and pop matches.
diff --git a/gix-worktree/src/index/checkout.rs b/gix-worktree/src/index/checkout.rs
@@ -1,6 +1,5 @@
 #![allow(missing_docs)]
 use bstr::BString;
-use gix_attributes::Attributes;
 use gix_utils::FilesystemCapabilities;
 
 #[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
@@ -61,7 +60,7 @@ 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::MatchGroup<Attributes>,
+    pub attribute_globals: gix_attributes::Search,
 }
 
 impl Default for Options {
diff --git a/gix-worktree/tests/worktree/fs/cache/ignore.rs b/gix-worktree/tests/worktree/fs/cache/ignore.rs
@@ -45,7 +45,7 @@ fn special_exclude_cases_we_handle_differently() {
         Default::default(),
         gix_worktree::fs::cache::state::Ignore::new(
             Default::default(),
-            gix_attributes::MatchGroup::from_git_dir(&git_dir, None, &mut buf).unwrap(),
+            gix_ignore::Search::from_git_dir(&git_dir, None, &mut buf).unwrap(),
             None,
             case,
         ),
@@ -99,8 +99,8 @@ fn check_against_baseline() -> crate::Result {
     let state = gix_worktree::fs::cache::State::for_add(
         Default::default(), // TODO: attribute tests
         gix_worktree::fs::cache::state::Ignore::new(
-            gix_attributes::MatchGroup::from_overrides(vec!["!force-include"]),
-            gix_attributes::MatchGroup::from_git_dir(&git_dir, Some(user_exclude_path), &mut buf)?,
+            gix_ignore::Search::from_overrides(vec!["!force-include"]),
+            gix_ignore::Search::from_git_dir(&git_dir, Some(user_exclude_path), &mut buf)?,
             None,
             case,
         ),
diff --git a/gix-worktree/tests/worktree/fs/cache/mod.rs b/gix-worktree/tests/worktree/fs/cache/mod.rs
@@ -1,4 +1,4 @@
 mod create_directory;
 
 #[allow(unused)]
-mod ignore_and_attributes;
+mod ignore;
diff --git a/gix/Cargo.toml b/gix/Cargo.toml
@@ -65,6 +65,7 @@ serde1 = [  "serde",
             "gix-mailmap/serde1",
             "gix-url/serde1",
             "gix-attributes/serde1",
+            "gix-ignore/serde1",
             "gix-revision/serde1",
             "gix-credentials/serde1" ]
 
@@ -138,6 +139,7 @@ gix-mailmap = { version = "^0.11.0", path = "../gix-mailmap" }
 gix-features = { version = "^0.28.1", path = "../gix-features", features = ["progress", "once_cell"] }
 
 gix-attributes = { version = "^0.10.0", path = "../gix-attributes" }
+gix-ignore = { version = "^0.1.0", path = "../gix-ignore" }
 gix-glob = { version = "^0.5.5", path = "../gix-glob" }
 gix-credentials = { version = "^0.12.0", path = "../gix-credentials" }
 gix-prompt = { version = "^0.3.3", path = "../gix-prompt" }
diff --git a/gix/src/config/cache/access.rs b/gix/src/config/cache/access.rs
@@ -157,15 +157,15 @@ impl Cache {
         fn assemble_attribute_globals(
             me: &Cache,
             _git_dir: &std::path::Path,
-        ) -> Result<gix_attributes::MatchGroup, checkout_options::Error> {
+        ) -> 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::MatchGroup::<gix_attributes::Attributes>::from_git_dir(), similar to what's done for `Ignore`.
+            // TODO: implement gix_attributes::Search::from_git_dir(), similar to what's done for `Ignore`.
             Ok(Default::default())
         }
 
@@ -203,7 +203,7 @@ impl Cache {
         std::env::var_os("XDG_CONFIG_HOME")
             .map(|path| (PathBuf::from(path), &self.xdg_config_home_env))
             .or_else(|| {
-                gix_path::home_dir().map(|mut p| {
+                gix_path::env::home_dir().map(|mut p| {
                     (
                         {
                             p.push(".config");
@@ -225,6 +225,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::home_dir().and_then(|path| self.home_env.check_opt(path))
+        gix_path::env::home_dir().and_then(|path| self.home_env.check_opt(path))
     }
 }
diff --git a/gix/src/config/cache/init.rs b/gix/src/config/cache/init.rs
@@ -95,7 +95,7 @@ impl Cache {
                             "HOME" => Some(home_env),
                             _ => None,
                         }
-                        .and_then(|perm| perm.check_opt(name).and_then(gix_path::env_var))
+                        .and_then(|perm| perm.check_opt(name).and_then(gix_path::env::var))
                     })
                     .map(|p| (source, p.into_owned()))
             })
diff --git a/gix/src/lib.rs b/gix/src/lib.rs
@@ -75,6 +75,7 @@ use gix_features::threading::OwnShared;
 pub use gix_features::{parallel, progress::Progress, threading};
 pub use gix_glob as glob;
 pub use gix_hash as hash;
+pub use gix_ignore as ignore;
 #[doc(inline)]
 pub use gix_index as index;
 pub use gix_lock as lock;
diff --git a/gix/src/open/repository.rs b/gix/src/open/repository.rs
@@ -180,7 +180,7 @@ impl ThreadSafeRepository {
         };
         let head = refs.find("HEAD").ok();
         let git_install_dir = crate::path::install_dir().ok();
-        let home = gix_path::home_dir().and_then(|home| env.home.check_opt(home));
+        let home = gix_path::env::home_dir().and_then(|home| env.home.check_opt(home));
 
         let mut filter_config_section = filter_config_section.unwrap_or(config::section::is_trusted);
         let config = config::Cache::from_stage_one(
diff --git a/gix/src/worktree/mod.rs b/gix/src/worktree/mod.rs
@@ -119,19 +119,20 @@ pub mod excludes {
     impl<'repo> crate::Worktree<'repo> {
         /// Configure a file-system cache checking if files below the repository are excluded.
         ///
-        /// This takes into consideration all the usual repository configuration.
+        /// This takes into consideration all the usual repository configuration, namely:
+        ///
+        /// * `$XDG_CONFIG_HOME/…/ignore` if `core.excludesFile` is *not* set, otherwise use the configured file.
+        /// * `$GIT_DIR/info/exclude` if present.
         ///
         /// `index` may be used to obtain `.gitignore` files directly from the index under certain conditions.
         // TODO: test, provide higher-level interface that is much easier to use and doesn't panic when accessing entries
         //       by non-relative path.
         // TODO: `index` might be so special (given the conditions we are talking about) that it's better obtained internally
         //        so the caller won't have to care.
-        // TODO: global files like `~/.gitignore` seem to be missing here, but we need a way to control if these should be loaded.
-        //       probably that needs another permission in the repo options or a custom config variable. The latter is easiest to manage.
         pub fn excludes(
             &self,
             index: &gix_index::State,
-            overrides: Option<gix_attributes::MatchGroup<gix_attributes::Ignore>>,
+            overrides: Option<gix_ignore::Search>,
         ) -> Result<gix_worktree::fs::Cache, Error> {
             let repo = self.parent;
             let case = if repo.config.ignore_case {
@@ -146,11 +147,7 @@ pub mod excludes {
             };
             let state = gix_worktree::fs::cache::State::IgnoreStack(gix_worktree::fs::cache::state::Ignore::new(
                 overrides.unwrap_or_default(),
-                gix_attributes::MatchGroup::<gix_attributes::Ignore>::from_git_dir(
-                    repo.git_dir(),
-                    excludes_file,
-                    &mut buf,
-                )?,
+                gix_ignore::Search::from_git_dir(repo.git_dir(), excludes_file, &mut buf)?,
                 None,
                 case,
             ));

Original file line number	Diff line number	Diff line change
`@@ -157,15 +157,15 @@ impl Cache {`
`157`	`157`	`fn assemble_attribute_globals(`
`158`	`158`	`me: &Cache,`
`159`	`159`	`_git_dir: &std::path::Path,`
`160`		`- ) -> Result<gix_attributes::MatchGroup, checkout_options::Error> {`
	`160`	`+ ) -> Result<gix_attributes::Search, checkout_options::Error> {`
`161`	`161`	`let _attributes_file = match me`
`162`	`162`	`.trusted_file_path("core", None, Core::ATTRIBUTES_FILE.name)`
`163`	`163`	`.transpose()?`
`164`	`164`	`{`
`165`	`165`	`Some(attributes) => Some(attributes.into_owned()),`
`166`	`166`	`None => me.xdg_config_path("attributes").ok().flatten(),`
`167`	`167`	`};`
`168`		- // TODO: implement gix_attributes::MatchGroup::<gix_attributes::Attributes>::from_git_dir(), similar to what's done for `Ignore`.
	`168`	+ // TODO: implement gix_attributes::Search::from_git_dir(), similar to what's done for `Ignore`.
`169`	`169`	`Ok(Default::default())`
`170`	`170`	`}`
`171`	`171`
`@@ -203,7 +203,7 @@ impl Cache {`
`203`	`203`	`std::env::var_os("XDG_CONFIG_HOME")`
`204`	`204`	`.map(\|path\| (PathBuf::from(path), &self.xdg_config_home_env))`
`205`	`205`	`.or_else(\|\| {`
`206`		`- gix_path::home_dir().map(\|mut p\| {`
	`206`	`+ gix_path::env::home_dir().map(\|mut p\| {`
`207`	`207`	`(`
`208`	`208`	`{`
`209`	`209`	`p.push(".config");`
`@@ -225,6 +225,6 @@ impl Cache {`
`225`	`225`	/// We never fail for here even if the permission is set to deny as we `gix-config` will fail later
`226`	`226`	`/// if it actually wants to use the home directory - we don't want to fail prematurely.`
`227`	`227`	`pub(crate) fn home_dir(&self) -> Option<PathBuf> {`
`228`		`- gix_path::home_dir().and_then(\|path\| self.home_env.check_opt(path))`
	`228`	`+ gix_path::env::home_dir().and_then(\|path\| self.home_env.check_opt(path))`
`229`	`229`	`}`
`230`	`230`	`}`