Merge branch 'master' into fixes/application-cache-invalidation

Author: StanleyGoldman

common/SolutionInfo.cs

@@ -31,6 +31,6 @@
 namespace System
 {
     internal static class AssemblyVersionInformation {
-        internal const string Version = "0.23.0";
+        internal const string Version = "0.24.0";
     }
 }

src/GitHub.Api/Cache/CacheInterfaces.cs

@@ -55,7 +55,9 @@ public interface IGitUserCache : IManagedCache
 
     public interface IGitStatusCache : IManagedCache
     {
-        GitStatus GitStatus { get; set; }
+        int Ahead { get; set; }
+        int Behind { get; set; }
+        List<GitStatusEntry> Entries { get; set; }
     }
 
     public interface ILocalConfigBranchDictionary : IDictionary<string, ConfigBranch>

src/GitHub.Api/Extensions/GitStatusExtensions.cs

@@ -0,0 +1,23 @@
+using System;
+
+namespace GitHub.Unity
+{
+    [Serializable]
+    public struct GitAheadBehindStatus
+    {
+        public static GitAheadBehindStatus Default = new GitAheadBehindStatus();
+
+        public int ahead;
+        public int behind;
+
+        public GitAheadBehindStatus(int ahead, int behind)
+        {
+            this.ahead = ahead;
+            this.behind = behind;
+        }
+
+        public int Ahead => ahead;
+
+        public int Behind => behind;
+    }
+}

src/GitHub.Api/Git/GitAheadBehindStatus.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/GitClient.cs

@@ -9,25 +9,56 @@ namespace GitHub.Unity
     [Serializable]
     public struct ConfigRemote
     {
-        public string Name;
-        public string Url;
+        public static ConfigRemote Default = new ConfigRemote(String.Empty, String.Empty);
+
+        public string name;
+        public string url;
+
+        public ConfigRemote(string name, string url)
+        {
+            this.name = name;
+            this.url = url;
+        }
+
+        public string Name => name;
+
+        public string Url => url;
 
         public override string ToString()
         {
-            return String.Format("{{Remote {0} {1}}}", Name, Url);
+            return $"{{Remote {Name} {Url}}}";
         }
     }
 
     [Serializable]
     public struct ConfigBranch
     {
-        public string Name;
-        public ConfigRemote? Remote;
-        public bool IsTracking => Remote.HasValue;
+        public static ConfigBranch Default = new ConfigBranch(String.Empty);
+
+        public string name;
+        public ConfigRemote remote;
+
+        public ConfigBranch(string name)
+        {
+            this.name = name;
+            remote = ConfigRemote.Default;
+        }
+
+        public ConfigBranch(string name, ConfigRemote? remote)
+        {
+            this.name = name;
+            this.remote = remote ?? ConfigRemote.Default;
+        }
+
+        public bool IsTracking => !remote.Equals(ConfigRemote.Default);
+
+        public string Name => name;
+
+        public ConfigRemote? Remote => remote;
 
         public override string ToString()
         {
-            return String.Format("{{Branch {0} {1}}}", Name, Remote?.ToString() ?? "Untracked");
+            return $"{{Branch {Name} {Remote?.ToString() ?? "Untracked"}}}";
         }
     }
 
@@ -74,11 +105,7 @@ public IEnumerable<ConfigBranch> GetBranches()
             return groups
                 .Where(x => x.Key == "branch")
                 .SelectMany(x => x.Value)
-                .Select(x => new ConfigBranch
-                {
-                    Name = x.Key,
-                    Remote = GetRemote(x.Value.TryGetString("remote"))
-                });
+                .Select(x => new ConfigBranch(x.Key, GetRemote(x.Value.TryGetString("remote"))));
         }
 
         public IEnumerable<ConfigRemote> GetRemotes()
@@ -87,11 +114,7 @@ public IEnumerable<ConfigRemote> GetRemotes()
                 .Where(x => x.Key == "remote")
                 .SelectMany(x => x.Value)
                 .Where(x => x.Value.TryGetString("url") != null)
-                .Select(x => new ConfigRemote
-                {
-                    Name = x.Key,
-                    Url = x.Value.TryGetString("url")
-                });
+                .Select(x => new ConfigRemote(x.Key, x.Value.TryGetString("url")));
         }
 
         public ConfigRemote? GetRemote(string remote)
@@ -100,11 +123,7 @@ public IEnumerable<ConfigRemote> GetRemotes()
                 .Where(x => x.Key == "remote")
                 .SelectMany(x => x.Value)
                 .Where(x => x.Key == remote && x.Value.TryGetString("url") != null)
-                .Select(x => new ConfigRemote
-                {
-                    Name = x.Key,
-                    Url = x.Value.GetString("url")
-                } as ConfigRemote?)
+                .Select(x => new ConfigRemote(x.Key,x.Value.GetString("url")) as ConfigRemote?)
                 .FirstOrDefault();
         }
 
@@ -114,11 +133,7 @@ public IEnumerable<ConfigRemote> GetRemotes()
                 .Where(x => x.Key == "branch")
                 .SelectMany(x => x.Value)
                 .Where(x => x.Key == branch)
-                .Select(x => new ConfigBranch
-                {
-                    Name = x.Key,
-                    Remote = GetRemote(x.Value.TryGetString("remote"))
-                } as ConfigBranch?)
+                .Select(x => new ConfigBranch(x.Key,GetRemote(x.Value.TryGetString("remote"))) as ConfigBranch?)
                 .FirstOrDefault();
         }
 

src/GitHub.Api/Git/GitConfig.cs

@@ -14,7 +14,7 @@ public enum GitRemoteFunction
     [Serializable]
     public struct GitRemote
     {
-        public static GitRemote Default = new GitRemote();
+        public static GitRemote Default = new GitRemote(String.Empty, String.Empty, String.Empty, GitRemoteFunction.Unknown, string.Empty, string.Empty, string.Empty);
 
         public string name;
         public string url;

src/GitHub.Api/Git/GitRemote.cs

@@ -57,7 +57,9 @@ public interface IRepository : IEquatable<IRepository>
         /// Gets the current branch of the repository.
         /// </summary>
         GitBranch? CurrentBranch { get; }
-        GitStatus CurrentStatus { get; }
+        int CurrentAhead { get; }
+        int CurrentBehind { get; }
+        List<GitStatusEntry> CurrentChanges { get; }
         GitRemote[] Remotes { get; }
         GitBranch[] LocalBranches { get; }
         GitBranch[] RemoteBranches { get; }

src/GitHub.Api/Git/IRepository.cs

@@ -49,7 +49,9 @@ public void Initialize(IRepositoryManager initRepositoryManager)
             repositoryManager = initRepositoryManager;
             repositoryManager.CurrentBranchUpdated += RepositoryManagerOnCurrentBranchUpdated;
             repositoryManager.GitStatusUpdated += RepositoryManagerOnGitStatusUpdated;
+            repositoryManager.GitAheadBehindStatusUpdated += RepositoryManagerOnGitAheadBehindStatusUpdated;
             repositoryManager.GitLogUpdated += RepositoryManagerOnGitLogUpdated;
+            repositoryManager.GitLocksUpdated += RepositoryManagerOnGitLocksUpdated;
             repositoryManager.LocalBranchesUpdated += RepositoryManagerOnLocalBranchesUpdated;
             repositoryManager.RemoteBranchesUpdated += RepositoryManagerOnRemoteBranchesUpdated;
         }
@@ -267,7 +269,7 @@ private void CacheContainer_OnCacheInvalidated(CacheType cacheType)
                     break;
 
                 case CacheType.GitLocksCache:
-                    repositoryManager?.UpdateLocks();
+                    UpdateLocks();
                     break;
 
                 case CacheType.GitUserCache:
@@ -353,26 +355,36 @@ private void RepositoryManagerOnCurrentBranchUpdated(ConfigBranch? branch, Confi
             new ActionTask(CancellationToken.None, () => {
                 if (!Nullable.Equals(CurrentConfigBranch, branch))
                 {
-                        var currentBranch = branch != null ? (GitBranch?)GetLocalGitBranch(branch.Value) : null;
+                    var currentBranch = branch != null ? (GitBranch?)GetLocalGitBranch(branch.Value) : null;
 
-                        CurrentConfigBranch = branch;
-                        CurrentBranch = currentBranch;
-                        UpdateLocalBranches();
+                    CurrentConfigBranch = branch;
+                    CurrentBranch = currentBranch;
+                    UpdateLocalBranches();
                 }
 
                 if (!Nullable.Equals(CurrentConfigRemote, remote))
                 {
-                        CurrentConfigRemote = remote;
-                        CurrentRemote = GetGitRemote(remote.Value);
-                        ClearRepositoryInfo();
+                    CurrentConfigRemote = remote;
+                    CurrentRemote = remote.HasValue ? (GitRemote?)GetGitRemote(remote.Value) : null;
+                    ClearRepositoryInfo();
                 }
             }) { Affinity = TaskAffinity.UI }.Start();
         }
 
         private void RepositoryManagerOnGitStatusUpdated(GitStatus gitStatus)
         {
             new ActionTask(CancellationToken.None, () => {
-                CurrentStatus = gitStatus;
+                CurrentChanges = gitStatus.Entries;
+                CurrentAhead = gitStatus.Ahead;
+                CurrentBehind = gitStatus.Behind;
+            }) { Affinity = TaskAffinity.UI }.Start();
+        }
+
+        private void RepositoryManagerOnGitAheadBehindStatusUpdated(GitAheadBehindStatus aheadBehindStatus)
+        {
+            new ActionTask(CancellationToken.None, () => {
+                CurrentAhead = aheadBehindStatus.Ahead;
+                CurrentBehind = aheadBehindStatus.Behind;
             }) { Affinity = TaskAffinity.UI }.Start();
         }
 
@@ -383,6 +395,14 @@ private void RepositoryManagerOnGitLogUpdated(List<GitLogEntry> gitLogEntries)
             }) { Affinity = TaskAffinity.UI }.Start();
         }
 
+        private void RepositoryManagerOnGitLocksUpdated(List<GitLock> gitLocks)
+        {
+            new ActionTask(CancellationToken.None, () => {
+                    CurrentLocks = gitLocks;
+                })
+                { Affinity = TaskAffinity.UI }.Start();
+        }
+
         private void RepositoryManagerOnRemoteBranchesUpdated(Dictionary<string, ConfigRemote> remotes,
             Dictionary<string, Dictionary<string, ConfigBranch>> branches)
         {
@@ -401,6 +421,14 @@ private void RepositoryManagerOnLocalBranchesUpdated(Dictionary<string, ConfigBr
             }) { Affinity = TaskAffinity.UI }.Start();
         }
 
+        private void UpdateLocks()
+        {
+            if (CurrentRemote.HasValue)
+            {
+                repositoryManager?.UpdateLocks();
+            }
+        }
+
         private void UpdateLocalBranches()
         {
             LocalBranches = LocalConfigBranches.Values.Select(GetLocalGitBranch).ToArray();
@@ -469,10 +497,22 @@ private ConfigRemote? CurrentConfigRemote
             set { cacheContainer.BranchCache.CurrentConfigRemote = value; }
         }
 
-        public GitStatus CurrentStatus
+        public int CurrentAhead
+        {
+            get { return cacheContainer.GitStatusCache.Ahead; }
+            private set { cacheContainer.GitStatusCache.Ahead = value; }
+        }
+
+        public int CurrentBehind
+        {
+            get { return cacheContainer.GitStatusCache.Behind; }
+            private set { cacheContainer.GitStatusCache.Behind = value; }
+        }
+
+        public List<GitStatusEntry> CurrentChanges
         {
-            get { return cacheContainer.GitStatusCache.GitStatus; }
-            private set { cacheContainer.GitStatusCache.GitStatus = value; }
+            get { return cacheContainer.GitStatusCache.Entries; }
+            private set { cacheContainer.GitStatusCache.Entries = value; }
         }
 
         public GitBranch? CurrentBranch