Introduce basic merging

LibGit2Sharp.Tests/MergeFixture.cs

@@ -1,5 +1,5 @@
-using System.Linq;
-using LibGit2Sharp.Tests.TestHelpers;
+using LibGit2Sharp.Tests.TestHelpers;
+using System.Linq;
 using Xunit;
 
 namespace LibGit2Sharp.Tests
@@ -80,5 +80,45 @@ public void CanRetrieveTheBranchBeingMerged()
                 Assert.Null(mergedHeads[1].Tip);
             }
         }
+
+        [Fact]
+        public void CanMergeRepos()
+        {
+            string path = CloneStandardTestRepo();
+            using (var repo = new Repository(path))
+            {
+                var firstBranch = repo.CreateBranch("FirstBranch");
+                firstBranch.Checkout();
+                var originalTreeCount = firstBranch.Tip.Tree.Count;
+
+                //Commit with ONE new file to both first & second branch (SecondBranch is created on this commit).
+                AddFileCommitToRepo(repo, "first+second branch file");  
+
+                var secondBranch = repo.CreateBranch("SecondBranch");
+                //Commit with ONE new file to first branch (FirstBranch moves forward as it is checked out, SecondBranch stays back one).
+                var firstBranchCommit = AddFileCommitToRepo(repo, "first branch file"); 
+
+                secondBranch.Checkout();
+                //Commit with ONE new file to second branch (FirstBranch and SecondBranch now point to separate commits that both have the same parent commit).
+                var secondBranchCommit = AddFileCommitToRepo(repo, "second branch file");
+
+                MergeResult mergeResult = repo.Merge(repo.Branches["FirstBranch"].Tip);
+
+                var mergeCommit = repo.Commit("Merge First+Second", Constants.Signature, Constants.Signature);
+
+                Assert.Equal(mergeCommit.Tree.Count, originalTreeCount + 3);    //Expecting original tree count plussed by the 3 added files.
+                Assert.Equal(mergeCommit.Parents.Count(), 2);   //Merge commit should have 2 parents
+            }
+        }
+
+        private Commit AddFileCommitToRepo(IRepository repository, string filename, string content = null)
+        {
+            filename = filename + ".txt";
+            Touch(repository.Info.WorkingDirectory, filename, content);
+
+            repository.Index.Stage(filename);
+
+            return repository.Commit("New commit", Constants.Signature, Constants.Signature);
+        }
     }
 }

LibGit2Sharp/Core/GitMergeHead.cs

@@ -0,0 +1,17 @@
+using LibGit2Sharp.Core.Handles;
+using System;
+using System.Runtime.InteropServices;
+
+namespace LibGit2Sharp.Core
+{
+    [StructLayout(LayoutKind.Sequential)]
+    internal struct GitMergeHead
+    {
+	    [MarshalAs(UnmanagedType.CustomMarshaler, MarshalCookie = UniqueId.UniqueIdentifier, MarshalTypeRef = typeof(StrictUtf8Marshaler))] string RefName;
+	    [MarshalAs(UnmanagedType.CustomMarshaler, MarshalCookie = UniqueId.UniqueIdentifier, MarshalTypeRef = typeof(StrictUtf8Marshaler))] string RemoteUrl;
+
+	    GitOid Oid;
+	    [MarshalAs(UnmanagedType.CustomMarshaler, MarshalCookie = UniqueId.UniqueIdentifier, MarshalTypeRef = typeof(StrictUtf8Marshaler))] string OidStr;
+	    GitObjectSafeHandle Commit;
+    }
+}

LibGit2Sharp/Core/GitMergeOpts.cs

@@ -0,0 +1,22 @@
+using System;
+using System.Runtime.InteropServices;
+
+namespace LibGit2Sharp.Core
+{
+    [Flags]
+    internal enum MergeFlags
+    {
+        GIT_MERGE_NO_FASTFORWARD = 1,
+        GIT_MERGE_FASTFORWARD_ONLY = 2,
+    }
+
+    [StructLayout(LayoutKind.Sequential)]
+    internal struct GitMergeOpts
+    {
+        public uint Version;
+
+        public MergeFlags MergeFlags;
+        public GitMergeTreeOpts MergeTreeOpts;
+        public GitCheckoutOpts CheckoutOpts;
+    }
+}

LibGit2Sharp/Core/GitMergeTreeOpts.cs

@@ -0,0 +1,34 @@
+using LibGit2Sharp.Core.Handles;
+using System;
+using System.Runtime.InteropServices;
+
+namespace LibGit2Sharp.Core
+{
+    [Flags]
+    internal enum MergeTreeFlags
+    {
+	    GIT_MERGE_TREE_FIND_RENAMES = (1 << 0),
+    }
+    [Flags]
+    internal enum MergeAutomergeFlags
+    {
+	    GIT_MERGE_AUTOMERGE_NORMAL = 0,
+	    GIT_MERGE_AUTOMERGE_NONE = 1,
+	    GIT_MERGE_AUTOMERGE_FAVOR_OURS = 2,
+	    GIT_MERGE_AUTOMERGE_FAVOR_THEIRS = 3,
+    }
+
+    [StructLayout(LayoutKind.Sequential)]
+    internal struct GitMergeTreeOpts
+    {
+        public uint Version;
+
+        public MergeTreeFlags MergeTreeFlags;
+        public uint RenameThreshold;
+        public uint TargetLimit;
+
+        public UIntPtr Metric;
+
+        public MergeAutomergeFlags MergeAutomergeFlags;
+    }
+}

LibGit2Sharp/Core/Handles/GitMergeHeadHandle.cs

@@ -0,0 +1,13 @@
+using System.Runtime.InteropServices;
+
+namespace LibGit2Sharp.Core.Handles
+{
+    internal class GitMergeHeadHandle : SafeHandleBase
+    {
+        protected override bool ReleaseHandleImpl()
+        {
+            Proxy.git_merge_head_free(handle);
+            return true;
+        }
+    }
+}

LibGit2Sharp/Core/Handles/GitMergeResultHandle.cs

@@ -0,0 +1,13 @@
+using System.Runtime.InteropServices;
+
+namespace LibGit2Sharp.Core.Handles
+{
+    internal class GitMergeResultHandle : SafeHandleBase
+    {
+        protected override bool ReleaseHandleImpl()
+        {
+            Proxy.git_merge_result_free(handle);
+            return true;
+        }
+    }
+}

LibGit2Sharp/Core/NativeMethods.cs

@@ -561,6 +561,55 @@ internal static extern int git_merge_base(
             GitObjectSafeHandle one,
             GitObjectSafeHandle two);
 
+        [DllImport(libgit2)]
+        internal static extern int git_merge_head_from_ref(
+            out GitMergeHeadHandle mergehead,
+            RepositorySafeHandle repo,
+            ReferenceSafeHandle reference);
+
+        [DllImport(libgit2)]
+        internal static extern int git_merge_head_from_fetchhead(
+            out GitMergeHeadHandle mergehead,
+            RepositorySafeHandle repo,
+            [MarshalAs(UnmanagedType.CustomMarshaler, MarshalCookie = UniqueId.UniqueIdentifier, MarshalTypeRef = typeof(StrictUtf8Marshaler))] string branch_name,
+            [MarshalAs(UnmanagedType.CustomMarshaler, MarshalCookie = UniqueId.UniqueIdentifier, MarshalTypeRef = typeof(StrictUtf8Marshaler))] string remote_url,
+            ref GitOid oid);
+
+        [DllImport(libgit2)]
+        internal static extern int git_merge_head_from_oid(
+            out GitMergeHeadHandle mergehead,
+            RepositorySafeHandle repo,
+            ref GitOid oid);
+
+        [DllImport(libgit2)]
+        internal static extern int git_merge(
+            out GitMergeResultHandle mergeResult,
+            RepositorySafeHandle repo,
+            [MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 2)] [In] IntPtr[] their_heads,
+            UIntPtr their_heads_len,
+            ref GitMergeOpts given_opts);
+
+        [DllImport(libgit2)]
+        internal static extern int git_merge_result_is_uptodate(
+            GitMergeResultHandle merge_result);
+
+        [DllImport(libgit2)]
+        internal static extern int git_merge_result_is_fastforward(
+            GitMergeResultHandle merge_result);
+
+        [DllImport(libgit2)]
+        internal static extern int git_merge_result_fastforward_oid(
+            out GitOid oid,
+            GitMergeResultHandle merge_result);
+
+        [DllImport(libgit2)]
+        internal static extern void git_merge_result_free(
+            IntPtr merge_result);
+
+        [DllImport(libgit2)]
+        internal static extern void git_merge_head_free(
+            IntPtr merge_head);
+
         [DllImport(libgit2)]
         internal static extern int git_message_prettify(
             byte[] message_out, // NB: This is more properly a StringBuilder, but it's UTF8

LibGit2Sharp/Core/Proxy.cs

@@ -934,6 +934,91 @@ public static ObjectId git_merge_base(RepositorySafeHandle repo, Commit first, C
             }
         }
 
+        public static GitMergeHeadHandle git_merge_head_from_oid(RepositorySafeHandle repo, GitOid oid)
+        {
+            using (ThreadAffinity())
+            {
+                GitMergeHeadHandle their_head;
+
+                int res = NativeMethods.git_merge_head_from_oid(out their_head, repo, ref oid);
+                if (res == (int)GitErrorCode.NotFound)
+                    return null;
+
+                Ensure.ZeroResult(res);
+
+                return their_head;
+            }
+        }
+
+        public static GitMergeResultHandle git_merge(RepositorySafeHandle repo, GitMergeHeadHandle[] heads, GitMergeOpts options)
+        {
+            using (ThreadAffinity())
+            {
+                GitMergeResultHandle ret;
+
+                IntPtr[] their_heads = new IntPtr[heads.Length];
+                for (int i = 0; i < heads.Length; i++)
+                {
+                    their_heads[i] = heads[i].DangerousGetHandle();
+                }
+
+                int res = NativeMethods.git_merge(
+                    out ret,
+                    repo,
+                    their_heads,
+                    (UIntPtr)their_heads.Length,
+                    ref options);
+
+                Ensure.ZeroResult(res);
+
+                return ret;
+            }
+        }
+
+        public static bool git_merge_result_is_uptodate(GitMergeResultHandle handle)
+        {
+            using (ThreadAffinity())
+            {
+                int res = NativeMethods.git_merge_result_is_uptodate(handle);
+                Ensure.BooleanResult(res);
+
+                return (res == 1);
+            }
+        }
+
+        public static bool git_merge_result_is_fastforward(GitMergeResultHandle handle)
+        {
+            using (ThreadAffinity())
+            {
+                int res = NativeMethods.git_merge_result_is_fastforward(handle);
+                Ensure.BooleanResult(res);
+
+                return (res == 1);
+            }
+        }
+
+        public static GitOid git_merge_result_fastforward_oid(GitMergeResultHandle handle)
+        {
+            using (ThreadAffinity())
+            {
+                GitOid oid;
+                int res = NativeMethods.git_merge_result_fastforward_oid(out oid, handle);
+                Ensure.ZeroResult(res);
+
+                return oid;
+            }
+        }
+
+        public static void git_merge_result_free(IntPtr handle)
+        {
+            NativeMethods.git_merge_result_free(handle);
+        }
+
+        public static void git_merge_head_free(IntPtr handle)
+        {
+            NativeMethods.git_merge_head_free(handle);
+        }
+
         #endregion
 
         #region git_message_

LibGit2Sharp/IRepository.cs

@@ -202,6 +202,11 @@ public interface IRepository : IDisposable
         /// </summary>
         IEnumerable<MergeHead> MergeHeads { get; }
 
+        /// <summary>
+        /// Merges the given commit into HEAD.
+        /// </summary>
+        MergeResult Merge(Commit commit);
+
         /// <summary>
         /// Manipulate the currently ignored files.
         /// </summary>

LibGit2Sharp/LibGit2Sharp.csproj

@@ -77,15 +77,21 @@
     <Compile Include="RefSpec.cs" />
     <Compile Include="RefSpecCollection.cs" />
     <Compile Include="Core\EncodingMarshaler.cs" />
+    <Compile Include="Core\GitMergeHead.cs" />
+    <Compile Include="Core\GitMergeOpts.cs" />
+    <Compile Include="Core\GitMergeTreeOpts.cs" />
     <Compile Include="Core\Handles\BranchIteratorSafeHandle.cs" />
     <Compile Include="Core\Handles\ConfigurationIteratorSafeHandle.cs" />
     <Compile Include="Core\GitBlame.cs" />
     <Compile Include="Core\Handles\BlameSafeHandle.cs" />
+    <Compile Include="Core\Handles\GitMergeHeadHandle.cs" />
+    <Compile Include="Core\Handles\GitMergeResultHandle.cs" />
     <Compile Include="Core\PushTransferProgressCallbacks.cs" />
     <Compile Include="Core\PackbuilderCallbacks.cs" />
     <Compile Include="PushOptions.cs" />
     <Compile Include="Core\GitBuf.cs" />
     <Compile Include="FilteringOptions.cs" />
+    <Compile Include="MergeResult.cs" />
     <Compile Include="ResetMode.cs" />
     <Compile Include="NoteCollectionExtensions.cs" />
     <Compile Include="RefSpecDirection.cs" />

LibGit2Sharp/MergeResult.cs

@@ -0,0 +1,37 @@
+using LibGit2Sharp.Core;
+using LibGit2Sharp.Core.Handles;
+using System.Diagnostics;
+
+namespace LibGit2Sharp
+{
+    public class MergeResult
+    {
+        public MergeResult(){}
+        internal MergeResult(GitMergeResultHandle handle)
+        {
+            _isUpToDate = Proxy.git_merge_result_is_uptodate(handle);
+            _isFastForward = Proxy.git_merge_result_is_fastforward(handle);
+
+            if (_isFastForward)
+                _oid = Proxy.git_merge_result_fastforward_oid(handle);
+        }
+
+        private bool _isUpToDate;
+        public virtual bool IsUpToDate
+        {
+            get { return _isUpToDate; }
+        }
+
+        private bool _isFastForward;
+        public virtual bool IsFastForward
+        {
+            get { return _isFastForward; }
+        }
+
+        private readonly GitOid _oid;
+        internal GitOid FastForwardOid
+        {
+            get { return _oid; }
+        }
+    }
+}