feat!: use gix_path::convert::ToPathComponents

Author: cruessler

Cargo.lock

@@ -20,6 +20,7 @@ serde = ["dep:serde"]
 
 [dependencies]
 gix-features = { version = "^0.40.0", path = "../gix-features", features = ["fs-read-dir"] }
+gix-path = { version = "^0.10.14", path = "../gix-path" }
 gix-utils = { version = "^0.1.14", path = "../gix-utils" }
 serde = { version = "1.0.114", optional = true, default-features = false, features = ["std", "derive"] }
 

gix-fs/Cargo.toml

@@ -1,4 +1,4 @@
-use std::path::{Component, Path, PathBuf};
+use std::path::{Path, PathBuf};
 
 use crate::Stack;
 
@@ -62,8 +62,14 @@ impl Stack {
     /// `relative` paths are terminal, so point to their designated file or directory.
     /// The path is also expected to be normalized, and should not contain extra separators, and must not contain `..`
     /// or have leading or trailing slashes (or additionally backslashes on Windows).
-    pub fn make_relative_path_current(&mut self, relative: &Path, delegate: &mut dyn Delegate) -> std::io::Result<()> {
-        if self.valid_components != 0 && relative.as_os_str().is_empty() {
+    pub fn make_relative_path_current(
+        &mut self,
+        relative: impl gix_path::ToPathComponents,
+        delegate: &mut dyn Delegate,
+    ) -> std::io::Result<()> {
+        let components: Vec<_> = relative.to_components().collect();
+
+        if self.valid_components != 0 && components.is_empty() {
             return Err(std::io::Error::new(
                 std::io::ErrorKind::Other,
                 "empty inputs are not allowed",
@@ -73,16 +79,21 @@ impl Stack {
             delegate.push_directory(self)?;
         }
 
-        let mut components = relative.components().peekable();
+        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()) {
-            if existing_comp == *new_comp {
-                components.next();
-                matching_components += 1;
-            } else {
-                break;
-            }
+            match new_comp {
+                Ok(new_comp) => {
+                    if existing_comp.as_os_str() == *new_comp {
+                        components.next();
+                        matching_components += 1;
+                    } else {
+                        break;
+                    }
+                }
+                Err(err) => return Err(std::io::Error::new(std::io::ErrorKind::Other, format!("{err}"))),
+            };
         }
 
         for _ in 0..self.valid_components - matching_components {
@@ -100,15 +111,12 @@ impl Stack {
         }
 
         while let Some(comp) = components.next() {
-            if !matches!(comp, Component::Normal(_)) {
-                return Err(std::io::Error::new(
-                    std::io::ErrorKind::Other,
-                    format!(
-                        "Input path \"{}\" contains relative or absolute components",
-                        relative.display()
-                    ),
-                ));
-            }
+            let comp = match comp {
+                Ok(comp) => comp,
+                Err(err) => {
+                    return Err(std::io::Error::new(std::io::ErrorKind::Other, format!("{err}")));
+                }
+            };
             let is_last_component = components.peek().is_none();
             self.current_is_directory = !is_last_component;
             self.current.push(comp);