Add ExplicitPathsOptions to Repository.Diff.Compare()

All the overloads can now report and/or fail upon unmatched explicit paths.
By default, the passed list of paths will be treated as a list of pathspecs.

When an ExplicitPathsOptions is passed to the overloads, this list of paths
will be treated as explicit paths. In that case, the default behavior is to
throw when one of this explicit path is unmatched.

Author: yorah

LibGit2Sharp.Tests/DiffTreeToTargetFixture.cs

@@ -283,7 +283,7 @@ public void CanCompareASubsetofTheTreeAgainstTheIndex()
                 Tree tree = repo.Head.Tip.Tree;
 
                 TreeChanges changes = repo.Diff.Compare(tree, DiffTargets.Index,
-                    new[] { "deleted_staged_file.txt", "1/branch_file.txt", "I-do/not-exist" });
+                    new[] { "deleted_staged_file.txt", "1/branch_file.txt" });
 
                 Assert.NotNull(changes);
 
@@ -292,6 +292,42 @@ public void CanCompareASubsetofTheTreeAgainstTheIndex()
             }
         }
 
+        private static void AssertCanCompareASubsetOfTheTreeAgainstTheIndex(TreeChanges changes)
+        {
+            Assert.NotNull(changes);
+            Assert.Equal(1, changes.Count());
+            Assert.Equal("deleted_staged_file.txt", changes.Deleted.Single().Path);
+        }
+
+        [Fact]
+        public void CanCompareASubsetofTheTreeAgainstTheIndexWithLaxExplicitPathsValidationAndANonExistentPath()
+        {
+            using (var repo = new Repository(StandardTestRepoPath))
+            {
+                Tree tree = repo.Head.Tip.Tree;
+
+                TreeChanges changes = repo.Diff.Compare(tree, DiffTargets.Index,
+                    new[] { "deleted_staged_file.txt", "1/branch_file.txt", "I-do/not-exist" }, new ExplicitPathsOptions { ShouldFailOnUnmatchedPath = false });
+                AssertCanCompareASubsetOfTheTreeAgainstTheIndex(changes);
+
+                changes = repo.Diff.Compare(tree, DiffTargets.Index,
+                    new[] { "deleted_staged_file.txt", "1/branch_file.txt", "I-do/not-exist" });
+                AssertCanCompareASubsetOfTheTreeAgainstTheIndex(changes);
+            }
+        }
+
+        [Fact]
+        public void ComparingASubsetofTheTreeAgainstTheIndexWithStrictExplicitPathsValidationAndANonExistentPathThrows()
+        {
+            using (var repo = new Repository(StandardTestRepoPath))
+            {
+                Tree tree = repo.Head.Tip.Tree;
+
+                Assert.Throws<UnmatchedPathException>(() => repo.Diff.Compare(tree, DiffTargets.Index,
+                    new[] { "deleted_staged_file.txt", "1/branch_file.txt", "I-do/not-exist" }, new ExplicitPathsOptions()));
+            }
+        }
+
         [Fact]
         /*
          * $ git init .

LibGit2Sharp.Tests/DiffTreeToTreeFixture.cs

@@ -87,7 +87,7 @@ public void CanCompareASubsetofTheTreeAgainstOneOfItsAncestor()
                 Tree tree = repo.Head.Tip.Tree;
                 Tree ancestor = repo.Lookup<Commit>("9fd738e").Tree;
 
-                TreeChanges changes = repo.Diff.Compare(ancestor, tree, new[]{ "1", "2/" });
+                TreeChanges changes = repo.Diff.Compare(ancestor, tree, new[]{ "1" });
                 Assert.NotNull(changes);
 
                 Assert.Equal(1, changes.Count());
@@ -133,6 +133,38 @@ public void CanCompareACommitTreeAgainstATreeWithNoCommonAncestor()
             }
         }
 
+        [Fact]
+        public void CanCompareATreeAgainstAnotherTreeWithLaxExplicitPathsValidationAndNonExistentPath()
+        {
+            using (var repo = new Repository(StandardTestRepoPath))
+            {
+                Tree commitTree = repo.Head.Tip.Tree;
+                Tree commitTreeWithDifferentAncestor = repo.Branches["refs/remotes/origin/test"].Tip.Tree;
+
+                TreeChanges changes = repo.Diff.Compare(commitTreeWithDifferentAncestor, commitTree,
+                        new[] { "if-I-exist-this-test-is-really-unlucky.txt" }, new ExplicitPathsOptions { ShouldFailOnUnmatchedPath = false });
+                Assert.Equal(0, changes.Count());
+
+                changes = repo.Diff.Compare(commitTreeWithDifferentAncestor, commitTree,
+                    new[] { "if-I-exist-this-test-is-really-unlucky.txt" });
+                Assert.Equal(0, changes.Count());
+            }
+        }
+
+        [Fact]
+        public void ComparingATreeAgainstAnotherTreeWithStrictExplicitPathsValidationThrows()
+        {
+            using (var repo = new Repository(StandardTestRepoPath))
+            {
+                Tree commitTree = repo.Head.Tip.Tree;
+                Tree commitTreeWithDifferentAncestor = repo.Branches["refs/remotes/origin/test"].Tip.Tree;
+
+                Assert.Throws<UnmatchedPathException>(() =>
+                    repo.Diff.Compare(commitTreeWithDifferentAncestor, commitTree,
+                        new[] { "if-I-exist-this-test-is-really-unlucky.txt" }, new ExplicitPathsOptions()));
+            }
+        }
+
         /*
          * $ git diff -M f8d44d7..4be51d6
          * diff --git a/my-name-does-not-feel-right.txt b/super-file.txt

LibGit2Sharp.Tests/DiffWorkdirToIndexFixture.cs

@@ -1,6 +1,10 @@
+using System;
+using System.IO;
 using System.Linq;
+using System.Text;
 using LibGit2Sharp.Tests.TestHelpers;
 using Xunit;
+using Xunit.Extensions;
 
 namespace LibGit2Sharp.Tests
 {
@@ -36,6 +40,129 @@ public void CanCompareTheWorkDirAgainstTheIndex()
             }
         }
 
+        [Theory]
+        [InlineData("new_untracked_file.txt", FileStatus.Untracked)]
+        [InlineData("really-i-cant-exist.txt", FileStatus.Nonexistent)]
+        public void CanCompareTheWorkDirAgainstTheIndexWithLaxUnmatchedExplicitPathsValidation(string relativePath, FileStatus currentStatus)
+        {
+            using (var repo = new Repository(StandardTestRepoPath))
+            {
+                Assert.Equal(currentStatus, repo.Index.RetrieveStatus(relativePath));
+
+                TreeChanges changes = repo.Diff.Compare(new[] { relativePath }, false, new ExplicitPathsOptions { ShouldFailOnUnmatchedPath = false });
+                Assert.Equal(0, changes.Count());
+
+                changes = repo.Diff.Compare(new[] { relativePath });
+                Assert.Equal(0, changes.Count());
+            }
+        }
+
+        [Theory]
+        [InlineData("new_untracked_file.txt", FileStatus.Untracked)]
+        [InlineData("really-i-cant-exist.txt", FileStatus.Nonexistent)]
+        public void ComparingTheWorkDirAgainstTheIndexWithStrictUnmatchedExplicitPathsValidationAndANonExistentPathspecThrows(string relativePath, FileStatus currentStatus)
+        {
+            using (var repo = new Repository(StandardTestRepoPath))
+            {
+                Assert.Equal(currentStatus, repo.Index.RetrieveStatus(relativePath));
+
+                Assert.Throws<UnmatchedPathException>(() => repo.Diff.Compare(new[] { relativePath }, false, new ExplicitPathsOptions()));
+            }
+        }
+
+        [Theory]
+        [InlineData("new_untracked_file.txt", FileStatus.Untracked)]
+        [InlineData("where-am-I.txt", FileStatus.Nonexistent)]
+        public void CallbackForUnmatchedExplicitPathsIsCalledWhenSet(string relativePath, FileStatus currentStatus)
+        {
+            var callback = new AssertUnmatchedPathspecsCallbackIsCalled();
+
+            using (var repo = new Repository(StandardTestRepoPath))
+            {
+                Assert.Equal(currentStatus, repo.Index.RetrieveStatus(relativePath));
+
+                repo.Diff.Compare(new[] { relativePath }, false, new ExplicitPathsOptions { ShouldFailOnUnmatchedPath = false,
+                    OnUnmatchedPath = callback.OnUnmatchedPath });
+
+                Assert.True(callback.WasCalled);
+            }
+        }
+
+        private class AssertUnmatchedPathspecsCallbackIsCalled
+        {
+            public bool WasCalled;
+
+            public void OnUnmatchedPath(string unmatchedpath)
+            {
+                WasCalled = true;
+            }
+        }
+
+        [Fact]
+        public void ComparingReliesOnProvidedConfigEntriesIfAny()
+        {
+            const string file = "1/branch_file.txt";
+
+            string path = CloneStandardTestRepo();
+            using (var repo = new Repository(path))
+            {
+                TreeEntry entry = repo.Head[file];
+                Assert.Equal(Mode.ExecutableFile, entry.Mode);
+
+                // Recreate the file in the workdir without the executable bit
+                string fullpath = Path.Combine(repo.Info.WorkingDirectory, file);
+                File.Delete(fullpath);
+                File.WriteAllBytes(fullpath, ((Blob)(entry.Target)).Content);
+
+                // Unset the local core.filemode, if any.
+                repo.Config.Unset("core.filemode", ConfigurationLevel.Local);
+            }
+
+            SelfCleaningDirectory scd = BuildSelfCleaningDirectory();
+
+            var options = BuildFakeSystemConfigFilemodeOption(scd, true);
+
+            using (var repo = new Repository(path, options))
+            {
+                TreeChanges changes = repo.Diff.Compare(new[] { file });
+
+                Assert.Equal(1, changes.Count());
+
+                var change = changes.Modified.Single();
+                Assert.Equal(Mode.ExecutableFile, change.OldMode);
+                Assert.Equal(Mode.NonExecutableFile, change.Mode);
+            }
+
+            options = BuildFakeSystemConfigFilemodeOption(scd, false);
+
+            using (var repo = new Repository(path, options))
+            {
+                TreeChanges changes = repo.Diff.Compare(new[] { file });
+
+                Assert.Equal(0, changes.Count());
+            }
+        }
+
+        private RepositoryOptions BuildFakeSystemConfigFilemodeOption(
+            SelfCleaningDirectory scd,
+            bool value)
+        {
+            Directory.CreateDirectory(scd.DirectoryPath);
+
+            var options = new RepositoryOptions
+            {
+                SystemConfigurationLocation = Path.Combine(
+                    scd.RootedDirectoryPath, "fake-system.config")
+            };
+
+            StringBuilder sb = new StringBuilder()
+                .AppendFormat("[core]{0}", Environment.NewLine)
+                .AppendFormat("filemode = {1}{0}", Environment.NewLine, value);
+            File.WriteAllText(options.SystemConfigurationLocation, sb.ToString());
+
+            return options;
+        }
+
         [Fact]
         public void CanCompareTheWorkDirAgainstTheIndexWithUntrackedFiles()
         {

LibGit2Sharp.Tests/MetaFixture.cs

@@ -18,6 +18,7 @@ public class MetaFixture
             typeof(Repository),
             typeof(RepositoryOptions),
             typeof(Signature),
+            typeof(ExplicitPathsOptions),
         };
 
         // Related to https://github.com/libgit2/libgit2sharp/pull/251

LibGit2Sharp/Core/GitDiff.cs

@@ -159,6 +159,12 @@ public void Dispose()
         }
     }
 
+    internal delegate int diff_notify_cb(
+        IntPtr diff_so_far,
+        IntPtr delta_to_add,
+        IntPtr matched_pathspec,
+        IntPtr payload);
+
     [StructLayout(LayoutKind.Sequential)]
     internal class GitDiffOptions : IDisposable
     {
@@ -174,7 +180,7 @@ internal class GitDiffOptions : IDisposable
         public GitStrArrayIn PathSpec;
         public Int64 MaxSize;
 
-        public IntPtr NotifyCallback;
+        public diff_notify_cb NotifyCallback;
         public IntPtr NotifyPayload;
 
         public void Dispose()