Make Diff.Compare able to expose type changes

Fix #196

Author: nulltoken

LibGit2Sharp.Tests/DiffTreeToTreeFixture.cs

@@ -356,6 +356,78 @@ public void CanCompareTwoVersionsOfAFileWithADiffOfTwoHunks()
             }
         }
 
+        [Fact]
+        public void CanHandleTwoTreeEntryChangesWithTheSamePath()
+        {
+            SelfCleaningDirectory scd = BuildSelfCleaningDirectory();
+
+            using (Repository repo = Repository.Init(scd.DirectoryPath))
+            {
+                Blob mainContent = CreateBlob(repo, "awesome content\n");
+                Blob linkContent = CreateBlob(repo, "../../objc/Nu.h");
+
+                string path = string.Format("include{0}Nu{0}Nu.h", Path.DirectorySeparatorChar);
+
+                var tdOld = new TreeDefinition()
+                    .Add(path, linkContent, Mode.SymbolicLink)
+                    .Add("objc/Nu.h", mainContent, Mode.NonExecutableFile);
+
+                Tree treeOld = repo.ObjectDatabase.CreateTree(tdOld);
+
+                var tdNew = new TreeDefinition()
+                    .Add(path, mainContent, Mode.NonExecutableFile);
+
+                Tree treeNew = repo.ObjectDatabase.CreateTree(tdNew);
+
+                TreeChanges changes = repo.Diff.Compare(treeOld, treeNew);
+
+                /*
+                 * $ git diff-tree -p 5c87b67 d5278d0
+                 * diff --git a/include/Nu/Nu.h b/include/Nu/Nu.h
+                 * deleted file mode 120000
+                 * index 19bf568..0000000
+                 * --- a/include/Nu/Nu.h
+                 * +++ /dev/null
+                 * @@ -1 +0,0 @@
+                 * -../../objc/Nu.h
+                 * \ No newline at end of file
+                 * diff --git a/include/Nu/Nu.h b/include/Nu/Nu.h
+                 * new file mode 100644
+                 * index 0000000..f9e6561
+                 * --- /dev/null
+                 * +++ b/include/Nu/Nu.h
+                 * @@ -0,0 +1 @@
+                 * +awesome content
+                 * diff --git a/objc/Nu.h b/objc/Nu.h
+                 * deleted file mode 100644
+                 * index f9e6561..0000000
+                 * --- a/objc/Nu.h
+                 * +++ /dev/null
+                 * @@ -1 +0,0 @@
+                 * -awesome content
+                 */
+
+                Assert.Equal(1, changes.Deleted.Count());
+                Assert.Equal(0, changes.Modified.Count());
+                Assert.Equal(1, changes.TypeChanged.Count());
+
+                TreeEntryChanges change = changes[path];
+                Assert.Equal(Mode.SymbolicLink, change.OldMode);
+                Assert.Equal(Mode.NonExecutableFile, change.Mode);
+                Assert.Equal(ChangeKind.TypeChanged, change.Status);
+                Assert.Equal(path, change.Path);
+            }
+        }
+
+        private static Blob CreateBlob(Repository repo, string content)
+        {
+            using (var stream = new MemoryStream(Encoding.UTF8.GetBytes(content)))
+            using (var binReader = new BinaryReader(stream))
+            {
+                return repo.ObjectDatabase.CreateBlob(binReader);
+            }
+        }
+
         [Fact]
         public void CanCompareATreeAgainstANullTree()
         {

LibGit2Sharp/ChangeKind.cs

@@ -44,5 +44,11 @@ public enum ChangeKind
         ///   The file is untracked in the workdir.
         /// </summary>
         Untracked = 7,
+
+        /// <summary>
+        ///   The type (i.e. regular file, symlink, submodule, ...)
+        ///   of the file was changed.
+        /// </summary>
+        TypeChanged = 8,
     }
-}
+}

LibGit2Sharp/Diff.cs

@@ -22,6 +22,8 @@ private GitDiffOptions BuildOptions(DiffOptions diffOptions, IEnumerable<string>
         {
             var options = new GitDiffOptions();
 
+            options.Flags |= GitDiffOptionFlags.GIT_DIFF_INCLUDE_TYPECHANGE;
+
             if (diffOptions.HasFlag(DiffOptions.IncludeUntracked))
             {
                 options.Flags |= GitDiffOptionFlags.GIT_DIFF_INCLUDE_UNTRACKED |

LibGit2Sharp/TreeChanges.cs

@@ -21,6 +21,7 @@ public class TreeChanges : IEnumerable<TreeEntryChanges>
         private readonly List<TreeEntryChanges> added = new List<TreeEntryChanges>();
         private readonly List<TreeEntryChanges> deleted = new List<TreeEntryChanges>();
         private readonly List<TreeEntryChanges> modified = new List<TreeEntryChanges>();
+        private readonly List<TreeEntryChanges> typeChanged = new List<TreeEntryChanges>();
         private int linesAdded;
         private int linesDeleted;
 
@@ -37,6 +38,7 @@ private static IDictionary<ChangeKind, Action<TreeChanges, TreeEntryChanges>> Bu
                            { ChangeKind.Modified, (de, d) => de.modified.Add(d) },
                            { ChangeKind.Deleted, (de, d) => de.deleted.Add(d) },
                            { ChangeKind.Added, (de, d) => de.added.Add(d) },
+                           { ChangeKind.TypeChanged, (de, d) => de.typeChanged.Add(d) },
                        };
         }
 
@@ -176,6 +178,14 @@ public virtual IEnumerable<TreeEntryChanges> Modified
             get { return modified; }
         }
 
+        /// <summary>
+        ///   List of <see cref = "TreeEntryChanges"/> which type have been changed.
+        /// </summary>
+        public virtual IEnumerable<TreeEntryChanges> TypeChanged
+        {
+            get { return typeChanged; }
+        }
+
         /// <summary>
         ///   The total number of lines added in this diff.
         /// </summary>
@@ -205,8 +215,9 @@ private string DebuggerDisplay
             get
             {
                 return string.Format(CultureInfo.InvariantCulture,
-                    "Added: {0}, Deleted: {1}, Modified: {2}",
-                    Added.Count(), Deleted.Count(), Modified.Count());
+                    "Add: {0}, Del: {1}, Mod: {2}, Typ: {3}",
+                    Added.Count(), Deleted.Count(),
+                    Modified.Count(), TypeChanged.Count());
             }
         }
     }

LibGit2Sharp/TreeDefinition.cs

@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Collections.Generic;
 using System.Globalization;
 using System.IO;
@@ -135,8 +135,7 @@ public virtual TreeDefinition Add(string targetTreeEntryPath, TreeEntryDefinitio
         public virtual TreeDefinition Add(string targetTreeEntryPath, Blob blob, Mode mode)
         {
             Ensure.ArgumentNotNull(blob, "blob");
-            Ensure.ArgumentConformsTo(mode,
-                                      m => m.HasAny(new[] { Mode.ExecutableFile, Mode.NonExecutableFile, Mode.NonExecutableGroupWritableFile }), "mode");
+            Ensure.ArgumentConformsTo(mode, m => m.HasAny(TreeEntryDefinition.BlobModes), "mode");
 
             TreeEntryDefinition ted = TreeEntryDefinition.From(blob, mode);
 

LibGit2Sharp/TreeEntryDefinition.cs

@@ -1,4 +1,4 @@
-using System;
+using System;
 using LibGit2Sharp.Core;
 using LibGit2Sharp.Core.Compat;
 
@@ -14,6 +14,8 @@ public class TreeEntryDefinition : IEquatable<TreeEntryDefinition>
         private static readonly LambdaEqualityHelper<TreeEntryDefinition> equalityHelper =
             new LambdaEqualityHelper<TreeEntryDefinition>(x => x.Mode, x => x.Type, x => x.TargetId);
 
+        internal static readonly Mode[] BlobModes = new[] { Mode.NonExecutableFile, Mode.ExecutableFile, Mode.NonExecutableGroupWritableFile, Mode.SymbolicLink };
+
         /// <summary>
         ///   Needed for mocking purposes.
         /// </summary>
@@ -65,7 +67,7 @@ internal static TreeEntryDefinition From(Blob blob, Mode mode)
 
         internal static TreeEntryDefinition TransientBlobFrom(string filePath, Mode mode)
         {
-            Ensure.ArgumentConformsTo(mode, m => m.HasAny(new[] { Mode.NonExecutableFile, Mode.ExecutableFile, Mode.NonExecutableGroupWritableFile }), "mode");
+            Ensure.ArgumentConformsTo(mode, m => m.HasAny(BlobModes), "mode");
 
             return new TransientBlobTreeEntryDefinition
                        {