can update reference target

This works for both direct and symbolic references.

Author: tclem

LibGit2Sharp.Tests/ReferenceFixture.cs

@@ -125,6 +125,43 @@ public void CanResolveRefsByName()
             }
         }
 
+        [Test]
+        public void CanUpdateTargetOnReference()
+        {
+            const string masterRef = "refs/heads/master";
+            using (var path = new TemporaryCloneOfTestRepo())
+            using (var repo = new Repository(path.RepositoryPath))
+            {
+                var sha = repo.Refs["refs/heads/test"].ResolveToDirectReference().Target.Sha;
+                var master = repo.Refs[masterRef];
+                master.ResolveToDirectReference().Target.Sha.ShouldNotEqual(sha);
+
+                repo.Refs.UpdateTarget(masterRef, sha);
+
+                master = repo.Refs[masterRef];
+                master.ResolveToDirectReference().Target.Sha.ShouldEqual(sha);
+            }
+        }
+
+        [Test]
+        public void CanUpdateTargetOnSymolicReference()
+        {
+            const string name = "refs/heads/unit_test";
+            using (var path = new TemporaryCloneOfTestRepo())
+            using (var repo = new Repository(path.RepositoryPath))
+            {
+                var newRef = (SymbolicReference) repo.Refs.Create(name, "refs/heads/master");
+                newRef.ShouldNotBeNull();
+
+                repo.Refs.UpdateTarget(newRef.CanonicalName, "refs/heads/test");
+
+                newRef = (SymbolicReference) repo.Refs[newRef.CanonicalName];
+                newRef.ResolveToDirectReference().Target.ShouldEqual(repo.Refs["refs/heads/test"].ResolveToDirectReference().Target);
+
+                repo.Refs.Delete(newRef.CanonicalName);
+            }
+        }
+
         [Test]
         public void CreateWithEmptyStringForTargetThrows()
         {
@@ -200,5 +237,46 @@ public void ResolvingWithNullThrows()
                 Assert.Throws<ArgumentNullException>(() => { var head = repo.Refs[null]; });
             }
         }
+
+        [Test]
+        public void TryingToUpdateADirectRefWithSymbolFails()
+        {
+            const string name = "refs/heads/unit_test";
+            using (var path = new TemporaryCloneOfTestRepo())
+            using (var repo = new Repository(path.RepositoryPath))
+            {
+                var newRef = (SymbolicReference) repo.Refs.Create(name, "refs/heads/master");
+                newRef.ShouldNotBeNull();
+
+                Assert.Throws<ArgumentException>(
+                    () => repo.Refs.UpdateTarget(newRef.CanonicalName, repo.Refs["refs/heads/test"].ResolveToDirectReference().Target.Sha));
+
+                repo.Refs.Delete(newRef.CanonicalName);
+            }
+        }
+
+        [Test]
+        public void TryingToUpdateASymbolicRefWithOidFails()
+        {
+            const string masterRef = "refs/heads/master";
+            using (var path = new TemporaryCloneOfTestRepo())
+            using (var repo = new Repository(path.RepositoryPath))
+            {
+                Assert.Throws<ArgumentException>(() => repo.Refs.UpdateTarget(masterRef, "refs/heads/test"));
+            }
+        }
+
+        [Test]
+        public void UpdateReferenceTargetWithBadParametersFails()
+        {
+            using (var path = new TemporaryCloneOfTestRepo())
+            using (var repo = new Repository(path.RepositoryPath))
+            {
+                Assert.Throws<ArgumentException>(() => repo.Refs.UpdateTarget(string.Empty, "refs/heads/packed"));
+                Assert.Throws<ArgumentException>(() => repo.Refs.UpdateTarget("master", string.Empty));
+                Assert.Throws<ArgumentNullException>(() => repo.Refs.UpdateTarget(null, "refs/heads/packed"));
+                Assert.Throws<ArgumentNullException>(() => repo.Refs.UpdateTarget("master", null));
+            }
+        }
     }
 }

LibGit2Sharp/Core/NativeMethods.cs

@@ -91,6 +91,12 @@ internal class NativeMethods
         [DllImport(libgit2)]
         public static extern int git_reference_resolve(out IntPtr resolvedReference, IntPtr reference);
 
+        [DllImport(libgit2, SetLastError = true)]
+        public static extern int git_reference_set_oid(IntPtr reference, ref GitOid id);
+
+        [DllImport(libgit2, SetLastError = true)]
+        public static extern int git_reference_set_target(IntPtr reference, string target);
+
         [DllImport(libgit2)]
         [return: MarshalAs(UnmanagedType.AnsiBStr)]
         public static extern string git_reference_target(IntPtr reference);

LibGit2Sharp/ReferenceCollection.cs

@@ -131,5 +131,37 @@ internal T Resolve<T>(string name) where T : class
 
             return Reference.BuildFromPtr<T>(reference, repo);
         }
+
+        /// <summary>
+        ///   Updates the target on a reference.
+        /// </summary>
+        /// <param name = "name">The name of the reference.</param>
+        /// <param name = "target">The target which can be either a sha or the name of another reference.</param>
+        public void UpdateTarget(string name, string target)
+        {
+            Ensure.ArgumentNotNullOrEmptyString(name, "name");
+            Ensure.ArgumentNotNullOrEmptyString(target, "target");
+
+            IntPtr reference;
+            var res = NativeMethods.git_reference_lookup(out reference, repo.Handle, name);
+            Ensure.Success(res);
+
+            var id = ObjectId.CreateFromMaybeSha(target);
+            var type = NativeMethods.git_reference_type(reference);
+            switch (type)
+            {
+                case GitReferenceType.Oid:
+                    if (id == null) throw new ArgumentException(String.Format("The reference specified by {0} is an Oid reference, you must provide a sha as the target.", name), "target");
+                    var oid = id.Oid;
+                    res = NativeMethods.git_reference_set_oid(reference, ref oid);
+                    break;
+                case GitReferenceType.Symbolic:
+                    if (id != null) throw new ArgumentException(String.Format("The reference specified by {0} is an Symbolic reference, you must provide a symbol as the target.", name), "target");
+                    res = NativeMethods.git_reference_set_target(reference, target);
+                    break;
+            }
+
+            Ensure.Success(res);
+        }
     }
 }