Add CompareOptions

* ContextLines
* InterhunkLines

Closes #423

Author: dahlbyk

LibGit2Sharp.Tests/DiffTreeToTreeFixture.cs

@@ -4,6 +4,7 @@
 using System.Text;
 using LibGit2Sharp.Tests.TestHelpers;
 using Xunit;
+using Xunit.Extensions;
 
 namespace LibGit2Sharp.Tests
 {
@@ -222,23 +223,31 @@ public void CanDetectTheRenamingOfAModifiedFile()
          * $ git diff --shortstat f8d44d7..ec9e401
          *  1 file changed, 2 insertions(+), 1 deletion(-)
          */
-        [Fact]
-        public void CanCompareTwoVersionsOfAFileWithATrailingNewlineDeletion()
+        [Theory]
+        [InlineData(0, 175)]
+        [InlineData(1, 191)]
+        [InlineData(2, 184)]
+        [InlineData(3, 187)]
+        [InlineData(4, 193)]
+        public void CanCompareTwoVersionsOfAFileWithATrailingNewlineDeletion(int contextLines, int expectedPatchLength)
         {
             using (var repo = new Repository(StandardTestRepoPath))
             {
                 Tree rootCommitTree = repo.Lookup<Commit>("f8d44d7").Tree;
                 Tree commitTreeWithUpdatedFile = repo.Lookup<Commit>("ec9e401").Tree;
 
-                TreeChanges changes = repo.Diff.Compare(rootCommitTree, commitTreeWithUpdatedFile);
+                TreeChanges changes = repo.Diff.Compare(rootCommitTree, commitTreeWithUpdatedFile,
+                                                        compareOptions: new CompareOptions { ContextLines = (short)contextLines });
 
                 Assert.Equal(1, changes.Count());
                 Assert.Equal(1, changes.Modified.Count());
+                Assert.Equal(expectedPatchLength, changes.Patch.Length);
 
                 TreeEntryChanges treeEntryChanges = changes.Modified.Single();
 
                 Assert.Equal(2, treeEntryChanges.LinesAdded);
                 Assert.Equal(1, treeEntryChanges.LinesDeleted);
+                Assert.Equal(expectedPatchLength, treeEntryChanges.Patch.Length);
             }
         }
 
@@ -479,7 +488,7 @@ public void ComparingTwoNullTreesReturnsAnEmptyTreeChanges()
         {
             using (var repo = new Repository(StandardTestRepoPath))
             {
-                TreeChanges changes = repo.Diff.Compare(null, null, null);
+                TreeChanges changes = repo.Diff.Compare(default(Tree), default(Tree));
 
                 Assert.Equal(0, changes.Count());
             }

LibGit2Sharp/CompareOptions.cs

@@ -0,0 +1,27 @@
+namespace LibGit2Sharp
+{
+    /// <summary>
+    ///   Options to define file comparison behavior.
+    /// </summary>
+    public class CompareOptions
+    {
+        /// <summary>
+        ///   Initializes a new instance of the <see cref = "CompareOptions" /> class.
+        /// </summary>
+        public CompareOptions()
+        {
+            ContextLines = 3;
+            InterhunkLines = 0;
+        }
+
+        /// <summary>
+        ///   The number of unchanged lines that define the boundary of a hunk (and to display before and after)
+        /// </summary>
+        public short ContextLines { get; set; }
+
+        /// <summary>
+        ///   The maximum number of unchanged lines between hunk boundaries before the hunks will be merged into a one. (Default = 0)
+        /// </summary>
+        public short InterhunkLines { get; set; }
+    }
+}

LibGit2Sharp/Diff.cs

@@ -19,12 +19,15 @@ public class Diff
     {
         private readonly Repository repo;
 
-        private static GitDiffOptions BuildOptions(DiffOptions diffOptions, FilePath[] filePaths = null, MatchedPathsAggregator matchedPathsAggregator = null)
+        private static GitDiffOptions BuildOptions(DiffOptions diffOptions, FilePath[] filePaths = null, MatchedPathsAggregator matchedPathsAggregator = null, CompareOptions compareOptions = null)
         {
             var options = new GitDiffOptions();
 
             options.Flags |= GitDiffOptionFlags.GIT_DIFF_INCLUDE_TYPECHANGE;
-            options.ContextLines = 3;
+
+            compareOptions = compareOptions ?? new CompareOptions();
+            options.ContextLines = (ushort)compareOptions.ContextLines;
+            options.InterhunkLines = (ushort)compareOptions.InterhunkLines;
 
             if (diffOptions.HasFlag(DiffOptions.IncludeUntracked))
             {
@@ -110,8 +113,9 @@ internal Diff(Repository repo)
         ///   If set, the passed <paramref name="paths"/> will be treated as explicit paths.
         ///   Use these options to determine how unmatched explicit paths should be handled.
         /// </param>
+        /// <param name = "compareOptions">Additional options to define comparison behavior.</param>
         /// <returns>A <see cref = "TreeChanges"/> containing the changes between the <paramref name = "oldTree"/> and the <paramref name = "newTree"/>.</returns>
-        public virtual TreeChanges Compare(Tree oldTree, Tree newTree, IEnumerable<string> paths = null, ExplicitPathsOptions explicitPathsOptions = null)
+        public virtual TreeChanges Compare(Tree oldTree, Tree newTree, IEnumerable<string> paths = null, ExplicitPathsOptions explicitPathsOptions = null, CompareOptions compareOptions = null)
         {
             var comparer = TreeToTree(repo);
             ObjectId oldTreeId = oldTree != null ? oldTree.Id : null;
@@ -129,18 +133,19 @@ public virtual TreeChanges Compare(Tree oldTree, Tree newTree, IEnumerable<strin
                 }
             }
 
-            return BuildTreeChangesFromComparer(oldTreeId, newTreeId, comparer, diffOptions, paths, explicitPathsOptions);
+            return BuildTreeChangesFromComparer(oldTreeId, newTreeId, comparer, diffOptions, paths, explicitPathsOptions, compareOptions);
         }
 
         /// <summary>
         ///   Show changes between two <see cref = "Blob"/>s.
         /// </summary>
         /// <param name = "oldBlob">The <see cref = "Blob"/> you want to compare from.</param>
         /// <param name = "newBlob">The <see cref = "Blob"/> you want to compare to.</param>
+        /// <param name = "compareOptions">Additional options to define comparison behavior.</param>
         /// <returns>A <see cref = "ContentChanges"/> containing the changes between the <paramref name = "oldBlob"/> and the <paramref name = "newBlob"/>.</returns>
-        public virtual ContentChanges Compare(Blob oldBlob, Blob newBlob)
+        public virtual ContentChanges Compare(Blob oldBlob, Blob newBlob, CompareOptions compareOptions = null)
         {
-            using (GitDiffOptions options = BuildOptions(DiffOptions.None))
+            using (GitDiffOptions options = BuildOptions(DiffOptions.None, compareOptions: compareOptions))
             {
                 return new ContentChanges(repo, oldBlob, newBlob, options);
             }
@@ -168,8 +173,9 @@ private static IDictionary<DiffTargets, Func<Repository, TreeComparisonHandleRet
         ///   If set, the passed <paramref name="paths"/> will be treated as explicit paths.
         ///   Use these options to determine how unmatched explicit paths should be handled.
         /// </param>
+        /// <param name = "compareOptions">Additional options to define comparison behavior.</param>
         /// <returns>A <see cref = "TreeChanges"/> containing the changes between the <see cref="Tree"/> and the selected target.</returns>
-        public virtual TreeChanges Compare(Tree oldTree, DiffTargets diffTargets, IEnumerable<string> paths = null, ExplicitPathsOptions explicitPathsOptions = null)
+        public virtual TreeChanges Compare(Tree oldTree, DiffTargets diffTargets, IEnumerable<string> paths = null, ExplicitPathsOptions explicitPathsOptions = null, CompareOptions compareOptions = null)
         {
             var comparer = handleRetrieverDispatcher[diffTargets](repo);
             ObjectId oldTreeId = oldTree != null ? oldTree.Id : null;
@@ -188,7 +194,7 @@ public virtual TreeChanges Compare(Tree oldTree, DiffTargets diffTargets, IEnume
                 }
             }
 
-            return BuildTreeChangesFromComparer(oldTreeId, null, comparer, diffOptions, paths, explicitPathsOptions);
+            return BuildTreeChangesFromComparer(oldTreeId, null, comparer, diffOptions, paths, explicitPathsOptions, compareOptions);
         }
 
         /// <summary>
@@ -200,14 +206,15 @@ public virtual TreeChanges Compare(Tree oldTree, DiffTargets diffTargets, IEnume
         ///   If set, the passed <paramref name="paths"/> will be treated as explicit paths.
         ///   Use these options to determine how unmatched explicit paths should be handled.
         /// </param>
+        /// <param name = "compareOptions">Additional options to define comparison behavior.</param>
         /// <returns>A <see cref = "TreeChanges"/> containing the changes between the working directory and the index.</returns>
-        public virtual TreeChanges Compare(IEnumerable<string> paths = null, bool includeUntracked = false, ExplicitPathsOptions explicitPathsOptions = null)
+        public virtual TreeChanges Compare(IEnumerable<string> paths = null, bool includeUntracked = false, ExplicitPathsOptions explicitPathsOptions = null, CompareOptions compareOptions = null)
         {
-            return Compare(includeUntracked ? DiffOptions.IncludeUntracked : DiffOptions.None, paths, explicitPathsOptions);
+            return Compare(includeUntracked ? DiffOptions.IncludeUntracked : DiffOptions.None, paths, explicitPathsOptions, compareOptions);
         }
 
         internal virtual TreeChanges Compare(DiffOptions diffOptions, IEnumerable<string> paths = null,
-                                             ExplicitPathsOptions explicitPathsOptions = null)
+                                             ExplicitPathsOptions explicitPathsOptions = null, CompareOptions compareOptions = null)
         {
             var comparer = WorkdirToIndex(repo);
 
@@ -222,7 +229,7 @@ internal virtual TreeChanges Compare(DiffOptions diffOptions, IEnumerable<string
                 }
             }
 
-            return BuildTreeChangesFromComparer(null, null, comparer, diffOptions, paths, explicitPathsOptions);
+            return BuildTreeChangesFromComparer(null, null, comparer, diffOptions, paths, explicitPathsOptions, compareOptions);
         }
 
         private delegate DiffListSafeHandle TreeComparisonHandleRetriever(ObjectId oldTreeId, ObjectId newTreeId, GitDiffOptions options);
@@ -275,14 +282,12 @@ private static TreeComparisonHandleRetriever IndexToTree(Repository repo)
             return (oh, nh, o) => Proxy.git_diff_tree_to_index(repo.Handle, repo.Index.Handle, oh, o);
         }
 
-        private TreeChanges BuildTreeChangesFromComparer(
-            ObjectId oldTreeId, ObjectId newTreeId, TreeComparisonHandleRetriever comparisonHandleRetriever,
-            DiffOptions diffOptions, IEnumerable<string> paths = null, ExplicitPathsOptions explicitPathsOptions = null)
+        private TreeChanges BuildTreeChangesFromComparer(ObjectId oldTreeId, ObjectId newTreeId, TreeComparisonHandleRetriever comparisonHandleRetriever, DiffOptions diffOptions, IEnumerable<string> paths = null, ExplicitPathsOptions explicitPathsOptions = null, CompareOptions compareOptions = null)
         {
             var matchedPaths = new MatchedPathsAggregator();
             var filePaths = ToFilePaths(repo, paths);
 
-            using (GitDiffOptions options = BuildOptions(diffOptions, filePaths, matchedPaths))
+            using (GitDiffOptions options = BuildOptions(diffOptions, filePaths, matchedPaths, compareOptions))
             using (DiffListSafeHandle diffList = comparisonHandleRetriever(oldTreeId, newTreeId, options))
             {
                 if (explicitPathsOptions != null)

LibGit2Sharp/LibGit2Sharp.csproj

@@ -67,6 +67,7 @@
     <Compile Include="Changes.cs" />
     <Compile Include="CheckoutCallbacks.cs" />
     <Compile Include="CheckoutOptions.cs" />
+    <Compile Include="CompareOptions.cs" />
     <Compile Include="ObjectType.cs" />
     <Compile Include="ReferenceExtensions.cs" />
     <Compile Include="Conflict.cs" />