Added HasDifferences property to DiffPaneModel.cs

mmanela · May 21, 2020 · 30a65b8 · 30a65b8
1 parent f14e86d
commit 30a65b8
Show file tree

Hide file tree

Showing 6 changed files with 67 additions and 10 deletions.
diff --git a/.idea/.gitignore b/.idea/.gitignore
diff --git a/DiffPlex/DiffBuilder/InlineDiffBuilder.cs b/DiffPlex/DiffBuilder/InlineDiffBuilder.cs
@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.Linq;
 using DiffPlex.Chunkers;
 using DiffPlex.DiffBuilder.Model;
 using DiffPlex.Model;
@@ -35,9 +36,12 @@ public DiffPaneModel BuildDiffModel(string oldText, string newText, bool ignoreW
             if (newText == null) throw new ArgumentNullException(nameof(newText));
 
             var model = new DiffPaneModel();
+            bool hasDifferences;
 
             var diffResult = differ.CreateDiffs(oldText, newText, ignoreWhitespace, ignoreCase: ignoreCase, chunker);
-            BuildDiffPieces(diffResult, model.Lines);
+            BuildDiffPieces(diffResult, model.Lines, out hasDifferences);
+            model.HasDifferences = hasDifferences;
+
             return model;
         }
 
@@ -71,12 +75,16 @@ public static DiffPaneModel Diff(IDiffer differ, string oldText, string newText,
             if (newText == null) throw new ArgumentNullException(nameof(newText));
 
             var model = new DiffPaneModel();
+            bool hasDifferences;
+
             var diffResult = (differ ?? Differ.Instance).CreateDiffs(oldText, newText, ignoreWhiteSpace, ignoreCase, chunker ?? LineChunker.Instance);
-            BuildDiffPieces(diffResult, model.Lines);
+            BuildDiffPieces(diffResult, model.Lines, out hasDifferences);
+            model.HasDifferences = hasDifferences;
+
             return model;
         }
 
-        private static void BuildDiffPieces(DiffResult diffResult, List<DiffPiece> pieces)
+        private static void BuildDiffPieces(DiffResult diffResult, List<DiffPiece> pieces, out bool hasDifferences)
         {
             int bPos = 0;
 
@@ -113,6 +121,8 @@ private static void BuildDiffPieces(DiffResult diffResult, List<DiffPiece> piece
 
             for (; bPos < diffResult.PiecesNew.Length; bPos++)
                 pieces.Add(new DiffPiece(diffResult.PiecesNew[bPos], ChangeType.Unchanged, bPos + 1));
+
+            hasDifferences = pieces.Any(x => x.Type != ChangeType.Unchanged);
         }
     }
 }
diff --git a/DiffPlex/DiffBuilder/Model/DiffPaneModel.cs b/DiffPlex/DiffBuilder/Model/DiffPaneModel.cs
@@ -5,6 +5,8 @@ namespace DiffPlex.DiffBuilder.Model
     public class DiffPaneModel
     {
         public List<DiffPiece> Lines { get; }
+
+        public bool HasDifferences { get; internal set; } = false;
 
         public DiffPaneModel()
         {

diff --git a/DiffPlex/DiffBuilder/SideBySideDiffBuilder.cs b/DiffPlex/DiffBuilder/SideBySideDiffBuilder.cs
@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.Linq;
 using DiffPlex.Chunkers;
 using DiffPlex.DiffBuilder.Model;
 using DiffPlex.Model;
@@ -61,8 +62,14 @@ public static SideBySideDiffModel Diff(string oldText, string newText, bool igno
             if (newText == null) throw new ArgumentNullException(nameof(newText));
 
             var model = new SideBySideDiffModel();
+            bool hasDifferences;
+
             var diffResult = Differ.Instance.CreateDiffs(oldText, newText, ignoreWhiteSpace, ignoreCase, LineChunker.Instance);
-            BuildDiffPieces(diffResult, model.OldText.Lines, model.NewText.Lines, BuildWordDiffPiecesInternal);
+            BuildDiffPieces(diffResult, model.OldText.Lines, model.NewText.Lines, out hasDifferences, BuildWordDiffPiecesInternal);
+
+            model.NewText.HasDifferences = hasDifferences;
+            model.OldText.HasDifferences = hasDifferences;
+
             return model;
         }
 
@@ -84,36 +91,49 @@ public static SideBySideDiffModel Diff(IDiffer differ, string oldText, string ne
 
             if (differ == null) return Diff(oldText, newText, ignoreWhiteSpace, ignoreCase);
             var model = new SideBySideDiffModel();
+            bool hasDifferences;
+
             var diffResult = differ.CreateDiffs(oldText, newText, ignoreWhiteSpace, ignoreCase, lineChunker ?? LineChunker.Instance);
-            BuildDiffPieces(diffResult, model.OldText.Lines, model.NewText.Lines, (ot, nt, op, np) =>
+            BuildDiffPieces(diffResult, model.OldText.Lines, model.NewText.Lines, out hasDifferences, (ot, nt, op, np) =>
             {
                 var r = differ.CreateDiffs(oldText, newText, false, false, wordChunker ?? WordChunker.Instance);
-                BuildDiffPieces(r, op, np, null);
+                BuildDiffPieces(r, op, np, out hasDifferences, null);
             });
+            model.NewText.HasDifferences = hasDifferences;
+            model.OldText.HasDifferences = hasDifferences;
+
             return model;
         }
 
         private static void BuildWordDiffPiecesInternal(string oldText, string newText, List<DiffPiece> oldPieces, List<DiffPiece> newPieces)
         {
             var diffResult = Differ.Instance.CreateDiffs(oldText, newText, false, false, WordChunker.Instance);
-            BuildDiffPieces(diffResult, oldPieces, newPieces, null);
+            bool hasDifferences;
+            BuildDiffPieces(diffResult, oldPieces, newPieces, out hasDifferences, null);
         }
 
         private SideBySideDiffModel BuildLineDiff(string oldText, string newText, bool ignoreWhitespace)
         {
             var model = new SideBySideDiffModel();
+            bool hasDifferences;
+
             var diffResult = differ.CreateDiffs(oldText, newText, ignoreWhitespace, false, lineChunker);
-            BuildDiffPieces(diffResult, model.OldText.Lines, model.NewText.Lines, BuildWordDiffPieces);
+            BuildDiffPieces(diffResult, model.OldText.Lines, model.NewText.Lines, out hasDifferences, BuildWordDiffPieces);
+
+            model.NewText.HasDifferences = hasDifferences;
+            model.OldText.HasDifferences = hasDifferences;
+
             return model;
         }
 
         private void BuildWordDiffPieces(string oldText, string newText, List<DiffPiece> oldPieces, List<DiffPiece> newPieces)
         {
+            bool hasDifferences;
             var diffResult = differ.CreateDiffs(oldText, newText, ignoreWhiteSpace: false, false, wordChunker);
-            BuildDiffPieces(diffResult, oldPieces, newPieces, subPieceBuilder: null);
+            BuildDiffPieces(diffResult, oldPieces, newPieces, out hasDifferences, subPieceBuilder: null);
         }
 
-        private static void BuildDiffPieces(DiffResult diffResult, List<DiffPiece> oldPieces, List<DiffPiece> newPieces, PieceBuilder subPieceBuilder)
+        private static void BuildDiffPieces(DiffResult diffResult, List<DiffPiece> oldPieces, List<DiffPiece> newPieces, out bool hasDifferences, PieceBuilder subPieceBuilder)
         {
             int aPos = 0;
             int bPos = 0;
@@ -173,6 +193,8 @@ private static void BuildDiffPieces(DiffResult diffResult, List<DiffPiece> oldPi
                 aPos++;
                 bPos++;
             }
+
+            hasDifferences = newPieces.Any(x => x.Type != ChangeType.Unchanged);
         }
     }
 }
diff --git a/Facts.DiffPlex/InlineDiffBuilderFacts.cs b/Facts.DiffPlex/InlineDiffBuilderFacts.cs
@@ -69,6 +69,8 @@ public void Will_build_diffModel_for_duplicate_strings()
                     Assert.Equal(ChangeType.Unchanged, bidiff.Lines[i].Type);
                     Assert.Equal(i + 1, bidiff.Lines[i].Position);
                 }
+
+                Assert.False(bidiff.HasDifferences);
             }
 
             [Fact]
@@ -94,6 +96,8 @@ public void Will_build_diffModel_when_oldText_is_empty()
                     Assert.Equal(ChangeType.Inserted, bidiff.Lines[j].Type);
                     Assert.Equal(j + 1, bidiff.Lines[j].Position);
                 }
+
+                Assert.True(bidiff.HasDifferences);
             }
 
             [Fact]
@@ -119,6 +123,8 @@ public void Will_build_diffModel_when_newText_is_empty()
                     Assert.Equal(ChangeType.Deleted, bidiff.Lines[j].Type);
                     Assert.Null(bidiff.Lines[j].Position);
                 }
+
+                Assert.True(bidiff.HasDifferences);
             }
 
             [Fact]
@@ -157,6 +163,7 @@ public void Will_build_diffModel_for_unique_strings()
                 Assert.Equal("", bidiff.Lines[8].Text);
                 Assert.Equal(ChangeType.Deleted, bidiff.Lines[8].Type);
                 Assert.Null(bidiff.Lines[8].Position);
+                Assert.True(bidiff.HasDifferences);
             }
 
             [Fact]
@@ -203,6 +210,7 @@ public void Will_build_diffModel_for_middle_is_different_documents()
                 Assert.Equal("f", bidiff.Lines[11].Text);
                 Assert.Equal(ChangeType.Unchanged, bidiff.Lines[11].Type);
                 Assert.Equal(8, bidiff.Lines[11].Position);
+                Assert.True(bidiff.HasDifferences);
             }
 
             [Fact]
@@ -255,6 +263,7 @@ public void Will_build_diffModel_for_multiple_diff_blocks()
                 Assert.Equal("f", bidiff.Lines[10].Text);
                 Assert.Equal(ChangeType.Unchanged, bidiff.Lines[10].Type);
                 Assert.Equal(8, bidiff.Lines[10].Position);
+                Assert.True(bidiff.HasDifferences);
             }
 
             [Fact]

diff --git a/Facts.DiffPlex/SideBySideDiffBuilderFacts.cs b/Facts.DiffPlex/SideBySideDiffBuilderFacts.cs
@@ -75,6 +75,8 @@ public void Will_build_diffModel_for_duplicate_strings()
                     Assert.Equal(ChangeType.Unchanged, bidiff.NewText.Lines[i].Type);
                     Assert.Equal(i + 1, bidiff.NewText.Lines[i].Position);
                 }
+
+                Assert.False(bidiff.OldText.HasDifferences && bidiff.NewText.HasDifferences);
             }
 
             [Fact]
@@ -107,6 +109,8 @@ public void Will_build_diffModel_when_oldText_is_empty()
                     Assert.Equal(ChangeType.Imaginary, bidiff.OldText.Lines[j].Type);
                     Assert.False(bidiff.OldText.Lines[j].Position.HasValue);
                 }
+
+                Assert.True(bidiff.OldText.HasDifferences && bidiff.NewText.HasDifferences);
             }
 
             [Fact]
@@ -137,6 +141,8 @@ public void Will_build_diffModel_when_newText_is_empty()
                     Assert.Equal(ChangeType.Imaginary, bidiff.NewText.Lines[j].Type);
                     Assert.False(bidiff.NewText.Lines[j].Position.HasValue);
                 }
+
+                Assert.True(bidiff.OldText.HasDifferences && bidiff.NewText.HasDifferences);
             }
 
             [Fact]
@@ -196,6 +202,8 @@ public void Will_build_diffModel_for_unique_strings()
                         Assert.False(bidiff.NewText.Lines[j].Position.HasValue);
                     }
                 }
+
+                Assert.True(bidiff.OldText.HasDifferences && bidiff.NewText.HasDifferences);
             }
 
             [Fact]
@@ -266,6 +274,8 @@ public void Will_build_diffModel_for_partially_different_documents()
                         Assert.False(bidiff.NewText.Lines[j].Position.HasValue);
                     }
                 }
+
+                Assert.True(bidiff.OldText.HasDifferences && bidiff.NewText.HasDifferences);
             }
 
 
@@ -302,6 +312,8 @@ public void Will_build_diffModel_for_partially_different_lines()
                 Assert.Equal(ChangeType.Unchanged, bidiff.OldText.Lines[0].SubPieces[2].Type);
                 Assert.Equal(ChangeType.Imaginary, bidiff.OldText.Lines[0].SubPieces[3].Type);
                 Assert.Equal(ChangeType.Unchanged, bidiff.OldText.Lines[0].SubPieces[4].Type);
+
+                Assert.True(bidiff.OldText.HasDifferences && bidiff.NewText.HasDifferences);
             }
 
             [Fact]