Use Into<Cow<>>

Author: moroten

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".as_bstr().into())?
+                        .prefixed(b"refs/heads".as_bstr())?
                         .filter_map(Result::ok)
                         .map(|r| r.target.into_id()),
                 ) {

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

@@ -87,7 +87,7 @@ impl file::Store {
     /// Return an iterator over all loose references that start with the given `prefix`.
     ///
     /// Otherwise it's similar to [`loose_iter()`][file::Store::loose_iter()].
-    pub fn loose_iter_prefixed(&self, prefix: Cow<'_, BStr>) -> std::io::Result<LooseThenPacked<'_, '_>> {
-        self.iter_prefixed_packed(prefix, None)
+    pub fn loose_iter_prefixed<'a>(&self, prefix: impl Into<Cow<'a, BStr>>) -> std::io::Result<LooseThenPacked<'_, '_>> {
+        self.iter_prefixed_packed(prefix.into(), None)
     }
 }

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

@@ -197,9 +197,9 @@ impl Platform<'_> {
 
     /// As [`iter(…)`][file::Store::iter()], but filters by `prefix`, i.e. "refs/heads/" or
     /// "refs/heads/feature-".
-    pub fn prefixed(&self, prefix: Cow<'_, BStr>) -> std::io::Result<LooseThenPacked<'_, '_>> {
+    pub fn prefixed<'a>(&self, prefix: impl Into<Cow<'a, BStr>>) -> std::io::Result<LooseThenPacked<'_, '_>> {
         self.store
-            .iter_prefixed_packed(prefix, self.packed.as_ref().map(|b| &***b))
+            .iter_prefixed_packed(prefix.into(), self.packed.as_ref().map(|b| &***b))
     }
 }
 
@@ -284,8 +284,9 @@ impl<'a> IterInfo<'a> {
         .peekable()
     }
 
-    fn from_prefix(base: &'a Path, prefix: Cow<'a, BStr>, precompose_unicode: bool) -> std::io::Result<Self> {
-        let prefix_path = gix_path::from_bstring(prefix.as_ref());
+    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_bstring(prefix.clone().into_owned());
         if prefix_path.is_absolute() {
             return Err(std::io::Error::new(
                 std::io::ErrorKind::InvalidInput,
@@ -375,7 +376,7 @@ impl file::Store {
                 self.iter_from_info(git_dir_info, common_dir_info, packed)
             }
             Some(namespace) => {
-                let prefix = namespace.to_owned().into_namespaced_prefix(prefix.as_ref());
+                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 common_dir_info = self
                     .common_dir()

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

@@ -28,7 +28,7 @@ mod with_namespace {
         let ns_two = gix_ref::namespace::expand("bar")?;
         let namespaced_refs = store
             .iter()?
-            .prefixed(ns_two.as_bstr().into())?
+            .prefixed(ns_two.as_bstr())?
             .map(Result::unwrap)
             .map(|r: gix_ref::Reference| r.name)
             .collect::<Vec<_>>();
@@ -47,7 +47,7 @@ mod with_namespace {
         );
         assert_eq!(
             store
-                .loose_iter_prefixed(ns_two.as_bstr().into())?
+                .loose_iter_prefixed(ns_two.as_bstr())?
                 .map(Result::unwrap)
                 .map(|r| r.name.into_inner())
                 .collect::<Vec<_>>(),
@@ -61,7 +61,7 @@ mod with_namespace {
             packed
                 .as_ref()
                 .expect("present")
-                .iter_prefixed(ns_two.as_bstr().into())?
+                .iter_prefixed(ns_two.as_bstr().to_owned())?
                 .map(Result::unwrap)
                 .map(|r| r.name.to_owned().into_inner())
                 .collect::<Vec<_>>(),
@@ -92,7 +92,7 @@ mod with_namespace {
         assert_eq!(
             store
                 .iter()?
-                .prefixed(ns_one.as_bstr().into())?
+                .prefixed(ns_one.as_bstr())?
                 .map(Result::unwrap)
                 .map(|r: gix_ref::Reference| (
                     r.name.as_bstr().to_owned(),
@@ -339,7 +339,7 @@ fn loose_iter_with_prefix() -> crate::Result {
     let store = store()?;
 
     let actual = store
-        .loose_iter_prefixed(b"refs/heads/".as_bstr().into())?
+        .loose_iter_prefixed(b"refs/heads/".as_bstr())?
         .collect::<Result<Vec<_>, _>>()
         .expect("no broken ref in this subset")
         .into_iter()
@@ -369,7 +369,7 @@ fn loose_iter_with_partial_prefix_dir() -> crate::Result {
     let store = store()?;
 
     let actual = store
-        .loose_iter_prefixed(b"refs/heads".as_bstr().into())?
+        .loose_iter_prefixed(b"refs/heads".as_bstr())?
         .collect::<Result<Vec<_>, _>>()
         .expect("no broken ref in this subset")
         .into_iter()
@@ -398,7 +398,7 @@ fn loose_iter_with_partial_prefix() -> crate::Result {
     let store = store()?;
 
     let actual = store
-        .loose_iter_prefixed(b"refs/heads/d".as_bstr().into())?
+        .loose_iter_prefixed(b"refs/heads/d".as_bstr())?
         .collect::<Result<Vec<_>, _>>()
         .expect("no broken ref in this subset")
         .into_iter()
@@ -556,7 +556,7 @@ fn overlay_prefixed_iter() -> crate::Result {
     let store = store_at("make_packed_ref_repository_for_overlay.sh")?;
     let ref_names = store
         .iter()?
-        .prefixed(b"refs/heads/".as_bstr().into())?
+        .prefixed(b"refs/heads/".as_bstr())?
         .map(|r| r.map(|r| (r.name.as_bstr().to_owned(), r.target)))
         .collect::<Result<Vec<_>, _>>()?;
     let c1 = hex_to_id("134385f6d781b7e97062102c6a483440bfda2a03");
@@ -579,7 +579,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".as_bstr().into())? // 'm' is partial
+        .prefixed(b"refs/heads/m".as_bstr())? // '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");
@@ -597,7 +597,7 @@ fn overlay_partial_prefix_iter_reproduce_1934() -> crate::Result {
 
     let ref_names = store
         .iter()?
-        .prefixed(b"refs/d".as_bstr().into())?
+        .prefixed(b"refs/d".as_bstr())?
         .map(|r| r.map(|r| (r.name.as_bstr().to_owned(), r.target)))
         .collect::<Result<Vec<_>, _>>()?;
     // Should not match `refs/heads/d1`.
@@ -615,7 +615,7 @@ fn overlay_partial_prefix_iter_when_prefix_is_dir() -> crate::Result {
 
     let ref_names = store
         .iter()?
-        .prefixed(b"refs/prefix/feature".as_bstr().into())?
+        .prefixed(b"refs/prefix/feature".as_bstr())?
         .map(|r| r.map(|r| (r.name.as_bstr().to_owned(), r.target)))
         .collect::<Result<Vec<_>, _>>()?;
     assert_eq!(
@@ -628,7 +628,7 @@ fn overlay_partial_prefix_iter_when_prefix_is_dir() -> crate::Result {
 
     let ref_names = store
         .iter()?
-        .prefixed(b"refs/prefix/feature/".as_bstr().into())?
+        .prefixed(b"refs/prefix/feature/".as_bstr())?
         .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

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

gix/src/open/repository.rs

@@ -349,7 +349,7 @@ impl ThreadSafeRepository {
             .and_then(|prefix| {
                 let _span = gix_trace::detail!("find replacement objects");
                 let platform = refs.iter().ok()?;
-                let iter = platform.prefixed(prefix.clone().into()).ok()?;
+                let iter = platform.prefixed(&prefix).ok()?;
                 let replacements = iter
                     .filter_map(Result::ok)
                     .filter_map(|r: gix_ref::Reference| {

gix/src/reference/iter.rs

@@ -48,30 +48,24 @@ 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(&self, prefix: Cow<'_, BStr>) -> Result<Iter<'_>, init::Error> {
-        Ok(Iter::new(self.repo, self.platform.prefixed(prefix)?))
+    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())?))
     }
 
     // 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/".as_bstr().into())?,
-        ))
+        Ok(Iter::new(self.repo, self.platform.prefixed(b"refs/tags/".as_bstr())?))
     }
 
     // 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/".as_bstr().into())?,
-        ))
+        Ok(Iter::new(self.repo, self.platform.prefixed(b"refs/heads/".as_bstr())?))
     }
 
     // TODO: tests
@@ -81,7 +75,7 @@ impl Platform<'_> {
     pub fn remote_branches(&self) -> Result<Iter<'_>, init::Error> {
         Ok(Iter::new(
             self.repo,
-            self.platform.prefixed(b"refs/remotes/".as_bstr().into())?,
+            self.platform.prefixed(b"refs/remotes/".as_bstr())?,
         ))
     }
 }

gix/tests/gix/repository/reference.rs

@@ -48,7 +48,7 @@ mod set_namespace {
 
         assert_eq!(
             repo.references()?
-                .prefixed(b"refs/tags/".as_bstr().into())?
+                .prefixed(b"refs/tags/".as_bstr())?
                 .filter_map(Result::ok)
                 .map(|r| r.name().as_bstr().to_owned())
                 .collect::<Vec<_>>(),
@@ -125,7 +125,7 @@ mod iter_references {
         let repo = repo()?;
         assert_eq!(
             repo.references()?
-                .prefixed(b"refs/heads/".as_bstr().into())?
+                .prefixed(b"refs/heads/".as_bstr())?
                 .filter_map(Result::ok)
                 .map(|r| (
                     r.name().as_bstr().to_string(),
@@ -156,7 +156,7 @@ mod iter_references {
         let repo = repo()?;
         assert_eq!(
             repo.references()?
-                .prefixed(b"refs/heads/".as_bstr().into())?
+                .prefixed(b"refs/heads/".as_bstr())?
                 .peeled()?
                 .filter_map(Result::ok)
                 .map(|r| (