Merge pull request #193 from github-for-unity/fixes/192-wrong-environment-mac

Add symlink resolver so we can figure out paths properly

Author: shana

src/GitHub.Api/Git/GitClient.cs

@@ -134,13 +134,18 @@ private Task<NPath> LookForPortableGit()
 
         private async Task<NPath> LookForSystemGit()
         {
-            if (environment.IsMac)
+            NPath path = null;
+            if (!environment.IsWindows)
             {
-                var path = "/usr/local/bin/git".ToNPath();
-                if (path.FileExists())
-                    return path;
+                var p = new NPath("/usr/local/bin/git");
+                if (p.FileExists())
+                    path = p;
             }
-            return await new FindExecTask("git", taskManager.Token).StartAwait();
+
+            if (path == null)
+                path = await new FindExecTask("git", taskManager.Token).StartAwait();
+
+            return path;
         }
 
         public bool ValidateGitInstall(NPath path)

src/GitHub.Api/GitHub.Api.csproj

@@ -69,6 +69,9 @@
     <Reference Include="Mono.Security">
       <HintPath>$(SolutionDir)lib\Mono.Security.dll</HintPath>
     </Reference>
+    <Reference Include="Mono.Posix">
+      <HintPath>$(SolutionDir)lib\Mono.Posix.dll</HintPath>
+    </Reference>
     <Reference Include="Rackspace.Threading, Version=2.0.0.0, Culture=neutral, PublicKeyToken=bb62785d398726f0, processorArchitecture=MSIL">
       <HintPath>$(SolutionDir)\packages\TunnelVisionLabs.Threading.2.0.0-unity\lib\net35-client\Rackspace.Threading.dll</HintPath>
       <Private>True</Private>

src/GitHub.Api/IO/NiceIO.cs

@@ -283,6 +283,8 @@ public bool DirectoryExists(string append = "")
 
         public bool DirectoryExists(NPath append)
         {
+            if (append == null)
+                return FileSystem.DirectoryExists(ToString());
             return FileSystem.DirectoryExists(Combine(append).ToString());
         }
 
@@ -295,6 +297,8 @@ public bool FileExists(string append = "")
 
         public bool FileExists(NPath append)
         {
+            if (append == null)
+                return FileSystem.FileExists(ToString());
             return FileSystem.FileExists(Combine(append).ToString());
         }
 
@@ -749,11 +753,14 @@ public static NPath HomeDirectory
             }
         }
 
+        private static NPath systemTemp;
         public static NPath SystemTemp
         {
             get
             {
-                return new NPath(FileSystem.GetTempPath());
+                if (systemTemp == null)
+                    systemTemp = new NPath(FileSystem.GetTempPath());
+                return systemTemp;
             }
         }
 
@@ -1018,6 +1025,14 @@ public static NPath ToNPath(this string path)
                 return null;
             return new NPath(path);
         }
+
+        public static NPath Resolve(this NPath path)
+        {
+            if (path == null || DefaultEnvironment.OnWindows || path.IsRelative || !path.FileExists())
+                return path;
+
+            return new NPath(Mono.Unix.UnixPath.GetCompleteRealPath(path.ToString()));
+        }
     }
 
     public enum SlashMode

src/GitHub.Api/OutputProcessors/ProcessManager.cs

@@ -74,8 +74,13 @@ public void RunCommandLineWindow(NPath workingDirectory)
             }
             else if (environment.IsMac)
             {
+                // we need to create a temp bash script to set up the environment properly, because
+                // osx terminal app doesn't inherit the PATH env var and there's no way to pass it in
+                var envVarFile = environment.FileSystem.GetRandomFileName();
+                environment.FileSystem.WriteAllLines(envVarFile, new string[] { "cd $GHU_WORKINGDIR", "PATH=$GHU_FULLPATH:$PATH /bin/bash" });
+                Mono.Unix.Native.Syscall.chmod(envVarFile, (Mono.Unix.Native.FilePermissions)493); // -rwxr-xr-x mode (0755)
                 startInfo.FileName = "open";
-                startInfo.Arguments = $"-a Terminal {workingDirectory}";
+                startInfo.Arguments = $"-a Terminal {envVarFile}";
             }
             else
             {

src/GitHub.Api/Platform/DefaultEnvironment.cs

@@ -117,35 +117,14 @@ public NPath GitExecutablePath
             set
             {
                 gitExecutablePath = value;
-                gitInstallPath = null;
+                if (String.IsNullOrEmpty(gitExecutablePath))
+                    GitInstallPath = null;
+                else
+                    GitInstallPath = GitExecutablePath.Resolve().Parent.Parent;
             }
         }
 
-        private NPath gitInstallPath;
-        public NPath GitInstallPath
-        {
-            get
-            {
-                if (gitInstallPath == null)
-                {
-
-                    if (!String.IsNullOrEmpty(GitExecutablePath))
-                    {
-                        if (IsWindows)
-                        {
-                            gitInstallPath = GitExecutablePath.Parent.Parent;
-                        }
-                        else
-                        {
-                            gitInstallPath = GitExecutablePath.Parent;
-                        }
-                    }
-                    else
-                        gitInstallPath = GitExecutablePath;
-                }
-                return gitInstallPath;
-            }
-        }
+        public NPath GitInstallPath { get; private set; }
 
         public NPath RepositoryPath { get; private set; }
         public IRepository Repository { get; set; }

src/GitHub.Api/Platform/ProcessEnvironment.cs

@@ -54,6 +54,7 @@ public void Configure(ProcessStartInfo psi, NPath workingDirectory)
 
             var gitPathRoot = Environment.GitInstallPath;
             var gitLfsPath = Environment.GitInstallPath;
+            var gitExecutableDir = Environment.GitExecutablePath.Parent; // original path to git (might be different from install path if it's a symlink)
 
             // Paths to developer tools such as msbuild.exe
             //var developerPaths = StringExtensions.JoinForAppending(";", developerEnvironment.GetPaths());
@@ -78,19 +79,17 @@ public void Configure(ProcessStartInfo psi, NPath workingDirectory)
             if (Environment.IsWindows)
             {
                 var userPath = @"C:\windows\system32;C:\windows";
-                path = String.Format(CultureInfo.InvariantCulture, @"{0}\cmd;{0}\usr\bin;{1};{2};{0}\usr\share\git-tfs;{3};{4}{5}",
-                    gitPathRoot, execPath, binPath,
-                    gitLfsPath, userPath, developerPaths);
+                path = $"{gitPathRoot}\\cmd;{gitPathRoot}\\usr\\bin;{execPath};{binPath};{gitLfsPath};{userPath}{developerPaths}";
             }
             else
             {
-                var userPath = Environment.Path;
-                path = String.Format(CultureInfo.InvariantCulture, @"{0}:{1}:{2}:{3}{4}",
-                    binPath, execPath, gitLfsPath, userPath, developerPaths);
+                path = $"{gitExecutableDir}:{binPath}:{execPath}:{gitLfsPath}:{Environment.Path}:{developerPaths}";
             }
             psi.EnvironmentVariables["GIT_EXEC_PATH"] = execPath.ToString();
 
             psi.EnvironmentVariables["PATH"] = path;
+            psi.EnvironmentVariables["GHU_FULLPATH"] = path;
+            psi.EnvironmentVariables["GHU_WORKINGDIR"] = workingDirectory;
 
             psi.EnvironmentVariables["PLINK_PROTOCOL"] = "ssh";
             psi.EnvironmentVariables["TERM"] = "msys";

src/UnityExtension/Assets/Editor/GitHub.Unity/UI/PUblishView.cs

@@ -222,9 +222,7 @@ public override void OnGUI()
                             return;
                         }
 
-                        var repositoryCloneUrl = Environment.IsWindows ? repository.CloneUrl : repository.SshUrl;
-
-                        GitClient.RemoteAdd("origin", repositoryCloneUrl)
+                        GitClient.RemoteAdd("origin", repository.CloneUrl)
                                  .Then(GitClient.Push("origin", Repository.CurrentBranch.Value.Name))
                                  .ThenInUI(Parent.Finish)
                                  .Start();