Merge master into fixes/task-field-cleanup

shana · shana · commit c9b040f99c76 · 2017-08-01T15:47:38.000+02:00
diff --git a/src/GitHub.Api/Application/ApplicationManagerBase.cs b/src/GitHub.Api/Application/ApplicationManagerBase.cs
@@ -11,7 +11,6 @@ abstract class ApplicationManagerBase : IApplicationManager
     {
         protected static ILogging Logger { get; } = Logging.GetLogger<IApplicationManager>();
 
-        private IEnvironment environment;
         private RepositoryManager repositoryManager;
 
         public ApplicationManagerBase(SynchronizationContext synchronizationContext)
diff --git a/src/GitHub.Api/Authentication/ICredentialManager.cs b/src/GitHub.Api/Authentication/ICredentialManager.cs
@@ -14,7 +14,7 @@ interface ICredential : IDisposable
     interface ICredentialManager
     {
         Task<ICredential> Load(UriString host);
-        Task Save(ICredential credential);
+        Task Save(ICredential cred);
         Task Delete(UriString host);
         bool HasCredentials();
         ICredential CachedCredentials { get; }
diff --git a/src/GitHub.Api/Authentication/LoginManager.cs b/src/GitHub.Api/Authentication/LoginManager.cs
@@ -94,7 +94,7 @@ public async Task<LoginResultData> Login(
                 if (e is TwoFactorRequiredException)
                 {
                     result = LoginResultCodes.CodeRequired;
-                    logger.Debug("2FA TwoFactorAuthorizationException: {0} {1}", LoginResultCodes.CodeRequired, e.Message);
+                    logger.Trace("2FA TwoFactorAuthorizationException: {0} {1}", LoginResultCodes.CodeRequired, e.Message);
                 }
                 else
                 {
@@ -166,21 +166,21 @@ public async Task<LoginResultData> ContinueLogin(LoginResultData loginResultData
             }
             catch (TwoFactorAuthorizationException e)
             {
-                logger.Debug(e, "2FA TwoFactorAuthorizationException: {0} {1}", LoginResultCodes.CodeFailed, e.Message);
+                logger.Trace(e, "2FA TwoFactorAuthorizationException: {0} {1}", LoginResultCodes.CodeFailed, e.Message);
 
                 return new LoginResultData(LoginResultCodes.CodeFailed, Localization.Wrong2faCode, client, host, newAuth);
             }
             catch (ApiValidationException e)
             {
-                logger.Debug(e, "2FA ApiValidationException: {0}", e.Message);
+                logger.Trace(e, "2FA ApiValidationException: {0}", e.Message);
 
                 var message = e.ApiError.FirstErrorMessageSafe();
                 await keychain.Clear(host, false);
                 return new LoginResultData(LoginResultCodes.Failed, message, host);
             }
             catch (Exception e)
             {
-                logger.Debug(e, "Exception: {0}", e.Message);
+                logger.Trace(e, "Exception: {0}", e.Message);
 
                 await keychain.Clear(host, false);
                 return new LoginResultData(LoginResultCodes.Failed, e.Message, host);
diff --git a/src/GitHub.Api/Events/RepositoryWatcher.cs b/src/GitHub.Api/Events/RepositoryWatcher.cs
@@ -71,14 +71,14 @@ public void Start()
         {
             if (disableNative)
             {
-                Logger.Debug("Native interface is disabled");
+                Logger.Trace("Native interface is disabled");
                 return;
             }
 
             if (nativeInterface == null)
             {
                 Logger.Warning("NativeInterface is null");
-                throw new Exception("Not initialized");
+                throw new InvalidOperationException("NativeInterface is null");
             }
 
             running = true;
diff --git a/src/GitHub.Api/Git/GitCredentialManager.cs b/src/GitHub.Api/Git/GitCredentialManager.cs
@@ -97,11 +97,11 @@ public async Task<ICredential> Load(UriString host)
             return credential;
         }
 
-        public async Task Save(ICredential credential)
+        public async Task Save(ICredential cred)
         {
-            Logger.Trace("Save: {0}", credential.Host);
+            this.credential = cred;
 
-            this.credential = credential;
+            Logger.Trace("Save: {0}", credential.Host);
 
             if (!await LoadCredentialHelper())
                 return;
diff --git a/src/GitHub.Api/Git/GitStatusEntry.cs b/src/GitHub.Api/Git/GitStatusEntry.cs
@@ -5,12 +5,12 @@ namespace GitHub.Unity
     [Serializable]
     struct GitStatusEntry
     {
-        public readonly string Path;
-        public readonly string FullPath;
-        public readonly string ProjectPath;
-        public readonly string OriginalPath;
-        public readonly GitFileStatus Status;
-        public readonly bool Staged;
+        public string Path;
+        public string FullPath;
+        public string ProjectPath;
+        public string OriginalPath;
+        public GitFileStatus Status;
+        public bool Staged;
 
         public GitStatusEntry(string path, string fullPath, string projectPath,
             GitFileStatus status,
diff --git a/src/GitHub.Api/IO/FileSystem.cs b/src/GitHub.Api/IO/FileSystem.cs
@@ -14,15 +14,19 @@ public FileSystem()
         {
         }
 
-        public FileSystem(string currentDirectory)
+        /// <summary>
+        /// Initialize the filesystem object with the path passed in set as the current directory
+        /// </summary>
+        /// <param name="directory">Current directory</param>
+        public FileSystem(string directory)
         {
-            this.currentDirectory = currentDirectory;
+            this.currentDirectory = directory;
         }
 
-        public void SetCurrentDirectory(string currentDirectory)
+        public void SetCurrentDirectory(string directory)
         {
-            Debug.Assert(Path.IsPathRooted(currentDirectory));
-            this.currentDirectory = currentDirectory;
+            Debug.Assert(Path.IsPathRooted(directory));
+            this.currentDirectory = directory;
         }
 
         public bool FileExists(string filename)
diff --git a/src/GitHub.Api/IO/FileSystemHelpers.cs b/src/GitHub.Api/IO/FileSystemHelpers.cs
@@ -7,12 +7,16 @@ static class FileSystemHelpers
     {
         public static string FindCommonPath(IEnumerable<string> paths)
         {
-            var pathsArray = paths.Where(s => s != null).Select(s => s.ToNPath().Parent).ToArray();
-            var maxDepth = pathsArray.Max(path => path.Depth);
-            var deepestPath = pathsArray.First(path => path.Depth == maxDepth);
+            var parentPaths = paths.Where(s => !string.IsNullOrEmpty(s)).Select(s => s.ToNPath().Parent);
+            if (!parentPaths.Any())
+                return null;
+
+            var parentsArray = parentPaths.ToArray();
+            var maxDepth = parentsArray.Max(path => path.Depth);
+            var deepestPath = parentsArray.First(path => path.Depth == maxDepth);
 
             var commonParent = deepestPath;
-            foreach (var path in pathsArray)
+            foreach (var path in parentsArray)
             {
                 var cp = path.Elements.Any() ? commonParent.GetCommonParent(path) : null;
                 if (cp != null)
diff --git a/src/GitHub.Api/NewTaskSystem/ConcurrentExclusiveInterleave.cs b/src/GitHub.Api/NewTaskSystem/ConcurrentExclusiveInterleave.cs
@@ -391,8 +391,8 @@ protected override IEnumerable<Task> GetScheduledTasks()
             /// <param name="task">The task to be executed.</param>
             internal void ExecuteTask(Task task)
             {
-                var processingTaskOnCurrentThread = this.processingTaskOnCurrentThread.Value;
-                if (!processingTaskOnCurrentThread) this.processingTaskOnCurrentThread.Value = true;
+                var isProcessingTaskOnCurrentThread = this.processingTaskOnCurrentThread.Value;
+                if (!isProcessingTaskOnCurrentThread) this.processingTaskOnCurrentThread.Value = true;
                 //try
                 //{
                     TryExecuteTask(task);
@@ -403,7 +403,7 @@ internal void ExecuteTask(Task task)
                 //    throw;
                 //}
 
-                if (!processingTaskOnCurrentThread) this.processingTaskOnCurrentThread.Value = false;
+                if (!isProcessingTaskOnCurrentThread) this.processingTaskOnCurrentThread.Value = false;
             }
 
             /// <summary>Gets the maximum concurrency level this scheduler is able to support.</summary>
diff --git a/src/GitHub.Api/NewTaskSystem/TaskBase.cs b/src/GitHub.Api/NewTaskSystem/TaskBase.cs
@@ -10,7 +10,7 @@ interface ITask : IAsyncResult
         ITask Catch(Action<Exception> handler);
         ITask Catch(Func<Exception, bool> handler);
         ITask Finally(Action handler);
-        ITask Finally(Action<bool, Exception> continuation, TaskAffinity affinity = TaskAffinity.Concurrent);
+        ITask Finally(Action<bool, Exception> actionToContinueWith, TaskAffinity affinity = TaskAffinity.Concurrent);
         ITask Defer<T>(Func<T, Task> continueWith, TaskAffinity affinity = TaskAffinity.Concurrent, bool always = false);
         ITask Start();
         ITask Start(TaskScheduler scheduler);
@@ -157,22 +157,22 @@ public ITask Finally(Action handler)
             return this;
         }
 
-        public ITask Finally(Action<bool, Exception> continuation, TaskAffinity affinity = TaskAffinity.Concurrent)
+        public ITask Finally(Action<bool, Exception> actionToContinueWith, TaskAffinity affinity = TaskAffinity.Concurrent)
         {
-            Guard.ArgumentNotNull(continuation, "continuation");
-            var ret = Then(new ActionTask(Token, continuation) { Affinity = affinity, Name = "Finally" }, true);
+            Guard.ArgumentNotNull(actionToContinueWith, nameof(actionToContinueWith));
+            var ret = Then(new ActionTask(Token, actionToContinueWith) { Affinity = affinity, Name = "Finally" }, true);
             DependsOn?.SetFaultHandler(ret);
             ret.ContinuationIsFinally = true;
             return ret;
         }
 
-        internal virtual ITask Finally<T>(T continuation)
+        internal virtual ITask Finally<T>(T taskToContinueWith)
             where T : TaskBase
         {
-            Guard.ArgumentNotNull(continuation, "continuation");
+            Guard.ArgumentNotNull(taskToContinueWith, nameof(taskToContinueWith));
+            continuation = (TaskBase)(object)taskToContinueWith;
+            continuationAlways = true;
             continuation.SetDependsOn(this);
-            this.continuation = (TaskBase)(object)continuation;
-            this.continuationAlways = true;
             DependsOn?.SetFaultHandler((TaskBase)(object)continuation);
             return continuation;
         }
@@ -413,7 +413,6 @@ public TaskBase(CancellationToken token)
         public TaskBase(Task<TResult> task)
             : base()
         {
-            var scheduler = TaskManager.GetScheduler(Affinity);
             Task = new Task<TResult>(t =>
             {
                 TResult ret = default(TResult);
diff --git a/src/GitHub.Api/OutputProcessors/LockOutputProcessor.cs b/src/GitHub.Api/OutputProcessors/LockOutputProcessor.cs
@@ -29,7 +29,7 @@ public override void LineReceived(string line)
             {
                 return;
             }
-            Logger.Debug(line);
+            Logger.Trace(line);
             var path = proc.ReadUntil('\t').Trim();
             var user = proc.ReadUntilLast("ID:").Trim();
             proc.MoveToAfter("ID:");
diff --git a/src/GitHub.Api/OutputProcessors/StatusOutputProcessor.cs b/src/GitHub.Api/OutputProcessors/StatusOutputProcessor.cs
@@ -66,7 +66,7 @@ public override void LineReceived(string line)
                                 }
                                 else
                                 {
-                                    throw new Exception("Unexpected deltaComponent in o");
+                                    throw new InvalidOperationException("Unexpected deltaComponent in o");
                                 }
                             }
                         }
diff --git a/src/GitHub.Api/Platform/Settings.cs b/src/GitHub.Api/Platform/Settings.cs
@@ -16,7 +16,7 @@ abstract class BaseSettings : ISettings
         public abstract void Unset(string key);
 
         protected virtual string SettingsFileName { get; set; }
-        protected virtual NPath SettingsPath { get; set; }
+        protected NPath SettingsPath { get; set; }
     }
 
     class JsonBackedSettings : BaseSettings
@@ -111,16 +111,16 @@ public override void Rename(string oldKey, string newKey)
             SaveToCache(cachePath);
         }
 
-        private void LoadFromCache(string cachePath)
+        private void LoadFromCache(string path)
         {
-            logger.Trace("LoadFromCache: {0}", cachePath);
+            logger.Trace("LoadFromCache: {0}", path);
 
-            EnsureCachePath(cachePath);
+            EnsureCachePath(path);
 
-            if (!fileExists(cachePath))
+            if (!fileExists(path))
                 return;
 
-            var data = readAllText(cachePath, Encoding.UTF8);
+            var data = readAllText(path, Encoding.UTF8);
 
             try
             {
@@ -135,21 +135,21 @@ private void LoadFromCache(string cachePath)
             if (cacheData == null)
             {
                 // cache is corrupt, remove
-                fileDelete(cachePath);
+                fileDelete(path);
                 return;
             }
         }
 
-        private bool SaveToCache(string cachePath)
+        private bool SaveToCache(string path)
         {
-            logger.Trace("SaveToCache: {0}", cachePath);
+            logger.Trace("SaveToCache: {0}", path);
 
-            EnsureCachePath(cachePath);
+            EnsureCachePath(path);
 
             try
             {
                 var data = SimpleJson.SerializeObject(cacheData);
-                writeAllText(cachePath, data);
+                writeAllText(path, data);
             }
             catch (Exception ex)
             {
@@ -160,12 +160,12 @@ private bool SaveToCache(string cachePath)
             return true;
         }
 
-        private void EnsureCachePath(string cachePath)
+        private void EnsureCachePath(string path)
         {
-            if (fileExists(cachePath))
+            if (fileExists(path))
                 return;
 
-            var di = Path.GetDirectoryName(cachePath);
+            var di = Path.GetDirectoryName(path);
             if (!dirExists(di))
                 dirCreate(di);
         }
diff --git a/src/UnityExtension/Assets/Editor/GitHub.Unity/ApplicationCache.cs b/src/UnityExtension/Assets/Editor/GitHub.Unity/ApplicationCache.cs
@@ -21,12 +21,6 @@ public bool FirstRun
                 return val;
             }
         }
-
-        [SerializeField] private string createdDate;
-        public string CreatedDate
-        {
-            get { return createdDate; }
-        }
     }
 
     sealed class EnvironmentCache : ScriptObjectSingleton<EnvironmentCache>
@@ -83,15 +77,14 @@ public void Flush()
         }
     }
 
-    [Location("cache/branches.yaml", LocationAttribute.Location.UserFolder)]
+    [Location("cache/branches.yaml", LocationAttribute.Location.LibraryFolder)]
     sealed class BranchCache : ScriptObjectSingleton<BranchCache>, IBranchCache
     {
         [SerializeField] private List<GitBranch> localBranches;
         [SerializeField] private List<GitBranch> remoteBranches;
-        [SerializeField] private List<GitBranch> test;
+
         public BranchCache()
         {
-            test = new List<GitBranch>() { new GitBranch("name", "tracking", false) };
         }
 
         public List<GitBranch> LocalBranches
@@ -104,7 +97,6 @@ public List<GitBranch> LocalBranches
             }
             set
             {
-                Logging.GetLogger().Debug("Saving branches {0}", value.Join(","));
                 localBranches = value;
                 Save(true);
             }
@@ -125,7 +117,7 @@ public List<GitBranch> RemoteBranches
         }
     }
 
-    [Location("views/branches.yaml", LocationAttribute.Location.UserFolder)]
+    [Location("views/branches.yaml", LocationAttribute.Location.LibraryFolder)]
     sealed class Favourites : ScriptObjectSingleton<Favourites>
     {
         [SerializeField] private List<string> favouriteBranches;
@@ -174,4 +166,27 @@ public bool IsFavourite(string branchName)
             return FavouriteBranches.Contains(branchName);
         }
     }
+
+    [Location("cache/gitlog.yaml", LocationAttribute.Location.LibraryFolder)]
+    sealed class GitLogCache : ScriptObjectSingleton<GitLogCache>
+    {
+        [SerializeField] private List<GitLogEntry> log;
+        public GitLogCache()
+        {}
+
+        public List<GitLogEntry> Log
+        {
+            get
+            {
+                if (log == null)
+                    log = new List<GitLogEntry>();
+                return log;
+            }
+            set
+            {
+                log = value;
+                Save(true);
+            }
+        }
+    }
 }
diff --git a/src/UnityExtension/Assets/Editor/GitHub.Unity/ApplicationManager.cs b/src/UnityExtension/Assets/Editor/GitHub.Unity/ApplicationManager.cs
@@ -34,9 +34,9 @@ protected override void InitializeUI()
         {
             Logger.Trace("Restarted {0}", Environment.Repository);
             ProjectWindowInterface.Initialize(Environment.Repository);
-            var view = Window.GetWindow();
-            if (view != null)
-                view.Initialize(this);
+            var window = Window.GetWindow();
+            if (window != null)
+                window.Initialize(this);
         }
 
         protected override void SetProjectToTextSerialization()
diff --git a/src/UnityExtension/Assets/Editor/GitHub.Unity/Misc/Installer.cs b/src/UnityExtension/Assets/Editor/GitHub.Unity/Misc/Installer.cs
diff --git a/src/UnityExtension/Assets/Editor/GitHub.Unity/ScriptObjectSingleton.cs b/src/UnityExtension/Assets/Editor/GitHub.Unity/ScriptObjectSingleton.cs
diff --git a/src/UnityExtension/Assets/Editor/GitHub.Unity/Tasks/EvaluateProjectConfigurationTask.cs b/src/UnityExtension/Assets/Editor/GitHub.Unity/Tasks/EvaluateProjectConfigurationTask.cs
diff --git a/src/UnityExtension/Assets/Editor/GitHub.Unity/UI/AuthenticationView.cs b/src/UnityExtension/Assets/Editor/GitHub.Unity/UI/AuthenticationView.cs
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
diff --git a/src/tests/UnitTests/IO/FileSystemHelperTests.cs b/src/tests/UnitTests/IO/FileSystemHelperTests.cs

Original file line number	Diff line number	Diff line change
`@@ -11,7 +11,6 @@ abstract class ApplicationManagerBase : IApplicationManager`
`11`	`11`	`{`
`12`	`12`	`protected static ILogging Logger { get; } = Logging.GetLogger<IApplicationManager>();`
`13`	`13`
`14`		`- private IEnvironment environment;`
`15`	`14`	`private RepositoryManager repositoryManager;`
`16`	`15`
`17`	`16`	`public ApplicationManagerBase(SynchronizationContext synchronizationContext)`
Original file line number	Diff line number	Diff line change
`@@ -14,7 +14,7 @@ interface ICredential : IDisposable`
`14`	`14`	`interface ICredentialManager`
`15`	`15`	`{`
`16`	`16`	`Task<ICredential> Load(UriString host);`
`17`		`- Task Save(ICredential credential);`
	`17`	`+ Task Save(ICredential cred);`
`18`	`18`	`Task Delete(UriString host);`
`19`	`19`	`bool HasCredentials();`
`20`	`20`	`ICredential CachedCredentials { get; }`
Original file line number	Diff line number	Diff line change
`@@ -94,7 +94,7 @@ public async Task<LoginResultData> Login(`
`94`	`94`	`if (e is TwoFactorRequiredException)`
`95`	`95`	`{`
`96`	`96`	`result = LoginResultCodes.CodeRequired;`
`97`		`- logger.Debug("2FA TwoFactorAuthorizationException: {0} {1}", LoginResultCodes.CodeRequired, e.Message);`
	`97`	`+ logger.Trace("2FA TwoFactorAuthorizationException: {0} {1}", LoginResultCodes.CodeRequired, e.Message);`
`98`	`98`	`}`
`99`	`99`	`else`
`100`	`100`	`{`
`@@ -166,21 +166,21 @@ public async Task<LoginResultData> ContinueLogin(LoginResultData loginResultData`
`166`	`166`	`}`
`167`	`167`	`catch (TwoFactorAuthorizationException e)`
`168`	`168`	`{`
`169`		`- logger.Debug(e, "2FA TwoFactorAuthorizationException: {0} {1}", LoginResultCodes.CodeFailed, e.Message);`
	`169`	`+ logger.Trace(e, "2FA TwoFactorAuthorizationException: {0} {1}", LoginResultCodes.CodeFailed, e.Message);`
`170`	`170`
`171`	`171`	`return new LoginResultData(LoginResultCodes.CodeFailed, Localization.Wrong2faCode, client, host, newAuth);`
`172`	`172`	`}`
`173`	`173`	`catch (ApiValidationException e)`
`174`	`174`	`{`
`175`		`- logger.Debug(e, "2FA ApiValidationException: {0}", e.Message);`
	`175`	`+ logger.Trace(e, "2FA ApiValidationException: {0}", e.Message);`
`176`	`176`
`177`	`177`	`var message = e.ApiError.FirstErrorMessageSafe();`
`178`	`178`	`await keychain.Clear(host, false);`
`179`	`179`	`return new LoginResultData(LoginResultCodes.Failed, message, host);`
`180`	`180`	`}`
`181`	`181`	`catch (Exception e)`
`182`	`182`	`{`
`183`		`- logger.Debug(e, "Exception: {0}", e.Message);`
	`183`	`+ logger.Trace(e, "Exception: {0}", e.Message);`
`184`	`184`
`185`	`185`	`await keychain.Clear(host, false);`
`186`	`186`	`return new LoginResultData(LoginResultCodes.Failed, e.Message, host);`
Original file line number	Diff line number	Diff line change
`@@ -71,14 +71,14 @@ public void Start()`
`71`	`71`	`{`
`72`	`72`	`if (disableNative)`
`73`	`73`	`{`
`74`		`- Logger.Debug("Native interface is disabled");`
	`74`	`+ Logger.Trace("Native interface is disabled");`
`75`	`75`	`return;`
`76`	`76`	`}`
`77`	`77`
`78`	`78`	`if (nativeInterface == null)`
`79`	`79`	`{`
`80`	`80`	`Logger.Warning("NativeInterface is null");`
`81`		`- throw new Exception("Not initialized");`
	`81`	`+ throw new InvalidOperationException("NativeInterface is null");`
`82`	`82`	`}`
`83`	`83`
`84`	`84`	`running = true;`
Original file line number	Diff line number	Diff line change
`@@ -97,11 +97,11 @@ public async Task<ICredential> Load(UriString host)`
`97`	`97`	`return credential;`
`98`	`98`	`}`
`99`	`99`
`100`		`- public async Task Save(ICredential credential)`
	`100`	`+ public async Task Save(ICredential cred)`
`101`	`101`	`{`
`102`		`- Logger.Trace("Save: {0}", credential.Host);`
	`102`	`+ this.credential = cred;`
`103`	`103`
`104`		`- this.credential = credential;`
	`104`	`+ Logger.Trace("Save: {0}", credential.Host);`
`105`	`105`
`106`	`106`	`if (!await LoadCredentialHelper())`
`107`	`107`	`return;`
Original file line number	Diff line number	Diff line change
`@@ -14,15 +14,19 @@ public FileSystem()`
`14`	`14`	`{`
`15`	`15`	`}`
`16`	`16`
`17`		`- public FileSystem(string currentDirectory)`
	`17`	`+ /// <summary>`
	`18`	`+ /// Initialize the filesystem object with the path passed in set as the current directory`
	`19`	`+ /// </summary>`
	`20`	`+ /// <param name="directory">Current directory</param>`
	`21`	`+ public FileSystem(string directory)`
`18`	`22`	`{`
`19`		`- this.currentDirectory = currentDirectory;`
	`23`	`+ this.currentDirectory = directory;`
`20`	`24`	`}`
`21`	`25`
`22`		`- public void SetCurrentDirectory(string currentDirectory)`
	`26`	`+ public void SetCurrentDirectory(string directory)`
`23`	`27`	`{`
`24`		`- Debug.Assert(Path.IsPathRooted(currentDirectory));`
`25`		`- this.currentDirectory = currentDirectory;`
	`28`	`+ Debug.Assert(Path.IsPathRooted(directory));`
	`29`	`+ this.currentDirectory = directory;`
`26`	`30`	`}`
`27`	`31`
`28`	`32`	`public bool FileExists(string filename)`