feat: Prefer / over \ in bash.exe path (for fixtures)

Starting in #1712, `gix-testtools` looks for `bash.exe` on Windows
in one of its common locations as provided by Git for Windows, by
taking the path given by `git --exec-path`, going up by three
components, and going down to `bin/bash.exe` under that. But the
`bin` and `bash.exe` components were appended in a way that used
`\` directory separators.

Ordinarily, that would be ideal, since `\` is the primary directory
separator on Windows. However, in this case, appending with `\`
produces a path that is harder to read (especially in diagostic
messages), and that may cause problems if it is processed by a
shell or in a way that is intended to operate similarly to shell
processing of `\`.

A path that does not explicitly prefer `/` but instead uses
`PathBuf::push` will have `\` in front of the new components, but
will still usually have `/` in front of the old components. This is
because, aside from the unusual case that the `GIT_EXEC_PATH`
environment vairable is set explicitly and its value uses all `\`
separators, the output of `git --exec-path`, which we use to find
where `git` installed on Windows, uses `/` separators.

The effect of this change seems to be fairly minor, with existing
test fixtures having worked before it was done. This is partly
because, on Windows, the value of `argv[0]` that the shell
actually sees -- and that populates `$0` when no script name is
available, as happens in `bash -c '...'` with no subsequent
arguments -- is translated by an MSYS DLL such as `msys-2.0.dll`
(or, for Cygwin, `cygwin1.dll`) into a Unix-style path meaningful
to the shell.

This also refactors for clarity, and adds new tests related to the
change.

Author: EliahKagan

tests/tools/src/lib.rs

@@ -653,20 +653,27 @@ fn configure_command<'a, I: IntoIterator<Item = S>, S: AsRef<OsStr>>(
 }
 
 fn bash_program() -> &'static Path {
-    if cfg!(windows) {
-        // TODO(deps): Once `gix_path::env::shell()` is available, maybe do `shell().parent()?.join("bash.exe")`
-        static GIT_BASH: Lazy<Option<PathBuf>> = Lazy::new(|| {
+    // TODO(deps): *Maybe* add something to `gix-path` like `env::shell()` that can be used to
+    //             find bash and, once the version `gix-testtools` depends on has it, use it.
+    static GIT_BASH: Lazy<PathBuf> = Lazy::new(|| {
+        if cfg!(windows) {
             GIT_CORE_DIR
-                .parent()?
-                .parent()?
-                .parent()
-                .map(|installation_dir| installation_dir.join("bin").join("bash.exe"))
+                .ancestors()
+                .nth(3)
+                .map(OsString::from)
+                .map(|mut raw_path| {
+                    // Go down to where `bash.exe` usually is. Keep using `/` separators (not `\`).
+                    raw_path.push("/bin/bash.exe");
+                    raw_path
+                })
+                .map(PathBuf::from)
                 .filter(|bash| bash.is_file())
-        });
-        GIT_BASH.as_deref().unwrap_or(Path::new("bash.exe"))
-    } else {
-        Path::new("bash")
-    }
+                .unwrap_or_else(|| "bash.exe".into())
+        } else {
+            "bash".into()
+        }
+    });
+    GIT_BASH.as_ref()
 }
 
 fn write_failure_marker(failure_marker: &Path) {
@@ -1059,4 +1066,32 @@ mod tests {
     fn bash_program_ok_for_platform() {
         assert_eq!(bash_program(), Path::new("bash"));
     }
+
+    #[test]
+    fn bash_program_unix_path() {
+        let path = bash_program()
+            .to_str()
+            .expect("This test depends on the bash path being valid Unicode");
+        assert!(
+            !path.contains('\\'),
+            "The path to bash should have no backslashes, barring very unusual environments"
+        );
+    }
+
+    fn is_rooted_relative(path: impl AsRef<Path>) -> bool {
+        let p = path.as_ref();
+        p.is_relative() && p.has_root()
+    }
+
+    #[test]
+    #[cfg(windows)]
+    fn unix_style_absolute_is_rooted_relative() {
+        assert!(is_rooted_relative("/bin/bash"), "can detect paths like /bin/bash");
+    }
+
+    #[test]
+    fn bash_program_absolute_or_unrooted() {
+        let bash = bash_program();
+        assert!(!is_rooted_relative(bash), "{bash:?}");
+    }
 }