refactor

Author: Byron

gix-fs/Cargo.toml

@@ -8,7 +8,7 @@ license = "MIT OR Apache-2.0"
 description = "A crate providing file system specific utilities to `gitoxide`"
 authors = ["Sebastian Thiel <[email protected]>"]
 edition = "2021"
-rust-version = "1.70"
+rust-version = "1.74"
 include = ["src/**/*", "LICENSE-*"]
 
 [lib]

gix-fs/src/stack.rs

@@ -64,12 +64,11 @@ impl Stack {
     /// or have leading or trailing slashes (or additionally backslashes on Windows).
     pub fn make_relative_path_current(
         &mut self,
-        relative: impl gix_path::ToPathComponents,
+        relative: impl gix_path::ToNormalPathComponents,
         delegate: &mut dyn Delegate,
     ) -> std::io::Result<()> {
-        let components: Vec<_> = relative.to_components().collect();
-
-        if self.valid_components != 0 && components.is_empty() {
+        let mut components = relative.to_normal_path_components().peekable();
+        if self.valid_components != 0 && components.peek().is_none() {
             return Err(std::io::Error::new(
                 std::io::ErrorKind::Other,
                 "empty inputs are not allowed",
@@ -79,7 +78,6 @@ impl Stack {
             delegate.push_directory(self)?;
         }
 
-        let mut components = components.into_iter().peekable();
         let mut existing_components = self.current_relative.components();
         let mut matching_components = 0;
         while let (Some(existing_comp), Some(new_comp)) = (existing_components.next(), components.peek()) {
@@ -92,8 +90,8 @@ impl Stack {
                         break;
                     }
                 }
-                Err(err) => return Err(std::io::Error::new(std::io::ErrorKind::Other, format!("{err}"))),
-            };
+                Err(err) => return Err(std::io::Error::other(format!("{err}"))),
+            }
         }
 
         for _ in 0..self.valid_components - matching_components {
@@ -111,12 +109,7 @@ impl Stack {
         }
 
         while let Some(comp) = components.next() {
-            let comp = match comp {
-                Ok(comp) => comp,
-                Err(err) => {
-                    return Err(std::io::Error::new(std::io::ErrorKind::Other, format!("{err}")));
-                }
-            };
+            let comp = comp.map_err(std::io::Error::other)?;
             let is_last_component = components.peek().is_none();
             self.current_is_directory = !is_last_component;
             self.current.push(comp);

gix-path/src/convert.rs

@@ -341,25 +341,37 @@ pub fn relativize_with_prefix<'a>(relative_path: &'a Path, prefix: &Path) -> Cow
     }
 }
 
-/// The error used in [`ToPathComponents::to_components()`][crate::convert::ToPathComponents::to_components()].
-#[derive(Debug, thiserror::Error)]
-#[allow(missing_docs)]
-pub enum Error<'a> {
-    #[error("Input path {path:?} contains relative or absolute components", path = .0)]
-    NotANormalComponent(&'a OsStr),
+///
+pub mod to_normal_path_components {
+    use std::ffi::OsString;
+
+    /// The error used in [`ToNormalPathComponents::to_normal_path_components()`](crate::ToNormalPathComponents::to_normal_path_components()).
+    #[derive(Debug, thiserror::Error)]
+    #[allow(missing_docs)]
+    pub enum Error {
+        #[error("Input path {path:?} contains relative or absolute components", path = .0)]
+        NotANormalComponent(OsString),
+    }
 }
 
-/// Obtain an iterator over `OsStr`-components.
-pub trait ToPathComponents {
-    /// Return an iterator over the components of a path, without the separator.
-    fn to_components(&self) -> impl Iterator<Item = Result<&OsStr, Error<'_>>>;
+/// Obtain an iterator over `OsStr`-components which are normal, none-relative and not absolute.
+pub trait ToNormalPathComponents {
+    /// Return an iterator over the normal components of a path, without the separator.
+    // TODO(MSRV): turn this into `impl Iterator` once MSRV is 1.75 or higher
+    fn to_normal_path_components(
+        &self,
+    ) -> Box<dyn Iterator<Item = Result<&OsStr, to_normal_path_components::Error>> + '_>;
 }
 
-impl ToPathComponents for &Path {
-    fn to_components(&self) -> impl Iterator<Item = Result<&OsStr, Error<'_>>> {
-        self.components().map(|component| match component {
+impl ToNormalPathComponents for &Path {
+    fn to_normal_path_components(
+        &self,
+    ) -> Box<dyn Iterator<Item = Result<&OsStr, to_normal_path_components::Error>> + '_> {
+        Box::new(self.components().map(|component| match component {
             Component::Normal(os_str) => Ok(os_str),
-            _ => Err(Error::NotANormalComponent(self.as_os_str())),
-        })
+            _ => Err(to_normal_path_components::Error::NotANormalComponent(
+                self.as_os_str().to_owned(),
+            )),
+        }))
     }
 }