- Add option to skip data

Author: jycr

src/main/java/difflib/DiffAlgorithm.java

@@ -15,7 +15,9 @@
  */
 package difflib;
 
-import java.util.*;
+import java.util.List;
+
+import difflib.myers.Equalizer;
 
 /**
  * The general interface for computing diffs between two lists of elements of type T. 
@@ -44,4 +46,10 @@ public interface DiffAlgorithm<T> {
      * @return The patch representing the diff of the given sequences. Never {@code null}.
      */
     public Patch<T> diff(List<T> original, List<T> revised);
+    
+    /**
+     * Get equalizer use to compare data.
+     * @return
+     */
+    public Equalizer<T> getEqualizer();
 }

src/main/java/difflib/DiffRow.java

@@ -41,7 +41,7 @@ public DiffRow(@Nonnull Tag tag, @Nullable String oldLine, @Nullable String newL
     }
 
     public static enum Tag {
-        INSERT, DELETE, CHANGE, EQUAL
+        INSERT, DELETE, CHANGE, EQUAL, SKIP
     }
 
     /**

src/main/java/difflib/DiffRowGenerator.java

@@ -71,6 +71,11 @@ public class DiffRowGenerator {
         public boolean equals(String original, String revised) {
             return Objects.equals(original, revised);
         }
+
+        @Override
+        public boolean skip(String original) {
+            return false;
+        }
     });
 
     private final boolean showInlineDiffs;
@@ -331,6 +336,9 @@ public List<DiffRow> generateDiffRows(List<String> original, List<String> revise
         int orgEndPos = 0;
         int revEndPos = 0;
         final List<Delta<String>> deltaList = patch.getDeltas();
+
+        Equalizer<String> equalizer = diffAlgorithm.getEqualizer();
+
         for (int i = 0; i < deltaList.size(); i++) {
             Delta<String> delta = deltaList.get(i);
             Chunk<String> orig = delta.getOriginal();
@@ -345,14 +353,19 @@ public List<DiffRow> generateDiffRows(List<String> original, List<String> revise
                 rev.setLines(StringUtills.wrapText(rev.getLines(), this.columnWidth));
             }
             // catch the equal prefix for each chunk
-            copyEqualsLines(diffRows, original, orgEndPos, orig.getPosition(), revised, revEndPos, rev.getPosition());
+            copyEqualsLines(equalizer, diffRows, original, orgEndPos, orig.getPosition(), revised, revEndPos,
+                    rev.getPosition());
 
             // Inserted DiffRow
             if (delta.getClass() == InsertDelta.class) {
                 orgEndPos = orig.last() + 1;
                 revEndPos = rev.last() + 1;
                 for (String line : rev.getLines()) {
-                    diffRows.add(new DiffRow(Tag.INSERT, defaultString, line));
+                    if (equalizer.skip(line)) {
+                        diffRows.add(new DiffRow(Tag.SKIP, defaultString, line));
+                    } else {
+                        diffRows.add(new DiffRow(Tag.INSERT, defaultString, line));
+                    }
                 }
                 continue;
             }
@@ -362,7 +375,11 @@ public List<DiffRow> generateDiffRows(List<String> original, List<String> revise
                 orgEndPos = orig.last() + 1;
                 revEndPos = rev.last() + 1;
                 for (String line : orig.getLines()) {
-                    diffRows.add(new DiffRow(Tag.DELETE, line, defaultString));
+                    if (equalizer.skip(line)) {
+                        diffRows.add(new DiffRow(Tag.SKIP, line, defaultString));
+                    } else {
+                        diffRows.add(new DiffRow(Tag.DELETE, line, defaultString));
+                    }
                 }
                 continue;
             }
@@ -373,30 +390,49 @@ public List<DiffRow> generateDiffRows(List<String> original, List<String> revise
             // the changed size is match
             if (orig.size() == rev.size()) {
                 for (int j = 0; j < orig.size(); j++) {
-                    diffRows.add(new DiffRow(Tag.CHANGE, orig.getLines().get(j), rev.getLines().get(j)));
+                    addChangeDiffRow(equalizer, diffRows, orig.getLines().get(j), rev.getLines().get(j), defaultString);
                 }
             } else if (orig.size() > rev.size()) {
                 for (int j = 0; j < orig.size(); j++) {
-                    diffRows.add(new DiffRow(Tag.CHANGE, orig.getLines().get(j),
-                            rev.getLines().size() > j ? (String) rev.getLines().get(j) : defaultString));
+                    final String orgLine = orig.getLines().get(j);
+                    final String revLine = rev.getLines().size() > j ? rev.getLines().get(j) : defaultString;
+                    addChangeDiffRow(equalizer, diffRows, orgLine, revLine, defaultString);
                 }
             } else {
                 for (int j = 0; j < rev.size(); j++) {
-                    diffRows.add(new DiffRow(Tag.CHANGE, orig.getLines().size() > j ? orig.getLines().get(j)
-                            : defaultString, rev.getLines().get(j)));
+                    final String orgLine = orig.getLines().size() > j ? orig.getLines().get(j) : defaultString;
+                    final String revLine = rev.getLines().get(j);
+                    addChangeDiffRow(equalizer, diffRows, orgLine, revLine, defaultString);
                 }
             }
             orgEndPos = orig.last() + 1;
             revEndPos = rev.last() + 1;
         }
 
         // Copy the final matching chunk if any.
-        copyEqualsLines(diffRows, original, orgEndPos, original.size(), revised, revEndPos, revised.size());
+        copyEqualsLines(equalizer, diffRows, original, orgEndPos, original.size(), revised, revEndPos, revised.size());
         return diffRows;
     }
 
-    protected void copyEqualsLines(List<DiffRow> diffRows, List<String> original, int originalStartPos,
-            int originalEndPos, List<String> revised, int revisedStartPos, int revisedEndPos) {
+    private static final void addChangeDiffRow(Equalizer<String> equalizer, List<DiffRow> diffRows, String orgLine,
+            String revLine, String defaultString) {
+        boolean skipOrg = equalizer.skip(orgLine);
+        boolean skipRev = equalizer.skip(revLine);
+        if (skipOrg && skipRev) {
+            diffRows.add(new DiffRow(Tag.SKIP, orgLine, revLine));
+        } else if (skipOrg) {
+            diffRows.add(new DiffRow(Tag.SKIP, orgLine, defaultString));
+            diffRows.add(new DiffRow(Tag.CHANGE, defaultString, revLine));
+        } else if (skipRev) {
+            diffRows.add(new DiffRow(Tag.CHANGE, orgLine, defaultString));
+            diffRows.add(new DiffRow(Tag.SKIP, defaultString, revLine));
+        } else {
+            diffRows.add(new DiffRow(Tag.CHANGE, orgLine, revLine));
+        }
+    }
+
+    protected void copyEqualsLines(Equalizer<String> equalizer, List<DiffRow> diffRows, List<String> original,
+            int originalStartPos, int originalEndPos, List<String> revised, int revisedStartPos, int revisedEndPos) {
         String[][] lines = new String[originalEndPos - originalStartPos][2];
         int idx = 0;
         for (String line : original.subList(originalStartPos, originalEndPos)) {
@@ -407,7 +443,13 @@ protected void copyEqualsLines(List<DiffRow> diffRows, List<String> original, in
             lines[idx++][1] = line;
         }
         for (String[] line : lines) {
-            diffRows.add(new DiffRow(Tag.EQUAL, line[0], line[1]));
+            String orgLine = line[0];
+            String revLine = line[1];
+            if (equalizer.skip(orgLine) && equalizer.skip(revLine)) {
+                diffRows.add(new DiffRow(Tag.SKIP, orgLine, revLine));
+            } else {
+                diffRows.add(new DiffRow(Tag.EQUAL, orgLine, revLine));
+            }
         }
     }
 

src/main/java/difflib/myers/Equalizer.java

@@ -9,13 +9,21 @@
  * @param T The type of the compared elements in the 'lines'.
  */
 public interface Equalizer<T> {
-	
-	/**
-	 * Indicates if two elements are equal according to the diff mechanism.
-	 * @param original The original element. Must not be {@code null}.
-	 * @param revised The revised element. Must not be {@code null}.
-	 * @return Returns true if the elements are equal.
-	 */
+
+    /**
+     * Indicates if two elements are equal according to the diff mechanism.
+     * @param original The original element. Must not be {@code null}.
+     * @param revised The revised element. Must not be {@code null}.
+     * @return Returns true if the elements are equal.
+     */
+    @CheckReturnValue
+    public boolean equals(@Nullable T original, @Nullable T revised);
+
+    /**
+     * Indicates if elements must be skipped.
+     * @param original
+     * @return
+     */
     @CheckReturnValue
-	public boolean equals(@Nullable T original, @Nullable T revised);
+    public boolean skip(@Nullable T original);
 }

src/main/java/difflib/myers/MyersDiff.java

@@ -75,11 +75,21 @@
  * @param T The type of the compared elements in the 'lines'.
  */
 public class MyersDiff<T> implements DiffAlgorithm<T> {
-    
-	/**	Default equalizer. */
-	private final Equalizer<T> DEFAULT_EQUALIZER = new Equalizer<T>() {
+  /** Default equalizer. */
+  private final Equalizer<T> DEFAULT_EQUALIZER = new Equalizer<T>() {
         public boolean equals(final T original, final T revised) {
-            return original.equals(revised);
+            if (original == null && revised == null) {
+                return true;
+            }
+            if (original != null) {
+                return original.equals(revised);
+            }
+            return false;
+        }
+
+        @Override
+        public boolean skip(T original) {
+            return false;
         }
     };
 
@@ -295,5 +305,8 @@ public static <T, U> T[] copyOfRange2(U[] original, int from, int to,
         System.arraycopy(original, from, copy, 0, Math.min(original.length - from, newLength));
         return copy;
     }
-
-}
+    
+    public Equalizer<T> getEqualizer() {
+        return equalizer;
+    }
+}