environment: manually scan $PATH on POSIX systems

Because the `which` command is not always located in `/usr/bin` on all
POSIX systems, we cannot directly call `/usr/bin/which` to do program
location for us. Oh the irony..

We might be able to use `env` to locate `which`, but again the `env`
utility isn't always found in the same place, so we're stuck.

Instead we now manually scan the $PATH variable directories looking for
the program we need to find, in the same way we do on Windows (for
different reasons).

This should also be slightly faster as you'd hope .NET's String.Split
method and lstat calls are faster than fork/exec-ing another executable?

Author: mjcheetham

src/shared/Core/EnvironmentBase.cs

@@ -1,6 +1,7 @@
 using System;
 using System.Collections.Generic;
 using System.Diagnostics;
+using System.IO;
 using System.Linq;
 
 namespace GitCredentialManager
@@ -89,8 +90,6 @@ public bool IsDirectoryOnPath(string directoryPath)
 
         protected abstract string[] SplitPathVariable(string value);
 
-        public abstract bool TryLocateExecutable(string program, out string path);
-
         public virtual Process CreateProcess(string path, string args, bool useShellExecute, string workingDirectory)
         {
             var psi = new ProcessStartInfo(path, args)
@@ -104,6 +103,38 @@ public virtual Process CreateProcess(string path, string args, bool useShellExec
 
             return new Process { StartInfo = psi };
         }
+
+        public bool TryLocateExecutable(string program, out string path)
+        {
+            // On UNIX-like systems we would normally use the "which" utility to locate a program,
+            // but since distributions don't always place "which" in a consistent location we cannot
+            // find it! Oh the irony..
+            // We could also try using "env" to then locate "which", but the same problem exists in
+            // that "env" isn't always in a standard location.
+            //
+            // On Windows we should avoid using the equivalent utility "where.exe" because this will
+            // include the current working directory in the search, and we don't want this.
+            //
+            // The upshot of the above means we cannot use either of "which" or "where.exe" and must
+            // instead manually scan the PATH variable looking for the program.
+            // At least both Windows and UNIX use the same name for the $PATH or %PATH% variable!
+            if (Variables.TryGetValue("PATH", out string pathValue))
+            {
+                string[] paths = SplitPathVariable(pathValue);
+                foreach (var basePath in paths)
+                {
+                    string candidatePath = Path.Combine(basePath, program);
+                    if (FileSystem.FileExists(candidatePath))
+                    {
+                        path = candidatePath;
+                        return true;
+                    }
+                }
+            }
+
+            path = null;
+            return false;
+        }
     }
 
     public static class EnvironmentExtensions

src/shared/Core/Interop/Posix/PosixEnvironment.cs

@@ -1,7 +1,5 @@
 using System;
 using System.Collections.Generic;
-using System.Diagnostics;
-using System.Linq;
 
 namespace GitCredentialManager.Interop.Posix
 {
@@ -29,40 +27,6 @@ protected override string[] SplitPathVariable(string value)
             return value.Split(':');
         }
 
-        public override bool TryLocateExecutable(string program, out string path)
-        {
-            // The "which" utility scans over the PATH and does not include the current working directory
-            // (unlike the equivalent "where.exe" on Windows), which is exactly what we want. Let's use it.
-            const string whichPath = "/usr/bin/which";
-            var psi = new ProcessStartInfo(whichPath, program)
-            {
-                UseShellExecute = false,
-                RedirectStandardOutput = true
-            };
-
-            using (var where = new Process {StartInfo = psi})
-            {
-                where.Start();
-                where.WaitForExit();
-
-                switch (where.ExitCode)
-                {
-                    case 0: // found
-                        string stdout = where.StandardOutput.ReadToEnd();
-                        string[] results = stdout.Split(new[] {'\n'}, StringSplitOptions.RemoveEmptyEntries);
-                        path = results.First();
-                        return true;
-
-                    case 1: // not found
-                        path = null;
-                        return false;
-
-                    default:
-                        throw new Exception($"Unknown error locating '{program}' using {whichPath}. Exit code: {where.ExitCode}.");
-                }
-            }
-        }
-
         #endregion
 
         private static IReadOnlyDictionary<string, string> GetCurrentVariables()

src/shared/Core/Interop/Windows/WindowsEnvironment.cs

@@ -67,28 +67,6 @@ public override void RemoveDirectoryFromPath(string directoryPath, EnvironmentVa
             }
         }
 
-        public override bool TryLocateExecutable(string program, out string path)
-        {
-            // Don't use "where.exe" on Windows as this includes the current working directory
-            // and we don't want to enumerate this location; only the PATH.
-            if (Variables.TryGetValue("PATH", out string pathValue))
-            {
-                string[] paths = SplitPathVariable(pathValue);
-                foreach (var basePath in paths)
-                {
-                    string candidatePath = Path.Combine(basePath, program);
-                    if (FileSystem.FileExists(candidatePath))
-                    {
-                        path = candidatePath;
-                        return true;
-                    }
-                }
-            }
-
-            path = null;
-            return false;
-        }
-
         public override Process CreateProcess(string path, string args, bool useShellExecute, string workingDirectory)
         {
             // If we're asked to start a WSL executable we must launch via the wsl.exe command tool