Draft gix_path::relative_path::RelativePath

Author: cruessler

Cargo.lock

@@ -16,6 +16,7 @@ doctest = false
 
 [dependencies]
 gix-trace = { version = "^0.1.12", path = "../gix-trace" }
+gix-validate = { version = "^0.9.4", path = "../gix-validate" }
 bstr = { version = "1.12.0", default-features = false, features = ["std"] }
 thiserror = "2.0.0"
 once_cell = "1.21.3"

gix-path/Cargo.toml

@@ -62,3 +62,6 @@ pub use realpath::function::{realpath, realpath_opts};
 
 /// Information about the environment in terms of locations of resources.
 pub mod env;
+
+///
+pub mod relative_path;

gix-path/src/lib.rs

@@ -0,0 +1,86 @@
+use bstr::BStr;
+use bstr::BString;
+use bstr::ByteSlice;
+use gix_validate::path::component::Options;
+use std::borrow::Cow;
+use std::u8;
+
+use crate::os_str_into_bstr;
+use crate::try_from_bstr;
+
+/// A wrapper for `BStr`. It is used to enforce the following constraints:
+///
+/// - The path separator always is `/`, independent of the platform.
+/// - Only normal components are allowed.
+/// - It is always represented as a bunch of bytes.
+#[derive()]
+pub struct RelativePath {
+    inner: BStr,
+}
+
+impl RelativePath {
+    /// TODO
+    /// Needs docs.
+    pub fn ends_with(&self, needle: &[u8]) -> bool {
+        self.inner.ends_with(needle)
+    }
+}
+
+/// The error used in [`RelativePath`](RelativePath).
+#[derive(Debug, thiserror::Error)]
+#[allow(missing_docs)]
+pub enum Error {
+    #[error(transparent)]
+    ContainsInvalidComponent(#[from] gix_validate::path::component::Error),
+    #[error(transparent)]
+    IllegalUtf8(#[from] crate::Utf8Error),
+}
+
+impl<'a> TryFrom<&'a BStr> for &'a RelativePath {
+    type Error = Error;
+
+    fn try_from(value: &'a BStr) -> Result<Self, Self::Error> {
+        let path: &std::path::Path = &try_from_bstr(value)?;
+        let options: Options = Default::default();
+
+        for component in path.components() {
+            let component = os_str_into_bstr(component.as_os_str())?;
+
+            gix_validate::path::component(component, None, options)?;
+        }
+
+        todo!()
+    }
+}
+
+impl<'a, const N: usize> TryFrom<&'a [u8; N]> for &'a RelativePath {
+    type Error = Error;
+
+    #[inline]
+    fn try_from(_value: &'a [u8; N]) -> Result<Self, Self::Error> {
+        todo!()
+    }
+}
+
+impl TryFrom<BString> for &RelativePath {
+    type Error = Error;
+
+    fn try_from(_value: BString) -> Result<Self, Self::Error> {
+        todo!()
+    }
+}
+
+/// This is required by a trait bound on [`from_str`](crate::from_bstr).
+impl<'a> From<&'a RelativePath> for Cow<'a, BStr> {
+    #[inline]
+    fn from(value: &'a RelativePath) -> Cow<'a, BStr> {
+        Cow::Borrowed(&value.inner)
+    }
+}
+
+impl AsRef<[u8]> for RelativePath {
+    #[inline]
+    fn as_ref(&self) -> &[u8] {
+        self.inner.as_bytes()
+    }
+}

gix-path/src/relative_path.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};
 
@@ -21,8 +22,8 @@ impl Namespace {
     ///
     /// 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<'a>(mut self, prefix: &'a 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/namespace.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 {
@@ -89,7 +90,7 @@ impl file::Store {
     ///
     /// 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<'a>(&self, prefix: &'a RelativePath) -> std::io::Result<LooseThenPacked<'_, '_>> {
+        self.iter_prefixed_packed(prefix, None)
     }
 }

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

@@ -12,6 +12,8 @@ use crate::{
     BStr, FullName, Namespace, Reference,
 };
 
+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.
 ///
@@ -204,9 +206,9 @@ impl Platform<'_> {
     ///
     /// 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<'a>(&self, prefix: &'a 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,13 +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());
+    fn from_prefix(base: &'a Path, prefix: &'a RelativePath, precompose_unicode: bool) -> std::io::Result<Self> {
+        let prefix_path = gix_path::from_bstr(prefix);
         if prefix_path.is_absolute() {
             return Err(std::io::Error::new(
                 std::io::ErrorKind::InvalidInput,
@@ -326,7 +323,7 @@ impl<'a> IterInfo<'a> {
                 .to_owned();
             Ok(IterInfo::ComputedIterationRoot {
                 base,
-                prefix,
+                prefix: prefix.into(),
                 iter_root,
                 precompose_unicode,
             })
@@ -380,7 +377,7 @@ impl file::Store {
     // TODO: use `RelativePath` type instead (see #1921), or a trait that helps convert into it.
     pub fn iter_prefixed_packed<'a, 's, 'p>(
         &'s self,
-        prefix: impl Into<&'a BStr>,
+        prefix: &'a RelativePath,
         packed: Option<&'p packed::Buffer>,
     ) -> std::io::Result<LooseThenPacked<'p, 's>> {
         let prefix = prefix.into();
@@ -394,8 +391,12 @@ 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);
-                let git_dir_info = IterInfo::from_prefix(self.git_dir(), prefix.clone(), self.precompose_unicode)?;
+                let prefix = namespace
+                    .to_owned()
+                    .into_namespaced_prefix(prefix)
+                    .try_into()
+                    .expect("TODO");
+                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/src/store/file/overlay_iter.rs

@@ -1,7 +1,6 @@
 #![allow(clippy::result_large_err)]
 use super::{Error, Options};
 use crate::{
-    bstr,
     bstr::BString,
     config,
     config::{
@@ -347,10 +346,9 @@ impl ThreadSafeRepository {
         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 iter = platform.prefixed(prefix.clone().try_into().expect("TODO")).ok()?;
                 let replacements = iter
                     .filter_map(Result::ok)
                     .filter_map(|r: gix_ref::Reference| {

gix/src/open/repository.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,38 @@ 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: &'a RelativePath) -> Result<Iter<'_>, init::Error> {
+        Ok(Iter::new(self.repo, self.platform.prefixed(prefix)?))
     }
 
     // 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 +129,8 @@ pub mod init {
     pub enum Error {
         #[error(transparent)]
         Io(#[from] std::io::Error),
+        #[error(transparent)]
+        RelativePath(#[from] gix_path::relative_path::Error),
     }
 }