Use gix_fs::stack::ToNormalPathComponents everywhere.

Author: Byron

Cargo.lock

@@ -8,10 +8,10 @@ pub struct Options {
 }
 
 pub(crate) mod function {
-    use std::{borrow::Cow, io, path::Path};
-
     use anyhow::bail;
     use gix::bstr::BStr;
+    use std::borrow::Cow;
+    use std::{io, path::Path};
 
     use crate::{
         is_dir_to_mode,
@@ -44,7 +44,7 @@ pub(crate) mod function {
                         .ok()
                         .map(|m| is_dir_to_mode(m.is_dir()));
 
-                    let entry = cache.at_entry(path.as_slice(), mode)?;
+                    let entry = cache.at_entry(&path, mode)?;
                     if !entry.matching_attributes(&mut matches) {
                         continue;
                     }

gitoxide-core/src/repository/attributes/query.rs

@@ -48,7 +48,7 @@ pub fn query(
                     .metadata()
                     .ok()
                     .map(|m| is_dir_to_mode(m.is_dir()));
-                let entry = cache.at_entry(path.as_slice(), mode)?;
+                let entry = cache.at_entry(&path, mode)?;
                 let match_ = entry
                     .matching_exclude_pattern()
                     .and_then(|m| (show_ignore_patterns || !m.pattern.is_negative()).then_some(m));

gitoxide-core/src/repository/exclude.rs

@@ -19,6 +19,8 @@ doctest = false
 serde = ["dep:serde"]
 
 [dependencies]
+bstr = "1.5.0"
+gix-path = { version = "^0.10.14", path = "../gix-path" }
 gix-features = { version = "^0.40.0", path = "../gix-features", features = ["fs-read-dir"] }
 gix-utils = { version = "^0.1.14", path = "../gix-utils" }
 thiserror = "2.0.0"

gix-fs/Cargo.toml

@@ -1,8 +1,8 @@
+use crate::Stack;
+use bstr::{BStr, BString, ByteSlice};
 use std::ffi::OsStr;
 use std::path::{Component, Path, PathBuf};
 
-use crate::Stack;
-
 ///
 pub mod to_normal_path_components {
     use std::ffi::OsString;
@@ -13,6 +13,8 @@ pub mod to_normal_path_components {
     pub enum Error {
         #[error("Input path \"{path}\" contains relative or absolute components", path = std::path::Path::new(.0.as_os_str()).display())]
         NotANormalComponent(OsString),
+        #[error("Could not convert to UTF8 or from UTF8 due to ill-formed input")]
+        IllegalUtf8,
     }
 }
 
@@ -33,6 +35,36 @@ impl ToNormalPathComponents for &Path {
     }
 }
 
+impl ToNormalPathComponents for &BStr {
+    fn to_normal_path_components(&self) -> impl Iterator<Item = Result<&OsStr, to_normal_path_components::Error>> {
+        self.split(|b| *b == b'/').map(|component| {
+            gix_path::try_from_byte_slice(component.as_bstr())
+                .map_err(|_| to_normal_path_components::Error::IllegalUtf8)
+                .map(|p| p.as_os_str())
+        })
+    }
+}
+
+impl ToNormalPathComponents for &str {
+    fn to_normal_path_components(&self) -> impl Iterator<Item = Result<&OsStr, to_normal_path_components::Error>> {
+        self.split('/').map(|component| {
+            gix_path::try_from_byte_slice(component.as_bytes())
+                .map_err(|_| to_normal_path_components::Error::IllegalUtf8)
+                .map(|p| p.as_os_str())
+        })
+    }
+}
+
+impl ToNormalPathComponents for &BString {
+    fn to_normal_path_components(&self) -> impl Iterator<Item = Result<&OsStr, to_normal_path_components::Error>> {
+        self.split(|b| *b == b'/').map(|component| {
+            gix_path::try_from_byte_slice(component.as_bstr())
+                .map_err(|_| to_normal_path_components::Error::IllegalUtf8)
+                .map(|p| p.as_os_str())
+        })
+    }
+}
+
 /// Access
 impl Stack {
     /// Returns the top-level path of the stack.

gix-fs/src/stack.rs

@@ -1,10 +1,10 @@
+use crate::SymlinkCheck;
 use bstr::BStr;
+use gix_fs::stack::ToNormalPathComponents;
 use gix_fs::Stack;
 use std::borrow::Cow;
 use std::path::{Path, PathBuf};
 
-use crate::SymlinkCheck;
-
 impl SymlinkCheck {
     /// Create a new stack that starts operating at `root`.
     pub fn new(root: PathBuf) -> Self {
@@ -24,7 +24,7 @@ impl SymlinkCheck {
     /// ### Note
     ///
     /// On windows, no verification is performed, instead only the combined path is provided as usual.
-    pub fn verified_path(&mut self, relative_path: &Path) -> std::io::Result<&Path> {
+    pub fn verified_path(&mut self, relative_path: impl ToNormalPathComponents) -> std::io::Result<&Path> {
         self.inner.make_relative_path_current(relative_path, &mut Delegate)?;
         Ok(self.inner.current())
     }
@@ -34,7 +34,7 @@ impl SymlinkCheck {
     /// For convenience, this incarnation is tuned to be easy to use with Git paths, i.e. slash-separated `BString` path.
     pub fn verified_path_allow_nonexisting(&mut self, relative_path: &BStr) -> std::io::Result<Cow<'_, Path>> {
         let rela_path = gix_path::try_from_bstr(relative_path).map_err(std::io::Error::other)?;
-        if let Err(err) = self.verified_path(&rela_path) {
+        if let Err(err) = self.verified_path(rela_path.as_ref()) {
             if err.kind() == std::io::ErrorKind::NotFound {
                 Ok(Cow::Owned(self.inner.root().join(rela_path)))
             } else {

gix-status/src/stack.rs

@@ -80,7 +80,7 @@ where
     let dest_relative = gix_path::try_from_bstr(entry_path).map_err(|_| crate::checkout::Error::IllformedUtf8 {
         path: entry_path.to_owned(),
     })?;
-    let path_cache = path_cache.at_path(dest_relative, Some(entry.mode), &*objects)?;
+    let path_cache = path_cache.at_path(dest_relative.as_ref(), Some(entry.mode), &*objects)?;
     let dest = path_cache.path();
 
     let object_size = match entry.mode {

gix-worktree-state/src/checkout/entry.rs

@@ -9,7 +9,7 @@ description = "A crate of the gitoxide project for shared worktree related types
 authors = ["Sebastian Thiel <sebastian.thiel@icloud.com>"]
 edition = "2021"
 include = ["src/**/*", "LICENSE-*"]
-rust-version = "1.70"
+rust-version = "1.74"
 autotests = false
 
 [lib]

gix-worktree/Cargo.toml

@@ -113,7 +113,7 @@ impl Stack {
     /// Provide access to cached information for that `relative` path via the returned platform.
     pub fn at_path(
         &mut self,
-        relative: impl AsRef<Path>,
+        relative: impl ToNormalPathComponents,
         mode: Option<gix_index::entry::Mode>,
         objects: &dyn gix_object::Find,
     ) -> std::io::Result<Platform<'_>> {
@@ -127,8 +127,7 @@ impl Stack {
             case: self.case,
             statistics: &mut self.statistics,
         };
-        self.stack
-            .make_relative_path_current(relative.as_ref(), &mut delegate)?;
+        self.stack.make_relative_path_current(relative, &mut delegate)?;
         Ok(Platform {
             parent: self,
             is_dir: mode_is_dir(mode),
@@ -148,15 +147,8 @@ impl Stack {
         objects: &dyn gix_object::Find,
     ) -> std::io::Result<Platform<'_>> {
         let relative = relative.into();
-        let relative_path = gix_path::try_from_bstr(relative).map_err(|_err| {
-            std::io::Error::new(
-                std::io::ErrorKind::Other,
-                format!("The path \"{relative}\" contained invalid UTF-8 and could not be turned into a path"),
-            )
-        })?;
-
         self.at_path(
-            relative_path,
+            relative,
             mode.or_else(|| relative.ends_with_str("/").then_some(gix_index::entry::Mode::DIR)),
             objects,
         )
@@ -210,6 +202,7 @@ impl Stack {
 ///
 pub mod delegate;
 use delegate::StackDelegate;
+use gix_fs::stack::ToNormalPathComponents;
 
 mod platform;
 ///

gix-worktree/src/stack/mod.rs

@@ -1,7 +1,7 @@
+use crate::{types::AttributeStack, Repository};
+use gix_fs::stack::ToNormalPathComponents;
 use std::ops::{Deref, DerefMut};
 
-use crate::{bstr::BStr, types::AttributeStack, Repository};
-
 /// Lifecycle
 impl<'repo> AttributeStack<'repo> {
     /// Create a new instance from a `repo` and the underlying pre-configured `stack`.
@@ -44,7 +44,7 @@ impl AttributeStack<'_> {
         relative: impl AsRef<std::path::Path>,
         mode: Option<gix_index::entry::Mode>,
     ) -> std::io::Result<gix_worktree::stack::Platform<'_>> {
-        self.inner.at_path(relative, mode, &self.repo.objects)
+        self.inner.at_path(relative.as_ref(), mode, &self.repo.objects)
     }
 
     /// Obtain a platform for attribute or ignore lookups from a repo-`relative` path, typically obtained from an index entry.
@@ -53,9 +53,9 @@ impl AttributeStack<'_> {
     /// If `relative` ends with `/` and `mode` is `None`, it is automatically assumed to be a directory.
     pub fn at_entry<'r>(
         &mut self,
-        relative: impl Into<&'r BStr>,
+        relative: impl ToNormalPathComponents,
         mode: Option<gix_index::entry::Mode>,
     ) -> std::io::Result<gix_worktree::stack::Platform<'_>> {
-        self.inner.at_entry(relative, mode, &self.repo.objects)
+        self.inner.at_path(relative, mode, &self.repo.objects)
     }
 }