Added support for revert in a bare repository.

Author: Jeremy Koritzinsky

LibGit2Sharp.Tests/RevertFixture.cs

@@ -458,5 +458,77 @@ public void RevertOrphanedBranchThrows()
                 Assert.Throws<UnbornBranchException>(() => repo.Revert(commitToRevert, Constants.Signature));
             }
         }
+
+        [Fact]
+        public void RevertWithNothingToRevertInObjectDatabaseSucceeds()
+        {
+            // The branch name to perform the revert on
+            const string revertBranchName = "refs/heads/revert";
+
+            string path = SandboxRevertTestRepo();
+            using (var repo = new Repository(path))
+            {
+                // Checkout the revert branch.
+                Branch branch = Commands.Checkout(repo, revertBranchName);
+                Assert.NotNull(branch);
+
+                Commit commitToRevert = repo.Head.Tip;
+
+                // Revert tip commit.
+                RevertResult result = repo.Revert(commitToRevert, Constants.Signature);
+                Assert.NotNull(result);
+                Assert.Equal(RevertStatus.Reverted, result.Status);
+
+                var revertResult = repo.ObjectDatabase.RevertCommit(commitToRevert, repo.Branches[revertBranchName].Tip, 0, null);
+
+                Assert.NotNull(revertResult);
+                Assert.Equal(MergeTreeStatus.Succeeded, revertResult.Status);
+            }
+        }
+
+        [Fact]
+        public void RevertWithConflictReportsConflict()
+       {
+            // The branch name to perform the revert on,
+            // and the file whose contents we expect to be reverted.
+            const string revertBranchName = "refs/heads/revert";
+
+            string path = SandboxRevertTestRepo();
+            using (var repo = new Repository(path))
+            {
+                // The commit to revert - we know that reverting this
+                // specific commit will generate conflicts.
+                Commit commitToRevert = repo.Lookup<Commit>("cb4f7f0eca7a0114cdafd8537332aa17de36a4e9");
+                Assert.NotNull(commitToRevert);
+
+                // Perform the revert and verify there were conflicts.
+                var result = repo.ObjectDatabase.RevertCommit(commitToRevert, repo.Branches[revertBranchName].Tip, 0, null);
+                Assert.NotNull(result);
+                Assert.Equal(MergeTreeStatus.Conflicts, result.Status);
+                Assert.Null(result.Tree);
+            }
+        }
+
+        [Fact]
+        public void CanRevertInObjectDatabase()
+        {
+            // The branch name to perform the revert on,
+            // and the file whose contents we expect to be reverted.
+            const string revertBranchName = "refs/heads/revert";
+
+            string path = SandboxRevertTestRepo();
+            using (var repo = new Repository(path))
+            {
+
+                
+                // Checkout the revert branch.
+                Branch branch = Commands.Checkout(repo, revertBranchName);
+                Assert.NotNull(branch);
+
+                // Revert tip commit.
+                var result = repo.ObjectDatabase.RevertCommit(repo.Head.Tip, repo.Head.Tip, 0, null);
+                Assert.Equal(MergeTreeStatus.Succeeded, result.Status);
+            }
+        }
     }
 }

LibGit2Sharp/Core/NativeMethods.cs

@@ -1503,6 +1503,15 @@ internal static extern unsafe int git_revert(
             git_object* commit,
             GitRevertOpts opts);
 
+        [DllImport(libgit2)]
+        internal static extern unsafe int git_revert_commit(
+            out git_index* index,
+            git_repository* repo,
+            git_object* revert_commit,
+            git_object* our_commit,
+            uint mainline,
+            ref GitMergeOpts opts);
+
         [DllImport(libgit2)]
         internal static extern unsafe int git_revparse_ext(
             out git_object* obj,

LibGit2Sharp/Core/Proxy.cs

@@ -2670,6 +2670,21 @@ public static unsafe void git_revert(
             }
         }
 
+        internal static unsafe IndexHandle git_revert_commit(RepositoryHandle repo, ObjectHandle revertCommit, ObjectHandle ourCommit, uint mainline, GitMergeOpts opts, out bool earlyStop)
+        {
+            git_index* index;
+            int res = NativeMethods.git_revert_commit(out index, repo, revertCommit, ourCommit, mainline, ref opts);
+            if (res == (int)GitErrorCode.MergeConflict)
+            {
+                earlyStop = true;
+            }
+            else
+            {
+                earlyStop = false;
+                Ensure.ZeroResult(res);
+            }
+            return new IndexHandle(index, true);
+        }
         #endregion
 
         #region git_revparse_

LibGit2Sharp/LibGit2Sharp.csproj

@@ -161,6 +161,7 @@
     <Compile Include="RenameDetails.cs" />
     <Compile Include="RevertResult.cs" />
     <Compile Include="RevertOptions.cs" />
+    <Compile Include="RevertTreeResult.cs" />
     <Compile Include="SecureUsernamePasswordCredentials.cs" />
     <Compile Include="StageOptions.cs" />
     <Compile Include="StatusOptions.cs" />

LibGit2Sharp/ObjectDatabase.cs

@@ -551,7 +551,7 @@ public virtual HistoryDivergence CalculateHistoryDivergence(Commit one, Commit a
         /// <returns>A result containing a <see cref="Tree"/> if the cherry-pick was successful and a list of <see cref="Conflict"/>s if it is not.</returns>
         public virtual CherryPickTreeResult CherryPickCommit(Commit cherryPickCommit, Commit ours, int mainline, MergeOptions options)
         {
-            Ensure.ArgumentNotNull(cherryPickCommit, "commit");
+            Ensure.ArgumentNotNull(cherryPickCommit, "cherryPickCommit");
             Ensure.ArgumentNotNull(ours, "ours");
 
             options = options ?? new MergeOptions();
@@ -880,5 +880,79 @@ private PackBuilderResults InternalPack(PackBuilderOptions options, Action<PackB
 
             return results;
         }
+
+        /// <summary>
+        /// Performs a revert of <paramref name="revertCommit"/> onto <paramref name="ours"/> commit.
+        /// </summary>
+        /// <param name="revertCommit">The commit to revert.</param>
+        /// <param name="ours">The commit to revert onto.</param>
+        /// <param name="mainline">Which commit to consider the parent for the diff when reverting a merge commit.</param>
+        /// <param name="options">The options for the merging in the revert operation.</param>
+        /// <returns>A result containing a <see cref="Tree"/> if the revert was successful and a list of <see cref="Conflict"/>s if it is not.</returns>
+        public virtual RevertTreeResult RevertCommit(Commit revertCommit, Commit ours, int mainline, MergeOptions options)
+        {
+            Ensure.ArgumentNotNull(revertCommit, "revertCommit");
+            Ensure.ArgumentNotNull(ours, "ours");
+
+            options = options ?? new MergeOptions();
+
+            // We throw away the index after looking at the conflicts, so we'll never need the REUC
+            // entries to be there
+            GitMergeFlag mergeFlags = GitMergeFlag.GIT_MERGE_NORMAL | GitMergeFlag.GIT_MERGE_SKIP_REUC;
+            if (options.FindRenames)
+            {
+                mergeFlags |= GitMergeFlag.GIT_MERGE_FIND_RENAMES;
+            }
+            if (options.FailOnConflict)
+            {
+                mergeFlags |= GitMergeFlag.GIT_MERGE_FAIL_ON_CONFLICT;
+            }
+
+
+            var opts = new GitMergeOpts
+            {
+                Version = 1,
+                MergeFileFavorFlags = options.MergeFileFavor,
+                MergeTreeFlags = mergeFlags,
+                RenameThreshold = (uint)options.RenameThreshold,
+                TargetLimit = (uint)options.TargetLimit
+            };
+
+            bool earlyStop;
+
+            using (var ourHandle = Proxy.git_object_lookup(repo.Handle, ours.Id, GitObjectType.Commit))
+            using (var cherryPickCommitHandle = Proxy.git_object_lookup(repo.Handle, revertCommit.Id, GitObjectType.Commit))
+            using (var indexHandle = Proxy.git_revert_commit(repo.Handle, cherryPickCommitHandle, ourHandle, (uint)mainline, opts, out earlyStop))
+            {
+                RevertTreeResult revertTreeResult;
+
+                // Stopped due to FailOnConflict so there's no index or conflict list
+                if (earlyStop)
+                {
+                    return new RevertTreeResult(new Conflict[] { });
+                }
+
+                if (Proxy.git_index_has_conflicts(indexHandle))
+                {
+                    List<Conflict> conflicts = new List<Conflict>();
+                    Conflict conflict;
+                    using (ConflictIteratorHandle iterator = Proxy.git_index_conflict_iterator_new(indexHandle))
+                    {
+                        while ((conflict = Proxy.git_index_conflict_next(iterator)) != null)
+                        {
+                            conflicts.Add(conflict);
+                        }
+                    }
+                    revertTreeResult = new RevertTreeResult(conflicts);
+                }
+                else
+                {
+                    var treeId = Proxy.git_index_write_tree_to(indexHandle, repo.Handle);
+                    revertTreeResult = new RevertTreeResult(this.repo.Lookup<Tree>(treeId));
+                }
+
+                return revertTreeResult;
+            }
+        }
     }
 }

LibGit2Sharp/RevertTreeResult.cs

@@ -0,0 +1,42 @@
+using System.Collections.Generic;
+
+namespace LibGit2Sharp
+{
+    public class RevertTreeResult
+    {
+        /// <summary>
+        /// Needed for mocking purposes.
+        /// </summary>
+        protected RevertTreeResult()
+        { }
+
+        internal RevertTreeResult(Tree tree)
+        {
+            this.Tree = tree;
+            this.Status = MergeTreeStatus.Succeeded;
+            this.Conflicts = new List<Conflict>();
+        }
+
+        internal RevertTreeResult(IEnumerable<Conflict> conflicts)
+        {
+            this.Conflicts = conflicts;
+            this.Status = MergeTreeStatus.Conflicts;
+        }
+
+        /// <summary>
+        /// The resulting tree of the cherry-pick.
+        /// <para>This will return <code>null</code> if the cherry-pick has been unsuccessful due to conflicts.</para>
+        /// </summary>
+        public virtual Tree Tree { get; private set; }
+
+        /// <summary>
+        /// The resulting conflicts from the cherry-pick.
+        /// </summary>
+        public virtual IEnumerable<Conflict> Conflicts { get; private set; }
+
+        /// <summary>
+        /// The status of the cherry pick.
+        /// </summary>
+        public virtual MergeTreeStatus Status { get; private set; }
+    }
+}