feat: Allow PartialNameRef to be created from owned items (#251)

Author: Byron

git-ref/src/fullname.rs

@@ -59,7 +59,7 @@ impl<'a> From<crate::FullNameRef<'a>> for FullName {
 impl FullName {
     /// Interpret this fully qualified reference name as partial name.
     pub fn to_partial(&self) -> crate::PartialNameRef<'_> {
-        crate::PartialNameRef(self.0.as_bstr())
+        crate::PartialNameRef(self.0.as_bstr().into())
     }
 
     /// Interpret this fully qualified reference as shared full name

git-ref/src/lib.rs

@@ -18,9 +18,11 @@
 //!   * supersedes all of the above to allow handling hundreds of thousands of references.
 #![forbid(unsafe_code)]
 #![deny(missing_docs, rust_2018_idioms)]
+
 use git_hash::{oid, ObjectId};
 pub use git_object::bstr;
 use git_object::bstr::{BStr, BString};
+use std::borrow::Cow;
 
 mod store;
 pub use store::{file, packed};
@@ -55,8 +57,8 @@ pub struct FullName(pub(crate) BString);
 #[derive(PartialEq, Eq, Debug, Hash, Ord, PartialOrd, Clone, Copy)]
 pub struct FullNameRef<'a>(&'a BStr);
 /// A validated complete and fully qualified reference name, safe to use for all operations.
-#[derive(PartialEq, Eq, Debug, Hash, Ord, PartialOrd, Clone, Copy)]
-pub struct PartialNameRef<'a>(&'a BStr);
+#[derive(PartialEq, Eq, Debug, Hash, Ord, PartialOrd, Clone)]
+pub struct PartialNameRef<'a>(Cow<'a, BStr>);
 
 /// A _validated_ prefix for references to act as a namespace.
 #[derive(PartialEq, Eq, Debug, Hash, Ord, PartialOrd, Clone)]

git-ref/src/name.rs

@@ -4,7 +4,7 @@ use std::{
     path::Path,
 };
 
-use git_object::bstr::{BStr, ByteSlice};
+use git_object::bstr::{BStr, BString, ByteSlice};
 
 use crate::{FullNameRef, PartialNameRef};
 
@@ -26,13 +26,13 @@ impl<'a> FullNameRef<'a> {
 impl<'a> PartialNameRef<'a> {
     /// Convert this name into the relative path possibly identifying the reference location.
     /// Note that it may be only a partial path though.
-    pub fn to_partial_path(self) -> Cow<'a, Path> {
+    pub fn to_partial_path(&'a self) -> Cow<'a, Path> {
         self.0.to_path().expect("UTF-8 conversion always succeeds").into()
     }
 
     /// Provide the name as binary string which is known to be a valid partial ref name.
-    pub fn as_bstr(&self) -> &'a BStr {
-        self.0
+    pub fn as_bstr(&'a self) -> &'a BStr {
+        self.0.as_ref()
     }
 }
 
@@ -48,15 +48,15 @@ impl<'a> TryFrom<FullNameRef<'a>> for PartialNameRef<'a> {
     type Error = Infallible;
 
     fn try_from(v: FullNameRef<'a>) -> Result<Self, Self::Error> {
-        Ok(PartialNameRef(v.0))
+        Ok(PartialNameRef(v.0.into()))
     }
 }
 
 impl<'a> TryFrom<&'a BStr> for PartialNameRef<'a> {
     type Error = Error;
 
     fn try_from(v: &'a BStr) -> Result<Self, Self::Error> {
-        Ok(PartialNameRef(git_validate::reference::name_partial(v)?))
+        Ok(PartialNameRef(git_validate::reference::name_partial(v)?.into()))
     }
 }
 
@@ -74,7 +74,7 @@ impl<'a> TryFrom<&'a str> for PartialNameRef<'a> {
 
     fn try_from(v: &'a str) -> Result<Self, Self::Error> {
         let v = v.as_bytes().as_bstr();
-        Ok(PartialNameRef(git_validate::reference::name_partial(v)?))
+        Ok(PartialNameRef(git_validate::reference::name_partial(v)?.into()))
     }
 }
 
@@ -92,6 +92,24 @@ impl<'a> TryFrom<&'a String> for PartialNameRef<'a> {
 
     fn try_from(v: &'a String) -> Result<Self, Self::Error> {
         let v = v.as_bytes().as_bstr();
-        Ok(PartialNameRef(git_validate::reference::name_partial(v)?))
+        Ok(PartialNameRef(git_validate::reference::name_partial(v)?.into()))
+    }
+}
+
+impl TryFrom<String> for PartialNameRef<'static> {
+    type Error = Error;
+
+    fn try_from(v: String) -> Result<Self, Self::Error> {
+        git_validate::reference::name_partial(v.as_bytes().as_bstr())?;
+        Ok(PartialNameRef(BString::from(v).into()))
+    }
+}
+
+impl TryFrom<BString> for PartialNameRef<'static> {
+    type Error = Error;
+
+    fn try_from(v: BString) -> Result<Self, Self::Error> {
+        git_validate::reference::name_partial(v.as_ref())?;
+        Ok(PartialNameRef(v.into()))
     }
 }

git-ref/src/store/file/find.rs

@@ -125,7 +125,7 @@ impl file::Store {
                             None => relative_path,
                             Some(namespace) => namespace.to_owned().into_namespaced_prefix(relative_path),
                         });
-                        let full_name = PartialNameRef((*full_name).as_bstr());
+                        let full_name = PartialNameRef((*full_name).as_bstr().into());
                         if let Some(packed_ref) = packed.try_find(full_name)? {
                             let mut res: Reference = packed_ref.into();
                             if let Some(namespace) = &self.namespace {

git-ref/src/store/packed/find.rs

@@ -15,7 +15,7 @@ impl packed::Buffer {
         let name = name.try_into()?;
         for inbetween in &["", "tags", "heads", "remotes"] {
             let (name, was_absolute) = if name.0.starts_with_str(b"refs/") {
-                (Cow::Borrowed(name.0), true)
+                (Cow::Borrowed(name.0.as_ref()), true)
             } else {
                 let mut full_name: BString = format!(
                     "refs/{}",
@@ -26,7 +26,7 @@ impl packed::Buffer {
                     }
                 )
                 .into();
-                full_name.extend_from_slice(name.0);
+                full_name.extend_from_slice(name.0.as_ref());
                 (Cow::Owned(full_name), false)
             };
             match self.binary_search_by(name.as_ref()) {

git-repository/tests/easy/reference.rs

@@ -35,6 +35,14 @@ mod find {
             fn to_partial_name(&self) -> String {
                 format!("{}/{}", self.remote, self.branch)
             }
+            fn to_partial_name_from_string(&self) -> git_ref::PartialNameRef<'static> {
+                self.to_partial_name().try_into().expect("cannot fail")
+            }
+            fn to_partial_name_from_bstring(&self) -> git_ref::PartialNameRef<'static> {
+                git_object::bstr::BString::from(self.to_partial_name())
+                    .try_into()
+                    .expect("cannot fail")
+            }
             fn to_full_name(&self) -> git_ref::FullName {
                 format!("{}/{}", self.remote, self.branch)
                     .try_into()
@@ -46,6 +54,9 @@ mod find {
             branch: "main",
         };
         repo.find_reference(&name.to_partial_name())?;
+        repo.find_reference(name.to_partial_name())?;
+        repo.find_reference(name.to_partial_name_from_string())?;
+        repo.find_reference(name.to_partial_name_from_bstring())?;
         repo.find_reference(name.to_full_name().to_partial())?;
 
         Ok(())