Expose merge analysis

This allows us to ask the library about what kind of actions
are available for merging into HEAD.

Author: carlosmn

LibGit2Sharp.Tests/MergeFixture.cs

@@ -874,6 +874,72 @@ private Commit AddFileCommitToRepo(IRepository repository, string filename, stri
             return repository.Commit("New commit", Constants.Signature, Constants.Signature);
         }
 
+
+        [Theory]
+        [InlineData("master", MergeAnalysis.Unborn | MergeAnalysis.FastForward, true)]
+        [InlineData("fast_forward", MergeAnalysis.Normal | MergeAnalysis.FastForward, false)]
+        [InlineData("conflicts", MergeAnalysis.Normal, false)]
+
+        public void CanAnalyzeMerge(string branchName, MergeAnalysis analysis, bool makeUnborn)
+        {
+            string path = SandboxMergeTestRepo();
+            using (var repo = new Repository(path))
+            {
+                if (makeUnborn)
+                {
+                    repo.Refs.UpdateTarget("HEAD", "refs/heads/unborn");
+                }
+
+                // test both Commit and Reference overload
+                MergeAnalysisResult result = repo.AnalyzeMerge(repo.Branches[branchName].Tip);
+                MergeAnalysisResult result2 = repo.AnalyzeMerge(repo.Refs["refs/heads/" + branchName]);
+
+                Assert.Equal(analysis, result.Analysis);
+                Assert.Equal(analysis, result2.Analysis);
+            }
+        }
+
+        [Theory]
+        [InlineData("false", MergePreference.NoFastForward)]
+        [InlineData("only", MergePreference.FastForwardOnly)]
+        [InlineData(null, MergePreference.Default)]
+        public void CanRetrieveMergePreference(string value, MergePreference preference)
+        {
+            string path = SandboxMergeTestRepo();
+            using (var repo = new Repository(path))
+            {
+                if (value != null)
+                {
+                    repo.Config.Set("merge.ff", value);
+                }
+
+                // it doesn't matter too much which branch we ask about, we want the preference
+                MergeAnalysisResult result = repo.AnalyzeMerge(repo.Branches["fast_forward"].Tip);
+
+                Assert.Equal(preference, result.Preference);
+            }
+        }
+
+        [Fact]
+        public void CanAnalyzeFastForward()
+        {
+            string path = SandboxMergeTestRepo();
+            using (var repo = new Repository(path))
+            {
+                // test both Commit and Reference overload
+                MergeAnalysisResult result = repo.AnalyzeMerge(repo.Branches["fast_forward"].Tip);
+                MergeAnalysisResult result2 = repo.AnalyzeMerge(repo.Refs["refs/heads/fast_forward"]);
+
+                Assert.True(result.Analysis.HasFlag(MergeAnalysis.FastForward));
+                Assert.True(result.Analysis.HasFlag(MergeAnalysis.Normal));
+                Assert.False(result.Analysis.HasFlag(MergeAnalysis.Unborn));
+                Assert.False(result.Analysis.HasFlag(MergeAnalysis.UpToDate));
+
+                Assert.Equal(result, result2);
+            }
+        }
+
+
         // Commit IDs of the checked in merge_testrepo
         private const string masterBranchInitialId = "83cebf5389a4adbcb80bda6b68513caee4559802";
         private const string fastForwardBranchInitialId = "4dfaa1500526214ae7b33f9b2c1144ca8b6b1f53";

LibGit2Sharp/Core/DisposableArray.cs

@@ -0,0 +1,60 @@
+using System;
+using System.Linq;
+using System.Collections.Generic;
+
+namespace LibGit2Sharp.Core
+{
+    /// <summary>
+    /// An array containing disposables, for convenience when dealing with handles
+    /// </summary>
+    internal class DisposableArray<T> : IDisposable where T : IDisposable
+    {
+        readonly T[] array;
+
+        /// <summary>
+        /// Create a wrapper for the given array so the contents will be disposed when this class is disposed.
+        /// </summary>
+        /// <param name="handles">The array of dispsables</param>
+        public DisposableArray(T[] handles)
+        {
+            array = handles;
+        }
+
+        /// <summary>
+        /// Create a wrapper for the given array so the contents will be disposed when this class is disposed.
+        /// <para>
+        /// The enumerable is first made into an array
+        /// </para>
+        /// </summary>
+        /// <param name="handles">Handles.</param>
+        public DisposableArray(IEnumerable<T> handles)
+        {
+            array = handles.ToArray();
+        }
+
+        /// <summary>
+        /// The underlying array
+        /// </summary>
+        public T[] Array { get { return array; } }
+
+        /// <summary>
+        /// Return the underlying array so we can use this wherever the methods expect an array
+        /// </summary>
+        public static implicit operator T[](DisposableArray<T> da)
+        {
+            return da.array;
+        }
+
+        /// <summary>
+        /// Call Dispose on each of the elements of the array
+        /// </summary>
+        public void Dispose()
+        {
+            foreach (var handle in array)
+            {
+                handle.Dispose();
+            }
+        }
+    }
+}
+

LibGit2Sharp/IRepository.cs

@@ -226,6 +226,21 @@ public interface IRepository : IDisposable
         /// <returns>The <see cref="MergeResult"/> of the merge.</returns>
         MergeResult Merge(string committish, Signature merger, MergeOptions options);
 
+        /// <summary>
+        /// Analyze the possibilities of updating HEAD with the given commit(s).
+        /// </summary>
+        /// <param name="commits">Commits to merge into HEAD</param>
+        /// <returns>Which update methods are possible and which preference the user has specified</returns>
+        MergeAnalysisResult AnalyzeMerge(params Commit[] commits);
+
+
+        /// <summary>
+        /// Analyze the possibilities of updating HEAD with the given reference(s)
+        /// </summary>
+        /// <param name="references">References to merge into HEAD</param>
+        /// <returns>Which update methods are possible and which preference the user has specified</returns>
+        MergeAnalysisResult AnalyzeMerge(params Reference[] references);
+
         /// <summary>
         /// Access to Rebase functionality.
         /// </summary>

LibGit2Sharp/LibGit2Sharp.csproj

@@ -119,10 +119,13 @@
     <Compile Include="IndexReucEntry.cs" />
     <Compile Include="IndexReucEntryCollection.cs" />
     <Compile Include="IndexNameEntry.cs" />
+    <Compile Include="MergeAnalysis.cs" />
+    <Compile Include="MergeAnalysisResult.cs" />
     <Compile Include="MergeAndCheckoutOptionsBase.cs" />
     <Compile Include="CheckoutConflictException.cs" />
     <Compile Include="MergeOptions.cs" />
     <Compile Include="MergeOptionsBase.cs" />
+    <Compile Include="MergePreference.cs" />
     <Compile Include="MergeResult.cs" />
     <Compile Include="MergeTreeOptions.cs" />
     <Compile Include="MergeTreeResult.cs" />
@@ -355,6 +358,7 @@
     <Compile Include="Commands\Stage.cs" />
     <Compile Include="Commands\Remove.cs" />
     <Compile Include="Commands\Checkout.cs" />
+    <Compile Include="Core\DisposableArray.cs" />
   </ItemGroup>
   <ItemGroup>
     <CodeAnalysisDictionary Include="CustomDictionary.xml" />

LibGit2Sharp/MergeAnalysis.cs

@@ -0,0 +1,44 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace LibGit2Sharp
+{
+    /// <summary>
+    /// Description of the possibilities for merging one or multiple branches into HEAD
+    /// </summary>
+    [Flags]
+    public enum MergeAnalysis
+    {
+        /// <summary>
+        /// No update possible. This is a dummy to serve as default value.
+        /// </summary>
+        None = 0,
+        /// <summary>
+        /// A "normal" merge; both HEAD and the given merge input have diverged
+        /// from their common ancestor.  The divergent commits must be merged.
+        /// </summary>
+        Normal = (1 << 0),
+
+        /// <summary>
+        /// All given merge inputs are reachable from HEAD, meaning the
+        /// repository is up-to-date and no merge needs to be performed.
+        /// </summary>
+        UpToDate = (1 << 1),
+
+        /// <summary>
+        /// The given merge input is a fast-forward from HEAD and no merge
+        /// needs to be performed.  Instead, the client can check out the
+        /// given merge input.
+        /// </summary>
+        FastForward = (1 << 2),
+
+        /// <summary>
+        /// The HEAD of the current repository is "unborn" and does not point to
+        /// a valid commit.  No merge can be performed, but the caller may wish
+        /// to simply set HEAD to the target commit(s).
+        /// </summary>
+        Unborn = (1 << 3),
+    }
+}

LibGit2Sharp/MergeAnalysisResult.cs

@@ -0,0 +1,66 @@
+using System;
+using LibGit2Sharp.Core;
+
+namespace LibGit2Sharp
+{
+    /// <summary>
+    /// The result of analyzing the possibilities of merging a commit or branch into HEAD.
+    /// </summary>
+    public struct MergeAnalysisResult
+    {
+        /// <summary>
+        /// The result of the analysis done on the commits given.
+        /// </summary>
+        public MergeAnalysis Analysis;
+        /// <summary>
+        /// The user's preference for the type of merge to perform.
+        /// </summary>
+        public MergePreference Preference;
+
+        static MergeAnalysis MergeAnalysisFromGitMergeAnalysis(GitMergeAnalysis analysisIn)
+        {
+            MergeAnalysis analysis = default(MergeAnalysis);
+
+            if (analysisIn.HasFlag(GitMergeAnalysis.GIT_MERGE_ANALYSIS_NORMAL))
+            {
+                analysis |= MergeAnalysis.Normal;
+            }
+            if (analysisIn.HasFlag(GitMergeAnalysis.GIT_MERGE_ANALYSIS_UP_TO_DATE))
+            {
+                analysis |= MergeAnalysis.UpToDate;
+            }
+            if (analysisIn.HasFlag(GitMergeAnalysis.GIT_MERGE_ANALYSIS_FASTFORWARD))
+            {
+                analysis |= MergeAnalysis.FastForward;
+            }
+
+            if (analysisIn.HasFlag(GitMergeAnalysis.GIT_MERGE_ANALYSIS_UNBORN))
+            {
+                analysis |= MergeAnalysis.Unborn;
+            }
+
+            return analysis;
+        }
+
+        static MergePreference MergePreferenceFromGitMergePreference(GitMergePreference preference)
+        {
+            switch (preference)
+            {
+                case GitMergePreference.GIT_MERGE_PREFERENCE_NONE:
+                    return MergePreference.Default;
+                case GitMergePreference.GIT_MERGE_PREFERENCE_FASTFORWARD_ONLY:
+                    return MergePreference.FastForwardOnly;
+                case GitMergePreference.GIT_MERGE_PREFERENCE_NO_FASTFORWARD:
+                    return MergePreference.NoFastForward;
+                default:
+                    throw new InvalidOperationException(String.Format("Unknown merge preference: {0}", preference));
+            }
+        }
+
+        internal MergeAnalysisResult(GitMergeAnalysis analysis, GitMergePreference preference)
+        {
+            Analysis = MergeAnalysisFromGitMergeAnalysis(analysis);
+            Preference = MergePreferenceFromGitMergePreference(preference);
+        }
+    }
+}

LibGit2Sharp/MergePreference.cs

@@ -0,0 +1,31 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace LibGit2Sharp
+{
+    /// <summary>
+    /// Indicates the user's stated preference for merges
+    /// </summary>
+    public enum MergePreference
+    {
+        /// <summary>
+        /// No configuration was found that suggests a preferred behavior for
+        /// merge.
+        /// </summary>
+        Default = 0,
+
+        /// <summary>
+        /// There is a `merge.ff=false` configuration setting, suggesting that
+        /// the user does not want to allow a fast-forward merge.
+        /// </summary>
+        NoFastForward = (1 << 0),
+
+        /// <summary>
+        /// There is a `merge.ff=only` configuration setting, suggesting that
+        /// the user only wants fast-forward merges.
+        /// </summary>
+        FastForwardOnly = (1 << 1),
+    }
+}

LibGit2Sharp/Repository.cs

@@ -1412,6 +1412,43 @@ public CherryPickResult CherryPick(Commit commit, Signature committer, CherryPic
             return result;
         }
 
+        private MergeAnalysisResult AnalyzeMerge(AnnotatedCommitHandle[] annotatedCommits)
+        {
+            GitMergeAnalysis mergeAnalysis;
+            GitMergePreference mergePreference;
+
+            Proxy.git_merge_analysis(Handle, annotatedCommits, out mergeAnalysis, out mergePreference);
+            return new MergeAnalysisResult(mergeAnalysis, mergePreference);
+        }
+
+        /// <summary>
+        /// Analyze the possibilities of updating HEAD with the given commit(s).
+        /// </summary>
+        /// <param name="commits">Commits to merge into HEAD</param>
+        /// <returns>Which update methods are possible and which preference the user has specified</returns>
+        public MergeAnalysisResult AnalyzeMerge(params Commit[] commits)
+        {
+            using (var handles = new DisposableArray<AnnotatedCommitHandle>(commits.Select(commit =>
+                Proxy.git_annotated_commit_lookup(Handle, commit.Id.Oid)).ToArray()))
+            {
+                return AnalyzeMerge(handles);
+            }
+        }
+
+        /// <summary>
+        /// Analyze the possibilities of updating HEAD with the given reference(s)
+        /// </summary>
+        /// <param name="references">References to merge into HEAD</param>
+        /// <returns>Which update methods are possible and which preference the user has specified</returns>
+        public MergeAnalysisResult AnalyzeMerge(params Reference[] references)
+        {
+            using (var refHandles = new DisposableArray<ReferenceHandle>(references.Select(r => refs.RetrieveReferencePtr(r.CanonicalName))))
+            using (var handles = new DisposableArray<AnnotatedCommitHandle>(refHandles.Array.Select(rh => Proxy.git_annotated_commit_from_ref(Handle, rh))))
+            {
+                return AnalyzeMerge(handles);
+            }
+        }
+
         private FastForwardStrategy FastForwardStrategyFromMergePreference(GitMergePreference preference)
         {
             switch (preference)