Merge master into fixes/disable-selected-asset-history-view

Author: shana

docs/process/release-process.md

@@ -0,0 +1,68 @@
+# Release process
+
+## Release information
+
+### Tag name format
+
+***Alpha releases***: `v[major].[minor]-alpha`
+
+***Beta releases***: `v[major].[minor]-beta`
+
+***Releases***: `v[major].[minor]`
+
+## The process
+
+#### TL;DR
+
+1. Dev branches to a release branch every week, create draft release with release notes
+2. QA tests release branch for up to a week
+3. Dev continues work on master
+4. Dev fixes shipblockers on release branch and updates build on draft release page, and makes sure fixes are also sent to master
+5. QA publishes release by tagging the release branch and hitting "Publish"
+6. Goto 1
+
+#### The long explanation
+
+Every week:
+
+1. Create a release branch from master with the name `release/[Major].[Minor]`, where `[Major].[Minor]` are the current major and minor parts of the version set on master.
+1. Bump the version on master
+1. Create a draft release with the release notes, following the format below
+1. Upload a build created from the release branch
+1. QA tests the release and logs any issues found in it. Issues are fixed on the next release unless they are related to the issues that are reported as fixed in the current release, and they are shipblockers.
+1. If the release requires fixes:
+   1. If the fix is reverting a PR, that doesn't have to be done on master, only on the release branch. Otherwise:
+   1. Create a branch from the release branch fork point (the commit that the release branch is based on)
+   1. Push the fix to this branch and create a PR targetting the release branch
+   1. Upload a new build from the release branch
+   1. Create another branch from master, merge the fix branch into it and create a PR targetting master
+1. QA approves release by:
+   1. Filling out the tag name, in the format shown above
+   1. Selecting the release branch corresponding to the build
+   1. Clicking `Publish release`
+
+
+## Template for release notes
+
+The https://github.com/github-for-unity/unity-release-notes node project generates draft release notes by outputting all issues labeled `Feature`, `Enhancement` and `Bug` closed since the last release in the correct format for release notes, and also outputs all PRs closed since the last release, in case some issues might not have been correctly labeled and/or created.
+
+The markdown format for release notes is below. This is what the project above generates (more or less).
+
+```
+# Release notes
+
+[any special notes and/or funny/relevant image for the release here, if needed]
+
+## Features
+
+- #XXX - Title of issue (adjust for user consumption if needed)
+
+## Enhancements
+
+- #XXX - Title of issue (adjust for user consumption if needed)
+
+## Fixes
+
+- #XXX - Title of issue (adjust for user consumption if needed)
+
+```

docs/readme.md

@@ -24,8 +24,9 @@ Details about how the team is organizing and shipping GitHub for Unity:
 
  - **[Issue Triage](process/issue-triage.md)** - how we address issues reported
     by users
- - **[Review Process](process/reviews.md)** - how we review contributions
+ - **[Review](process/reviews.md)** - how we review contributions
  - **[Roadmap](process/roadmap.md)** - how we plan for the future
+ - **[Release](process/release-process.md)** - how we review contributions
 
 ## Technical
 

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;