feat: provide env::executable_invocation() to know how to invoke Git.

That way we can make it easier to rely on Git even if finding it is a bit
more involved.

Author: Byron

gix-path/src/env/git.rs

@@ -1,29 +1,67 @@
+use std::path::PathBuf;
 use std::{
     path::Path,
     process::{Command, Stdio},
 };
 
 use bstr::{BStr, BString, ByteSlice};
 
+/// Other places to find Git in.
+#[cfg(windows)]
+pub(super) static ALTERNATIVE_LOCATIONS: &[&str] = &[
+    "C:/Program Files/Git/mingw64/bin",
+    "C:/Program Files (x86)/Git/mingw32/bin",
+];
+#[cfg(not(windows))]
+pub(super) static ALTERNATIVE_LOCATIONS: &[&str] = &[];
+
+#[cfg(windows)]
+pub(super) static EXE_NAME: &str = "git.exe";
+#[cfg(not(windows))]
+pub(super) static EXE_NAME: &str = "git";
+
+/// Invoke the git executable in PATH to obtain the origin configuration, which is cached and returned.
+pub(super) static EXE_INFO: once_cell::sync::Lazy<Option<BString>> = once_cell::sync::Lazy::new(|| {
+    let git_cmd = |executable: PathBuf| {
+        let mut cmd = Command::new(executable);
+        cmd.args(["config", "-l", "--show-origin"])
+            .stdin(Stdio::null())
+            .stderr(Stdio::null());
+        cmd
+    };
+    let mut cmd = git_cmd(EXE_NAME.into());
+    gix_trace::debug!(cmd = ?cmd, "invoking git for installation config path");
+    let cmd_output = match cmd.output() {
+        Ok(out) => out.stdout,
+        #[cfg(windows)]
+        Err(err) if err.kind() == std::io::ErrorKind::NotFound => {
+            let executable = ALTERNATIVE_LOCATIONS.into_iter().find_map(|prefix| {
+                let candidate = Path::new(prefix).join(EXE_NAME);
+                candidate.is_file().then_some(candidate)
+            })?;
+            gix_trace::debug!(cmd = ?cmd, "invoking git for installation config path in alternate location");
+            git_cmd(executable).output().ok()?.stdout
+        }
+        Err(_) => return None,
+    };
+
+    first_file_from_config_with_origin(cmd_output.as_slice().into()).map(ToOwned::to_owned)
+});
+
 /// Returns the file that contains git configuration coming with the installation of the `git` file in the current `PATH`, or `None`
 /// if no `git` executable was found or there were other errors during execution.
-pub(crate) fn install_config_path() -> Option<&'static BStr> {
+pub(super) fn install_config_path() -> Option<&'static BStr> {
     let _span = gix_trace::detail!("gix_path::git::install_config_path()");
     static PATH: once_cell::sync::Lazy<Option<BString>> = once_cell::sync::Lazy::new(|| {
-        // Shortcut: in Msys shells this variable is set which allows to deduce the installation directory
+        // Shortcut: in Msys shells this variable is set which allows to deduce the installation directory,
         // so we can save the `git` invocation.
         #[cfg(windows)]
         if let Some(mut exec_path) = std::env::var_os("EXEPATH").map(std::path::PathBuf::from) {
             exec_path.push("etc");
             exec_path.push("gitconfig");
             return crate::os_string_into_bstring(exec_path.into()).ok();
         }
-        let mut cmd = Command::new(if cfg!(windows) { "git.exe" } else { "git" });
-        cmd.args(["config", "-l", "--show-origin"])
-            .stdin(Stdio::null())
-            .stderr(Stdio::null());
-        gix_trace::debug!(cmd = ?cmd, "invoking git for installation config path");
-        first_file_from_config_with_origin(cmd.output().ok()?.stdout.as_slice().into()).map(ToOwned::to_owned)
+        EXE_INFO.clone()
     });
     PATH.as_ref().map(AsRef::as_ref)
 }
@@ -35,7 +73,7 @@ fn first_file_from_config_with_origin(source: &BStr) -> Option<&BStr> {
 }
 
 /// Given `config_path` as obtained from `install_config_path()`, return the path of the git installation base.
-pub(crate) fn config_to_base_path(config_path: &Path) -> &Path {
+pub(super) fn config_to_base_path(config_path: &Path) -> &Path {
     config_path
         .parent()
         .expect("config file paths always have a file name to pop")

gix-path/src/env/mod.rs

@@ -3,6 +3,7 @@ use std::{
     path::{Path, PathBuf},
 };
 
+use crate::env::git::EXE_NAME;
 use bstr::{BString, ByteSlice};
 
 mod git;
@@ -27,6 +28,39 @@ pub fn installation_config_prefix() -> Option<&'static Path> {
     installation_config().map(git::config_to_base_path)
 }
 
+/// Return the name of the Git executable to invoke it.
+/// If it's in the `PATH`, it will always be a short name.
+///
+/// Note that on Windows, we will find the executable in the `PATH` if it exists there, or search it
+/// in alternative locations which when found yields the full path to it.
+pub fn exe_invocation() -> &'static Path {
+    if cfg!(windows) {
+        /// The path to the Git executable as located in the `PATH` or in other locations that it's known to be installed to.
+        /// It's `None` if environment variables couldn't be read or if no executable could be found.
+        static EXECUTABLE_PATH: once_cell::sync::Lazy<Option<PathBuf>> = once_cell::sync::Lazy::new(|| {
+            std::env::split_paths(&std::env::var_os("PATH")?)
+                .chain(git::ALTERNATIVE_LOCATIONS.iter().map(Into::into))
+                .find_map(|prefix| {
+                    let full_path = prefix.join(EXE_NAME);
+                    full_path.is_file().then_some(full_path)
+                })
+                .map(|exe_path| {
+                    let is_in_alternate_location = git::ALTERNATIVE_LOCATIONS
+                        .iter()
+                        .any(|prefix| exe_path.strip_prefix(prefix).is_ok());
+                    if is_in_alternate_location {
+                        exe_path
+                    } else {
+                        EXE_NAME.into()
+                    }
+                })
+        });
+        EXECUTABLE_PATH.as_deref().unwrap_or(Path::new(git::EXE_NAME))
+    } else {
+        Path::new("git")
+    }
+}
+
 /// Returns the fully qualified path in the *xdg-home* directory (or equivalent in the home dir) to `file`,
 /// accessing `env_var(<name>)` to learn where these bases are.
 ///
@@ -74,7 +108,7 @@ pub fn system_prefix() -> Option<&'static Path> {
                 }
             }
 
-            let mut cmd = std::process::Command::new("git.exe");
+            let mut cmd = std::process::Command::new(exe_invocation());
             cmd.arg("--exec-path").stderr(std::process::Stdio::null());
             gix_trace::debug!(cmd = ?cmd, "invoking git to get system prefix/exec path");
             let path = cmd.output().ok()?.stdout;

gix-path/tests/path.rs

@@ -14,29 +14,67 @@ mod home_dir {
     }
 }
 
-mod xdg_config_path {
-    use std::ffi::OsStr;
+mod env {
+    #[test]
+    fn executable_invocation() {
+        let actual = gix_path::env::exe_invocation();
+        assert!(
+            !actual.as_os_str().is_empty(),
+            "it finds something as long as git is installed somewhere on the system (or a default location)"
+        );
+    }
+
+    #[test]
+    fn installation_config() {
+        assert_ne!(
+            gix_path::env::installation_config().map(|p| p.components().count()),
+            gix_path::env::installation_config_prefix().map(|p| p.components().count()),
+            "the prefix is a bit shorter than the installation config path itself"
+        );
+    }
 
     #[test]
-    fn prefers_xdg_config_bases() {
-        let actual = gix_path::env::xdg_config("test", &mut |n| {
-            (n == OsStr::new("XDG_CONFIG_HOME")).then(|| "marker".into())
-        })
-        .expect("set");
-        #[cfg(unix)]
-        assert_eq!(actual.to_str(), Some("marker/git/test"));
-        #[cfg(windows)]
-        assert_eq!(actual.to_str(), Some("marker\\git\\test"));
+    fn system_prefix() {
+        assert_ne!(
+            gix_path::env::system_prefix(),
+            None,
+            "git should be present when running tests"
+        );
     }
 
     #[test]
-    fn falls_back_to_home() {
-        let actual = gix_path::env::xdg_config("test", &mut |n| (n == OsStr::new("HOME")).then(|| "marker".into()))
+    fn home_dir() {
+        assert_ne!(
+            gix_path::env::home_dir(),
+            None,
+            "we find a home on every system these tests execute"
+        );
+    }
+
+    mod xdg_config {
+        use std::ffi::OsStr;
+
+        #[test]
+        fn prefers_xdg_config_bases() {
+            let actual = gix_path::env::xdg_config("test", &mut |n| {
+                (n == OsStr::new("XDG_CONFIG_HOME")).then(|| "marker".into())
+            })
             .expect("set");
-        #[cfg(unix)]
-        assert_eq!(actual.to_str(), Some("marker/.config/git/test"));
-        #[cfg(windows)]
-        assert_eq!(actual.to_str(), Some("marker\\.config\\git\\test"));
+            #[cfg(unix)]
+            assert_eq!(actual.to_str(), Some("marker/git/test"));
+            #[cfg(windows)]
+            assert_eq!(actual.to_str(), Some("marker\\git\\test"));
+        }
+
+        #[test]
+        fn falls_back_to_home() {
+            let actual = gix_path::env::xdg_config("test", &mut |n| (n == OsStr::new("HOME")).then(|| "marker".into()))
+                .expect("set");
+            #[cfg(unix)]
+            assert_eq!(actual.to_str(), Some("marker/.config/git/test"));
+            #[cfg(windows)]
+            assert_eq!(actual.to_str(), Some("marker\\.config\\git\\test"));
+        }
     }
 }
 mod util;