Introduced suggested GitHub changes. +Added more tests.

Put an implicit fast forward into the Merge method in Repository.cs,
cleaned up usings/comments, removed GitMergeHead and made other
suggested changes from github.

Author: angusbjones

LibGit2Sharp.Tests/MergeFixture.cs

@@ -1,5 +1,5 @@
-using LibGit2Sharp.Tests.TestHelpers;
-using System.Linq;
+using System.Linq;
+using LibGit2Sharp.Tests.TestHelpers;
 using Xunit;
 
 namespace LibGit2Sharp.Tests
@@ -84,36 +84,184 @@ public void CanRetrieveTheBranchBeingMerged()
         [Fact]
         public void CanMergeRepos()
         {
+            string firstBranchFileName = "first branch file.txt";
+            string secondBranchFileName = "second branch file.txt";
+            string sharedBranchFileName = "first+second branch file.txt";
+
             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");  
-                
+                // Commit with ONE new file to both first & second branch (SecondBranch is created on this commit).
+                AddFileCommitToRepo(repo, sharedBranchFileName);
+
                 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"); 
+                // Commit with ONE new file to first branch (FirstBranch moves forward as it is checked out, SecondBranch stays back one).
+                var firstBranchCommit = AddFileCommitToRepo(repo, firstBranchFileName);
 
                 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");
+                // 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, secondBranchFileName);
 
                 MergeResult mergeResult = repo.Merge(repo.Branches["FirstBranch"].Tip);
 
+                Assert.False(mergeResult.IsUpToDate);
+                Assert.False(mergeResult.IsFastForward);
+
+                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
+            }
+        }
+
+        [Fact]
+        public void IsUpToDateMerge()
+        {
+            string sharedBranchFileName = "first+second branch file.txt";
+
+            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, sharedBranchFileName);
+
+                var secondBranch = repo.CreateBranch("SecondBranch");
+
+                secondBranch.Checkout();
+
+                MergeResult mergeResult = repo.Merge(repo.Branches["FirstBranch"].Tip);
+
+                Assert.True(mergeResult.IsUpToDate);
+                Assert.False(mergeResult.IsFastForward);
+            }
+        }
+
+        [Fact]
+        public void CanFastForwardRepos()
+        {
+            string firstBranchFileName = "first branch file.txt";
+            string sharedBranchFileName = "first+second branch file.txt";
+
+            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, sharedBranchFileName);
+
+                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, firstBranchFileName);
+
+                secondBranch.Checkout();
+
+                MergeResult mergeResult = repo.Merge(repo.Branches["FirstBranch"].Tip);
+
+                Assert.False(mergeResult.IsUpToDate);
+                Assert.True(mergeResult.IsFastForward);
+                
                 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
+                Assert.Equal(mergeCommit.Tree.Count, originalTreeCount + 2);    // Expecting original tree count plussed by the 3 added files.
+            }
+        }
+
+        [Fact]
+        public void ConflictingMergeRepos()
+        {
+            string firstBranchFileName = "first branch file.txt";
+            string secondBranchFileName = "second branch file.txt";
+            string sharedBranchFileName = "first+second branch file.txt";
+
+            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, sharedBranchFileName);
+
+                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).
+                AddFileCommitToRepo(repo, firstBranchFileName);
+                AddFileCommitToRepo(repo, sharedBranchFileName, "The first branches comment");  // Change file in first branch
+
+                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).
+                AddFileCommitToRepo(repo, secondBranchFileName);
+                AddFileCommitToRepo(repo, sharedBranchFileName, "The second branches comment");  // Change file in second branch
+
+                MergeResult mergeResult = repo.Merge(repo.Branches["FirstBranch"].Tip);
+
+                Assert.False(mergeResult.IsUpToDate);
+                Assert.False(mergeResult.IsFastForward);
+
+                Assert.Equal(repo.Index.Conflicts.Count(), 1);
+
+                var conflict = repo.Index.Conflicts.First();
+                var changes = repo.Diff.Compare(repo.Lookup<Blob>(conflict.Theirs.Id), repo.Lookup<Blob>(conflict.Ours.Id));
+
+                Assert.False(changes.IsBinaryComparison);
+            }
+        }
+
+        [Fact]
+        public void ConflictingMergeReposBinary()
+        {
+            string firstBranchFileName = "first branch file.bin";
+            string secondBranchFileName = "second branch file.bin";
+            string sharedBranchFileName = "first+second branch file.bin";
+
+            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, sharedBranchFileName);
+
+                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).
+                AddFileCommitToRepo(repo, firstBranchFileName);
+                AddFileCommitToRepo(repo, sharedBranchFileName, "\0The first branches comment\0");  // Change file in first branch
+
+                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).
+                AddFileCommitToRepo(repo, secondBranchFileName);
+                AddFileCommitToRepo(repo, sharedBranchFileName, "\0The second branches comment\0");  // Change file in second branch
+
+                MergeResult mergeResult = repo.Merge(repo.Branches["FirstBranch"].Tip);
+
+                Assert.False(mergeResult.IsUpToDate);
+                Assert.False(mergeResult.IsFastForward);
+
+                Assert.Equal(repo.Index.Conflicts.Count(), 1);
+
+                Conflict conflict = repo.Index.Conflicts.First();
+
+                var changes = repo.Diff.Compare(repo.Lookup<Blob>(conflict.Theirs.Id), repo.Lookup<Blob>(conflict.Ours.Id));
+
+                Assert.True(changes.IsBinaryComparison);
             }
         }
 
         private Commit AddFileCommitToRepo(IRepository repository, string filename, string content = null)
         {
-            filename = filename + ".txt";
             Touch(repository.Info.WorkingDirectory, filename, content);
 
             repository.Index.Stage(filename);

LibGit2Sharp/Core/GitMergeHead.cs

@@ -1,5 +1,4 @@
-using LibGit2Sharp.Core.Handles;
-using System;
+using System;
 using System.Runtime.InteropServices;
 
 namespace LibGit2Sharp.Core
@@ -9,7 +8,7 @@ internal enum MergeTreeFlags
     {
 	    GIT_MERGE_TREE_FIND_RENAMES = (1 << 0),
     }
-    [Flags]
+
     internal enum MergeAutomergeFlags
     {
 	    GIT_MERGE_AUTOMERGE_NORMAL = 0,

LibGit2Sharp/Core/GitMergeTreeOpts.cs

@@ -955,8 +955,6 @@ public static GitMergeHeadHandle git_merge_head_from_oid(RepositorySafeHandle re
                 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);
 

LibGit2Sharp/Core/Proxy.cs

@@ -79,7 +79,6 @@
     <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" />

LibGit2Sharp/LibGit2Sharp.csproj

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

LibGit2Sharp/MergeResult.cs

@@ -1033,8 +1033,10 @@ public IEnumerable<MergeHead> MergeHeads
         }
 
         /// <summary>
-        /// Merges the given commit into HEAD.
+        /// Merges the given commit into HEAD as well as performing a Fast Forward if possible.
         /// </summary>
+        /// <param name="commit">The commit to use as a reference for the changes that should be merged into HEAD.</param>
+        /// <returns>The result of the performed merge <see cref="MergeResult"/>.</returns>
         public MergeResult Merge(Commit commit)
         {
             using (GitMergeHeadHandle mergeHeadHandle = Proxy.git_merge_head_from_oid(Handle, commit.Id.Oid))
@@ -1043,15 +1045,27 @@ public MergeResult Merge(Commit commit)
                 {
                     Version = 1,
                     MergeTreeOpts = { Version = 1 },
-                    CheckoutOpts = { version = 1 }
+                    CheckoutOpts = { version = 1 },
                 };
                 using (GitMergeResultHandle mergeResultHandle = Proxy.git_merge(Handle, new GitMergeHeadHandle[] { mergeHeadHandle }, opts))
-                { 
-                    return new MergeResult(mergeResultHandle);
+                {
+                    var result = new MergeResult(mergeResultHandle);
+                    if (result.IsFastForward)
+                        FastForward(result);
+                    return result;
                 }
             }
         }
 
+        internal Branch FastForward(MergeResult mergeResult)
+        {
+            if (mergeResult == null)
+                throw new ArgumentNullException("A merge result must be provided.");
+            if (!mergeResult.IsFastForward)
+                throw new ArgumentException("The given merge result does not contain a Fast Forward OID.");
+            return this.Checkout(new ObjectId(mergeResult.FastForwardOid).Sha);
+        }
+
         internal StringComparer PathComparer
         {
             get { return pathCase.Value.Comparer; }