Adding functionality to query specifically for Ahead Behind status

Author: StanleyGoldman

src/GitHub.Api/Git/GitAheadBehindStatus.cs

@@ -0,0 +1,8 @@
+namespace GitHub.Unity
+{
+    public struct GitAheadBehindStatus
+    {
+        public int Ahead;
+        public int Behind;
+    }
+}

src/GitHub.Api/Git/GitClient.cs

@@ -15,6 +15,9 @@ public interface IGitClient
 
         ITask LfsInstall(IOutputProcessor<string> processor = null);
 
+        ITask<GitAheadBehindStatus> AheadBehindStatus(string gitRef, string otherRef, 
+            IOutputProcessor<GitAheadBehindStatus> processor = null);
+
         ITask<GitStatus> Status(IOutputProcessor<GitStatus> processor = null);
 
         ITask<string> GetConfig(string key, GitConfigSource configSource,
@@ -219,6 +222,14 @@ public ITask<GitStatus> Status(IOutputProcessor<GitStatus> processor = null)
                 .Configure(processManager);
         }
 
+        public ITask<GitAheadBehindStatus> AheadBehindStatus(string gitRef, string otherRef, IOutputProcessor<GitAheadBehindStatus> processor = null)
+        {
+            Logger.Trace("AheadBehindStatus");
+
+            return new GitAheadBehindStatusTask(gitRef, otherRef, cancellationToken, processor)
+                .Configure(processManager);
+        }
+
         public ITask<List<GitLogEntry>> Log(BaseOutputListProcessor<GitLogEntry> processor = null)
         {
             Logger.Trace("Log");

src/GitHub.Api/Git/Repository.cs

@@ -49,6 +49,7 @@ public void Initialize(IRepositoryManager initRepositoryManager)
             repositoryManager = initRepositoryManager;
             repositoryManager.CurrentBranchUpdated += RepositoryManagerOnCurrentBranchUpdated;
             repositoryManager.GitStatusUpdated += RepositoryManagerOnGitStatusUpdated;
+            repositoryManager.GitAheadBehindStatusUpdated += RepositoryManagerOnGitAheadBehindStatusUpdated;
             repositoryManager.GitLogUpdated += RepositoryManagerOnGitLogUpdated;
             repositoryManager.LocalBranchesUpdated += RepositoryManagerOnLocalBranchesUpdated;
             repositoryManager.RemoteBranchesUpdated += RepositoryManagerOnRemoteBranchesUpdated;
@@ -378,6 +379,15 @@ private void RepositoryManagerOnGitStatusUpdated(GitStatus gitStatus)
             }) { Affinity = TaskAffinity.UI }.Start();
         }
 
+        private void RepositoryManagerOnGitAheadBehindStatusUpdated(GitAheadBehindStatus aheadBehindStatus)
+        {
+            new ActionTask(CancellationToken.None, () => {
+                    CurrentAhead = aheadBehindStatus.Ahead;
+                    CurrentBehind = aheadBehindStatus.Behind;
+                })
+                { Affinity = TaskAffinity.UI }.Start();
+        }
+
         private void RepositoryManagerOnGitLogUpdated(List<GitLogEntry> gitLogEntries)
         {
             new ActionTask(CancellationToken.None, () => {
@@ -392,6 +402,12 @@ private void RepositoryManagerOnRemoteBranchesUpdated(Dictionary<string, ConfigR
                 cacheContainer.BranchCache.SetRemotes(remotes, branches);
                 Remotes = ConfigRemotes.Values.Select(GetGitRemote).ToArray();
                 RemoteBranches = RemoteConfigBranches.Values.SelectMany(x => x.Values).Select(GetRemoteGitBranch).ToArray();
+
+                var currentBranch = CurrentBranch;
+                if(!string.IsNullOrEmpty(currentBranch?.Tracking))
+                {
+                   repositoryManager.UpdateGitAheadBehindStatus(currentBranch.Value.name, currentBranch.Value.tracking); 
+                }
             }) { Affinity = TaskAffinity.UI }.Start();
         }
 

src/GitHub.Api/Git/RepositoryManager.cs

@@ -35,12 +35,14 @@ public interface IRepositoryManager : IDisposable
         ITask UnlockFile(string file, bool force);
         void UpdateGitLog();
         void UpdateGitStatus();
+        void UpdateGitAheadBehindStatus(string gitRef, string otherRef);
         void UpdateLocks();
         int WaitForEvents();
 
         IGitConfig Config { get; }
         IGitClient GitClient { get; }
         bool IsBusy { get; }
+        event Action<GitAheadBehindStatus> GitAheadBehindStatusUpdated;
     }
 
     interface IRepositoryPathConfiguration
@@ -101,6 +103,7 @@ class RepositoryManager : IRepositoryManager
         public event Action<ConfigBranch?, ConfigRemote?> CurrentBranchUpdated;
         public event Action<bool> IsBusyChanged;
         public event Action<GitStatus> GitStatusUpdated;
+        public event Action<GitAheadBehindStatus> GitAheadBehindStatusUpdated;
         public event Action<List<GitLock>> GitLocksUpdated;
         public event Action<List<GitLogEntry>> GitLogUpdated;
         public event Action<Dictionary<string, ConfigBranch>> LocalBranchesUpdated;
@@ -293,6 +296,19 @@ public void UpdateGitStatus()
             }).Start();
         }
 
+        public void UpdateGitAheadBehindStatus(string gitRef, string otherRef)
+        {
+            var task = GitClient.AheadBehindStatus(gitRef, otherRef);
+            task = HookupHandlers(task, true, false);
+            task.Then((success, status) =>
+            {
+                if (success)
+                {
+                    GitAheadBehindStatusUpdated?.Invoke(status);
+                }
+            }).Start();
+        }
+
         public void UpdateLocks()
         {
             var task = GitClient.ListLocks(false);

src/GitHub.Api/Git/Tasks/GitAheadBehindStatusTask.cs

@@ -0,0 +1,21 @@
+using System.Threading;
+
+namespace GitHub.Unity
+{
+    class GitAheadBehindStatusTask : ProcessTask<GitAheadBehindStatus>
+    {
+        private const string TaskName = "git rev-list";
+        private readonly string arguments;
+
+        public GitAheadBehindStatusTask(string gitRef, string otherRef,
+            CancellationToken token, IOutputProcessor<GitAheadBehindStatus> processor = null)
+            : base(token, processor ?? new GitAheadBehindStatusOutputProcessor())
+        {
+            Name = TaskName;
+            arguments = $"rev-list --left-right --count {gitRef}...{otherRef}";
+        }
+
+        public override string ProcessArguments => arguments;
+        public override TaskAffinity Affinity { get { return TaskAffinity.Exclusive; } }
+    }
+}

src/GitHub.Api/GitHub.Api.csproj

@@ -104,6 +104,8 @@
     <Compile Include="Cache\CacheInterfaces.cs" />
     <Compile Include="Extensions\ListExtensions.cs" />
     <Compile Include="Git\ManagedCacheExtensions.cs" />
+    <Compile Include="Git\GitAheadBehindStatus.cs" />
+    <Compile Include="Git\Tasks\GitAheadBehindStatusTask.cs" />
     <Compile Include="Git\Tasks\GitLfsVersionTask.cs" />
     <Compile Include="Git\Tasks\GitVersionTask.cs" />
     <Compile Include="Git\ValidateGitInstallResult.cs" />
@@ -115,6 +117,7 @@
     <Compile Include="Application\ApplicationManagerBase.cs" />
     <Compile Include="Helpers\Constants.cs" />
     <Compile Include="Helpers\Validation.cs" />
+    <Compile Include="OutputProcessors\GitAheadBehindStatusOutputProcessor.cs" />
     <Compile Include="OutputProcessors\LfsVersionOutputProcessor.cs" />
     <Compile Include="OutputProcessors\VersionOutputProcessor.cs" />
     <Compile Include="Helpers\TaskHelpers.cs" />

src/GitHub.Api/OutputProcessors/GitAheadBehindStatusOutputProcessor.cs

@@ -0,0 +1,20 @@
+namespace GitHub.Unity
+{
+    class GitAheadBehindStatusOutputProcessor : BaseOutputProcessor<GitAheadBehindStatus>
+    {
+        public override void LineReceived(string line)
+        {
+            if (line == null)
+            {
+                return;
+            }
+
+            var proc = new LineParser(line);
+
+            var ahead = int.Parse(proc.ReadUntilWhitespace());
+            var behind = int.Parse(proc.ReadToEnd());
+
+            RaiseOnEntry(new GitAheadBehindStatus { Ahead = ahead, Behind = behind });
+        }
+    }
+}

src/UnityExtension/Assets/Editor/GitHub.Unity/ApplicationCache.cs

@@ -838,7 +838,7 @@ sealed class GitStatusCache : ManagedCacheBase<GitStatusCache>, IGitStatusCache
         [SerializeField] private string initializedAtString = DateTimeOffset.MinValue.ToString();
         [SerializeField] private int ahead;
         [SerializeField] private int behind;
-        [SerializeField] private List<GitStatusEntry> entries;
+        [SerializeField] private List<GitStatusEntry> entries = new List<GitStatusEntry>();
 
         public GitStatusCache() : base(true)
         { }
@@ -868,20 +868,74 @@ public override TimeSpan DataTimeout
 
         public int Ahead
         {
-            get { return ahead; }
-            set { ahead = value; }
+            get
+            {
+                ValidateData();
+                return ahead;
+            }
+            set
+            {
+                var now = DateTimeOffset.Now;
+                var isUpdated = false;
+
+                Logger.Trace("Updating: {0} ahead:{1}", now, value);
+
+                if (ahead != value)
+                {
+                    ahead = value;
+                    isUpdated = true;
+                }
+
+                SaveData(now, isUpdated);
+            }
         }
 
         public int Behind
         {
-            get { return behind; }
-            set { behind = value; }
+            get
+            {
+                ValidateData();
+                return behind;
+            }
+            set
+            {
+                var now = DateTimeOffset.Now;
+                var isUpdated = false;
+
+                Logger.Trace("Updating: {0} behind:{1}", now, value);
+
+                if (behind != value)
+                {
+                    behind = value;
+                    isUpdated = true;
+                }
+
+                SaveData(now, isUpdated);
+            }
         }
 
         public List<GitStatusEntry> Entries
         {
-            get { return entries; }
-            set { entries = value; }
+            get
+            {
+                ValidateData();
+                return entries;
+            }
+            set
+            {
+                var now = DateTimeOffset.Now;
+                var isUpdated = false;
+
+                Logger.Trace("Updating: {0} entries:{1}", now, value.Count);
+
+                if (!entries.SequenceEqual(value))
+                {
+                    entries = value;
+                    isUpdated = true;
+                }
+
+                SaveData(now, isUpdated);
+            }
         }
     }