Refactoring RepositoryManager and Repository

src/GitHub.Api/Events/RepositoryWatcher.cs

@@ -11,7 +11,7 @@ interface IRepositoryWatcher : IDisposable
     {
         void Start();
         void Stop();
-        event Action<string> HeadChanged;
+        event Action HeadChanged;
         event Action IndexChanged;
         event Action ConfigChanged;
         event Action<string> LocalBranchChanged;
@@ -38,7 +38,7 @@ class RepositoryWatcher : IRepositoryWatcher
         private bool processingEvents;
         private readonly ManualResetEventSlim signalProcessingEventsDone = new ManualResetEventSlim(false);
 
-        public event Action<string> HeadChanged;
+        public event Action HeadChanged;
         public event Action IndexChanged;
         public event Action ConfigChanged;
         public event Action<string> LocalBranchChanged;
@@ -162,14 +162,7 @@ public int CheckAndProcessEvents()
 
         private int ProcessEvents(Event[] fileEvents)
         {
-            var eventsProcessed = 0;
-            var configChanged = false;
-            var headChanged = false;
-            var repositoryChanged = false;
-            var indexChanged = false;
-
-            string headContent = null;
-
+            Dictionary<EventType, List<EventData>> events = new Dictionary<EventType, List<EventData>>();
             foreach (var fileEvent in fileEvents)
             {
                 if (!running)
@@ -197,22 +190,17 @@ private int ProcessEvents(Event[] fileEvents)
                 // handling events in .git/*
                 if (fileA.IsChildOf(paths.DotGitPath))
                 {
-                    if (!configChanged && fileA.Equals(paths.DotGitConfig))
+                    if (!events.ContainsKey(EventType.ConfigChanged) && fileA.Equals(paths.DotGitConfig))
                     {
-                        configChanged = true;
+                        events.Add(EventType.ConfigChanged, null);
                     }
-                    else if (!headChanged && fileA.Equals(paths.DotGitHead))
+                    else if (!events.ContainsKey(EventType.HeadChanged) && fileA.Equals(paths.DotGitHead))
                     {
-                        if (fileEvent.Type != EventType.DELETED)
-                        {
-                            headContent = paths.DotGitHead.ReadAllLines().FirstOrDefault();
-                        }
-
-                        headChanged = true;
+                        events.Add(EventType.HeadChanged, null);
                     }
-                    else if (!indexChanged && fileA.Equals(paths.DotGitIndex))
+                    else if (!events.ContainsKey(EventType.IndexChanged) && fileA.Equals(paths.DotGitIndex))
                     {
-                        indexChanged = true;
+                        events.Add(EventType.IndexChanged, null);
                     }
                     else if (fileA.IsChildOf(paths.RemotesPath))
                     {
@@ -226,20 +214,17 @@ private int ProcessEvents(Event[] fileEvents)
 
                         var origin = relativePathElements[0];
 
-                        if (fileEvent.Type == EventType.DELETED)
+                        if (fileEvent.Type == sfw.net.EventType.DELETED)
                         {
                             if (fileA.ExtensionWithDot == ".lock")
                             {
                                 continue;
                             }
 
                             var branch = string.Join(@"/", relativePathElements.Skip(1).ToArray());
-
-                            Logger.Trace("RemoteBranchDeleted: {0}/{1}", origin, branch);
-                            RemoteBranchDeleted?.Invoke(origin, branch);
-                            eventsProcessed++;
+                            AddOrUpdateEventData(events, EventType.RemoteBranchDeleted, new EventData { Origin = origin, Branch = branch });
                         }
-                        else if (fileEvent.Type == EventType.RENAMED)
+                        else if (fileEvent.Type == sfw.net.EventType.RENAMED)
                         {
                             if (fileA.ExtensionWithDot != ".lock")
                             {
@@ -255,17 +240,14 @@ private int ProcessEvents(Event[] fileEvents)
                                         .Union(new[] { fileA.FileNameWithoutExtension }).ToArray();
 
                                     var branch = string.Join(@"/", branchPathElement);
-
-                                    Logger.Trace("RemoteBranchCreated: {0}/{1}", origin, branch);
-                                    RemoteBranchCreated?.Invoke(origin, branch);
-                                    eventsProcessed++;
+                                    AddOrUpdateEventData(events, EventType.RemoteBranchCreated, new EventData { Origin = origin, Branch = branch });
                                 }
                             }
                         }
                     }
                     else if (fileA.IsChildOf(paths.BranchesPath))
                     {
-                        if (fileEvent.Type == EventType.MODIFIED)
+                        if (fileEvent.Type == sfw.net.EventType.MODIFIED)
                         {
                             if (fileA.DirectoryExists())
                             {
@@ -287,11 +269,10 @@ private int ProcessEvents(Event[] fileEvents)
 
                             var branch = string.Join(@"/", relativePathElements.ToArray());
 
-                            Logger.Trace("LocalBranchChanged: {0}", branch);
-                            LocalBranchChanged?.Invoke(branch);
-                            eventsProcessed++;
+                            AddOrUpdateEventData(events, EventType.LocalBranchChanged, new EventData { Branch = branch });
+
                         }
-                        else if (fileEvent.Type == EventType.DELETED)
+                        else if (fileEvent.Type == sfw.net.EventType.DELETED)
                         {
                             if (fileA.ExtensionWithDot == ".lock")
                             {
@@ -307,12 +288,9 @@ private int ProcessEvents(Event[] fileEvents)
                             }
 
                             var branch = string.Join(@"/", relativePathElements.ToArray());
-
-                            Logger.Trace("LocalBranchDeleted: {0}", branch);
-                            LocalBranchDeleted?.Invoke(branch);
-                            eventsProcessed++;
+                            AddOrUpdateEventData(events, EventType.LocalBranchDeleted, new EventData { Branch = branch });
                         }
-                        else if (fileEvent.Type == EventType.RENAMED)
+                        else if (fileEvent.Type == sfw.net.EventType.RENAMED)
                         {
                             if (fileA.ExtensionWithDot != ".lock")
                             {
@@ -332,54 +310,117 @@ private int ProcessEvents(Event[] fileEvents)
                                     }
 
                                     var branch = string.Join(@"/", relativePathElements.ToArray());
-
-                                    Logger.Trace("LocalBranchCreated: {0}", branch);
-                                    LocalBranchCreated?.Invoke(branch);
-                                    eventsProcessed++;
+                                    AddOrUpdateEventData(events, EventType.LocalBranchCreated, new EventData { Branch = branch });
                                 }
                             }
                         }
                     }
                 }
                 else
                 {
-                    if (repositoryChanged || ignoredPaths.Any(ignoredPath => fileA.IsChildOf(ignoredPath)))
+                    if (events.ContainsKey(EventType.RepositoryChanged) || ignoredPaths.Any(ignoredPath => fileA.IsChildOf(ignoredPath)))
                     {
                         continue;
                     }
-
-                    repositoryChanged = true;
+                    events.Add(EventType.RepositoryChanged, null);
                 }
             }
 
-            if (configChanged)
+            return FireEvents(events);
+        }
+
+        private void AddOrUpdateEventData(Dictionary<EventType, List<EventData>> events, EventType type, EventData data)
+        {
+            if (!events.ContainsKey(type))
+                events.Add(type, new List<EventData>());
+            events[type].Add(data);
+        }
+
+        private int FireEvents(Dictionary<EventType, List<EventData>> events)
+        {
+            int eventsProcessed = 0;
+            if (events.ContainsKey(EventType.ConfigChanged))
             {
                 Logger.Trace("ConfigChanged");
                 ConfigChanged?.Invoke();
                 eventsProcessed++;
             }
 
-            if (headChanged)
+            if (events.ContainsKey(EventType.HeadChanged))
             {
-                Logger.Trace("HeadChanged: {0}", headContent ?? "[null]");
-                HeadChanged?.Invoke(headContent);
+                Logger.Trace("HeadChanged");
+                HeadChanged?.Invoke();
                 eventsProcessed++;
             }
 
-            if (indexChanged)
+            if (events.ContainsKey(EventType.IndexChanged))
             {
                 Logger.Trace("IndexChanged");
                 IndexChanged?.Invoke();
                 eventsProcessed++;
             }
 
-            if (repositoryChanged)
+            if (events.ContainsKey(EventType.RepositoryChanged))
             {
                 Logger.Trace("RepositoryChanged");
                 RepositoryChanged?.Invoke();
                 eventsProcessed++;
             }
 
+            List<EventData> localBranchesCreated;
+            if (events.TryGetValue(EventType.LocalBranchCreated, out localBranchesCreated))
+            {
+                foreach (var evt in localBranchesCreated)
+                {
+                    Logger.Trace($"LocalBranchCreated: {evt.Branch}");
+                    LocalBranchCreated?.Invoke(evt.Branch);
+                    eventsProcessed++;
+                }
+            }
+
+            List<EventData> localBranchesChanged;
+            if (events.TryGetValue(EventType.LocalBranchChanged, out localBranchesChanged))
+            {
+                foreach (var evt in localBranchesChanged)
+                {
+                    Logger.Trace($"LocalBranchChanged: {evt.Branch}");
+                    LocalBranchChanged?.Invoke(evt.Branch);
+                    eventsProcessed++;
+                }
+            }
+
+            List<EventData> localBranchesDeleted;
+            if (events.TryGetValue(EventType.LocalBranchDeleted, out localBranchesDeleted))
+            {
+                foreach (var evt in localBranchesDeleted)
+                {
+                    Logger.Trace($"LocalBranchDeleted: {evt.Branch}");
+                    LocalBranchDeleted?.Invoke(evt.Branch);
+                    eventsProcessed++;
+                }
+            }
+
+            List<EventData> remoteBranchesCreated;
+            if (events.TryGetValue(EventType.RemoteBranchCreated, out remoteBranchesCreated))
+            {
+                foreach (var evt in remoteBranchesCreated)
+                {
+                    Logger.Trace($"RemoteBranchCreated: {evt.Origin}/{evt.Branch}");
+                    RemoteBranchCreated?.Invoke(evt.Origin, evt.Branch);
+                    eventsProcessed++;
+                }
+            }
+
+            List<EventData> remoteBranchesDeleted;
+            if (events.TryGetValue(EventType.RemoteBranchDeleted, out remoteBranchesDeleted))
+            {
+                foreach (var evt in remoteBranchesDeleted)
+                {
+                    Logger.Trace($"RemoteBranchDeleted: {evt.Origin}/{evt.Branch}");
+                    RemoteBranchDeleted?.Invoke(evt.Origin, evt.Branch);
+                    eventsProcessed++;
+                }
+            }
             return eventsProcessed;
         }
 
@@ -407,5 +448,25 @@ public void Dispose()
         }
 
         protected static ILogging Logger { get; } = Logging.GetLogger<RepositoryWatcher>();
+
+        private enum EventType
+        {
+            None,
+            ConfigChanged,
+            HeadChanged,
+            RepositoryChanged,
+            IndexChanged,
+            RemoteBranchDeleted,
+            RemoteBranchCreated,
+            LocalBranchDeleted,
+            LocalBranchCreated,
+            LocalBranchChanged
+        }
+
+        private class EventData
+        {
+            public string Origin;
+            public string Branch;
+        }
     }
 }

src/GitHub.Api/Git/GitRemote.cs

@@ -3,7 +3,7 @@
 
 namespace GitHub.Unity
 {
-    enum GitRemoteFunction
+    public enum GitRemoteFunction
     {
         Unknown,
         Fetch,
@@ -12,7 +12,7 @@ enum GitRemoteFunction
     }
 
     [Serializable]
-    struct GitRemote
+    public struct GitRemote
     {
         public string Name;
         public string Url;

src/GitHub.Api/Git/IRepository.cs

@@ -45,24 +45,26 @@ public interface IRepository : IEquatable<IRepository>
         /// <summary>
         /// Gets the current remote of the repository.
         /// </summary>
-        ConfigRemote? CurrentRemote { get; set; }
+        GitRemote? CurrentRemote { get; }
         /// <summary>
         /// Gets the current branch of the repository.
         /// </summary>
-        ConfigBranch? CurrentBranch { get; set; }
-        GitStatus CurrentStatus { get; set; }
+        GitBranch? CurrentBranch { get; }
+        GitStatus CurrentStatus { get; }
+        IList<GitRemote> Remotes { get; }
         IEnumerable<GitBranch> LocalBranches { get; }
         IEnumerable<GitBranch> RemoteBranches { get; }
         IUser User { get; set; }
-        IEnumerable<GitLock> CurrentLocks { get; }
+        IList<GitLock> CurrentLocks { get; }
         string CurrentBranchName { get; }
 
-        event Action<GitStatus> OnStatusUpdated;
-        event Action<string> OnActiveBranchChanged;
-        event Action<string> OnActiveRemoteChanged;
+        event Action<GitStatus> OnStatusChanged;
+        event Action<string> OnCurrentBranchChanged;
+        event Action<string> OnCurrentRemoteChanged;
         event Action OnLocalBranchListChanged;
-        event Action OnHeadChanged;
-        event Action<IEnumerable<GitLock>> OnLocksUpdated;
+        event Action OnCurrentBranchUpdated;
+        event Action<IEnumerable<GitLock>> OnLocksChanged;
         event Action OnRepositoryInfoChanged;
+        event Action OnRemoteBranchListChanged;
     }
 }