Added Chunk surroundings

Author: Kogoro

README.md

@@ -50,6 +50,8 @@ This is a test ~senctence~**for diffutils**.
 But it can easily replaced by any other which is better for handing your texts. I have plan to add implementation of some in future.
 
 ### Changelog ###
+  * Version 2.2
+    * Added chunk to support surroundings of differences
   * Version 2.0
     * switch to maven and removed other artifacts
     * changed groupid to **com.github.java-diff-utils** due to different forks at github

pom.xml

@@ -3,7 +3,7 @@
     <groupId>com.github.java-diff-utils</groupId>
     <artifactId>diffutils</artifactId>
     <packaging>jar</packaging>
-    <version>2.1-SNAPSHOT</version>
+    <version>2.2-SNAPSHOT</version>
 
     <name>java-diff-utils</name>
     <description>The DiffUtils library for computing diffs, applying patches, generationg side-by-side view in Java.</description>
@@ -21,7 +21,7 @@
         <connection>scm:git:https://github.com/wumpz/java-diff-utils.git</connection>
         <developerConnection>scm:git:ssh://[email protected]:wumpz/java-diff-utils.git</developerConnection>
         <url>https://github.com/wumpz/java-diff-utils.git</url>
-      <tag>diffutils-2.0</tag>
+        <tag>diffutils-2.2</tag>
   </scm>
 
     <issueManagement>
@@ -34,6 +34,10 @@
     </organization>
 
     <developers>
+        <developer>
+            <name>Christopher Sontag</name>
+            <email>[email protected]</email>
+        </developer>
         <developer>
             <name>Tobias Warneke</name>
             <email>[email protected]</email>

src/main/java/com/github/difflib/DiffUtils.java

@@ -25,19 +25,18 @@
 import com.github.difflib.patch.Delta;
 import com.github.difflib.patch.Patch;
 import com.github.difflib.patch.PatchFailedException;
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.Collections;
-import java.util.List;
-import java.util.Objects;
+
+import java.util.*;
 import java.util.function.BiPredicate;
+
 import static java.util.stream.Collectors.joining;
 
 /**
  * Implements the difference and patching engine
  *
  * @author <a href="[email protected]">Dmitry Naumenko</a>
- * @version 0.4.1
+ * @author <a href="[email protected]">Christopher Sontag</a>
+ * @version 0.4.2
  */
 public final class DiffUtils {
 
@@ -47,18 +46,19 @@ public final class DiffUtils {
      *
      * @param original The original text. Must not be {@code null}.
      * @param revised The revised text. Must not be {@code null}.
+     * @param linesBeforeAfter - Amount of lines for before and after chunk content
      * @return The patch describing the difference between the original and revised sequences. Never
      * {@code null}.
      */
-    public static <T> Patch<T> diff(List<T> original, List<T> revised) throws DiffException {
-        return DiffUtils.diff(original, revised, new MyersDiff<>());
+    public static <T> Patch<T> diff(List<T> original, List<T> revised, int linesBeforeAfter) throws DiffException {
+        return DiffUtils.diff(original, revised, new MyersDiff<>(), linesBeforeAfter);
     }
 
     /**
      * Computes the difference between the original and revised text.
      */
-    public static Patch<String> diff(String originalText, String revisedText) throws DiffException {
-        return DiffUtils.diff(Arrays.asList(originalText.split("\n")), Arrays.asList(revisedText.split("\n")));
+    public static Patch<String> diff(String originalText, String revisedText, int linesBeforeAfter) throws DiffException {
+        return DiffUtils.diff(Arrays.asList(originalText.split("\n")), Arrays.asList(revisedText.split("\n")), linesBeforeAfter);
     }
 
     /**
@@ -70,16 +70,17 @@ public static Patch<String> diff(String originalText, String revisedText) throws
      *
      * @param equalizer the equalizer object to replace the default compare algorithm
      * (Object.equals). If {@code null} the default equalizer of the default algorithm is used..
+     * @param linesBeforeAfter - Amount of lines for before and after chunk content
      * @return The patch describing the difference between the original and revised sequences. Never
      * {@code null}.
      */
     public static <T> Patch<T> diff(List<T> original, List<T> revised,
-            BiPredicate<T,T> equalizer) throws DiffException {
+                                    BiPredicate<T, T> equalizer, int linesBeforeAfter) throws DiffException {
         if (equalizer != null) {
             return DiffUtils.diff(original, revised,
-                    new MyersDiff<>(equalizer));
+                    new MyersDiff<>(equalizer), linesBeforeAfter);
         }
-        return DiffUtils.diff(original, revised, new MyersDiff<>());
+        return DiffUtils.diff(original, revised, new MyersDiff<>(), linesBeforeAfter);
     }
 
     /**
@@ -89,16 +90,17 @@ public static <T> Patch<T> diff(List<T> original, List<T> revised,
      * @param original The original text. Must not be {@code null}.
      * @param revised The revised text. Must not be {@code null}.
      * @param algorithm The diff algorithm. Must not be {@code null}.
+     * @param linesBeforeAfter - Amount of lines for before and after chunk content
      * @return The patch describing the difference between the original and revised sequences. Never
      * {@code null}.
      */
     public static <T> Patch<T> diff(List<T> original, List<T> revised,
-            DiffAlgorithm<T> algorithm) throws DiffException {
+                                    DiffAlgorithm<T> algorithm, int linesBeforeAfter) throws DiffException {
         Objects.requireNonNull(original,"original must not be null");
         Objects.requireNonNull(revised,"revised must not be null");
         Objects.requireNonNull(algorithm,"algorithm must not be null");
-        
-        return Patch.generate(original, revised, algorithm.diff(original, revised));
+
+        return Patch.generate(original, revised, algorithm.diff(original, revised), linesBeforeAfter);
     }
 
     /**
@@ -108,9 +110,10 @@ public static <T> Patch<T> diff(List<T> original, List<T> revised,
      *
      * @param original
      * @param revised
+     * @param linesBeforeAfter - Amount of lines for before and after chunk content
      * @return
      */
-    public static Patch<String> diffInline(String original, String revised) throws DiffException {
+    public static Patch<String> diffInline(String original, String revised, int linesBeforeAfter) throws DiffException {
         List<String> origList = new ArrayList<>();
         List<String> revList = new ArrayList<>();
         for (Character character : original.toCharArray()) {
@@ -119,7 +122,7 @@ public static Patch<String> diffInline(String original, String revised) throws D
         for (Character character : revised.toCharArray()) {
             revList.add(character.toString());
         }
-        Patch<String> patch = DiffUtils.diff(origList, revList);
+        Patch<String> patch = DiffUtils.diff(origList, revList, linesBeforeAfter);
         for (Delta<String> delta : patch.getDeltas()) {
             delta.getOriginal().setLines(compressLines(delta.getOriginal().getLines(), ""));
             delta.getRevised().setLines(compressLines(delta.getRevised().getLines(), ""));

src/main/java/com/github/difflib/patch/Chunk.java

@@ -19,6 +19,7 @@
  */
 package com.github.difflib.patch;
 
+import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.List;
 
@@ -31,14 +32,17 @@
  * {@link java.lang.Object#hashCode hashCode()} and {@link java.lang.Object#equals equals()}
  * correctly can be subject to differencing using this library.
  * </p>
+ * T The type of the compared elements in the 'lines'.
  *
- * @author <a href="[email protected]>Dmitry Naumenko</a>
- * @param T The type of the compared elements in the 'lines'.
+ * @author <a href="[email protected]">Dmitry Naumenko</a>
+ * @author <a href="[email protected]">Christopher Sontag</a>
  */
 public final class Chunk<T> {
 
     private final int position;
     private List<T> lines;
+    private List<T> before = new ArrayList<>();
+    private List<T> after = new ArrayList<>();
 
     /**
      * Creates a chunk and saves a copy of affected lines
@@ -108,6 +112,28 @@ public int last() {
         return getPosition() + size() - 1;
     }
 
+    /**
+     * @return the lines before the affected lines
+     */
+    public List<T> getBefore() {
+        return before;
+    }
+
+    public void setBefore(List<T> before) {
+        this.before = before;
+    }
+
+    /**
+     * @return the lines after the affected lines
+     */
+    public List<T> getAfter() {
+        return after;
+    }
+
+    public void setAfter(List<T> after) {
+        this.after = after;
+    }
+
     /*
      * (non-Javadoc)
      * 
@@ -147,6 +173,8 @@ public boolean equals(Object obj) {
         } else if (!lines.equals(other.lines)) {
             return false;
         }
+        if (!before.equals(other.before)) return false;
+        if (!after.equals(other.after)) return false;
         return position == other.position;
     }
 

src/main/java/com/github/difflib/patch/Patch.java

@@ -20,19 +20,20 @@
 package com.github.difflib.patch;
 
 import com.github.difflib.algorithm.Change;
-import static com.github.difflib.patch.DeltaType.DELETE;
-import static com.github.difflib.patch.DeltaType.INSERT;
+
 import java.util.ArrayList;
 import java.util.Collections;
-import static java.util.Comparator.comparing;
 import java.util.List;
 import java.util.ListIterator;
 
+import static java.util.Comparator.comparing;
+
 /**
  * Describes the patch holding all deltas between the original and revised texts.
  *
+ * T The type of the compared elements in the 'lines'.
  * @author <a href="[email protected]">Dmitry Naumenko</a>
- * @param T The type of the compared elements in the 'lines'.
+ * @author <a href="[email protected]">Christopher Sontag</a>
  */
 public final class Patch<T> {
 
@@ -41,11 +42,11 @@ public final class Patch<T> {
     public Patch() {
         this(10);
     }
-    
+
     public Patch(int estimatedPatchSize) {
-         deltas = new ArrayList<>(estimatedPatchSize);
+        deltas = new ArrayList<>(estimatedPatchSize);
     }
-    
+
     /**
      * Apply this patch to the given target
      *
@@ -87,26 +88,34 @@ public void addDelta(Delta<T> delta) {
         deltas.add(delta);
     }
 
-    /** 
-     * Get the list of computed deltas
-     *
-     * @return the deltas
-     */
-    public List<Delta<T>> getDeltas() {
-        Collections.sort(deltas, comparing(d -> d.getOriginal().getPosition()));
-        return deltas;
-    }
-
-    @Override
-    public String toString() {
-        return "Patch{" + "deltas=" + deltas + '}';
-    }
-    
-    public static <T> Patch<T> generate(List<T> original, List<T> revised, List<Change> changes) {
+    public static <T> Patch<T> generate(List<T> original, List<T> revised, List<Change> changes, int surroundingLines) {
         Patch<T> patch = new Patch<>(changes.size());
         for (Change change : changes) {
+
             Chunk<T> orgChunk = new Chunk<>(change.startOriginal, new ArrayList<>(original.subList(change.startOriginal, change.endOriginal)));
+            if (change.startOriginal - surroundingLines >= 0) {
+                orgChunk.setBefore(new ArrayList<>(original.subList(change.startOriginal - surroundingLines, change.startOriginal)));
+            } else {
+                orgChunk.setBefore(new ArrayList<>(original.subList(0, change.startOriginal)));
+            }
+            if (change.endOriginal + surroundingLines <= original.size()) {
+                orgChunk.setAfter(new ArrayList<>(original.subList(change.endOriginal, change.endOriginal + surroundingLines)));
+            } else {
+                orgChunk.setAfter(new ArrayList<>(original.subList(change.endOriginal, original.size())));
+            }
+
             Chunk<T> revChunk = new Chunk<>(change.startRevised, new ArrayList<>(revised.subList(change.startRevised, change.endRevised)));
+            if (change.startRevised - surroundingLines >= 0) {
+                revChunk.setBefore(new ArrayList<>(revised.subList(change.startRevised - surroundingLines, change.startRevised)));
+            } else {
+                revChunk.setBefore(new ArrayList<>(revised.subList(0, change.startRevised)));
+            }
+            if (change.endRevised + surroundingLines <= revised.size()) {
+                revChunk.setAfter(new ArrayList<>(revised.subList(change.endRevised, change.endRevised + surroundingLines)));
+            } else {
+                revChunk.setAfter(new ArrayList<>(revised.subList(change.endRevised, revised.size())));
+            }
+
             switch (change.deltaType) {
                 case DELETE:
                     patch.addDelta(new DeleteDelta<>(orgChunk, revChunk));
@@ -121,4 +130,19 @@ public static <T> Patch<T> generate(List<T> original, List<T> revised, List<Chan
         }
         return patch;
     }
+
+    @Override
+    public String toString() {
+        return "Patch{" + "deltas=" + deltas + '}';
+    }
+
+    /**
+     * Get the list of computed deltas
+     *
+     * @return the deltas
+     */
+    public List<Delta<T>> getDeltas() {
+        Collections.sort(deltas, comparing(d -> d.getOriginal().getPosition()));
+        return deltas;
+    }
 }