Introduce ObjectDatabase.MergeCommits

Provide an API to merge two commits and return the result.  If
successful, a new tree will be written to the object database that
reflects the results of the merge.  If the merge had conflicts, a
ConflictCollection will be provided.

Author: Edward Thomson

LibGit2Sharp.Tests/MergeFixture.cs

@@ -748,6 +748,106 @@ public void CanMergeIntoOrphanedBranch()
             }
         }
 
+
+        [Fact]
+        public void CanMergeTreeIntoSameTree()
+        {
+            string path = SandboxMergeTestRepo();
+            using (var repo = new Repository(path))
+            {
+                var master = repo.Branches["master"].Tip;
+
+                var result = repo.ObjectDatabase.MergeCommits(master, master, null);
+                Assert.Equal(MergeTreeStatus.Succeeded, result.Status);
+                Assert.Equal(0, result.Conflicts.Count());
+            }
+        }
+
+        [Fact]
+        public void CanMergeTreeIntoTreeFromUnbornBranch()
+        {
+            string path = SandboxMergeTestRepo();
+            using (var repo = new Repository(path))
+            {
+                repo.Refs.UpdateTarget("HEAD", "refs/heads/unborn");
+
+                Touch(repo.Info.WorkingDirectory, "README", "Yeah!\n");
+                repo.Index.Clear();
+                repo.Stage("README");
+
+                repo.Commit("A new world, free of the burden of the history", Constants.Signature, Constants.Signature);
+
+                var master = repo.Branches["master"].Tip;
+                var branch = repo.Branches["unborn"].Tip;
+
+                var result = repo.ObjectDatabase.MergeCommits(master, branch, null);
+                Assert.Equal(MergeTreeStatus.Succeeded, result.Status);
+                Assert.NotNull(result.Tree);
+                Assert.Equal(0, result.Conflicts.Count());
+            }
+        }
+
+        [Fact]
+        public void CanMergeCommitsAndDetectConflicts()
+        {
+            string path = SandboxMergeTestRepo();
+            using (var repo = new Repository(path))
+            {
+                repo.Refs.UpdateTarget("HEAD", "refs/heads/unborn");
+
+                repo.Index.Replace(repo.Lookup<Commit>("conflicts"));
+
+                repo.Commit("A conflicting world, free of the burden of the history", Constants.Signature, Constants.Signature);
+
+                var master = repo.Branches["master"].Tip;
+                var branch = repo.Branches["unborn"].Tip;
+
+                var result = repo.ObjectDatabase.MergeCommits(master, branch, null);
+                Assert.Equal(MergeTreeStatus.Conflicts, result.Status);
+                Assert.Null(result.Tree);
+                Assert.NotEqual(0, result.Conflicts.Count());
+            }
+        }
+
+        [Fact]
+        public void CanMergeFastForwardTreeWithoutConflicts()
+        {
+            string path = SandboxMergeTestRepo();
+            using (var repo = new Repository(path))
+            {
+                var master = repo.Lookup<Commit>("master");
+                var branch = repo.Lookup<Commit>("fast_forward");
+
+                var result = repo.ObjectDatabase.MergeCommits(master, branch, null);
+                Assert.Equal(MergeTreeStatus.Succeeded, result.Status);
+                Assert.NotNull(result.Tree);
+                Assert.Equal(0, result.Conflicts.Count());
+            }
+        }
+
+        [Fact]
+        public void CanIdentifyConflictsInMergeCommits()
+        {
+            string path = SandboxMergeTestRepo();
+            using (var repo = new Repository(path))
+            {
+                var master = repo.Lookup<Commit>("master");
+                var branch = repo.Lookup<Commit>("conflicts");
+
+                var result = repo.ObjectDatabase.MergeCommits(master, branch, null);
+
+                Assert.Equal(MergeTreeStatus.Conflicts, result.Status);
+
+                Assert.Null(result.Tree);
+                Assert.Equal(1, result.Conflicts.Count());
+
+                var conflict = result.Conflicts.First();
+                Assert.Equal(new ObjectId("8e9daea300fbfef6c0da9744c6214f546d55b279"), conflict.Ancestor.Id);
+                Assert.Equal(new ObjectId("610b16886ca829cebd2767d9196f3c4378fe60b5"), conflict.Ours.Id);
+                Assert.Equal(new ObjectId("3dd9738af654bbf1c363f6c3bbc323bacdefa179"), conflict.Theirs.Id);
+            }
+        }
+
         private Commit AddFileCommitToRepo(IRepository repository, string filename, string content = null)
         {
             Touch(repository.Info.WorkingDirectory, filename, content);

LibGit2Sharp/Core/Handles/ConflictIteratorSafeHandle.cs

@@ -0,0 +1,11 @@
+namespace LibGit2Sharp.Core.Handles
+{
+    internal class ConflictIteratorSafeHandle : SafeHandleBase
+    {
+        protected override bool ReleaseHandleImpl()
+        {
+            Proxy.git_index_conflict_iterator_free(handle);
+            return true;
+        }
+    }
+}

LibGit2Sharp/Core/NativeMethods.cs

@@ -542,6 +542,22 @@ internal static extern int git_index_conflict_get(
             IndexSafeHandle index,
             [MarshalAs(UnmanagedType.CustomMarshaler, MarshalCookie = UniqueId.UniqueIdentifier, MarshalTypeRef = typeof(StrictFilePathMarshaler))] FilePath path);
 
+        [DllImport(libgit2)]
+        internal static extern int git_index_conflict_iterator_new(
+            out ConflictIteratorSafeHandle iterator,
+            IndexSafeHandle index);
+
+        [DllImport(libgit2)]
+        internal static extern int git_index_conflict_next(
+            out IndexEntrySafeHandle ancestor,
+            out IndexEntrySafeHandle ours,
+            out IndexEntrySafeHandle theirs,
+            ConflictIteratorSafeHandle iterator);
+
+        [DllImport(libgit2)]
+        internal static extern void git_index_conflict_iterator_free(
+            IntPtr iterator);
+
         [DllImport(libgit2)]
         internal static extern UIntPtr git_index_entrycount(IndexSafeHandle index);
 
@@ -602,6 +618,9 @@ internal static extern IndexReucEntrySafeHandle git_index_reuc_get_bypath(
         [DllImport(libgit2)]
         internal static extern int git_index_write_tree(out GitOid treeOid, IndexSafeHandle index);
 
+        [DllImport(libgit2)]
+        internal static extern int git_index_write_tree_to(out GitOid treeOid, IndexSafeHandle index, RepositorySafeHandle repo);
+
         [DllImport(libgit2)]
         internal static extern int git_index_read_tree(IndexSafeHandle index, GitObjectSafeHandle tree);
 
@@ -661,12 +680,11 @@ internal static extern int git_merge(
             ref GitCheckoutOpts checkout_opts);
 
         [DllImport(libgit2)]
-        internal static extern int git_merge_trees(
+        internal static extern int git_merge_commits(
             out IndexSafeHandle index,
             RepositorySafeHandle repo,
-            GitObjectSafeHandle ancestor_tree,
-            GitObjectSafeHandle our_tree,
-            GitObjectSafeHandle their_tree,
+            GitObjectSafeHandle our_commit,
+            GitObjectSafeHandle their_commit,
             ref GitMergeOpts merge_opts);
 
         [DllImport(libgit2)]

LibGit2Sharp/Core/Proxy.cs

@@ -939,6 +939,50 @@ public static Conflict git_index_conflict_get(
                 IndexEntry.BuildFromPtr(theirs));
         }
 
+        public static ConflictIteratorSafeHandle git_index_conflict_iterator_new(IndexSafeHandle index)
+        {
+            using (ThreadAffinity())
+            {
+                ConflictIteratorSafeHandle iter;
+                int res = NativeMethods.git_index_conflict_iterator_new(out iter, index);
+                Ensure.ZeroResult(res);
+
+                return iter;
+            }
+        }
+
+        public static Conflict git_index_conflict_next(ConflictIteratorSafeHandle iterator)
+        {
+            IndexEntrySafeHandle ancestor, ours, theirs;
+
+            using (ThreadAffinity())
+            {
+                int res = NativeMethods.git_index_conflict_next(out ancestor, out ours, out theirs, iterator);
+
+                if (res == (int)GitErrorCode.IterOver)
+                {
+                    return null;
+                }
+
+                Ensure.ZeroResult(res);
+
+                using (ancestor)
+                using (ours)
+                using (theirs)
+                {
+                    return new Conflict(
+                        IndexEntry.BuildFromPtr(ancestor),
+                        IndexEntry.BuildFromPtr(ours),
+                        IndexEntry.BuildFromPtr(theirs));
+                }
+            }
+        }
+
+        public static void git_index_conflict_iterator_free(IntPtr iterator)
+        {
+            NativeMethods.git_index_conflict_iterator_free(iterator);
+        }
+
         public static int git_index_entrycount(IndexSafeHandle index)
         {
             UIntPtr count = NativeMethods.git_index_entrycount(index);
@@ -1053,12 +1097,24 @@ public static void git_index_write(IndexSafeHandle index)
             }
         }
 
-        public static ObjectId git_tree_create_fromindex(Index index)
+        public static ObjectId git_index_write_tree(IndexSafeHandle index)
+        {
+            using (ThreadAffinity())
+            {
+                GitOid treeOid;
+                int res = NativeMethods.git_index_write_tree(out treeOid, index);
+                Ensure.ZeroResult(res);
+
+                return treeOid;
+            }
+        }
+
+        public static ObjectId git_index_write_tree_to(IndexSafeHandle index, RepositorySafeHandle repo)
         {
             using (ThreadAffinity())
             {
                 GitOid treeOid;
-                int res = NativeMethods.git_index_write_tree(out treeOid, index.Handle);
+                int res = NativeMethods.git_index_write_tree_to(out treeOid, index, repo);
                 Ensure.ZeroResult(res);
 
                 return treeOid;
@@ -1087,13 +1143,12 @@ public static void git_index_clear(Index index)
 
         #region git_merge_
 
-        public static IndexSafeHandle git_merge_trees(RepositorySafeHandle repo, GitObjectSafeHandle ancestorTree, GitObjectSafeHandle ourTree, GitObjectSafeHandle theirTree)
+        public static IndexSafeHandle git_merge_commits(RepositorySafeHandle repo, GitObjectSafeHandle ourCommit, GitObjectSafeHandle theirCommit, GitMergeOpts opts)
         {
             using (ThreadAffinity())
             {
                 IndexSafeHandle index;
-                GitMergeOpts opts = new GitMergeOpts { Version = 1 };
-                int res = NativeMethods.git_merge_trees(out index, repo, ancestorTree, ourTree, theirTree, ref opts);
+                int res = NativeMethods.git_merge_commits(out index, repo, ourCommit, theirCommit, ref opts);
                 Ensure.ZeroResult(res);
 
                 return index;

LibGit2Sharp/LibGit2Sharp.csproj

@@ -69,6 +69,7 @@
     <Compile Include="CommitSortStrategies.cs" />
     <Compile Include="CompareOptions.cs" />
     <Compile Include="Core\Platform.cs" />
+    <Compile Include="Core\Handles\ConflictIteratorSafeHandle.cs" />
     <Compile Include="DescribeOptions.cs" />
     <Compile Include="DescribeStrategy.cs" />
     <Compile Include="Core\GitDescribeFormatOptions.cs" />
@@ -101,6 +102,8 @@
     <Compile Include="IndexNameEntry.cs" />
     <Compile Include="MergeOptions.cs" />
     <Compile Include="MergeResult.cs" />
+    <Compile Include="MergeTreeOptions.cs" />
+    <Compile Include="MergeTreeResult.cs" />
     <Compile Include="NotFoundException.cs" />
     <Compile Include="GitObjectMetadata.cs" />
     <Compile Include="PatchEntryChanges.cs" />

LibGit2Sharp/MergeOptions.cs

@@ -132,41 +132,4 @@ public enum FastForwardStrategy
         /// </summary>
         FastForwardOnly = 2, /* GIT_MERGE_FASTFORWARD_ONLY */
     }
-
-    /// <summary>
-    /// Enum specifying how merge should deal with conflicting regions
-    /// of the files.
-    /// </summary>
-    public enum MergeFileFavor
-    {
-        /// <summary>
-        /// When a region of a file is changed in both branches, a conflict
-        /// will be recorded in the index so that the checkout operation can produce
-        /// a merge file with conflict markers in the working directory.
-        /// This is the default.
-        /// </summary>
-        Normal = 0,
-
-        /// <summary>
-        /// When a region of a file is changed in both branches, the file
-        /// created in the index will contain the "ours" side of any conflicting
-        /// region. The index will not record a conflict.
-        /// </summary>
-        Ours = 1,
-
-        /// <summary>
-        /// When a region of a file is changed in both branches, the file
-        /// created in the index will contain the "theirs" side of any conflicting
-        /// region. The index will not record a conflict.
-        /// </summary>
-        Theirs = 2,
-
-        /// <summary>
-        /// When a region of a file is changed in both branches, the file
-        /// created in the index will contain each unique line from each side,
-        /// which has the result of combining both files. The index will not
-        /// record a conflict.
-        /// </summary>
-        Union = 3,
-    }
 }