Adapt to changes in gix-path

Author: cruessler

gix-negotiate/tests/baseline/mod.rs

@@ -71,7 +71,7 @@ fn run() -> crate::Result {
                 // }
                 for tip in lookup_names(&["HEAD"]).into_iter().chain(
                     refs.iter()?
-                        .prefixed(b"refs/heads")?
+                        .prefixed(b"refs/heads".try_into().unwrap())?
                         .filter_map(Result::ok)
                         .map(|r| r.target.into_id()),
                 ) {

gix-ref/src/namespace.rs

@@ -1,6 +1,7 @@
 use std::path::Path;
 
 use gix_object::bstr::{BStr, BString, ByteSlice, ByteVec};
+use gix_path::relative_path::RelativePath;
 
 use crate::{FullName, FullNameRef, Namespace, PartialNameRef};
 
@@ -20,9 +21,8 @@ impl Namespace {
     /// Append the given `prefix` to this namespace so it becomes usable for prefixed iteration.
     ///
     /// The prefix is a relative path with slash-separated path components.
-    // TODO: use `RelativePath` type instead (see #1921), or a trait that helps convert into it.
-    pub fn into_namespaced_prefix<'a>(mut self, prefix: impl Into<&'a BStr>) -> BString {
-        self.0.push_str(prefix.into());
+    pub fn into_namespaced_prefix(mut self, prefix: &RelativePath) -> BString {
+        self.0.push_str(prefix);
         gix_path::to_unix_separators_on_windows(self.0).into_owned()
     }
     pub(crate) fn into_namespaced_name(mut self, name: &FullNameRef) -> FullName {

gix-ref/src/store/file/loose/iter.rs

@@ -2,8 +2,9 @@ use std::path::{Path, PathBuf};
 
 use gix_features::fs::walkdir::DirEntryIter;
 use gix_object::bstr::ByteSlice;
+use gix_path::relative_path::RelativePath;
 
-use crate::{file::iter::LooseThenPacked, store_impl::file, BStr, BString, FullName};
+use crate::{file::iter::LooseThenPacked, store_impl::file, BString, FullName};
 
 /// An iterator over all valid loose reference paths as seen from a particular base directory.
 pub(in crate::store_impl::file) struct SortedLoosePaths {
@@ -88,8 +89,7 @@ impl file::Store {
     /// starts with `foo`, like `refs/heads/foo` and `refs/heads/foobar`.
     ///
     /// Prefixes are relative paths with slash-separated components.
-    // TODO: use `RelativePath` type instead (see #1921), or a trait that helps convert into it.
-    pub fn loose_iter_prefixed<'a>(&self, prefix: impl Into<&'a BStr>) -> std::io::Result<LooseThenPacked<'_, '_>> {
-        self.iter_prefixed_packed(prefix.into(), None)
+    pub fn loose_iter_prefixed(&self, prefix: &RelativePath) -> std::io::Result<LooseThenPacked<'_, '_>> {
+        self.iter_prefixed_packed(prefix, None)
     }
 }

gix-ref/src/store/file/overlay_iter.rs

@@ -12,6 +12,9 @@ use crate::{
     BStr, FullName, Namespace, Reference,
 };
 
+use gix_object::bstr::ByteSlice;
+use gix_path::relative_path::RelativePath;
+
 /// An iterator stepping through sorted input of loose references and packed references, preferring loose refs over otherwise
 /// equivalent packed references.
 ///
@@ -203,10 +206,9 @@ impl Platform<'_> {
     /// starts with `foo`, like `refs/heads/foo` and `refs/heads/foobar`.
     ///
     /// Prefixes are relative paths with slash-separated components.
-    // TODO: use `RelativePath` type instead (see #1921), or a trait that helps convert into it.
-    pub fn prefixed<'a>(&self, prefix: impl Into<&'a BStr>) -> std::io::Result<LooseThenPacked<'_, '_>> {
+    pub fn prefixed(&self, prefix: &RelativePath) -> std::io::Result<LooseThenPacked<'_, '_>> {
         self.store
-            .iter_prefixed_packed(prefix.into(), self.packed.as_ref().map(|b| &***b))
+            .iter_prefixed_packed(prefix, self.packed.as_ref().map(|b| &***b))
     }
 }
 
@@ -291,26 +293,8 @@ impl<'a> IterInfo<'a> {
         .peekable()
     }
 
-    fn from_prefix(
-        base: &'a Path,
-        prefix: impl Into<Cow<'a, BStr>>,
-        precompose_unicode: bool,
-    ) -> std::io::Result<Self> {
-        let prefix = prefix.into();
-        let prefix_path = gix_path::from_bstr(prefix.as_ref());
-        if prefix_path.is_absolute() {
-            return Err(std::io::Error::new(
-                std::io::ErrorKind::InvalidInput,
-                "prefix must be a relative path, like 'refs/heads/'",
-            ));
-        }
-        use std::path::Component::*;
-        if prefix_path.components().any(|c| matches!(c, CurDir | ParentDir)) {
-            return Err(std::io::Error::new(
-                std::io::ErrorKind::InvalidInput,
-                "Refusing to handle prefixes with relative path components",
-            ));
-        }
+    fn from_prefix(base: &'a Path, prefix: &'a RelativePath, precompose_unicode: bool) -> std::io::Result<Self> {
+        let prefix_path = gix_path::from_bstr(prefix);
         let iter_root = base.join(&prefix_path);
         if prefix.ends_with(b"/") {
             Ok(IterInfo::BaseAndIterRoot {
@@ -326,7 +310,7 @@ impl<'a> IterInfo<'a> {
                 .to_owned();
             Ok(IterInfo::ComputedIterationRoot {
                 base,
-                prefix,
+                prefix: prefix.into(),
                 iter_root,
                 precompose_unicode,
             })
@@ -377,13 +361,11 @@ impl file::Store {
     /// starts with `foo`, like `refs/heads/foo` and `refs/heads/foobar`.
     ///
     /// Prefixes are relative paths with slash-separated components.
-    // TODO: use `RelativePath` type instead (see #1921), or a trait that helps convert into it.
-    pub fn iter_prefixed_packed<'a, 's, 'p>(
+    pub fn iter_prefixed_packed<'s, 'p>(
         &'s self,
-        prefix: impl Into<&'a BStr>,
+        prefix: &RelativePath,
         packed: Option<&'p packed::Buffer>,
     ) -> std::io::Result<LooseThenPacked<'p, 's>> {
-        let prefix = prefix.into();
         match self.namespace.as_ref() {
             None => {
                 let git_dir_info = IterInfo::from_prefix(self.git_dir(), prefix, self.precompose_unicode)?;
@@ -395,7 +377,8 @@ impl file::Store {
             }
             Some(namespace) => {
                 let prefix = namespace.to_owned().into_namespaced_prefix(prefix);
-                let git_dir_info = IterInfo::from_prefix(self.git_dir(), prefix.clone(), self.precompose_unicode)?;
+                let prefix = prefix.as_bstr().try_into().map_err(std::io::Error::other)?;
+                let git_dir_info = IterInfo::from_prefix(self.git_dir(), prefix, self.precompose_unicode)?;
                 let common_dir_info = self
                     .common_dir()
                     .map(|base| IterInfo::from_prefix(base, prefix, self.precompose_unicode))

gix-ref/tests/refs/file/store/iter.rs

@@ -26,7 +26,7 @@ mod with_namespace {
         let ns_two = gix_ref::namespace::expand("bar")?;
         let namespaced_refs = store
             .iter()?
-            .prefixed(ns_two.as_bstr())?
+            .prefixed(ns_two.as_bstr().try_into().unwrap())?
             .map(Result::unwrap)
             .map(|r: gix_ref::Reference| r.name)
             .collect::<Vec<_>>();
@@ -45,7 +45,7 @@ mod with_namespace {
         );
         assert_eq!(
             store
-                .loose_iter_prefixed(ns_two.as_bstr())?
+                .loose_iter_prefixed(ns_two.as_bstr().try_into().unwrap())?
                 .map(Result::unwrap)
                 .map(|r| r.name.into_inner())
                 .collect::<Vec<_>>(),
@@ -90,7 +90,7 @@ mod with_namespace {
         assert_eq!(
             store
                 .iter()?
-                .prefixed(ns_one.as_bstr())?
+                .prefixed(ns_one.as_bstr().try_into().unwrap())?
                 .map(Result::unwrap)
                 .map(|r: gix_ref::Reference| (
                     r.name.as_bstr().to_owned(),
@@ -316,26 +316,11 @@ fn loose_iter_with_broken_refs() -> crate::Result {
     Ok(())
 }
 
-#[test]
-fn loose_iter_with_prefix_wont_allow_absolute_paths() -> crate::Result {
-    let store = store()?;
-    #[cfg(not(windows))]
-    let abs_path = "/hello";
-    #[cfg(windows)]
-    let abs_path = r"c:\hello";
-
-    match store.loose_iter_prefixed(abs_path) {
-        Ok(_) => unreachable!("absolute paths aren't allowed"),
-        Err(err) => assert_eq!(err.to_string(), "prefix must be a relative path, like 'refs/heads/'"),
-    }
-    Ok(())
-}
-
 #[test]
 fn loose_iter_with_prefix() -> crate::Result {
     let prefix_with_slash = b"refs/heads/";
     let actual = store()?
-        .loose_iter_prefixed(prefix_with_slash)?
+        .loose_iter_prefixed(prefix_with_slash.try_into().unwrap())?
         .collect::<Result<Vec<_>, _>>()
         .expect("no broken ref in this subset")
         .into_iter()
@@ -363,7 +348,7 @@ fn loose_iter_with_prefix() -> crate::Result {
 fn loose_iter_with_partial_prefix_dir() -> crate::Result {
     let prefix_without_slash = b"refs/heads";
     let actual = store()?
-        .loose_iter_prefixed(prefix_without_slash)?
+        .loose_iter_prefixed(prefix_without_slash.try_into().unwrap())?
         .collect::<Result<Vec<_>, _>>()
         .expect("no broken ref in this subset")
         .into_iter()
@@ -390,7 +375,7 @@ fn loose_iter_with_partial_prefix_dir() -> crate::Result {
 #[test]
 fn loose_iter_with_partial_prefix() -> crate::Result {
     let actual = store()?
-        .loose_iter_prefixed(b"refs/heads/d".as_bstr())?
+        .loose_iter_prefixed(b"refs/heads/d".as_bstr().try_into().unwrap())?
         .collect::<Result<Vec<_>, _>>()
         .expect("no broken ref in this subset")
         .into_iter()
@@ -526,29 +511,14 @@ fn overlay_iter_reproduce_1928() -> crate::Result {
     Ok(())
 }
 
-#[test]
-fn overlay_iter_with_prefix_wont_allow_absolute_paths() -> crate::Result {
-    let store = store_with_packed_refs()?;
-    #[cfg(not(windows))]
-    let abs_path = "/hello";
-    #[cfg(windows)]
-    let abs_path = r"c:\hello";
-
-    match store.iter()?.prefixed(abs_path) {
-        Ok(_) => unreachable!("absolute paths aren't allowed"),
-        Err(err) => assert_eq!(err.to_string(), "prefix must be a relative path, like 'refs/heads/'"),
-    }
-    Ok(())
-}
-
 #[test]
 fn overlay_prefixed_iter() -> crate::Result {
     use gix_ref::Target::*;
 
     let store = store_at("make_packed_ref_repository_for_overlay.sh")?;
     let ref_names = store
         .iter()?
-        .prefixed(b"refs/heads/")?
+        .prefixed(b"refs/heads/".try_into().unwrap())?
         .map(|r| r.map(|r| (r.name.as_bstr().to_owned(), r.target)))
         .collect::<Result<Vec<_>, _>>()?;
     let c1 = hex_to_id("134385f6d781b7e97062102c6a483440bfda2a03");
@@ -571,7 +541,7 @@ fn overlay_partial_prefix_iter() -> crate::Result {
     let store = store_at("make_packed_ref_repository_for_overlay.sh")?;
     let ref_names = store
         .iter()?
-        .prefixed(b"refs/heads/m")? // 'm' is partial
+        .prefixed(b"refs/heads/m".try_into().unwrap())? // 'm' is partial
         .map(|r| r.map(|r| (r.name.as_bstr().to_owned(), r.target)))
         .collect::<Result<Vec<_>, _>>()?;
     let c1 = hex_to_id("134385f6d781b7e97062102c6a483440bfda2a03");
@@ -589,7 +559,7 @@ fn overlay_partial_prefix_iter_reproduce_1934() -> crate::Result {
 
     let ref_names = store
         .iter()?
-        .prefixed(b"refs/d")?
+        .prefixed(b"refs/d".try_into().unwrap())?
         .map(|r| r.map(|r| (r.name.as_bstr().to_owned(), r.target)))
         .collect::<Result<Vec<_>, _>>()?;
     assert_eq!(
@@ -610,7 +580,7 @@ fn overlay_partial_prefix_iter_when_prefix_is_dir() -> crate::Result {
 
     let ref_names = store
         .iter()?
-        .prefixed(b"refs/prefix/feature")?
+        .prefixed(b"refs/prefix/feature".try_into().unwrap())?
         .map(|r| r.map(|r| (r.name.as_bstr().to_owned(), r.target)))
         .collect::<Result<Vec<_>, _>>()?;
     assert_eq!(
@@ -623,7 +593,7 @@ fn overlay_partial_prefix_iter_when_prefix_is_dir() -> crate::Result {
 
     let ref_names = store
         .iter()?
-        .prefixed(b"refs/prefix/feature/")?
+        .prefixed(b"refs/prefix/feature/".try_into().unwrap())?
         .map(|r| r.map(|r| (r.name.as_bstr().to_owned(), r.target)))
         .collect::<Result<Vec<_>, _>>()?;
     assert_eq!(

gix-ref/tests/refs/file/worktree.rs

@@ -290,7 +290,7 @@ mod writable {
             assert_eq!(
                 store
                     .iter()?
-                    .prefixed(b"refs/stacks/")?
+                    .prefixed(b"refs/stacks/".try_into().unwrap())?
                     .map(Result::unwrap)
                     .map(|r| (r.name.to_string(), r.target.to_string()))
                     .collect::<Vec<_>>(),
@@ -571,7 +571,7 @@ mod writable {
             assert_eq!(
                 store
                     .iter()?
-                    .prefixed(b"refs/stacks/")?
+                    .prefixed(b"refs/stacks/".try_into().unwrap())?
                     .map(Result::unwrap)
                     .map(|r| (r.name.to_string(), r.target.to_string()))
                     .collect::<Vec<_>>(),

gix-ref/tests/refs/namespace.rs

@@ -3,13 +3,13 @@ fn into_namespaced_prefix() {
     assert_eq!(
         gix_ref::namespace::expand("foo")
             .unwrap()
-            .into_namespaced_prefix("prefix"),
+            .into_namespaced_prefix("prefix".try_into().unwrap()),
         "refs/namespaces/foo/prefix",
     );
     assert_eq!(
         gix_ref::namespace::expand("foo")
             .unwrap()
-            .into_namespaced_prefix("prefix/"),
+            .into_namespaced_prefix("prefix/".try_into().unwrap()),
         "refs/namespaces/foo/prefix/",
     );
 }

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(