Merge branch 'fixes/stop-watcher-for-commit' into enhancements/repository-watcher-refactor

# Conflicts:
#	src/GitHub.Api/Git/RepositoryManager.cs

Author: StanleyGoldman

src/GitHub.Api/Git/RepositoryManager.cs

@@ -1,6 +1,7 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using System.Threading;
 using System.Threading.Tasks;
 
 namespace GitHub.Unity
@@ -164,38 +165,38 @@ public int WaitForEvents()
 
         public ITask CommitAllFiles(string message, string body)
         {
-            var add = GitClient.AddAll();
-            add.OnStart += t => IsBusy = true;
-            return add
-                .Then(GitClient.Commit(message, body))
-                .Finally(() => IsBusy = false);
+            var task = GitClient
+                .AddAll()
+                .Then(GitClient.Commit(message, body));
+
+            return HookupHandlers(task);
         }
 
         public ITask CommitFiles(List<string> files, string message, string body)
         {
-            var add = GitClient.Add(files);
-            add.OnStart += t => IsBusy = true;
-            return add
-                .Then(GitClient.Commit(message, body))
-                .Finally(() => IsBusy = false);
+            var task = GitClient
+                .Add(files)
+                .Then(GitClient.Commit(message, body));
+
+            return HookupHandlers(task);
         }
 
         public ITask Fetch(string remote)
         {
             var task = GitClient.Fetch(remote);
-            return HookupHandlers(task);
+            return HookupHandlers(task, false);
         }
 
         public ITask Pull(string remote, string branch)
         {
             var task = GitClient.Pull(remote, branch);
-            return HookupHandlers(task, true);
+            return HookupHandlers(task);
         }
 
         public ITask Push(string remote, string branch)
         {
             var task = GitClient.Push(remote, branch);
-            return HookupHandlers(task);
+            return HookupHandlers(task, false);
         }
 
         public ITask Revert(string changeset)
@@ -207,7 +208,7 @@ public ITask Revert(string changeset)
         public ITask RemoteAdd(string remote, string url)
         {
             var task = GitClient.RemoteAdd(remote, url);
-            HookupHandlers(task);
+            task = HookupHandlers(task, false);
             if (!platform.Environment.IsWindows)
             {
                 task.Then(_ => {
@@ -220,7 +221,7 @@ public ITask RemoteAdd(string remote, string url)
         public ITask RemoteRemove(string remote)
         {
             var task = GitClient.RemoteRemove(remote);
-            HookupHandlers(task);
+            task = HookupHandlers(task, false);
             if (!platform.Environment.IsWindows)
             {
                 task.Then(_ => {
@@ -233,37 +234,37 @@ public ITask RemoteRemove(string remote)
         public ITask RemoteChange(string remote, string url)
         {
             var task = GitClient.RemoteChange(remote, url);
-            return HookupHandlers(task);
+            return HookupHandlers(task, false);
         }
 
         public ITask SwitchBranch(string branch)
         {
             var task = GitClient.SwitchBranch(branch);
-            return HookupHandlers(task, true);
+            return HookupHandlers(task);
         }
 
         public ITask DeleteBranch(string branch, bool deleteUnmerged = false)
         {
             var task = GitClient.DeleteBranch(branch, deleteUnmerged);
-            return HookupHandlers(task);
+            return HookupHandlers(task, false);
         }
 
         public ITask CreateBranch(string branch, string baseBranch)
         {
             var task = GitClient.CreateBranch(branch, baseBranch);
-            return HookupHandlers(task);
+            return HookupHandlers(task, false);
         }
 
         public ITask LockFile(string file)
         {
             var task = GitClient.Lock(file);
-            return HookupHandlers(task);
+            return HookupHandlers(task, false);
         }
 
         public ITask UnlockFile(string file, bool force)
         {
             var task = GitClient.Unlock(file, force);
-            return HookupHandlers(task);
+            return HookupHandlers(task, false);
         }
 
         public void UpdateGitLog()
@@ -279,17 +280,42 @@ public void UpdateGitLog()
             }).Start();
         }
 
-        public void UpdateGitStatus()
+        private ITask<T> HookupHandlers<T>(ITask<T> task, bool disableWatcher = true, bool toggleBusyFlag = true)
         {
-            var task = GitClient.Status();
-            HookupHandlers(task);
-            task.Then((success, status) =>
-            {
-                if (success)
-                {
-                    GitStatusUpdated?.Invoke(status);
-                }
-            }).Start();
+            return new ActionTask(CancellationToken.None, () => {
+                    if (toggleBusyFlag)
+                    {
+                        Logger.Trace("Starting Operation - Setting Busy Flag");
+                        IsBusy = true;
+                    }
+
+                    if (disableWatcher)
+                    {
+                        Logger.Trace("Starting Operation - Disable Watcher");
+                        watcher.Stop();
+                    }
+                })
+                .Then(task)
+                .Finally((success, exception, result) => {
+                    if (disableWatcher)
+                    {
+                        Logger.Trace("Ended Operation - Enable Watcher");
+                        watcher.Start();
+                    }
+
+                    if (toggleBusyFlag)
+                    {
+                        Logger.Trace("Ended Operation - Clearing Busy Flag");
+                        IsBusy = false;
+                    }
+
+                    if (success)
+                    {
+                        return result;
+                    }
+
+                    throw exception;
+                });
         }
 
         public void UpdateLocks()

src/GitHub.Api/Helpers/Constants.cs

@@ -9,7 +9,7 @@ static class Constants
         public const string UsageFile = "usage.json";
         public const string GitInstallPathKey = "GitInstallPath";
         public const string TraceLoggingKey = "EnableTraceLogging";
-        public const string Iso8601Format = "o";
+        public const string Iso8601Format = "yyyy-MM-ddTHH\\:mm\\:ss.fffffffzzz";
 
         public static readonly Version MinimumGitVersion = new Version(2, 11, 0);
         public static readonly Version MinimumGitLfsVersion = new Version(2, 3, 4);

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

@@ -51,8 +51,12 @@ public override void OnEnable()
             userSettingsView.OnEnable();
             AttachHandlers(Repository);
 
-            Repository.CheckCurrentRemoteChangedEvent(lastCurrentRemoteChangedEvent);
-            Repository.CheckLocksChangedEvent(lastLocksChangedEvent);
+            if (Repository != null)
+            {
+                Repository.CheckCurrentRemoteChangedEvent(lastCurrentRemoteChangedEvent);
+                Repository.CheckLocksChangedEvent(lastLocksChangedEvent);
+            }
+
             metricsHasChanged = true;
         }
 

src/tests/TaskSystemIntegrationTests/Tests.cs

@@ -108,6 +108,44 @@ public async Task ProcessReadsFromStandardInput()
             Assert.AreEqual(expectedOutput, output);
         }
 
+        [Test]
+        public async Task ProcessOnStartOnEndTaskOrder()
+        {
+            var values = new List<string>();
+            string process1Value = null;
+            string process2Value = null;
+
+            var process1Task = new FirstNonNullLineProcessTask(Token, TestApp, @"-s 100 -d process1")
+                .Configure(ProcessManager, true).Then((b, s) => {
+                    process1Value = s;
+                    values.Add(s);
+                });
+
+            var process2Task = new FirstNonNullLineProcessTask(Token, TestApp, @"-s 100 -d process2")
+                .Configure(ProcessManager, true).Then((b, s) => {
+                    process2Value = s;
+                    values.Add(s);
+                });
+
+            var combinedTask = process1Task
+                .Then(process2Task);
+
+            combinedTask.OnStart += task => {
+                values.Add("OnStart");
+            };
+
+            combinedTask.OnEnd += task => {
+                values.Add("OnEnd");
+            };
+
+            await combinedTask
+                .StartAsAsync();
+
+            Assert.AreEqual(process1Value, "process1");
+            Assert.AreEqual(process2Value, "process2");
+            Assert.True(values.SequenceEqual(new []{ "process1", "OnStart", "process2", "OnEnd" }));
+        }
+
         [Test]
         public async Task ProcessReturningErrorThrowsException()
         {