Issue-1471 Added functionality to apply or remove locks.

Author: mminns

LibGit2Sharp.Tests/WorktreeFixture.cs

@@ -71,6 +71,52 @@ public void CanViewLockStatusForWorktrees()
             }
         }
 
+        [Fact]
+        public void CanUnlockWorktree()
+        {
+            var testpath = SandboxWorktreeTestRepo();
+            var repoPath = testpath;
+            using (var repo = new Repository(repoPath))
+            {
+                // locked
+                var worktreeLocked = repo.Worktrees["logo"];
+                Assert.Equal("logo", worktreeLocked.Name);
+                Assert.True(worktreeLocked.IsLocked);
+                Assert.Equal("Test lock reason\n", worktreeLocked.LockReason);
+
+                worktreeLocked.Unlock();
+
+                // not locked
+                var worktreeUnlocked = repo.Worktrees["logo"];
+                Assert.Equal("logo", worktreeLocked.Name);
+                Assert.False(worktreeUnlocked.IsLocked);
+                Assert.Null(worktreeUnlocked.LockReason);
+            }
+        }
+
+        [Fact]
+        public void CanLockWorktree()
+        {
+            var testpath = SandboxWorktreeTestRepo();
+            var repoPath = testpath;
+            using (var repo = new Repository(repoPath))
+            {
+                // locked
+                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
+                var worktreeLocked = repo.Worktrees["i-do-numbers"];
+                Assert.Equal("i-do-numbers", worktreeLocked.Name);
+                Assert.True(worktreeLocked.IsLocked);
+                Assert.Equal("add a lock", worktreeLocked.LockReason);
+            }
+        }
+
         [Fact]
         public void CanGetRepositoryForWorktree()
         {

LibGit2Sharp/Core/NativeMethods.cs

@@ -1913,6 +1913,15 @@ internal static extern unsafe int git_worktree_is_locked(
         internal static extern unsafe int git_worktree_validate(
             git_worktree* worktree);
 
+        [DllImport(libgit2)]
+        internal static extern unsafe int git_worktree_lock(
+            git_worktree* worktree,
+            [MarshalAs(UnmanagedType.CustomMarshaler, MarshalCookie = UniqueId.UniqueIdentifier, MarshalTypeRef = typeof(StrictUtf8Marshaler))] string reason);
+
+        [DllImport(libgit2)]
+        internal static extern unsafe int git_worktree_unlock(
+            git_worktree* worktree);
+
     }
 }
 // ReSharper restore InconsistentNaming

LibGit2Sharp/Core/Proxy.cs

@@ -3531,6 +3531,21 @@ public static unsafe WorktreeLock git_worktree_is_locked(WorktreeHandle worktree
         public static unsafe bool git_worktree_validate(WorktreeHandle worktree)
         {
             int res = NativeMethods.git_worktree_validate(worktree);
+
+            return res == (int)GitErrorCode.Ok;
+        }
+
+        public static unsafe bool git_worktree_unlock(WorktreeHandle worktree)
+        {
+            int res = NativeMethods.git_worktree_unlock(worktree);
+
+            return res == (int)GitErrorCode.Ok;
+        }
+
+        public static unsafe bool git_worktree_lock(WorktreeHandle worktree, string reason)
+        {
+            int res = NativeMethods.git_worktree_lock(worktree, reason);
+
             return res == (int)GitErrorCode.Ok;
         }
 

LibGit2Sharp/Worktree.cs

@@ -1,4 +1,5 @@
 using LibGit2Sharp.Core;
+using LibGit2Sharp.Core.Handles;
 using System;
 using System.Collections.Generic;
 using System.Diagnostics;
@@ -16,19 +17,21 @@ public class Worktree : IEquatable<Worktree>, IBelongToARepository
         private static readonly LambdaEqualityHelper<Worktree> equalityHelper =
             new LambdaEqualityHelper<Worktree>(x => x.Name);
 
+        private readonly WorktreeHandle handle;
         private readonly Repository parent;
         private readonly Repository worktree;
         private readonly string name;
-        private readonly WorktreeLock worktreeLock;
+        private WorktreeLock worktreeLock;
 
         /// <summary>
         /// Needed for mocking purposes.
         /// </summary>
         protected Worktree()
         { }
 
-        internal Worktree(Repository repo, string name, Repository worktree, WorktreeLock worktreeLock)
+        internal Worktree(WorktreeHandle handle, Repository repo, string name, Repository worktree, WorktreeLock worktreeLock)
         {
+            this.handle = Proxy.git_worktree_lookup(repo.Handle, name);
             this.parent = repo;
             this.name = name;
             this.worktree = worktree;
@@ -75,6 +78,24 @@ public bool Equals(Worktree other)
             return equalityHelper.Equals(this, other);
         }
 
+        /// <summary>
+        ///  Unlock the worktree
+        /// </summary>
+        public void Unlock()
+        {
+            Proxy.git_worktree_unlock(handle);
+            this.worktreeLock = Proxy.git_worktree_is_locked(handle);
+        }
+        
+        /// <summary>
+        ///  Lock the worktree
+        /// </summary>
+        public void Lock(string reason)
+        {
+            Proxy.git_worktree_lock(handle, reason);
+            this.worktreeLock = Proxy.git_worktree_is_locked(handle);
+        }
+
         /// <summary>
         /// Returns the hash code for this instance.
         /// </summary>

LibGit2Sharp/WorktreeCollection.cs

@@ -40,7 +40,7 @@ public virtual Worktree this[string name]
             {
                 Ensure.ArgumentNotNullOrEmptyString(name, "name");
 
-                return Lookup(name, handle => new Worktree(repo,
+                return Lookup(name, handle => new Worktree(handle, repo,
                     name,
                     new Repository(handle),
                     Proxy.git_worktree_is_locked(handle)));
@@ -72,12 +72,9 @@ internal T Lookup<T>(string name, Func<WorktreeHandle, T> selector, bool throwIf
         public virtual IEnumerator<Worktree> GetEnumerator()
         {
             return Proxy.git_worktree_list(repo.Handle)
-                .Select(n => Lookup(n, handle => new Worktree(repo, n,
+                .Select(n => Lookup(n, handle => new Worktree(handle, repo, n,
                     new Repository(handle), Proxy.git_worktree_is_locked(handle))))
                 .GetEnumerator();
-            //return Proxy.git_submodule_foreach(repo.Handle, (h, n) => LaxUtf8Marshaler.FromNative(n))
-            //            .Select(n => this[n])
-            //            .GetEnumerator();
         }
 
         /// <summary>