create new gix-fs crate to consolidate all filesystem utilities

Author: Byron

Cargo.lock

@@ -178,6 +178,7 @@ members = [
     "gix-refspec",
     "gix-path",
     "gix-utils",
+    "gix-fs",
     "gix",
     "gitoxide-core",
     "gix-hashtable",

Cargo.toml

@@ -86,6 +86,7 @@ is usable to some extent.
   * `gitoxide-core`
 * **very early**  _(possibly without any documentation and many rough edges)_
   * [gix-utils](https://github.com/Byron/gitoxide/blob/main/crate-status.md#gix-utils)
+  * [gix-fs](https://github.com/Byron/gitoxide/blob/main/crate-status.md#gix-fs)
   * [gix-worktree](https://github.com/Byron/gitoxide/blob/main/crate-status.md#gix-worktree)
   * [gix-bitmap](https://github.com/Byron/gitoxide/blob/main/crate-status.md#gix-bitmap)
   * [gix-date](https://github.com/Byron/gitoxide/blob/main/crate-status.md#gix-date)

README.md

@@ -105,11 +105,15 @@ and itself relies on all `git-*` crates. It's not meant for consumption, for app
 * [x] hashset
 
 ### gix-utils
-
 * **filesystem**
    * [x] probe capabilities
    * [x] symlink creation and removal
    * [x] file snapshots
+    
+### gix-fs
+* [x] probe capabilities
+* [x] symlink creation and removal
+* [x] file snapshots
 
 ### gix-object
 * *decode (zero-copy)* borrowed objects

crate-status.md

@@ -17,6 +17,9 @@ function indent () {
 echo "in root: gitoxide CLI"
 (enter cargo-smart-release && indent cargo diet -n --package-size-limit 110KB)
 (enter gix-actor && indent cargo diet -n --package-size-limit 5KB)
+(enter gix-archive && indent cargo diet -n --package-size-limit 10KB)
+(enter gix-utils && indent cargo diet -n --package-size-limit 10KB)
+(enter gix-fs && indent cargo diet -n --package-size-limit 10KB)
 (enter gix-pathspec && indent cargo diet -n --package-size-limit 30KB)
 (enter gix-refspec && indent cargo diet -n --package-size-limit 30KB)
 (enter gix-path && indent cargo diet -n --package-size-limit 25KB)

etc/check-package-size.sh

@@ -56,7 +56,7 @@ pub fn checkout_exclusive(
     }
 
     let opts = gix::worktree::index::checkout::Options {
-        fs: gix::utils::FilesystemCapabilities::probe(dest_directory),
+        fs: gix::fs::Capabilities::probe(dest_directory),
 
         destination_is_initially_empty: true,
         overwrite_existing: false,

gitoxide-core/src/index/checkout.rs

@@ -33,7 +33,7 @@ document-features = { version = "0.2.1", optional = true }
 
 [dev-dependencies]
 gix-testtools = { path = "../tests/tools"}
-gix-utils = { path = "../gix-utils" }
+gix-fs = { path = "../gix-fs" }
 
 [package.metadata.docs.rs]
 all-features = true

gix-attributes/Cargo.toml

@@ -2,7 +2,7 @@ use bstr::{BStr, ByteSlice};
 use gix_attributes::search::{AttributeId, Outcome};
 use gix_attributes::{AssignmentRef, NameRef, StateRef};
 use gix_glob::pattern::Case;
-use gix_utils::FilesystemCapabilities;
+
 use std::collections::BTreeMap;
 
 mod specials {
@@ -62,7 +62,7 @@ fn baseline() -> crate::Result {
     let mut buf = Vec::new();
     // Due to the way our setup differs from gits dynamic stack (which involves trying to read files from disk
     // by path) we can only test one case baseline, so we require multiple platforms (or filesystems) to run this.
-    let case = if FilesystemCapabilities::probe("../.git").ignore_case {
+    let case = if gix_fs::Capabilities::probe("../.git").ignore_case {
         Case::Fold
     } else {
         Case::Sensitive

gix-attributes/tests/search/mod.rs

@@ -0,0 +1,18 @@
+[package]
+name = "gix-fs"
+version = "0.1.0"
+repository = "https://github.com/Byron/gitoxide"
+license = "MIT/Apache-2.0"
+description = "A crate providing file system specific utilities to `gitoxide`"
+authors = ["Sebastian Thiel <sebastian.thiel@icloud.com>"]
+edition = "2021"
+rust-version = "1.64"
+
+[lib]
+doctest = false
+
+[dependencies]
+gix-features = { path = "../gix-features" }
+
+[dev-dependencies]
+tempfile = "3.5.0"

gix-fs/Cargo.toml

@@ -1,11 +1,11 @@
 // TODO: tests
-use crate::FilesystemCapabilities;
+use crate::Capabilities;
 use std::path::Path;
 
 #[cfg(windows)]
-impl Default for FilesystemCapabilities {
+impl Default for Capabilities {
     fn default() -> Self {
-        FilesystemCapabilities {
+        Capabilities {
             precompose_unicode: false,
             ignore_case: true,
             executable_bit: false,
@@ -15,9 +15,9 @@ impl Default for FilesystemCapabilities {
 }
 
 #[cfg(target_os = "macos")]
-impl Default for FilesystemCapabilities {
+impl Default for Capabilities {
     fn default() -> Self {
-        FilesystemCapabilities {
+        Capabilities {
             precompose_unicode: true,
             ignore_case: true,
             executable_bit: true,
@@ -27,9 +27,9 @@ impl Default for FilesystemCapabilities {
 }
 
 #[cfg(all(unix, not(target_os = "macos")))]
-impl Default for FilesystemCapabilities {
+impl Default for Capabilities {
     fn default() -> Self {
-        FilesystemCapabilities {
+        Capabilities {
             precompose_unicode: false,
             ignore_case: false,
             executable_bit: true,
@@ -38,16 +38,16 @@ impl Default for FilesystemCapabilities {
     }
 }
 
-impl FilesystemCapabilities {
+impl Capabilities {
     /// try to determine all values in this context by probing them in the given `git_dir`, which
     /// should be on the file system the git repository is located on.
     /// `git_dir` is a typical git repository, expected to be populated with the typical files like `config`.
     ///
     /// All errors are ignored and interpreted on top of the default for the platform the binary is compiled for.
     pub fn probe(git_dir: impl AsRef<Path>) -> Self {
         let root = git_dir.as_ref();
-        let ctx = FilesystemCapabilities::default();
-        FilesystemCapabilities {
+        let ctx = Capabilities::default();
+        Capabilities {
             symlink: Self::probe_symlink(root).unwrap_or(ctx.symlink),
             ignore_case: Self::probe_ignore_case(root).unwrap_or(ctx.ignore_case),
             precompose_unicode: Self::probe_precompose_unicode(root).unwrap_or(ctx.precompose_unicode),

gix-utils/src/fs_capabilities.rs renamed to gix-fs/src/capabilities.rs

@@ -28,7 +28,7 @@ impl Default for Retries {
 mod error {
     use std::{fmt, path::Path};
 
-    use crate::fs::create_dir::Retries;
+    use crate::dir::create::Retries;
 
     /// The error returned by [all()][super::all()].
     #[allow(missing_docs)]

gix-tempfile/src/fs/create_dir.rs renamed to gix-fs/src/dir/create.rs

@@ -0,0 +1,4 @@
+///
+pub mod create;
+///
+pub mod remove;

gix-fs/src/dir/mod.rs

@@ -0,0 +1,34 @@
+//! A crate with file-system specific utilities.
+#![deny(rust_2018_idioms)]
+#![forbid(unsafe_code)]
+
+/// Common knowledge about the worktree that is needed across most interactions with the work tree
+#[cfg_attr(feature = "serde1", derive(serde::Serialize, serde::Deserialize))]
+#[derive(PartialEq, Eq, Debug, Hash, Ord, PartialOrd, Clone, Copy)]
+pub struct Capabilities {
+    /// If true, the filesystem will store paths as decomposed unicode, i.e. `ä` becomes `"a\u{308}"`, which means that
+    /// we have to turn these forms back from decomposed to precomposed unicode before storing it in the index or generally
+    /// using it. This also applies to input received from the command-line, so callers may have to be aware of this and
+    /// perform conversions accordingly.
+    /// If false, no conversions will be performed.
+    pub precompose_unicode: bool,
+    /// If true, the filesystem ignores the case of input, which makes `A` the same file as `a`.
+    /// This is also called case-folding.
+    pub ignore_case: bool,
+    /// If true, we assume the executable bit is honored as part of the files mode. If false, we assume the file system
+    /// ignores the executable bit, hence it will be reported as 'off' even though we just tried to set it to be on.
+    pub executable_bit: bool,
+    /// If true, the file system supports symbolic links and we should try to create them. Otherwise symbolic links will be checked
+    /// out as files which contain the link as text.
+    pub symlink: bool,
+}
+mod capabilities;
+
+mod snapshot;
+pub use snapshot::{FileSnapshot, SharedFileSnapshot, SharedFileSnapshotMut};
+
+///
+pub mod symlink;
+
+///
+pub mod dir;

gix-tempfile/src/fs/remove_dir.rs renamed to gix-fs/src/dir/remove.rs

@@ -1,3 +1,4 @@
+use std::io::ErrorKind::AlreadyExists;
 use std::{io, path::Path};
 
 #[cfg(not(windows))]
@@ -35,20 +36,16 @@ pub fn create(original: &Path, link: &Path) -> io::Result<()> {
     }
 }
 
-pub mod error {
-    use std::io::ErrorKind::AlreadyExists;
-
-    #[cfg(not(windows))]
-    pub fn indicates_collision(err: &std::io::Error) -> bool {
-        // TODO: use ::IsDirectory as well when stabilized instead of raw_os_error(), and ::FileSystemLoop respectively
-        err.kind() == AlreadyExists
+#[cfg(not(windows))]
+pub fn is_collision_error(err: &std::io::Error) -> bool {
+    // TODO: use ::IsDirectory as well when stabilized instead of raw_os_error(), and ::FileSystemLoop respectively
+    err.kind() == AlreadyExists
             || err.raw_os_error() == Some(21)
             || err.raw_os_error() == Some(62) // no-follow on symlnk on mac-os
             || err.raw_os_error() == Some(40) // no-follow on symlnk on ubuntu
-    }
+}
 
-    #[cfg(windows)]
-    pub fn indicates_collision(err: &std::io::Error) -> bool {
-        err.kind() == AlreadyExists || err.kind() == std::io::ErrorKind::PermissionDenied
-    }
+#[cfg(windows)]
+pub fn is_collision_error(err: &std::io::Error) -> bool {
+    err.kind() == AlreadyExists || err.kind() == std::io::ErrorKind::PermissionDenied
 }