Merge branch 'master' into enhancements/initialize-view

StanleyGoldman · StanleyGoldman · commit 0164af3c7b48 · 2017-09-18T14:26:00.000-04:00
diff --git a/common/SolutionInfo.cs b/common/SolutionInfo.cs
@@ -31,6 +31,6 @@
 namespace System
 {
     internal static class AssemblyVersionInformation {
-        internal const string Version = "0.20.0";
+        internal const string Version = "0.21.0";
     }
 }
diff --git a/src/GitHub.Api/Application/ApplicationManagerBase.cs b/src/GitHub.Api/Application/ApplicationManagerBase.cs
@@ -64,8 +64,15 @@ private async Task SetupGit()
                 if (Environment.IsWindows)
                 {
                     var credentialHelper = await GitClient.GetConfig("credential.helper", GitConfigSource.Global).StartAwait();
-                    if (string.IsNullOrEmpty(credentialHelper))
+
+                    if (!string.IsNullOrEmpty(credentialHelper))
+                    {
+                        Logger.Trace("Windows CredentialHelper: {0}", credentialHelper);
+                    }
+                    else
                     {
+                        Logger.Warning("No Windows CredentialHeloper found: Setting to wincred");
+
                         await GitClient.SetConfig("credential.helper", "wincred", GitConfigSource.Global).StartAwait();
                     }
                 }
diff --git a/src/GitHub.Api/Authentication/Keychain.cs b/src/GitHub.Api/Authentication/Keychain.cs
@@ -64,14 +64,15 @@ public async Task<IKeychainAdapter> Load(UriString host)
                 logger.Warning("Cannot load host from Credential Manager; removing from cache");
                 await Clear(host, false);
             }
-            else if (keychainItem.Username != cachedConnection.Username)
-            {
-                logger.Warning("Item loaded from credential manager does not match connection cache ; removing from cache");
-                await Clear(host, false);
-            }
             else
             {
-                logger.Trace($@"Loaded from Credential Manager Host:""{keychainItem.Host}"" Username:""{keychainItem.Username}""");
+                if (keychainItem.Username != cachedConnection.Username)
+                {
+                    logger.Warning("Keychain Username: {0} does not match; Hopefully it works", keychainItem.Username);
+                }
+
+                logger.Trace("Loaded from Credential Manager Host:\"{0}\" Username:\"{1}\"", keychainItem.Host, keychainItem.Username); 
+
                 keychainAdapter.Set(keychainItem);
             }
 
diff --git a/src/GitHub.Api/Git/GitClient.cs b/src/GitHub.Api/Git/GitClient.cs
@@ -103,17 +103,30 @@ public async Task<NPath> FindGitInstallation()
             if (!String.IsNullOrEmpty(environment.GitExecutablePath))
                 return environment.GitExecutablePath;
 
-            var path = await LookForPortableGit();
+            NPath path = null;
+
+            if (environment.IsWindows)
+                path = await LookForPortableGit();
+
             if (path == null)
                 path = await LookForSystemGit();
 
-            Logger.Trace("Git Installation folder {0} discovered: '{1}'", path == null ? "not" : "", path);
+            if (path == null)
+            {
+                Logger.Trace("Git Installation not discovered");
+            }
+            else
+            {
+                Logger.Trace("Git Installation discovered: '{0}'", path);
+            }
 
             return path;
         }
 
         private Task<NPath> LookForPortableGit()
         {
+            Logger.Trace("LookForPortableGit");
+
             var gitHubLocalAppDataPath = environment.UserCachePath;
             if (!gitHubLocalAppDataPath.DirectoryExists())
                 return null;
@@ -134,16 +147,22 @@ private Task<NPath> LookForPortableGit()
 
         private async Task<NPath> LookForSystemGit()
         {
+            Logger.Trace("LookForSystemGit");
+
             NPath path = null;
             if (!environment.IsWindows)
             {
                 var p = new NPath("/usr/local/bin/git");
+
                 if (p.FileExists())
                     path = p;
             }
 
             if (path == null)
-                path = await new FindExecTask("git", taskManager.Token).StartAwait();
+            {
+                path = await new FindExecTask("git", taskManager.Token)
+                    .Configure(processManager).StartAwait();
+            }
 
             return path;
         }
diff --git a/src/GitHub.Api/Git/GitCredentialManager.cs b/src/GitHub.Api/Git/GitCredentialManager.cs
@@ -133,6 +133,8 @@ private async Task<bool> LoadCredentialHelper()
                 .Configure(processManager)
                 .StartAwait();
 
+            Logger.Trace("Loaded Credential Helper: {0}", credHelper);
+
             if (credHelper != null)
             {
                 return true;
diff --git a/src/GitHub.Api/Git/RepositoryManager.cs b/src/GitHub.Api/Git/RepositoryManager.cs
@@ -312,16 +312,16 @@ public ITask LockFile(string file)
         {
             var task = GitClient.Lock(file);
             HookupHandlers(task);
-            ListLocks(false);
-            return task;
+            
+            return task.Then(ListLocks(false));
         }
 
         public ITask UnlockFile(string file, bool force)
         {
             var task = GitClient.Unlock(file, force);
             HookupHandlers(task).Schedule(taskManager);
-            ListLocks(false);
-            return task;
+
+            return task.Then(ListLocks(false));
         }
 
         private void LoadGitUser()
diff --git a/src/GitHub.Api/OutputProcessors/ProcessManager.cs b/src/GitHub.Api/OutputProcessors/ProcessManager.cs
@@ -24,15 +24,28 @@ public ProcessManager(IEnvironment environment, IProcessEnvironment gitEnvironme
 
         public T Configure<T>(T processTask, bool withInput = false) where T : IProcess
         {
+            NPath executableFileName;
+            if (processTask.ProcessName != null)
+            {
+                executableFileName = processTask.ProcessName.ToNPath();
+                //logger.Trace("Configuring Task:{0} with Exec:{1}", processTask.GetType().Name, executableFileName);
+            }
+            else
+            {
+                executableFileName = environment.GitExecutablePath;
+                //logger.Trace("Configuring Task:{0} with Git", processTask.GetType().Name);
+            }
+
             return Configure(processTask,
-                processTask.ProcessName?.ToNPath() ?? environment.GitExecutablePath,
+                executableFileName,
                 processTask.ProcessArguments,
                 environment.RepositoryPath, withInput);
         }
 
         public T Configure<T>(T processTask, string executableFileName, string arguments, NPath workingDirectory = null, bool withInput = false)
              where T : IProcess
         {
+            //If this null check fails, be sure you called Configure() on your task
             Guard.ArgumentNotNull(executableFileName, nameof(executableFileName));
 
             var startInfo = new ProcessStartInfo
diff --git a/src/GitHub.Api/Platform/FindExecTask.cs b/src/GitHub.Api/Platform/FindExecTask.cs
@@ -13,6 +13,7 @@ public FindExecTask(string executable, CancellationToken token)
             arguments = executable;
         }
 
+        public override string ProcessName { get { return Name; } }
         public override string ProcessArguments { get { return arguments; } }
         public override TaskAffinity Affinity { get { return TaskAffinity.Concurrent; } }
     }
diff --git a/src/UnityExtension/Assets/Editor/GitHub.Unity/UI/BranchesView.cs b/src/UnityExtension/Assets/Editor/GitHub.Unity/UI/BranchesView.cs
@@ -52,7 +52,7 @@ class BranchesView : Subview
         [SerializeField] private List<Remote> remotes = new List<Remote>();
         [SerializeField] private Vector2 scroll;
         [SerializeField] private BranchTreeNode selectedNode;
-        private List<string> favoritesList;
+        [SerializeField] private List<string> favoritesList = new List<string>();
 
         public override void InitializeView(IView parent)
         {
diff --git a/src/UnityExtension/Assets/Editor/GitHub.Unity/UI/PopupWindow.cs b/src/UnityExtension/Assets/Editor/GitHub.Unity/UI/PopupWindow.cs
@@ -41,9 +41,9 @@ public static PopupWindow Open(PopupViewType popupViewType, Action<bool> onClose
 
             popupWindow.ActiveViewType = popupViewType;
             popupWindow.titleContent = new GUIContent(popupWindow.ActiveView.Title, Styles.SmallLogo);
-
-            popupWindow.InitializeWindow(EntryPoint.ApplicationManager);
+            popupWindow.OnEnable();
             popupWindow.Show();
+            popupWindow.Refresh();
 
             return popupWindow;
         }
@@ -64,7 +64,6 @@ public override void Initialize(IApplicationManager applicationManager)
         public override void OnEnable()
         {
             base.OnEnable();
-
             minSize = maxSize = ActiveView.Size;
             ActiveView.OnEnable();
         }
@@ -75,6 +74,12 @@ public override void OnDisable()
             ActiveView.OnDisable();
         }
 
+        public override void OnDataUpdate()
+        {
+            base.OnDataUpdate();
+            ActiveView.OnDataUpdate();
+        }
+
         public override void OnUI()
         {
             base.OnUI();
@@ -132,7 +137,14 @@ private Subview ActiveView
         private PopupViewType ActiveViewType
         {
             get { return activeViewType; }
-            set { activeViewType = value; }
+            set
+            {
+                if (activeViewType != value)
+                {
+                    ActiveView.OnDisable();
+                    activeViewType = value;
+                }
+            }
         }
     }
 }
diff --git a/src/UnityExtension/Assets/Editor/GitHub.Unity/UI/ProjectWindowInterface.cs b/src/UnityExtension/Assets/Editor/GitHub.Unity/UI/ProjectWindowInterface.cs
@@ -22,6 +22,8 @@ class ProjectWindowInterface : AssetPostprocessor
 
         public static void Initialize(IRepository repo)
         {
+            Logger.Trace("Initialize HasRepository:{0}", repo != null);
+
             EditorApplication.projectWindowItemOnGUI -= OnProjectWindowItemGUI;
             EditorApplication.projectWindowItemOnGUI += OnProjectWindowItemGUI;
             initialized = true;
@@ -149,7 +151,9 @@ private static void Refresh()
         private static void RunLocksUpdateOnMainThread(IEnumerable<GitLock> update)
         {
             new ActionTask(EntryPoint.ApplicationManager.TaskManager.Token, _ => OnLocksUpdate(update))
-                .ScheduleUI(EntryPoint.ApplicationManager.TaskManager);
+            {
+                Affinity = TaskAffinity.UI
+            }.Start();
         }
 
         private static void OnLocksUpdate(IEnumerable<GitLock> update)
@@ -169,11 +173,16 @@ private static void OnLocksUpdate(IEnumerable<GitLock> update)
                 var g = AssetDatabase.AssetPathToGUID(assetPath);
                 guidsLocks.Add(g);
             }
+
+            EditorApplication.RepaintProjectWindow();
         }
 
         private static void RunStatusUpdateOnMainThread(GitStatus update)
         {
-            EntryPoint.ApplicationManager.TaskManager.ScheduleUI(new ActionTask(EntryPoint.ApplicationManager.TaskManager.Token, _ => OnStatusUpdate(update)));
+            new ActionTask(EntryPoint.ApplicationManager.TaskManager.Token, _ => OnStatusUpdate(update))
+            {
+                Affinity = TaskAffinity.UI
+            }.Start();
         }
 
         private static void OnStatusUpdate(GitStatus update)
diff --git a/src/UnityExtension/Assets/Editor/GitHub.Unity/UI/PublishView.cs b/src/UnityExtension/Assets/Editor/GitHub.Unity/UI/PublishView.cs
@@ -1,4 +1,5 @@
 ﻿using System;
+using System.Collections.Generic;
 using System.Linq;
 using Octokit;
 using UnityEditor;
@@ -23,6 +24,7 @@ class PublishView : Subview
 
         [SerializeField] private string username;
         [SerializeField] private string[] owners = { OwnersDefaultText };
+        [SerializeField] private IList<Organization> organizations;
         [SerializeField] private int selectedOwner;
         [SerializeField] private string repoName = String.Empty;
         [SerializeField] private string repoDescription = "";
@@ -31,6 +33,7 @@ class PublishView : Subview
         [NonSerialized] private IApiClient client;
         [NonSerialized] private bool isBusy;
         [NonSerialized] private string error;
+        [NonSerialized] private bool organizationsNeedLoading;
 
         public IApiClient Client
         {
@@ -56,23 +59,43 @@ public IApiClient Client
             }
         }
 
+        public override void OnEnable()
+        {
+            base.OnEnable();
+            organizationsNeedLoading = organizations == null && !isBusy;
+        }
+
+        public override void OnDataUpdate()
+        {
+            base.OnDataUpdate();
+            MaybeUpdateData();
+        }
+
+        private void MaybeUpdateData()
+        {
+            if (organizationsNeedLoading)
+            {
+                organizationsNeedLoading = false;
+                LoadOrganizations();
+            }
+        }
+
         public override void InitializeView(IView parent)
         {
             base.InitializeView(parent);
             Title = WindowTitle;
             Size = viewSize;
-            PopulateView();
         }
 
-        private void PopulateView()
+        private void LoadOrganizations()
         {
-            try
+            var keychainConnections = Platform.Keychain.Connections;
+            //TODO: ONE_USER_LOGIN This assumes only ever one user can login
+            if (keychainConnections.Any())
             {
-                var keychainConnections = Platform.Keychain.Connections;
-                //TODO: ONE_USER_LOGIN This assumes only ever one user can login
-                if (keychainConnections.Any())
+                try
                 {
-                    Logger.Trace("GetCurrentUser");
+                    Logger.Trace("Loading Keychain");
 
                     isBusy = true;
 
@@ -87,28 +110,30 @@ private void PopulateView()
                         //TODO: ONE_USER_LOGIN This assumes only ever one user can login
                         username = keychainConnections.First().Username;
 
-                        Client.GetOrganizations(organizations => {
+                        Logger.Trace("Loading Organizations");
+
+                        Client.GetOrganizations(orgs => {
+                            organizations = orgs;
                             Logger.Trace("Loaded {0} organizations", organizations.Count);
 
                             var organizationLogins = organizations
-                                .OrderBy(organization => organization.Login)
-                                .Select(organization => organization.Login);
+                                .OrderBy(organization => organization.Login).Select(organization => organization.Login);
 
                             owners = new[] { OwnersDefaultText, username }.Union(organizationLogins).ToArray();
 
                             isBusy = false;
                         });
                     });
                 }
-                else
+                catch (Exception e)
                 {
-                    Logger.Warning("No Keychain connections to use");
+                    Logger.Error(e, "Error PopulateView & GetOrganizations");
+                    isBusy = false;
                 }
             }
-            catch (Exception e)
+            else
             {
-                Logger.Error(e, "Error PopulateView & GetOrganizations");
-                throw;
+                Logger.Warning("No Keychain connections to use");
             }
         }
 
@@ -196,13 +221,18 @@ public override void OnGUI()
                     EditorGUI.BeginDisabledGroup(!IsFormValid);
                     if (GUILayout.Button(PublishViewCreateButton))
                     {
+                        GUI.FocusControl(null);
                         isBusy = true;
 
                         var organization = owners[selectedOwner] == username ? null : owners[selectedOwner];
 
+                        var cleanRepoDescription = repoDescription.Trim();
+                        cleanRepoDescription = cleanRepoDescription == string.Empty ? null : cleanRepoDescription;
+
                         Client.CreateRepository(new NewRepository(repoName)
                         {
                             Private = togglePrivate,
+                            Description = cleanRepoDescription
                         }, (repository, ex) =>
                         {
                             Logger.Trace("Create Repository Callback");
diff --git a/src/UnityExtension/Assets/Editor/GitHub.Unity/UI/SettingsView.cs b/src/UnityExtension/Assets/Editor/GitHub.Unity/UI/SettingsView.cs
diff --git a/src/tests/UnitTests/Authentication/KeychainTests.cs b/src/tests/UnitTests/Authentication/KeychainTests.cs

Original file line number	Diff line number	Diff line change
`@@ -31,6 +31,6 @@`
`31`	`31`	`namespace System`
`32`	`32`	`{`
`33`	`33`	`internal static class AssemblyVersionInformation {`
`34`		`- internal const string Version = "0.20.0";`
	`34`	`+ internal const string Version = "0.21.0";`
`35`	`35`	`}`
`36`	`36`	`}`
Original file line number	Diff line number	Diff line change
`@@ -64,8 +64,15 @@ private async Task SetupGit()`
`64`	`64`	`if (Environment.IsWindows)`
`65`	`65`	`{`
`66`	`66`	`var credentialHelper = await GitClient.GetConfig("credential.helper", GitConfigSource.Global).StartAwait();`
`67`		`- if (string.IsNullOrEmpty(credentialHelper))`
	`67`	`+`
	`68`	`+ if (!string.IsNullOrEmpty(credentialHelper))`
	`69`	`+ {`
	`70`	`+ Logger.Trace("Windows CredentialHelper: {0}", credentialHelper);`
	`71`	`+ }`
	`72`	`+ else`
`68`	`73`	`{`
	`74`	`+ Logger.Warning("No Windows CredentialHeloper found: Setting to wincred");`
	`75`	`+`
`69`	`76`	`await GitClient.SetConfig("credential.helper", "wincred", GitConfigSource.Global).StartAwait();`
`70`	`77`	`}`
`71`	`78`	`}`
Original file line number	Diff line number	Diff line change
`@@ -133,6 +133,8 @@ private async Task<bool> LoadCredentialHelper()`
`133`	`133`	`.Configure(processManager)`
`134`	`134`	`.StartAwait();`
`135`	`135`
	`136`	`+ Logger.Trace("Loaded Credential Helper: {0}", credHelper);`
	`137`	`+`
`136`	`138`	`if (credHelper != null)`
`137`	`139`	`{`
`138`	`140`	`return true;`
Original file line number	Diff line number	Diff line change
`@@ -312,16 +312,16 @@ public ITask LockFile(string file)`
`312`	`312`	`{`
`313`	`313`	`var task = GitClient.Lock(file);`
`314`	`314`	`HookupHandlers(task);`
`315`		`- ListLocks(false);`
`316`		`- return task;`
	`315`	`+`
	`316`	`+ return task.Then(ListLocks(false));`
`317`	`317`	`}`
`318`	`318`
`319`	`319`	`public ITask UnlockFile(string file, bool force)`
`320`	`320`	`{`
`321`	`321`	`var task = GitClient.Unlock(file, force);`
`322`	`322`	`HookupHandlers(task).Schedule(taskManager);`
`323`		`- ListLocks(false);`
`324`		`- return task;`
	`323`	`+`
	`324`	`+ return task.Then(ListLocks(false));`
`325`	`325`	`}`
`326`	`326`
`327`	`327`	`private void LoadGitUser()`
Original file line number	Diff line number	Diff line change
`@@ -13,6 +13,7 @@ public FindExecTask(string executable, CancellationToken token)`
`13`	`13`	`arguments = executable;`
`14`	`14`	`}`
`15`	`15`
	`16`	`+ public override string ProcessName { get { return Name; } }`
`16`	`17`	`public override string ProcessArguments { get { return arguments; } }`
`17`	`18`	`public override TaskAffinity Affinity { get { return TaskAffinity.Concurrent; } }`
`18`	`19`	`}`
Original file line number	Diff line number	Diff line change
`@@ -52,7 +52,7 @@ class BranchesView : Subview`
`52`	`52`	`[SerializeField] private List<Remote> remotes = new List<Remote>();`
`53`	`53`	`[SerializeField] private Vector2 scroll;`
`54`	`54`	`[SerializeField] private BranchTreeNode selectedNode;`
`55`		`- private List<string> favoritesList;`
	`55`	`+ [SerializeField] private List<string> favoritesList = new List<string>();`
`56`	`56`
`57`	`57`	`public override void InitializeView(IView parent)`
`58`	`58`	`{`
Original file line number	Diff line number	Diff line change
`@@ -41,9 +41,9 @@ public static PopupWindow Open(PopupViewType popupViewType, Action<bool> onClose`
`41`	`41`
`42`	`42`	`popupWindow.ActiveViewType = popupViewType;`
`43`	`43`	`popupWindow.titleContent = new GUIContent(popupWindow.ActiveView.Title, Styles.SmallLogo);`
`44`		`-`
`45`		`- popupWindow.InitializeWindow(EntryPoint.ApplicationManager);`
	`44`	`+ popupWindow.OnEnable();`
`46`	`45`	`popupWindow.Show();`
	`46`	`+ popupWindow.Refresh();`
`47`	`47`
`48`	`48`	`return popupWindow;`
`49`	`49`	`}`
`@@ -64,7 +64,6 @@ public override void Initialize(IApplicationManager applicationManager)`
`64`	`64`	`public override void OnEnable()`
`65`	`65`	`{`
`66`	`66`	`base.OnEnable();`
`67`		`-`
`68`	`67`	`minSize = maxSize = ActiveView.Size;`
`69`	`68`	`ActiveView.OnEnable();`
`70`	`69`	`}`
`@@ -75,6 +74,12 @@ public override void OnDisable()`
`75`	`74`	`ActiveView.OnDisable();`
`76`	`75`	`}`
`77`	`76`
	`77`	`+ public override void OnDataUpdate()`
	`78`	`+ {`
	`79`	`+ base.OnDataUpdate();`
	`80`	`+ ActiveView.OnDataUpdate();`
	`81`	`+ }`
	`82`	`+`
`78`	`83`	`public override void OnUI()`
`79`	`84`	`{`
`80`	`85`	`base.OnUI();`
`@@ -132,7 +137,14 @@ private Subview ActiveView`
`132`	`137`	`private PopupViewType ActiveViewType`
`133`	`138`	`{`
`134`	`139`	`get { return activeViewType; }`
`135`		`- set { activeViewType = value; }`
	`140`	`+ set`
	`141`	`+ {`
	`142`	`+ if (activeViewType != value)`
	`143`	`+ {`
	`144`	`+ ActiveView.OnDisable();`
	`145`	`+ activeViewType = value;`
	`146`	`+ }`
	`147`	`+ }`
`136`	`148`	`}`
`137`	`149`	`}`
`138`	`150`	`}`