Issue-1471 Added functionality to add and prune worktrees

Author: mminns

LibGit2Sharp.Tests/WorktreeFixture.cs

@@ -1,6 +1,7 @@
 using LibGit2Sharp.Tests.TestHelpers;
 using System;
 using System.Collections.Generic;
+using System.IO;
 using System.Linq;
 using System.Text;
 using System.Threading.Tasks;
@@ -86,7 +87,7 @@ public void CanUnlockWorktree()
 
                 worktreeLocked.Unlock();
 
-                // not locked
+                // unlocked
                 var worktreeUnlocked = repo.Worktrees["logo"];
                 Assert.Equal("logo", worktreeLocked.Name);
                 Assert.False(worktreeUnlocked.IsLocked);
@@ -101,15 +102,15 @@ public void CanLockWorktree()
             var repoPath = testpath;
             using (var repo = new Repository(repoPath))
             {
-                // locked
+                // unlocked
                 var worktreeUnlocked = repo.Worktrees["i-do-numbers"];
                 Assert.Equal("i-do-numbers", worktreeUnlocked.Name);
                 Assert.False(worktreeUnlocked.IsLocked);
                 Assert.Null(worktreeUnlocked.LockReason);
 
                 worktreeUnlocked.Lock("add a lock");
 
-                // not locked
+                // locked
                 var worktreeLocked = repo.Worktrees["i-do-numbers"];
                 Assert.Equal("i-do-numbers", worktreeLocked.Name);
                 Assert.True(worktreeLocked.IsLocked);
@@ -131,5 +132,136 @@ public void CanGetRepositoryForWorktree()
                 Assert.NotNull(worktreeRepo);
             }
         }
+
+        [Fact]
+        public void CanPruneUnlockedWorktree()
+        {
+            var repoPath = SandboxWorktreeTestRepo();
+            using (var repo = new Repository(repoPath))
+            {
+                Assert.Equal(2, repo.Worktrees.Count());
+
+                // unlocked
+                var worktreeUnlocked = repo.Worktrees["i-do-numbers"];
+                Assert.Equal("i-do-numbers", worktreeUnlocked.Name);
+                Assert.False(worktreeUnlocked.IsLocked);
+
+                Assert.True(repo.Worktrees.Prune(worktreeUnlocked));
+
+                Assert.Single(repo.Worktrees);
+            }
+        }
+
+        [Fact]
+        public void CanNotPruneLockedWorktree()
+        {
+            var repoPath = SandboxWorktreeTestRepo();
+            using (var repo = new Repository(repoPath))
+            {
+                Assert.Equal(2, repo.Worktrees.Count());
+
+                // locked
+                var worktreeUnlocked = repo.Worktrees["logo"];
+                Assert.Equal("logo", worktreeUnlocked.Name);
+                Assert.True(worktreeUnlocked.IsLocked);
+
+                Assert.Throws<LibGit2SharpException>(() => repo.Worktrees.Prune(worktreeUnlocked));
+            }
+        }
+
+        [Fact]
+        public void CanUnlockThenPruneLockedWorktree()
+        {
+            var repoPath = SandboxWorktreeTestRepo();
+            using (var repo = new Repository(repoPath))
+            {
+                Assert.Equal(2, repo.Worktrees.Count());
+
+                // locked
+                var worktreeLocked = repo.Worktrees["logo"];
+                Assert.Equal("logo", worktreeLocked.Name);
+                Assert.True(worktreeLocked.IsLocked);
+
+                worktreeLocked.Unlock();
+
+                repo.Worktrees.Prune(worktreeLocked);
+
+                Assert.Single(repo.Worktrees);
+            }
+        }
+
+        [Fact]
+        public void CanForcePruneLockedWorktree()
+        {
+            var repoPath = SandboxWorktreeTestRepo();
+            using (var repo = new Repository(repoPath))
+            {
+                Assert.Equal(2, repo.Worktrees.Count());
+
+                // locked
+                var worktreeLocked = repo.Worktrees["logo"];
+                Assert.Equal("logo", worktreeLocked.Name);
+                Assert.True(worktreeLocked.IsLocked);
+
+                repo.Worktrees.Prune(worktreeLocked, true);
+
+                Assert.Single(repo.Worktrees);
+            }
+        }
+
+        [Fact]
+        public void CanAddWorktree()
+        {
+            var repoPath = SandboxWorktreeTestRepo();
+            using (var repo = new Repository(repoPath))
+            {
+                Assert.Equal(2, repo.Worktrees.Count());
+
+                var name = "blah";
+                var path = Path.Combine(repo.Info.WorkingDirectory, @"..\worktrees", name);
+                var worktree = repo.Worktrees.Add(name, path, false);
+                Assert.Equal(name, worktree.Name);
+                Assert.False(worktree.IsLocked);
+
+                Assert.Equal(3, repo.Worktrees.Count());
+            }
+        }
+
+        [Fact]
+        public void CanAddLockedWorktree()
+        {
+            var repoPath = SandboxWorktreeTestRepo();
+            using (var repo = new Repository(repoPath))
+            {
+                Assert.Equal(2, repo.Worktrees.Count());
+
+                var name = "blah";
+                var path = Path.Combine(repo.Info.WorkingDirectory, @"..\worktrees", name);
+                var worktree = repo.Worktrees.Add(name, path, true);
+                Assert.Equal(name, worktree.Name);
+                Assert.True(worktree.IsLocked);
+
+                Assert.Equal(3, repo.Worktrees.Count());
+            }
+        }
+
+        [Fact]
+        public void CanAddWorktreeForCommittish()
+        {
+            var repoPath = SandboxWorktreeTestRepo();
+            using (var repo = new Repository(repoPath))
+            {
+                Assert.Equal(2, repo.Worktrees.Count());
+
+                var name = "blah";
+                var committish = "diff-test-cases";
+                var path = Path.Combine(repo.Info.WorkingDirectory, @"..\worktrees", name);
+                var worktree = repo.Worktrees.Add(committish, name, path, false);
+                Assert.Equal(name, worktree.Name);
+                Assert.False(worktree.IsLocked);
+                Assert.Equal(committish, worktree.WorktreeRepository.Head.FriendlyName);
+                Assert.Equal(3, repo.Worktrees.Count());
+            }
+        }
     }
 }

LibGit2Sharp/Core/GitWorktree.cs

@@ -0,0 +1,47 @@
+using System;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+using System.Text;
+
+namespace LibGit2Sharp.Core
+{
+    /**
+    * Flags which can be passed to git_worktree_prune to alter its
+    * behavior.
+    */
+    [Flags]
+    internal enum GitWorktreePruneOptionFlags : uint
+    {
+        /// <summary>
+        /// Prune working tree even if working tree is valid
+        /// </summary>
+        GIT_WORKTREE_PRUNE_VALID = (1u << 0),
+
+        /// <summary>
+        /// Prune working tree even if it is locked
+        /// </summary>
+        GIT_WORKTREE_PRUNE_LOCKED = (1u << 1),
+
+        /// <summary>
+        /// Prune checked out working tree
+        /// </summary>
+        GIT_WORKTREE_PRUNE_WORKING_TREE = (1u << 2)
+    }
+
+
+    [StructLayout(LayoutKind.Sequential)]
+    internal class git_worktree_add_options
+    {
+        public uint version = 1;
+        
+        public int locked;
+    }
+
+    [StructLayout(LayoutKind.Sequential)]
+    internal class git_worktree_prune_options
+    {
+        public uint version = 1;
+
+        public GitWorktreePruneOptionFlags flags;
+    }
+}

LibGit2Sharp/Core/NativeMethods.cs

@@ -1926,6 +1926,18 @@ internal static extern unsafe int git_worktree_lock(
         internal static extern unsafe int git_worktree_unlock(
             git_worktree* worktree);
 
+        [DllImport(libgit2)]
+        internal static extern unsafe int git_worktree_add (
+            out git_worktree* reference,
+            git_repository* repo,
+            [MarshalAs(UnmanagedType.CustomMarshaler, MarshalCookie = UniqueId.UniqueIdentifier, MarshalTypeRef = typeof(StrictUtf8Marshaler))] string name,
+            [MarshalAs(UnmanagedType.CustomMarshaler, MarshalCookie = UniqueId.UniqueIdentifier, MarshalTypeRef = typeof(StrictUtf8Marshaler))] string path,
+            git_worktree_add_options options);
+
+        [DllImport(libgit2)]
+        internal static extern unsafe int git_worktree_prune(
+            git_worktree* worktree,
+            git_worktree_prune_options options);
     }
 }
 // ReSharper restore InconsistentNaming

LibGit2Sharp/Core/Proxy.cs

@@ -3549,6 +3549,26 @@ public static unsafe bool git_worktree_lock(WorktreeHandle worktree, string reas
             return res == (int)GitErrorCode.Ok;
         }
 
+        public static unsafe WorktreeHandle git_worktree_add(
+            RepositoryHandle repo,
+            string name,
+            string path,
+            git_worktree_add_options options)
+        {
+            git_worktree* worktree;
+            int res = NativeMethods.git_worktree_add(out worktree, repo, name, path, options);
+            Ensure.ZeroResult(res);
+            return new WorktreeHandle(worktree, true);
+        }
+
+        public static unsafe bool git_worktree_prune(WorktreeHandle worktree,
+            git_worktree_prune_options options)
+        {
+            int res = NativeMethods.git_worktree_prune(worktree, options);
+            Ensure.ZeroResult(res);
+            return true;
+        }
+
         #endregion
 
         private static ICollection<TResult> git_foreach<T, TResult>(

LibGit2Sharp/IRepository.cs

@@ -69,6 +69,11 @@ public interface IRepository : IDisposable
         /// </summary>
         SubmoduleCollection Submodules { get; }
 
+        /// <summary>
+        /// Worktrees in the repository.
+        /// </summary>
+        WorktreeCollection Worktrees { get; }
+
         /// <summary>
         /// Checkout the specified tree.
         /// </summary>

LibGit2Sharp/Worktree.cs

@@ -81,7 +81,7 @@ public bool Equals(Worktree other)
         /// <summary>
         ///  Unlock the worktree
         /// </summary>
-        public void Unlock()
+        public virtual void Unlock()
         {
             Proxy.git_worktree_unlock(handle);
             this.worktreeLock = Proxy.git_worktree_is_locked(handle);
@@ -90,7 +90,7 @@ public void Unlock()
         /// <summary>
         ///  Lock the worktree
         /// </summary>
-        public void Lock(string reason)
+        public virtual void Lock(string reason)
         {
             Proxy.git_worktree_lock(handle, reason);
             this.worktreeLock = Proxy.git_worktree_is_locked(handle);
@@ -123,5 +123,7 @@ private string DebuggerDisplay
         }
 
         IRepository IBelongToARepository.Repository { get { return parent; } }
+
+        internal WorktreeHandle Handle { get { return this.handle; } }
     }
 }