Added support for cherry-picking commits in a bare repository via the object database.

Author: Jeremy Koritzinsky

LibGit2Sharp.Tests/CherryPickFixture.cs

@@ -126,6 +126,42 @@ public void CanSpecifyConflictFileStrategy(CheckoutFileConflictStrategy conflict
             }
         }
 
+        [Fact]
+        public void CanCherryPickCommit()
+        {
+            string path = SandboxMergeTestRepo();
+            using (var repo = new Repository(path))
+            {
+                var ours = repo.Head.Tip;
+
+                Commit commitToMerge = repo.Branches["fast_forward"].Tip;
+
+                var result = repo.ObjectDatabase.CherryPickCommit(commitToMerge, ours, 0, null);
+
+                Assert.Equal(CherryPickStatus.CherryPicked, result.Status);
+                Assert.Equal(0, result.Conflicts.Count());
+            }
+        }
+
+        [Fact]
+        public void CherryPickWithConflictsReturnsConflicts()
+        {
+            const string conflictBranchName = "conflicts";
+
+            string path = SandboxMergeTestRepo();
+            using (var repo = new Repository(path))
+            {
+                Branch branch = repo.Branches[conflictBranchName];
+                Assert.NotNull(branch);
+
+                var result = repo.ObjectDatabase.CherryPickCommit(branch.Tip, repo.Head.Tip, 0, null);
+
+                Assert.Equal(CherryPickStatus.Conflicts, result.Status);
+                Assert.NotEmpty(result.Conflicts);
+                
+            }
+        }
+
         private Commit AddFileCommitToRepo(IRepository repository, string filename, string content = null)
         {
             Touch(repository.Info.WorkingDirectory, filename, content);

LibGit2Sharp/CherryPickTreeResult.cs

@@ -0,0 +1,48 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace LibGit2Sharp
+{
+    /// <summary>
+    /// Class to report the result of a cherry picked.
+    /// </summary>
+    public class CherryPickTreeResult
+    {
+        /// <summary>
+        /// Needed for mocking purposes.
+        /// </summary>
+        protected CherryPickTreeResult()
+        { }
+
+        internal CherryPickTreeResult(Tree tree)
+        {
+            this.Tree = tree;
+            this.Status = CherryPickStatus.CherryPicked;
+            this.Conflicts = new List<Conflict>();
+        }
+
+        internal CherryPickTreeResult(IEnumerable<Conflict> conflicts)
+        {
+            this.Conflicts = conflicts;
+            this.Status = CherryPickStatus.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 CherryPickStatus Status { get; private set; }
+    }
+}

LibGit2Sharp/Core/NativeMethods.cs

@@ -1862,6 +1862,14 @@ internal static extern unsafe int git_treebuilder_insert(
         [DllImport(libgit2)]
         internal static extern unsafe int git_cherrypick(git_repository* repo, git_object* commit, GitCherryPickOptions options);
 
+        [DllImport(libgit2)]
+        internal static extern unsafe int git_cherrypick_commit(out git_index* index,
+            git_repository* repo,
+            git_object* cherrypick_commit,
+            git_object* our_commit,
+            uint mainline,
+            ref GitMergeOpts options);
+
         [DllImport(libgit2)]
         internal static extern int git_transaction_commit(IntPtr txn);
 

LibGit2Sharp/Core/Proxy.cs

@@ -325,6 +325,22 @@ internal static unsafe void git_cherrypick(RepositoryHandle repo, ObjectId commi
                 Ensure.ZeroResult(res);
             }
         }
+
+        internal static unsafe IndexHandle git_cherrypick_commit(RepositoryHandle repo, ObjectHandle cherrypickCommit, ObjectHandle ourCommit, uint mainline, GitMergeOpts opts, out bool earlyStop)
+        {
+            git_index* index;
+            int res = NativeMethods.git_cherrypick_commit(out index, repo, cherrypickCommit, 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_clone_

LibGit2Sharp/LibGit2Sharp.csproj

@@ -70,6 +70,7 @@
     <Compile Include="CheckoutOptions.cs" />
     <Compile Include="CherryPickOptions.cs" />
     <Compile Include="CherryPickResult.cs" />
+    <Compile Include="CherryPickTreeResult.cs" />
     <Compile Include="CloneOptions.cs" />
     <Compile Include="CommitFilter.cs" />
     <Compile Include="CommitOptions.cs" />
@@ -393,4 +394,4 @@
   </Target>
   -->
   <ItemGroup />
-</Project>
+</Project>

LibGit2Sharp/ObjectDatabase.cs

@@ -541,6 +541,80 @@ public virtual HistoryDivergence CalculateHistoryDivergence(Commit one, Commit a
             return new HistoryDivergence(repo, one, another);
         }
 
+        /// <summary>
+        /// Performs a cherry-pick of <paramref name="cherryPickCommit"/> onto <paramref name="ours"/> commit.
+        /// </summary>
+        /// <param name="cherryPickCommit">The commit to cherry-pick.</param>
+        /// <param name="ours">The commit to cherry-pick onto.</param>
+        /// <param name="mainline">Which commit to consider the parent for the diff when cherry-picking a merge commit.</param>
+        /// <param name="options">The options for the merging in the cherry-pick operation.</param>
+        /// <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(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, cherryPickCommit.Id, GitObjectType.Commit))
+            using (var indexHandle = Proxy.git_cherrypick_commit(repo.Handle, cherryPickCommitHandle, ourHandle, (uint)mainline, opts, out earlyStop))
+            {
+                CherryPickTreeResult cherryPickResult;
+
+                // Stopped due to FailOnConflict so there's no index or conflict list
+                if (earlyStop)
+                {
+                    return new CherryPickTreeResult(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);
+                        }
+                    }
+                    cherryPickResult = new CherryPickTreeResult(conflicts);
+                }
+                else
+                {
+                    var treeId = Proxy.git_index_write_tree_to(indexHandle, repo.Handle);
+                    cherryPickResult = new CherryPickTreeResult(this.repo.Lookup<Tree>(treeId));
+                }
+
+                return cherryPickResult;
+            }
+        }
+
         /// <summary>
         /// Calculates the current shortest abbreviated <see cref="ObjectId"/>
         /// string representation for a <see cref="GitObject"/>.