feat!: use RelativePath for prefixed ref iteration.

Its type captures the requirements better.

Co-authored-by: Sebastian Thiel <sebastian.thiel@icloud.com>

Author: cruessler

gix/src/open/mod.rs

@@ -56,6 +56,8 @@ pub enum Error {
     UnsafeGitDir { path: PathBuf },
     #[error(transparent)]
     EnvironmentAccessDenied(#[from] gix_sec::permission::Error<std::path::PathBuf>),
+    #[error(transparent)]
+    PrefixNotRelative(#[from] gix_path::relative_path::Error),
 }
 
 mod options;

gix/src/open/repository.rs

@@ -1,7 +1,6 @@
 #![allow(clippy::result_large_err)]
 use super::{Error, Options};
 use crate::{
-    bstr,
     bstr::BString,
     config,
     config::{
@@ -12,6 +11,8 @@ use crate::{
     ThreadSafeRepository,
 };
 use gix_features::threading::OwnShared;
+use gix_object::bstr::ByteSlice;
+use gix_path::relative_path::RelativePath;
 use std::ffi::OsStr;
 use std::{borrow::Cow, path::PathBuf};
 
@@ -345,24 +346,30 @@ impl ThreadSafeRepository {
 
         refs.write_reflog = config::cache::util::reflog_or_default(config.reflog, worktree_dir.is_some());
         refs.namespace.clone_from(&config.refs_namespace);
-        let replacements = replacement_objects_refs_prefix(&config.resolved, lenient_config, filter_config_section)?
-            .and_then(|prefix| {
-                use bstr::ByteSlice;
-                let _span = gix_trace::detail!("find replacement objects");
-                let platform = refs.iter().ok()?;
-                let iter = platform.prefixed(prefix.as_bstr()).ok()?;
-                let replacements = iter
-                    .filter_map(Result::ok)
-                    .filter_map(|r: gix_ref::Reference| {
-                        let target = r.target.try_id()?.to_owned();
-                        let source =
-                            gix_hash::ObjectId::from_hex(r.name.as_bstr().strip_prefix(prefix.as_slice())?).ok()?;
-                        Some((source, target))
-                    })
-                    .collect::<Vec<_>>();
-                Some(replacements)
-            })
-            .unwrap_or_default();
+        let prefix = replacement_objects_refs_prefix(&config.resolved, lenient_config, filter_config_section)?;
+        let replacements = match prefix {
+            Some(prefix) => {
+                let prefix: &RelativePath = prefix.as_bstr().try_into()?;
+
+                Some(prefix).and_then(|prefix| {
+                    let _span = gix_trace::detail!("find replacement objects");
+                    let platform = refs.iter().ok()?;
+                    let iter = platform.prefixed(prefix).ok()?;
+                    let replacements = iter
+                        .filter_map(Result::ok)
+                        .filter_map(|r: gix_ref::Reference| {
+                            let target = r.target.try_id()?.to_owned();
+                            let source =
+                                gix_hash::ObjectId::from_hex(r.name.as_bstr().strip_prefix(prefix.as_ref())?).ok()?;
+                            Some((source, target))
+                        })
+                        .collect::<Vec<_>>();
+                    Some(replacements)
+                })
+            }
+            None => None,
+        };
+        let replacements = replacements.unwrap_or_default();
 
         Ok(ThreadSafeRepository {
             objects: OwnShared::new(gix_odb::Store::at_opts(

gix/src/reference/iter.rs

@@ -1,8 +1,8 @@
 //!
 #![allow(clippy::empty_docs)]
-use std::borrow::Cow;
 
-use gix_ref::{bstr::BStr, file::ReferenceExt};
+use gix_path::relative_path::RelativePath;
+use gix_ref::file::ReferenceExt;
 
 /// A platform to create iterators over references.
 #[must_use = "Iterators should be obtained from this iterator platform"]
@@ -45,32 +45,41 @@ impl Platform<'_> {
     /// These are of the form `refs/heads/` or `refs/remotes/origin`, and must not contain relative paths components like `.` or `..`.
     // TODO: Create a custom `Path` type that enforces the requirements of git naturally, this type is surprising possibly on windows
     //       and when not using a trailing '/' to signal directories.
-    pub fn prefixed<'a>(&self, prefix: impl Into<Cow<'a, BStr>>) -> Result<Iter<'_>, init::Error> {
-        Ok(Iter::new(self.repo, self.platform.prefixed(prefix.into().as_ref())?))
+    pub fn prefixed<'a>(
+        &self,
+        prefix: impl TryInto<&'a RelativePath, Error = gix_path::relative_path::Error>,
+    ) -> Result<Iter<'_>, init::Error> {
+        Ok(Iter::new(self.repo, self.platform.prefixed(prefix.try_into()?)?))
     }
 
     // TODO: tests
     /// Return an iterator over all references that are tags.
     ///
     /// They are all prefixed with `refs/tags`.
     pub fn tags(&self) -> Result<Iter<'_>, init::Error> {
-        Ok(Iter::new(self.repo, self.platform.prefixed(b"refs/tags/")?))
+        Ok(Iter::new(self.repo, self.platform.prefixed(b"refs/tags/".try_into()?)?))
     }
 
     // TODO: tests
     /// Return an iterator over all local branches.
     ///
     /// They are all prefixed with `refs/heads`.
     pub fn local_branches(&self) -> Result<Iter<'_>, init::Error> {
-        Ok(Iter::new(self.repo, self.platform.prefixed(b"refs/heads/")?))
+        Ok(Iter::new(
+            self.repo,
+            self.platform.prefixed(b"refs/heads/".try_into()?)?,
+        ))
     }
 
     // TODO: tests
     /// Return an iterator over all remote branches.
     ///
     /// They are all prefixed with `refs/remotes`.
     pub fn remote_branches(&self) -> Result<Iter<'_>, init::Error> {
-        Ok(Iter::new(self.repo, self.platform.prefixed(b"refs/remotes/")?))
+        Ok(Iter::new(
+            self.repo,
+            self.platform.prefixed(b"refs/remotes/".try_into()?)?,
+        ))
     }
 }
 
@@ -123,6 +132,8 @@ pub mod init {
     pub enum Error {
         #[error(transparent)]
         Io(#[from] std::io::Error),
+        #[error(transparent)]
+        RelativePath(#[from] gix_path::relative_path::Error),
     }
 }