Merge branch 'improvements'

Author: Byron

gitoxide-core/src/hours/core.rs

@@ -6,7 +6,7 @@ use std::{
     },
 };
 
-use gix::{bstr::BStr, odb::FindExt};
+use gix::bstr::BStr;
 use itertools::Itertools;
 use smallvec::SmallVec;
 
@@ -182,11 +182,7 @@ pub fn spawn_tree_delta_threads<'scope>(
                                                 (true, true) => {
                                                     files.modified += 1;
                                                     if let Some((attrs, matches)) = attributes.as_mut() {
-                                                        let entry = attrs.at_entry(
-                                                            change.location,
-                                                            Some(false),
-                                                            |id, buf| repo.objects.find_blob(id, buf),
-                                                        )?;
+                                                        let entry = attrs.at_entry(change.location, Some(false))?;
                                                         let is_text_file = if entry.matching_attributes(matches) {
                                                             let attrs: SmallVec<[_; 2]> =
                                                                 matches.iter_selected().collect();

gitoxide-core/src/repository/attributes/query.rs

@@ -11,7 +11,7 @@ pub(crate) mod function {
     use std::{io, path::Path};
 
     use anyhow::{anyhow, bail};
-    use gix::{bstr::BStr, prelude::FindExt};
+    use gix::bstr::BStr;
 
     use crate::{
         repository::{
@@ -40,7 +40,7 @@ pub(crate) mod function {
                 for path in paths {
                     let is_dir = gix::path::from_bstr(path.as_ref()).metadata().ok().map(|m| m.is_dir());
 
-                    let entry = cache.at_entry(path.as_slice(), is_dir, |oid, buf| repo.objects.find_blob(oid, buf))?;
+                    let entry = cache.at_entry(path.as_slice(), is_dir)?;
                     if !entry.matching_attributes(&mut matches) {
                         continue;
                     }
@@ -59,7 +59,7 @@ pub(crate) mod function {
                     .index_entries_with_paths(&index)
                     .ok_or_else(|| anyhow!("Pathspec didn't match a single path in the index"))?
                 {
-                    let entry = cache.at_entry(path, Some(false), |oid, buf| repo.objects.find_blob(oid, buf))?;
+                    let entry = cache.at_entry(path, Some(false))?;
                     if !entry.matching_attributes(&mut matches) {
                         continue;
                     }
@@ -97,7 +97,7 @@ pub(crate) mod function {
 
 pub(crate) fn attributes_cache(
     repo: &gix::Repository,
-) -> anyhow::Result<(gix::worktree::Stack, IndexPersistedOrInMemory)> {
+) -> anyhow::Result<(gix::AttributeStack<'_>, IndexPersistedOrInMemory)> {
     let index = repo.index_or_load_from_head()?;
     let cache = repo.attributes(
         &index,

gitoxide-core/src/repository/attributes/validate_baseline.rs

@@ -18,7 +18,7 @@ pub(crate) mod function {
     };
 
     use anyhow::{anyhow, bail};
-    use gix::{attrs::Assignment, bstr::BString, odb::FindExt, Progress};
+    use gix::{attrs::Assignment, bstr::BString, Progress};
 
     use crate::{
         repository::attributes::{query::attributes_cache, validate_baseline::Options},
@@ -192,9 +192,7 @@ pub(crate) mod function {
         );
 
         for (rela_path, baseline) in rx_base {
-            let entry = cache.at_entry(rela_path.as_str(), Some(false), |oid, buf| {
-                repo.objects.find_blob(oid, buf)
-            })?;
+            let entry = cache.at_entry(rela_path.as_str(), Some(false))?;
             match baseline {
                 Baseline::Attribute { assignments: expected } => {
                     entry.matching_attributes(&mut matches);

gitoxide-core/src/repository/index/entries.rs

@@ -25,7 +25,6 @@ pub(crate) mod function {
 
     use gix::{
         bstr::{BStr, BString},
-        odb::FindExt,
         repository::IndexPersistedOrInMemory,
         Repository,
     };
@@ -133,27 +132,25 @@ pub(crate) mod function {
                     .and_then(|(attrs, cache)| {
                         // If the user wants to see assigned attributes, we always have to match.
                         attributes.is_some().then(|| {
-                            cache
-                                .at_entry(entry.path(&index), None, |id, buf| repo.objects.find_blob(id, buf))
-                                .map(|entry| {
-                                    let is_excluded = entry.is_excluded();
-                                    stats.excluded += usize::from(is_excluded);
-                                    let attributes: Vec<_> = {
-                                        last_match = Some(entry.matching_attributes(attrs));
-                                        attrs.iter().map(|m| m.assignment.to_owned()).collect()
-                                    };
-                                    stats.with_attributes += usize::from(!attributes.is_empty());
-                                    stats.max_attributes_per_path = stats.max_attributes_per_path.max(attributes.len());
-                                    if let Some(attrs) = repo_attrs.as_mut() {
-                                        attributes.iter().for_each(|attr| {
-                                            attrs.insert(attr.clone());
-                                        });
-                                    }
-                                    Attrs {
-                                        is_excluded,
-                                        attributes,
-                                    }
-                                })
+                            cache.at_entry(entry.path(&index), None).map(|entry| {
+                                let is_excluded = entry.is_excluded();
+                                stats.excluded += usize::from(is_excluded);
+                                let attributes: Vec<_> = {
+                                    last_match = Some(entry.matching_attributes(attrs));
+                                    attrs.iter().map(|m| m.assignment.to_owned()).collect()
+                                };
+                                stats.with_attributes += usize::from(!attributes.is_empty());
+                                stats.max_attributes_per_path = stats.max_attributes_per_path.max(attributes.len());
+                                if let Some(attrs) = repo_attrs.as_mut() {
+                                    attributes.iter().for_each(|attr| {
+                                        attrs.insert(attr.clone());
+                                    });
+                                }
+                                Attrs {
+                                    is_excluded,
+                                    attributes,
+                                }
+                            })
                         })
                     })
                     .transpose()?;
@@ -173,7 +170,7 @@ pub(crate) mod function {
                                     }
                                     // The user doesn't want attributes, so we set the cache position on demand only
                                     None => cache
-                                        .at_entry(rela_path, Some(is_dir), |id, buf| repo.objects.find_blob(id, buf))
+                                        .at_entry(rela_path, Some(is_dir))
                                         .ok()
                                         .map(|platform| platform.matching_attributes(out))
                                         .unwrap_or_default(),
@@ -251,7 +248,7 @@ pub(crate) mod function {
     ) -> anyhow::Result<(
         gix::pathspec::Search,
         IndexPersistedOrInMemory,
-        Option<(gix::attrs::search::Outcome, gix::worktree::Stack)>,
+        Option<(gix::attrs::search::Outcome, gix::AttributeStack<'_>)>,
     )> {
         let index = repo.index_or_load_from_head()?;
         let pathspec = repo.pathspec(

gix-attributes/src/state.rs

@@ -13,7 +13,7 @@ pub struct Value(KString);
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct ValueRef<'a>(#[cfg_attr(feature = "serde", serde(borrow))] KStringRef<'a>);
 
-/// Conversions
+/// Lifecycle
 impl<'a> ValueRef<'a> {
     /// Keep `input` as our value.
     pub fn from_bytes(input: &'a [u8]) -> Self {
@@ -25,7 +25,10 @@ impl<'a> ValueRef<'a> {
             },
         ))
     }
+}
 
+/// Access and conversions
+impl ValueRef<'_> {
     /// Access this value as byte string.
     pub fn as_bstr(&self) -> &BStr {
         self.0.as_bytes().as_bstr()
@@ -79,6 +82,14 @@ impl StateRef<'_> {
     pub fn is_unset(&self) -> bool {
         matches!(self, StateRef::Unset)
     }
+
+    /// Attempt to obtain the string value of this state, or return `None` if there is no such value.
+    pub fn as_bstr(&self) -> Option<&BStr> {
+        match self {
+            StateRef::Value(v) => Some(v.as_bstr()),
+            _ => None,
+        }
+    }
 }
 
 /// Initialization

gix/src/attribute_stack.rs

@@ -0,0 +1,69 @@
+use crate::bstr::BStr;
+use crate::types::AttributeStack;
+use crate::Repository;
+use gix_odb::FindExt;
+use std::ops::{Deref, DerefMut};
+
+/// Lifecycle
+impl<'repo> AttributeStack<'repo> {
+    /// Create a new instance from a `repo` and the underlying pre-configured `stack`.
+    ///
+    /// Note that this type is typically created by [`Repository::attributes()`] or [`Repository::attributes_only()`].
+    pub fn new(stack: gix_worktree::Stack, repo: &'repo Repository) -> Self {
+        AttributeStack { repo, inner: stack }
+    }
+
+    /// Detach the repository and return the underlying plumbing datatype.
+    pub fn detach(self) -> gix_worktree::Stack {
+        self.inner
+    }
+}
+
+impl Deref for AttributeStack<'_> {
+    type Target = gix_worktree::Stack;
+
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+
+impl DerefMut for AttributeStack<'_> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+
+/// Platform retrieval
+impl<'repo> AttributeStack<'repo> {
+    /// 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.
+    ///
+    /// Provide access to cached information for that `relative` path via the returned platform.
+    pub fn at_path(
+        &mut self,
+        relative: impl AsRef<std::path::Path>,
+        is_dir: Option<bool>,
+    ) -> std::io::Result<gix_worktree::stack::Platform<'_>> {
+        self.inner
+            .at_path(relative, is_dir, |id, buf| self.repo.objects.find_blob(id, buf))
+    }
+
+    /// 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.
+    ///
+    /// 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>(
+        &mut self,
+        relative: impl Into<&'r BStr>,
+        is_dir: Option<bool>,
+    ) -> std::io::Result<gix_worktree::stack::Platform<'_>> {
+        self.inner
+            .at_entry(relative, is_dir, |id, buf| self.repo.objects.find_blob(id, buf))
+    }
+}

gix/src/lib.rs

@@ -117,6 +117,8 @@ mod ext;
 ///
 pub mod prelude;
 
+mod attribute_stack;
+
 ///
 pub mod path;
 
@@ -129,7 +131,7 @@ pub(crate) type Config = OwnShared<gix_config::File<'static>>;
 
 mod types;
 pub use types::{
-    Commit, Head, Id, Object, ObjectDetached, Pathspec, Reference, Remote, Repository, Submodule, Tag,
+    AttributeStack, Commit, Head, Id, Object, ObjectDetached, Pathspec, Reference, Remote, Repository, Submodule, Tag,
     ThreadSafeRepository, Tree, Worktree,
 };
 

gix/src/pathspec.rs

@@ -2,7 +2,7 @@
 use gix_odb::FindExt;
 pub use gix_pathspec::*;
 
-use crate::{bstr::BStr, Pathspec, Repository};
+use crate::{bstr::BStr, AttributeStack, Pathspec, Repository};
 
 ///
 pub mod init {
@@ -59,21 +59,28 @@ impl<'repo> Pathspec<'repo> {
             )?,
         )?;
         let cache = needs_cache.then(make_attributes).transpose()?;
-        Ok(Self { repo, search, cache })
+        Ok(Self {
+            repo,
+            search,
+            stack: cache,
+        })
     }
     /// Turn ourselves into the functional parts for direct usage.
-    /// Note that the [`cache`](gix_worktree::Stack) is only set if one of the [`search` patterns](Search)
+    /// Note that the [`cache`](AttributeStack) is only set if one of the [`search` patterns](Search)
     /// is specifying attributes to match for.
-    pub fn into_parts(self) -> (Search, Option<gix_worktree::Stack>) {
-        (self.search, self.cache)
+    pub fn into_parts(self) -> (Search, Option<AttributeStack<'repo>>) {
+        (
+            self.search,
+            self.stack.map(|stack| AttributeStack::new(stack, self.repo)),
+        )
     }
 }
 
 /// Access
 impl<'repo> Pathspec<'repo> {
     /// Return the attributes cache which is used when matching attributes in pathspecs, or `None` if none of the pathspecs require that.
     pub fn attributes(&self) -> Option<&gix_worktree::Stack> {
-        self.cache.as_ref()
+        self.stack.as_ref()
     }
 
     /// Return the search itself which can be used for matching paths or accessing the actual patterns that will be used.
@@ -99,8 +106,8 @@ impl<'repo> Pathspec<'repo> {
     ) -> Option<gix_pathspec::search::Match<'_>> {
         self.search
             .pattern_matching_relative_path(relative_path, is_dir, |relative_path, case, is_dir, out| {
-                let cache = self.cache.as_mut().expect("initialized in advance");
-                cache
+                let stack = self.stack.as_mut().expect("initialized in advance");
+                stack
                     .set_case(case)
                     .at_entry(relative_path, Some(is_dir), |id, buf| {
                         self.repo.objects.find_blob(id, buf)