feat!: Support precompose_unicode flag in fs::walkdir types.

Author: Byron

Cargo.lock

@@ -25,7 +25,7 @@ progress-unit-human-numbers = ["prodash?/unit-human"]
 progress-unit-bytes = ["dep:bytesize", "prodash?/unit-bytes"]
 
 ## If set, walkdir iterators will be multi-threaded.
-fs-walkdir-parallel = [ "dep:jwalk" ]
+fs-walkdir-parallel = [ "dep:jwalk", "dep:gix-utils" ]
 
 ## Implement `tracing` with `tracing-core`, which provides applications with valuable performance details if they opt-in to it.
 ##
@@ -47,7 +47,7 @@ parallel = ["dep:crossbeam-channel",
 once_cell = ["dep:once_cell"]
 ## Makes facilities of the `walkdir` crate partially available.
 ## In conjunction with the **parallel** feature, directory walking will be parallel instead behind a compatible interface.
-walkdir = ["dep:walkdir"]
+walkdir = ["dep:walkdir", "dep:gix-utils"]
 #* an in-memory unidirectional pipe using `bytes` as efficient transfer mechanism.
 io-pipe = ["dep:bytes"]
 ## provide a proven and fast `crc32` implementation.
@@ -117,6 +117,9 @@ required-features = ["io-pipe"]
 gix-hash = { version = "^0.14.1", path = "../gix-hash" }
 gix-trace = { version = "^0.1.6", path = "../gix-trace" }
 
+# for walkdir
+gix-utils = { version = "^0.1.8", path = "../gix-utils", optional = true }
+
 # 'parallel' feature
 crossbeam-channel = { version = "0.5.0", optional = true }
 parking_lot = { version = "0.12.0", default-features = false, optional = true }

gix-features/Cargo.toml

@@ -21,17 +21,152 @@ mod shared {
     }
 }
 
+#[cfg(any(feature = "walkdir", feature = "fs-walkdir-parallel"))]
+mod walkdir_precompose {
+    use std::borrow::Cow;
+    use std::ffi::OsStr;
+    use std::path::Path;
+
+    pub struct DirEntry<T> {
+        inner: T,
+        precompose_unicode: bool,
+    }
+
+    pub trait DirEntryApi {
+        fn path(&self) -> Cow<'_, Path>;
+        fn file_name(&self) -> Cow<'_, OsStr>;
+        fn file_type(&self) -> std::fs::FileType;
+    }
+
+    impl<T: DirEntryApi> DirEntry<T> {
+        /// Obtain the full path of this entry, possibly with precomposed unicode if enabled.
+        ///
+        /// Note that decomposing filesystem like those made by Apple accept both precomposed and
+        /// decomposed names, and consider them equal.
+        pub fn path(&self) -> Cow<'_, Path> {
+            let path = self.inner.path();
+            if self.precompose_unicode {
+                gix_utils::str::precompose_path(path)
+            } else {
+                path
+            }
+        }
+
+        /// Obtain filen name of this entry, possibly with precomposed unicode if enabled.
+        pub fn file_name(&self) -> Cow<'_, OsStr> {
+            let name = self.inner.file_name();
+            if self.precompose_unicode {
+                gix_utils::str::precompose_os_string(name)
+            } else {
+                name
+            }
+        }
+
+        /// Return the file type for the file that this entry points to.
+        ///
+        /// If `follow_links` was `true`, this is the file type of the item the link points to.
+        pub fn file_type(&self) -> std::fs::FileType {
+            self.inner.file_type()
+        }
+    }
+
+    /// A platform over entries in a directory, which may or may not precompose unicode after retrieving
+    /// paths from the file system.
+    pub struct WalkDir<T> {
+        pub(crate) inner: Option<T>,
+        pub(crate) precompose_unicode: bool,
+    }
+
+    pub struct WalkDirIter<T, I, E>
+    where
+        T: Iterator<Item = Result<I, E>>,
+        I: DirEntryApi,
+    {
+        pub(crate) inner: T,
+        pub(crate) precompose_unicode: bool,
+    }
+
+    impl<T, I, E> Iterator for WalkDirIter<T, I, E>
+    where
+        T: Iterator<Item = Result<I, E>>,
+        I: DirEntryApi,
+    {
+        type Item = Result<DirEntry<I>, E>;
+
+        fn next(&mut self) -> Option<Self::Item> {
+            self.inner.next().map(|res| {
+                res.map(|entry| DirEntry {
+                    inner: entry,
+                    precompose_unicode: self.precompose_unicode,
+                })
+            })
+        }
+    }
+}
+
 ///
 #[cfg(feature = "fs-walkdir-parallel")]
 pub mod walkdir {
+    use std::borrow::Cow;
+    use std::ffi::OsStr;
+    use std::fs::FileType;
     use std::path::Path;
 
-    pub use jwalk::{DirEntry as DirEntryGeneric, DirEntryIter as DirEntryIterGeneric, Error, WalkDir};
+    use jwalk::WalkDir as WalkDirImpl;
+    pub use jwalk::{DirEntry as DirEntryGeneric, DirEntryIter as DirEntryIterGeneric, Error};
 
     pub use super::shared::Parallelism;
 
-    /// An alias for an uncustomized directory entry to match the one of the non-parallel version offered by `walkdir`.
-    pub type DirEntry = DirEntryGeneric<((), ())>;
+    type DirEntryImpl = DirEntryGeneric<((), ())>;
+
+    /// A directory entry returned by [DirEntryIter].
+    pub type DirEntry = super::walkdir_precompose::DirEntry<DirEntryImpl>;
+    /// A platform to create a [DirEntryIter] from.
+    pub type WalkDir = super::walkdir_precompose::WalkDir<WalkDirImpl>;
+
+    impl super::walkdir_precompose::DirEntryApi for DirEntryImpl {
+        fn path(&self) -> Cow<'_, Path> {
+            self.path().into()
+        }
+
+        fn file_name(&self) -> Cow<'_, OsStr> {
+            self.file_name().into()
+        }
+
+        fn file_type(&self) -> FileType {
+            self.file_type()
+        }
+    }
+
+    impl IntoIterator for WalkDir {
+        type Item = Result<DirEntry, jwalk::Error>;
+        type IntoIter = DirEntryIter;
+
+        fn into_iter(self) -> Self::IntoIter {
+            DirEntryIter {
+                inner: self.inner.expect("always set (builder fix)").into_iter(),
+                precompose_unicode: self.precompose_unicode,
+            }
+        }
+    }
+
+    impl WalkDir {
+        /// Set the minimum component depth of paths of entries.
+        pub fn min_depth(mut self, min: usize) -> Self {
+            self.inner = Some(self.inner.take().expect("always set").min_depth(min));
+            self
+        }
+        /// Set the maximum component depth of paths of entries.
+        pub fn max_depth(mut self, max: usize) -> Self {
+            self.inner = Some(self.inner.take().expect("always set").max_depth(max));
+            self
+        }
+        /// Follow symbolic links.
+        pub fn follow_links(mut self, toggle: bool) -> Self {
+            self.inner = Some(self.inner.take().expect("always set").follow_links(toggle));
+            self
+        }
+    }
 
     impl From<Parallelism> for jwalk::Parallelism {
         fn from(v: Parallelism) -> Self {
@@ -58,43 +193,122 @@ pub mod walkdir {
     }
 
     /// Instantiate a new directory iterator which will not skip hidden files, with the given level of `parallelism`.
-    pub fn walkdir_new(root: &Path, parallelism: Parallelism) -> WalkDir {
-        WalkDir::new(root).skip_hidden(false).parallelism(parallelism.into())
+    ///
+    /// Use `precompose_unicode` to represent the `core.precomposeUnicode` configuration option.
+    pub fn walkdir_new(root: &Path, parallelism: Parallelism, precompose_unicode: bool) -> WalkDir {
+        WalkDir {
+            inner: WalkDirImpl::new(root)
+                .skip_hidden(false)
+                .parallelism(parallelism.into())
+                .into(),
+            precompose_unicode,
+        }
     }
 
     /// Instantiate a new directory iterator which will not skip hidden files and is sorted
-    pub fn walkdir_sorted_new(root: &Path, parallelism: Parallelism) -> WalkDir {
-        WalkDir::new(root)
-            .skip_hidden(false)
-            .sort(true)
-            .parallelism(parallelism.into())
+    ///
+    /// Use `precompose_unicode` to represent the `core.precomposeUnicode` configuration option.
+    pub fn walkdir_sorted_new(root: &Path, parallelism: Parallelism, precompose_unicode: bool) -> WalkDir {
+        WalkDir {
+            inner: WalkDirImpl::new(root)
+                .skip_hidden(false)
+                .sort(true)
+                .parallelism(parallelism.into())
+                .into(),
+            precompose_unicode,
+        }
     }
 
+    type DirEntryIterImpl = DirEntryIterGeneric<((), ())>;
+
     /// The Iterator yielding directory items
-    pub type DirEntryIter = DirEntryIterGeneric<((), ())>;
+    pub type DirEntryIter = super::walkdir_precompose::WalkDirIter<DirEntryIterImpl, DirEntryImpl, jwalk::Error>;
 }
 
-#[cfg(all(feature = "walkdir", not(feature = "fs-walkdir-parallel")))]
 ///
+#[cfg(all(feature = "walkdir", not(feature = "fs-walkdir-parallel")))]
 pub mod walkdir {
+    use std::borrow::Cow;
+    use std::ffi::OsStr;
+    use std::fs::FileType;
     use std::path::Path;
 
-    pub use walkdir::{DirEntry, Error, WalkDir};
+    pub use walkdir::Error;
+    use walkdir::{DirEntry as DirEntryImpl, WalkDir as WalkDirImpl};
+
+    /// A directory entry returned by [DirEntryIter].
+    pub type DirEntry = super::walkdir_precompose::DirEntry<DirEntryImpl>;
+    /// A platform to create a [DirEntryIter] from.
+    pub type WalkDir = super::walkdir_precompose::WalkDir<WalkDirImpl>;
 
     pub use super::shared::Parallelism;
 
+    impl super::walkdir_precompose::DirEntryApi for DirEntryImpl {
+        fn path(&self) -> Cow<'_, Path> {
+            self.path().into()
+        }
+
+        fn file_name(&self) -> Cow<'_, OsStr> {
+            self.file_name().into()
+        }
+
+        fn file_type(&self) -> FileType {
+            self.file_type()
+        }
+    }
+
+    impl IntoIterator for WalkDir {
+        type Item = Result<DirEntry, walkdir::Error>;
+        type IntoIter = DirEntryIter;
+
+        fn into_iter(self) -> Self::IntoIter {
+            DirEntryIter {
+                inner: self.inner.expect("always set (builder fix)").into_iter(),
+                precompose_unicode: self.precompose_unicode,
+            }
+        }
+    }
+
+    impl WalkDir {
+        /// Set the minimum component depth of paths of entries.
+        pub fn min_depth(mut self, min: usize) -> Self {
+            self.inner = Some(self.inner.take().expect("always set").min_depth(min));
+            self
+        }
+        /// Set the maximum component depth of paths of entries.
+        pub fn max_depth(mut self, max: usize) -> Self {
+            self.inner = Some(self.inner.take().expect("always set").max_depth(max));
+            self
+        }
+        /// Follow symbolic links.
+        pub fn follow_links(mut self, toggle: bool) -> Self {
+            self.inner = Some(self.inner.take().expect("always set").follow_links(toggle));
+            self
+        }
+    }
+
     /// Instantiate a new directory iterator which will not skip hidden files, with the given level of `parallelism`.
-    pub fn walkdir_new(root: &Path, _: Parallelism) -> WalkDir {
-        WalkDir::new(root)
+    ///
+    /// Use `precompose_unicode` to represent the `core.precomposeUnicode` configuration option.
+    pub fn walkdir_new(root: &Path, _: Parallelism, precompose_unicode: bool) -> WalkDir {
+        WalkDir {
+            inner: WalkDirImpl::new(root).into(),
+            precompose_unicode,
+        }
     }
 
     /// Instantiate a new directory iterator which will not skip hidden files and is sorted, with the given level of `parallelism`.
-    pub fn walkdir_sorted_new(root: &Path, _: Parallelism) -> WalkDir {
-        WalkDir::new(root).sort_by_file_name()
+    ///
+    /// Use `precompose_unicode` to represent the `core.precomposeUnicode` configuration option.
+    pub fn walkdir_sorted_new(root: &Path, _: Parallelism, precompose_unicode: bool) -> WalkDir {
+        WalkDir {
+            inner: WalkDirImpl::new(root).sort_by_file_name().into(),
+            precompose_unicode,
+        }
     }
 
     /// The Iterator yielding directory items
-    pub type DirEntryIter = walkdir::IntoIter;
+    pub type DirEntryIter = super::walkdir_precompose::WalkDirIter<walkdir::IntoIter, DirEntryImpl, walkdir::Error>;
 }
 
 #[cfg(any(feature = "walkdir", feature = "fs-walkdir-parallel"))]