Refactored interface to enable rename and copy detection and added te…

…sts. Note that copy tests are currently failing.
libgit2 · roend83 · Dec 6, 2012 · Feb 8, 2013 · Feb 9, 2013 · Feb 8, 2013
commit d868ca6b7596bc3a0f5140523c4165bef70b548b
diff --git a/LibGit2Sharp.Tests/DiffTreeToTreeFixture.cs b/LibGit2Sharp.Tests/DiffTreeToTreeFixture.cs
@@ -355,7 +355,7 @@ public void CanCompareTwoVersionsOfAFileWithADiffOfTwoHunks()
                 Assert.Equal(expected.ToString(), changes.Patch);
             }
         }
-
+            
         [Fact]
         public void CanCompareATreeAgainstANullTree()
         {
@@ -436,6 +436,153 @@ public void ComparingReliesOnProvidedConfigEntriesIfAny()
             }
         }
 
+        [Fact]
+        public void CanDetectTheRenamingOfNonModifiedFilesWhenEnabled()
+        {
+            SelfCleaningDirectory scd = BuildSelfCleaningDirectory();
+            using (var repo = Repository.Init(scd.DirectoryPath))
+            {
+                string originalPath = Path.Combine(repo.Info.WorkingDirectory, "original.txt");
+                string renamedPath = Path.Combine(repo.Info.WorkingDirectory, "renamed.txt");
+
+                File.WriteAllText(originalPath, "a\nb\nc\nd\n");
+
+                repo.Index.Stage(originalPath);
+
+                Commit old = repo.Commit("Initial", DummySignature, DummySignature);
+
+                repo.Index.Move(originalPath, renamedPath);
+
+                Commit @new = repo.Commit("Updated", DummySignature, DummySignature);
+
+                TreeChanges changes = repo.Diff.Compare(old.Tree, @new.Tree, detectRenames: true);
+
+                Assert.Equal(1, changes.Count());
+                Assert.Equal(1, changes.Renamed.Count());
+                Assert.Equal("original.txt", changes.Renamed.Single().OldPath);
+                Assert.Equal("renamed.txt", changes.Renamed.Single().Path);
+            }
+        }
+
+        [Fact]
+        public void CanNotDetectTheRenamingOfNonModifiedFilesWhenNotEnabled()
+        {
+            SelfCleaningDirectory scd = BuildSelfCleaningDirectory();
+            using (var repo = Repository.Init(scd.DirectoryPath))
+            {
+                string originalPath = Path.Combine(repo.Info.WorkingDirectory, "original.txt");
+                string renamedPath = Path.Combine(repo.Info.WorkingDirectory, "renamed.txt");
+
+                File.WriteAllText(originalPath, "a\nb\nc\nd\n");
+
+                repo.Index.Stage(originalPath);
+
+                Commit old = repo.Commit("Initial", DummySignature, DummySignature);
+
+                repo.Index.Move(originalPath, renamedPath);
+
+                Commit @new = repo.Commit("Updated", DummySignature, DummySignature);
+
+                TreeChanges changes = repo.Diff.Compare(old.Tree, @new.Tree, detectRenames: false);
+
+                Assert.Equal(2, changes.Count());
+                Assert.Equal(0, changes.Renamed.Count());
+            }
+        }
+
+        [Fact]
+        public void CanDetectTheCopyingOfNonModifiedFilesWhenEnabled()
+        {
+            SelfCleaningDirectory scd = BuildSelfCleaningDirectory();
+            using (var repo = Repository.Init(scd.DirectoryPath))
+            {
+                string originalPath = Path.Combine(repo.Info.WorkingDirectory, "original.txt");
+                string copiedPath = Path.Combine(repo.Info.WorkingDirectory, "copied.txt");
+
+                File.WriteAllText(originalPath, "a\nb\nc\nd\n");
+
+                repo.Index.Stage(originalPath);
+
+                Commit old = repo.Commit("Initial", DummySignature, DummySignature);
+
+                File.Copy(originalPath, copiedPath);
+                repo.Index.Stage(copiedPath);
+
+                Commit @new = repo.Commit("Updated", DummySignature, DummySignature);
+
+                TreeChanges changes = repo.Diff.Compare(old.Tree, @new.Tree, detectCopies: true);
+
+                Assert.Equal(1, changes.Count());
+                Assert.Equal(1, changes.Copied.Count());
+                Assert.Equal("original.txt", changes.Copied.Single().OldPath);
+                Assert.Equal("copied.txt", changes.Copied.Single().Path);
+            }
+        }
+
+        [Fact]
+        public void CanNotDetectTheCopyingOfNonModifiedFilesWhenNotEnabled()
+        {
+            SelfCleaningDirectory scd = BuildSelfCleaningDirectory();
+            using (var repo = Repository.Init(scd.DirectoryPath))
+            {
+                string originalPath = Path.Combine(repo.Info.WorkingDirectory, "original.txt");
+                string copiedPath = Path.Combine(repo.Info.WorkingDirectory, "copied.txt");
+
+                File.WriteAllText(originalPath, "a\nb\nc\nd\n");
+
+                repo.Index.Stage(originalPath);
+
+                Commit old = repo.Commit("Initial", DummySignature, DummySignature);
+
+                File.Copy(originalPath, copiedPath);
+                repo.Index.Stage(copiedPath);
+
+                Commit @new = repo.Commit("Updated", DummySignature, DummySignature);
+
+                TreeChanges changes = repo.Diff.Compare(old.Tree, @new.Tree, detectCopies: false);
+
+                Assert.Equal(1, changes.Count());
+                Assert.Equal(0, changes.Copied.Count());
+            }
+        }
+
+        [Fact]
+        public void CanDetectTheRenamingAndCopyingOfNonModifiedFilesWhenEnabled()
+        {
+            SelfCleaningDirectory scd = BuildSelfCleaningDirectory();
+            using (var repo = Repository.Init(scd.DirectoryPath))
+            {
+                string originalPath = Path.Combine(repo.Info.WorkingDirectory, "original.txt");
+                string renamedPath = Path.Combine(repo.Info.WorkingDirectory, "renamed.txt");
+                string otherOriginalPath = Path.Combine(repo.Info.WorkingDirectory, "original2.txt");
+                string copiedPath = Path.Combine(repo.Info.WorkingDirectory, "copied.txt");
+
+                File.WriteAllText(originalPath, "a\nb\nc\nd\n");
+                File.WriteAllText(otherOriginalPath, "1\n2\n3\n4\n");
+
+                repo.Index.Stage(originalPath);
+                repo.Index.Stage(otherOriginalPath);
+
+                Commit old = repo.Commit("Initial", DummySignature, DummySignature);
+
+                File.Copy(otherOriginalPath, copiedPath);
+                repo.Index.Stage(copiedPath);
+                repo.Index.Move(originalPath, renamedPath);
+
+                Commit @new = repo.Commit("Updated", DummySignature, DummySignature);
+
+                TreeChanges changes = repo.Diff.Compare(old.Tree, @new.Tree, detectRenames: true, detectCopies: true);
+
+                Assert.Equal(2, changes.Count());
+                Assert.Equal(1, changes.Renamed.Count());
+                Assert.Equal("original.txt", changes.Renamed.Single().OldPath);
+                Assert.Equal("renamed.txt", changes.Renamed.Single().Path);
+                Assert.Equal(1, changes.Copied.Count());
+                Assert.Equal("original2.txt", changes.Copied.Single().OldPath);
+                Assert.Equal("copied.txt", changes.Copied.Single().Path);
+            }
+        }
+
         private RepositoryOptions BuildFakeSystemConfigFilemodeOption(
             SelfCleaningDirectory scd,
             bool value)

diff --git a/LibGit2Sharp/Diff.cs b/LibGit2Sharp/Diff.cs
@@ -92,32 +92,55 @@ internal Diff(Repository repo)
         }
 
         /// <summary>
-        ///   Show changes between two <see cref = "Tree"/>s.
+        /// Show changes between two <see cref="Tree" />s.
         /// </summary>
-        /// <param name = "oldTree">The <see cref = "Tree"/> you want to compare from.</param>
-        /// <param name = "newTree">The <see cref = "Tree"/> you want to compare to.</param>
-        /// <param name = "paths">The list of paths (either files or directories) that should be compared.</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)
+        /// <param name="oldTree">The <see cref="Tree" /> you want to compare from.</param>
+        /// <param name="newTree">The <see cref="Tree" /> you want to compare to.</param>
+        /// <param name="paths">The list of paths (either files or directories) that should be compared.</param>
+        /// <param name="detectRenames">if set to <c>true</c> renames will be detected in the diff.</param>
+        /// <param name="detectCopies">if set to <c>true</c> copies will be detected in the diff.</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, bool detectRenames = false, bool detectCopies = false)
         {
             using(GitDiffOptions options = BuildOptions(DiffOptions.None, paths))
             using (DiffListSafeHandle diff = BuildDiffListFromTrees(
                 oldTree != null ? oldTree.Id : null,
                 newTree != null ? newTree.Id : null,
-                options))
+                options,
+                detectRenames,
+                detectCopies))
             {
-                Proxy.git_diff_find_similar(diff, new GitDiffFindOptions
-                                                      {
-                                                          Flags = GitDiffFindOptionFlags.GIT_DIFF_FIND_RENAMES
-                                                      });
-
                 return new TreeChanges(diff);
             }
         }
 
-        private DiffListSafeHandle BuildDiffListFromTrees(ObjectId oldTree, ObjectId newTree, GitDiffOptions options)
+        private DiffListSafeHandle BuildDiffListFromTrees(ObjectId oldTree, ObjectId newTree, GitDiffOptions options, bool detectRenames, bool detectCopies)
         {
-            return Proxy.git_diff_tree_to_tree(repo.Handle, oldTree, newTree, options);
+            var diff = Proxy.git_diff_tree_to_tree(repo.Handle,
77E6
 oldTree, newTree, options);
+            return HandleRenameAndCopyDetection(diff, detectRenames, detectCopies);
+        }
+
+        private DiffListSafeHandle HandleRenameAndCopyDetection(DiffListSafeHandle diff, bool detectRenames, bool detectCopies)
+        {
+            if (detectRenames || detectCopies)
+            {
+                var diffFindOptions = new GitDiffFindOptions();
+
+                if (!detectCopies)
+                {
+                    diffFindOptions.Flags = GitDiffFindOptionFlags.GIT_DIFF_FIND_RENAMES;
+                }
+                else if (!detectRenames)
+                {
+                    diffFindOptions.Flags = GitDiffFindOptionFlags.GIT_DIFF_FIND_COPIES;
+                }
+
+                Proxy.git_diff_find_similar(diff, diffFindOptions);
+            }
+
+            return diff;
         }
 
         /// <summary>