Merge branch 'master' into use-local-zips-when-developing

Author: StanleyGoldman

src/GitHub.Api/Events/RepositoryWatcher.cs

@@ -30,6 +30,7 @@ class RepositoryWatcher : IRepositoryWatcher
         private readonly NPath[] ignoredPaths;
         private readonly ManualResetEventSlim pauseEvent;
         private NativeInterface nativeInterface;
+        private NativeInterface worktreeNativeInterface;
         private bool running;
         private int lastCountOfProcessedEvents = 0;
         private bool processingEvents;
@@ -64,6 +65,11 @@ public void Initialize()
             try
             {
                 nativeInterface = new NativeInterface(pathsRepositoryPath);
+
+                if (paths.IsWorktree)
+                {
+                    worktreeNativeInterface = new NativeInterface(paths.WorktreeDotGitPath);
+                }
             }
             catch (Exception ex)
             {
@@ -80,6 +86,18 @@ public void Start()
             }
 
             Logger.Trace("Watching Path: \"{0}\"", paths.RepositoryPath.ToString());
+
+            if (paths.IsWorktree)
+            {
+                if (worktreeNativeInterface == null)
+                {
+                    Logger.Warning("Worktree NativeInterface is null");
+                    throw new InvalidOperationException("Worktree NativeInterface is null");
+                }
+
+                Logger.Trace("Watching Additional Path for Worktree: \"{0}\"", paths.WorktreeDotGitPath);
+            }
+
             running = true;
             pauseEvent.Reset();
             Task.Factory.StartNew(WatcherLoop, cancellationToken, TaskCreationOptions.None, TaskScheduler.Default);
@@ -131,6 +149,15 @@ public int CheckAndProcessEvents()
                 processedEventCount = ProcessEvents(fileEvents);
             }
 
+            if (worktreeNativeInterface != null)
+            {
+                fileEvents = worktreeNativeInterface.GetEvents();
+                if (fileEvents.Length > 0)
+                {
+                    processedEventCount = processedEventCount + ProcessEvents(fileEvents);
+                }
+            }
+
             lastCountOfProcessedEvents = processedEventCount;
             processingEvents = false;
             signalProcessingEventsDone.Set();
@@ -158,7 +185,7 @@ private int ProcessEvents(Event[] fileEvents)
                 var fileA = eventDirectory.Combine(fileEvent.FileA);
 
                 // handling events in .git/*
-                if (fileA.IsChildOf(paths.DotGitPath))
+                if (fileA.IsChildOf(paths.DotGitPath) || (paths.WorktreeDotGitPath.IsInitialized && fileA.IsChildOf(paths.WorktreeDotGitPath)))
                 {
                     if (!events.Contains(EventType.ConfigChanged) && fileA.Equals(paths.DotGitConfig))
                     {

src/GitHub.Api/Git/RepositoryManager.cs

@@ -60,33 +60,57 @@ interface IRepositoryPathConfiguration
         NPath DotGitIndex { get; }
         NPath DotGitHead { get; }
         NPath DotGitConfig { get; }
+        NPath WorktreeDotGitPath { get; }
+        bool IsWorktree { get; }
     }
 
     class RepositoryPathConfiguration : IRepositoryPathConfiguration
     {
         public RepositoryPathConfiguration(NPath repositoryPath)
         {
             RepositoryPath = repositoryPath;
+            WorktreeDotGitPath = NPath.Default;
 
             DotGitPath = repositoryPath.Combine(".git");
+            NPath commonPath;
             if (DotGitPath.FileExists())
             {
                 DotGitPath =
                     DotGitPath.ReadAllLines()
                               .Where(x => x.StartsWith("gitdir:"))
                               .Select(x => x.Substring(7).Trim().ToNPath())
                               .First();
+                if (DotGitPath.Combine("commondir").FileExists())
+                {
+                    commonPath = DotGitPath.Combine("commondir").ReadAllLines()
+                        .Select(x => x.Trim().ToNPath())
+                        .First();
+                    commonPath = DotGitPath.Combine(commonPath);
+
+                    IsWorktree = true;
+                    WorktreeDotGitPath = commonPath;
+                }
+                else
+                {
+                    commonPath = DotGitPath;
+                }
+            }
+            else
+            {
+                commonPath = DotGitPath;
             }
 
-            BranchesPath = DotGitPath.Combine("refs", "heads");
-            RemotesPath = DotGitPath.Combine("refs", "remotes");
+            BranchesPath = commonPath.Combine("refs", "heads");
+            RemotesPath = commonPath.Combine("refs", "remotes");
             DotGitIndex = DotGitPath.Combine("index");
             DotGitHead = DotGitPath.Combine("HEAD");
-            DotGitConfig = DotGitPath.Combine("config");
+            DotGitConfig = commonPath.Combine("config");
             DotGitCommitEditMsg = DotGitPath.Combine("COMMIT_EDITMSG");
         }
 
+        public bool IsWorktree { get; }
         public NPath RepositoryPath { get; }
+        public NPath WorktreeDotGitPath { get; }
         public NPath DotGitPath { get; }
         public NPath BranchesPath { get; }
         public NPath RemotesPath { get; }

src/GitHub.Api/Platform/DefaultEnvironment.cs

@@ -89,9 +89,9 @@ public void InitializeRepository(NPath? repositoryPath = null)
 
                 expectedRepositoryPath = repositoryPath != null ? repositoryPath.Value : UnityProjectPath;
 
-                if (!expectedRepositoryPath.DirectoryExists(".git"))
+                if (!expectedRepositoryPath.Exists(".git"))
                 {
-                    NPath reporoot = UnityProjectPath.RecursiveParents.FirstOrDefault(d => d.DirectoryExists(".git"));
+                    NPath reporoot = UnityProjectPath.RecursiveParents.FirstOrDefault(d => d.Exists(".git"));
                     if (reporoot.IsInitialized)
                         expectedRepositoryPath = reporoot;
                 }
@@ -102,7 +102,7 @@ public void InitializeRepository(NPath? repositoryPath = null)
             }
 
             FileSystem.SetCurrentDirectory(expectedRepositoryPath);
-            if (expectedRepositoryPath.DirectoryExists(".git"))
+            if (expectedRepositoryPath.Exists(".git"))
             {
                 RepositoryPath = expectedRepositoryPath;
                 Repository = new Repository(RepositoryPath, CacheContainer);