feat: add current_dir(precompose_unicode).

Author: Byron

Cargo.lock

@@ -18,6 +18,7 @@ serde = ["dep:serde"]
 
 [dependencies]
 gix-features = { version = "^0.37.1", path = "../gix-features" }
+gix-utils = { version = "^0.1.8", path = "../gix-utils" }
 serde = { version = "1.0.114", optional = true, default-features = false, features = ["std", "derive"] }
 
 [dev-dependencies]

gix-fs/Cargo.toml

@@ -8,11 +8,17 @@ use std::path::PathBuf;
 #[cfg_attr(feature = "serde", 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.
+    /// If `true`, the filesystem will consider the precomposed umlaut `ä` similiar to its decomposed form `"a\u{308}"` and consider them the same.
+    /// If `false`, the filesystem will only see bytes which means that the above example could live side-by-side.
+    ///
+    /// Even though a filesystem that treats both forms the same will still reproduce the exact same byte sequence during traversal for instance,
+    /// this might also mean that we see paths in their decomposed form (this happens when creating directory `ä` in MacOS Finder for example).
+    ///
+    /// If Git would store such decomposed paths in the repository, which only sees bytes, on linux this might mean the path will look strange
+    /// at best, which is why it prefers to store precomposed unicode on systems where it matters, like MacOS and Windows.
+    ///
+    /// For best compatibility, and with this value being `true`, we will turn decomposed paths and input like command-line arguments into their
+    /// precomposed forms, so no decomposed byte sequences should end up in storage.
     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.
@@ -35,6 +41,22 @@ pub mod symlink;
 ///
 pub mod dir;
 
+/// Like [`std::env::current_dir()`], but it will `precompose_unicode` if that value is true, if the current directory
+/// is valid unicode and if there are decomposed unicode codepoints.
+///
+/// Thus, it will turn `"a\u{308}"` into `ä` if `true`.
+/// Keeping it `false` will not alter the output.
+///
+/// Note that `precompose_unicode` most be set using the `core.precomposeUnicode` git configuration.
+pub fn current_dir(precompose_unicode: bool) -> std::io::Result<PathBuf> {
+    let cwd = std::env::current_dir()?;
+    Ok(if precompose_unicode {
+        gix_utils::str::precompose_path(cwd.into()).into_owned()
+    } else {
+        cwd
+    })
+}
+
 /// A stack of path components with the delegation of side-effects as the currently set path changes, component by component.
 #[derive(Clone)]
 pub struct Stack {

gix-fs/src/lib.rs

@@ -2,8 +2,8 @@
 fn probe() {
     let dir = tempfile::tempdir().unwrap();
     std::fs::File::create(dir.path().join("config")).unwrap();
-    let ctx = gix_fs::Capabilities::probe(dir.path());
-    dbg!(ctx);
+    gix_fs::Capabilities::probe(dir.path());
+
     let entries: Vec<_> = std::fs::read_dir(dir.path())
         .unwrap()
         .filter_map(Result::ok)

gix-fs/tests/capabilities/mod.rs

@@ -0,0 +1,33 @@
+#[test]
+fn precompose_unicode() -> Result<(), Box<dyn std::error::Error + Send + Sync + 'static>> {
+    let tmp = tempfile::TempDir::new()?;
+
+    let decomposed = "a\u{308}";
+    // Note that even on MacOS decomposition doesn't happen reliably, so we assure it's decomposed
+    // which then should work everywhere.
+    let cwd = tmp.path().join(decomposed);
+
+    std::fs::create_dir(&cwd)?;
+    std::env::set_current_dir(&cwd)?;
+
+    let keep_as_is = false;
+    let dirname = gix_fs::current_dir(keep_as_is)?
+        .file_name()
+        .expect("present")
+        .to_str()
+        .expect("no illformed unicode")
+        .to_owned();
+
+    assert_eq!(dirname.chars().count(), decomposed.chars().count());
+
+    let precomposed = "ä";
+    let precompose_unicode = true;
+    let dirname = gix_fs::current_dir(precompose_unicode)?
+        .file_name()
+        .expect("present")
+        .to_str()
+        .expect("no illformed unicode")
+        .to_owned();
+    assert_eq!(dirname.chars().count(), precomposed.chars().count());
+    Ok(())
+}

gix-fs/tests/current_dir.rs

@@ -1,4 +1,5 @@
 type Result<T = ()> = std::result::Result<T, Box<dyn std::error::Error + Send + Sync + 'static>>;
+
 mod capabilities;
 mod dir;
 mod stack;