use gix_fs::current_dir(precompose_unicode).

That way, paths will be precomposed when we work with them.

Author: Byron

Cargo.lock

@@ -17,6 +17,7 @@ gix-sec = { version = "^0.10.3", path = "../gix-sec" }
 gix-path = { version = "^0.10.3", path = "../gix-path" }
 gix-ref = { version = "^0.40.1", path = "../gix-ref" }
 gix-hash = { version = "^0.14.1", path = "../gix-hash" }
+gix-fs = { version = "^0.9.1", path = "../gix-fs" }
 
 bstr = { version = "1.3.0", default-features = false, features = ["std", "unicode"] }
 thiserror = "1.0.26"

gix-discover/Cargo.toml

@@ -39,7 +39,15 @@ pub(crate) mod function {
         // us the parent directory. (`Path::parent` just strips off the last
         // path component, which means it will not do what you expect when
         // working with paths paths that contain '..'.)
-        let cwd = current_dir.map_or_else(|| std::env::current_dir().map(Cow::Owned), |cwd| Ok(Cow::Borrowed(cwd)))?;
+        let cwd = current_dir.map_or_else(
+            || {
+                // The paths we return are relevant to the repository, but at this time it's impossible to know
+                // what `core.precomposeUnicode` is going to be. Hence the one using these paths will have to
+                // transform the paths as needed, because we can't. `false` means to leave the obtained path as is.
+                gix_fs::current_dir(false).map(Cow::Owned)
+            },
+            |cwd| Ok(Cow::Borrowed(cwd)),
+        )?;
         #[cfg(windows)]
         let directory = dunce::simplified(directory);
         let dir = gix_path::normalize(directory.into(), cwd.as_ref()).ok_or_else(|| Error::InvalidInput {

gix-discover/src/upwards/mod.rs

@@ -63,6 +63,10 @@ pub struct Options<'a> {
     /// that this is merely an optimization for those who discover a lot of repositories in the same process.
     ///
     /// If unset, the current working directory will be obtained automatically.
+    /// Note that the path here might or might not contained decomposed unicode, which may end up in a path
+    /// relevant us, like the git-dir or the worktree-dir. However, when opening the repository, it will
+    /// change decomposed unicode to precomposed unicode based on the value of `core.precomposeUnicode`, and we
+    /// don't have to deal with that value here just yet.
     pub current_dir: Option<&'a std::path::Path>,
 }
 

gix-discover/src/upwards/types.rs

@@ -25,6 +25,7 @@ gix-path = { version = "^0.10.3", path = "../gix-path" }
 gix-quote = { version = "^0.4.10", path = "../gix-quote" }
 gix-object = { version = "^0.40.1", path = "../gix-object" }
 gix-pack = { version = "^0.46.1", path = "../gix-pack", default-features = false }
+gix-fs = { version = "^0.9.1", path = "../gix-fs" }
 serde = { version = "1.0.114", optional = true, default-features = false, features = ["derive"]}
 
 tempfile = "3.1.0"

gix-odb/Cargo.toml

@@ -17,7 +17,7 @@ pub struct Options {
     /// If false, no multi-pack indices will be used. If true, they will be used if their hash matches `object_hash`.
     pub use_multi_pack_index: bool,
     /// The current directory of the process at the time of instantiation.
-    /// If unset, it will be retrieved using `std::env::current_dir()`.
+    /// If unset, it will be retrieved using `gix_fs::current_dir(false)`.
     pub current_dir: Option<std::path::PathBuf>,
 }
 
@@ -80,7 +80,13 @@ impl Store {
         }: Options,
     ) -> std::io::Result<Self> {
         let _span = gix_features::trace::detail!("gix_odb::Store::at()");
-        let current_dir = current_dir.map_or_else(std::env::current_dir, Ok)?;
+        let current_dir = current_dir.map_or_else(
+            || {
+                // It's only used for real-pathing alternate paths and there it just needs to be consistent (enough).
+                gix_fs::current_dir(false)
+            },
+            Ok,
+        )?;
         if !objects_dir.is_dir() {
             return Err(std::io::Error::new(
                 std::io::ErrorKind::Other, // TODO: use NotADirectory when stabilized

gix-odb/src/store_impls/dynamic/init.rs

@@ -246,7 +246,7 @@ pub fn to_windows_separators<'a>(path: impl Into<Cow<'a, BStr>>) -> Cow<'a, BStr
 /// instead.
 ///
 /// Note that we might access the `current_dir` if we run out of path components to pop off, which is expected to be absolute
-/// as typical return value of `std::env::current_dir()`.
+/// as typical return value of `std::env::current_dir()` or `gix_fs::current_dir(…)` when `core.precomposeUnicode` is known.
 /// As a `current_dir` like `/c` can be exhausted by paths like `../../r`, `None` will be returned to indicate the inability
 /// to produce a logically consistent path.
 pub fn normalize<'a>(path: Cow<'a, Path>, current_dir: &Path) -> Option<Cow<'a, Path>> {

gix-path/src/convert.rs

@@ -30,6 +30,8 @@ pub(crate) mod function {
     /// Do not fail for non-existing components, but assume these are as is.
     ///
     /// If `path` is relative, the current working directory be used to make it absolute.
+    /// Note that the returned path will be verbatim, and repositories with `core.precomposeUnicode`
+    /// set will probably want to precompose the paths unicode.
     pub fn realpath(path: impl AsRef<Path>) -> Result<PathBuf, Error> {
         let path = path.as_ref();
         let cwd = path

gix-path/src/realpath.rs

@@ -1,6 +1,8 @@
 #![allow(clippy::result_large_err)]
+
 use super::{util, Error};
-use crate::config::tree::{Core, Extensions};
+use crate::config::cache::util::ApplyLeniency;
+use crate::config::tree::{Core, Extensions, Key};
 
 /// A utility to deal with the cyclic dependency between the ref store and the configuration. The ref-store needs the
 /// object hash kind, and the configuration needs the current branch name to resolve conditional includes with `onbranch`.
@@ -12,6 +14,7 @@ pub(crate) struct StageOne {
     pub lossy: Option<bool>,
     pub object_hash: gix_hash::Kind,
     pub reflog: Option<gix_ref::store::WriteReflog>,
+    pub precompose_unicode: bool,
 }
 
 /// Initialization
@@ -69,6 +72,13 @@ impl StageOne {
             )?;
             config.append(worktree_config);
         };
+        let precompose_unicode = config
+            .boolean("core", None, Core::PRECOMPOSE_UNICODE.name())
+            .map(|v| Core::PRECOMPOSE_UNICODE.enrich_error(v))
+            .transpose()
+            .with_leniency(lenient)
+            .map_err(Error::ConfigBoolean)?
+            .unwrap_or_default();
 
         let reflog = util::query_refupdates(&config, lenient)?;
         Ok(StageOne {
@@ -78,6 +88,7 @@ impl StageOne {
             lossy,
             object_hash,
             reflog,
+            precompose_unicode,
         })
     }
 }

gix/src/config/cache/incubate.rs

@@ -27,6 +27,7 @@ impl Cache {
             is_bare,
             object_hash,
             reflog: _,
+            precompose_unicode: _,
         }: StageOne,
         git_dir: &std::path::Path,
         branch_name: Option<&gix_ref::FullNameRef>,