Merge pull request #110 from CodesAway/dev-0.13.0

Dev 0.13.0

Author: CodesAway

BEXCodeCompare/pom.xml

@@ -4,7 +4,7 @@
 	<modelVersion>4.0.0</modelVersion>
 	<groupId>info.codesaway</groupId>
 	<artifactId>bex</artifactId>
-	<version>0.12.0</version>
+	<version>0.13.0</version>
 	<name>Be Enhanced Code Compare (BEϽC)</name>
 	<description>An enhanced code compare, utilities, and code matching</description>
 	<properties>

BEXCodeCompare/src/main/java/info/codesaway/bex/BEXPair.java

@@ -3,6 +3,7 @@
 import static info.codesaway.bex.BEXSide.LEFT;
 import static info.codesaway.bex.BEXSide.RIGHT;
 
+import java.util.Objects;
 import java.util.function.BiConsumer;
 import java.util.function.BiFunction;
 import java.util.function.BiPredicate;
@@ -99,7 +100,7 @@ public default IntBEXPair mapToInt(final ToIntFunction<T> function) {
 
 	/**
 	 * Applies the specified BiFunction, passing {@link #getLeft()} and {@link #getRight()} as arguments
-	
+
 	 * @param function the BiFunction to apply
 	 * @return the result of applying the BiFunction
 	 */
@@ -109,7 +110,7 @@ public default <R> R apply(final BiFunction<T, T, R> function) {
 
 	/**
 	 * Applies the specified ToIntBiFunction, passing {@link #getLeft()} and {@link #getRight()} as arguments
-	
+
 	 * @param function the ToIntBiFunction to apply
 	 * @return the result of applying the ToIntBiFunction
 	 */
@@ -119,7 +120,7 @@ public default int applyAsInt(final ToIntBiFunction<T, T> function) {
 
 	/**
 	 * Evaluates the specified BiPredicate, passing {@link #getLeft()} and {@link #getRight()} as arguments
-	
+
 	 * @param predicate the BiPredicate to apply
 	 * @return <code>true</code> if the predicate matches when applying the arugments; otherwise, <code>false</code>
 	 */
@@ -279,4 +280,13 @@ public default int compareTo(final BEXPair<T> o) {
 
 		return right1.compareTo(o.getRight());
 	}
+
+	/**
+	 * Indicates if the left value equals the right value
+	 * @return <code>true</code> if the left value equals the right value
+	 * @since 0.13
+	 */
+	public default boolean hasEqualValues() {
+		return Objects.equals(this.getLeft(), this.getRight());
+	}
 }

BEXCodeCompare/src/main/java/info/codesaway/bex/Indexed.java

@@ -0,0 +1,13 @@
+package info.codesaway.bex;
+
+/**
+ * Value with an index.
+ *
+ * @param <T> the value's type
+ * @since 0.13
+ */
+public interface Indexed<T> {
+	public int getIndex();
+
+	public T getValue();
+}

BEXCodeCompare/src/main/java/info/codesaway/bex/IndexedValue.java

@@ -0,0 +1,58 @@
+package info.codesaway.bex;
+
+import java.util.Objects;
+
+/**
+ * Value with an index.
+ *
+ * <p>Instances of this class are immutable if the generic class type is also immutable</p>
+ *
+ * @param <T> the value's type
+ * @since 0.13
+ */
+public final class IndexedValue<T> implements Indexed<T> {
+	// Referenced https://github.com/poetix/protonpack/blob/master/src/main/java/com/codepoetics/protonpack/Indexed.java
+
+	private final int index;
+	private final T value;
+
+	public IndexedValue(final int index, final T value) {
+		this.index = index;
+		this.value = value;
+	}
+
+	@Override
+	public int getIndex() {
+		return this.index;
+	}
+
+	@Override
+	public T getValue() {
+		return this.value;
+	}
+
+	@Override
+	public String toString() {
+		return this.index + " " + this.value;
+	}
+
+	@Override
+	public int hashCode() {
+		return Objects.hash(this.index, this.value);
+	}
+
+	@Override
+	public boolean equals(final Object obj) {
+		if (this == obj) {
+			return true;
+		}
+		if (obj == null) {
+			return false;
+		}
+		if (this.getClass() != obj.getClass()) {
+			return false;
+		}
+		IndexedValue<?> other = (IndexedValue<?>) obj;
+		return this.index == other.index && Objects.equals(this.value, other.value);
+	}
+}

BEXCodeCompare/src/main/java/info/codesaway/bex/IntBEXRange.java

@@ -126,5 +126,4 @@ public boolean equals(final Object obj) {
 		IntBEXRange other = (IntBEXRange) obj;
 		return this.end == other.end && this.hasInclusiveEnd == other.hasInclusiveEnd && this.start == other.start;
 	}
-
 }

BEXCodeCompare/src/main/java/info/codesaway/bex/IntRange.java

@@ -27,6 +27,33 @@ default int getRight() {
 
 	public boolean hasInclusiveEnd();
 
+	/**
+	 *
+	 * @return
+	 * @since 0.13
+	 */
+	public default int getInclusiveStart() {
+		return this.hasInclusiveStart() ? this.getStart() : this.getStart() + 1;
+	}
+
+	/**
+	 *
+	 * @return
+	 * @since 0.13
+	 */
+	public default int getInclusiveEnd() {
+		return this.hasInclusiveEnd() ? this.getEnd() : this.getEnd() - 1;
+	}
+
+	/**
+	 *
+	 * @return
+	 * @since 0.13
+	 */
+	public default int getCanonicalEnd() {
+		return this.hasInclusiveEnd() ? this.getEnd() + 1 : this.getEnd();
+	}
+
 	public default boolean contains(final int value) {
 		return value > this.getStart() && value < this.getEnd()
 				|| this.hasInclusiveStart() && value == this.getStart()
@@ -38,27 +65,32 @@ public default boolean isEmpty() {
 				&& !(this.hasInclusiveStart() && this.hasInclusiveEnd());
 	}
 
+	/**
+	 * Indicates if the range is a closed range containing one value
+	 *
+	 * @return <code>true</code> if the range is a closed range containing one value
+	 * @since 0.13
+	 */
+	public default boolean isSingleValue() {
+		return this.getStart() == this.getEnd()
+				&& this.hasInclusiveStart() && this.hasInclusiveEnd();
+	}
+
 	/**
 	 *
 	 * @return the length of the range
 	 * @since 0.10
 	 */
 	public default int length() {
-		// Logic from canonical
-		int start = this.hasInclusiveStart() ? this.getStart() : this.getStart() + 1;
-		int end = this.hasInclusiveEnd() ? this.getEnd() + 1 : this.getEnd();
-
-		return end - start;
+		return this.getCanonicalEnd() - this.getInclusiveStart();
 	}
 
 	public default IntRange canonical() {
 		if (this.hasInclusiveStart() && !this.hasInclusiveEnd()) {
 			return this;
 		}
 
-		int start = this.hasInclusiveStart() ? this.getStart() : this.getStart() + 1;
-		int end = this.hasInclusiveEnd() ? this.getEnd() + 1 : this.getEnd();
-		return IntBEXRange.of(start, end);
+		return IntBEXRange.of(this.getInclusiveStart(), this.getCanonicalEnd());
 	}
 
 	/**

BEXCodeCompare/src/main/java/info/codesaway/bex/diff/DiffHelper.java

@@ -30,6 +30,7 @@
 import java.util.TreeMap;
 import java.util.TreeSet;
 import java.util.function.BiFunction;
+import java.util.function.BiPredicate;
 import java.util.function.Function;
 import java.util.function.ToIntFunction;
 import java.util.stream.Collectors;
@@ -971,6 +972,8 @@ public static List<DiffUnit> combineToDiffBlocks(final List<DiffEdit> diff) {
 		return combineToDiffBlocks(diff, false);
 	}
 
+	private static final BiPredicate<DiffEdit, DiffEdit> ALWAYS_SHOULD_COMBINE = (x, y) -> true;
+
 	/**
 	 * Combines consecutive DiffEdit to form DiffBlock when possible
 	 *
@@ -980,12 +983,32 @@ public static List<DiffUnit> combineToDiffBlocks(final List<DiffEdit> diff) {
 	 * @return
 	 */
 	public static List<DiffUnit> combineToDiffBlocks(final List<DiffEdit> diff, final boolean allowReplacements) {
+		return combineToDiffBlocks(diff, allowReplacements, ALWAYS_SHOULD_COMBINE);
+	}
+
+	/**
+	 * Combines consecutive DiffEdit to form DiffBlock when possible and <code>shouldCombinePredicate</code> returns true
+	 *
+	 * <p>The returned list will consist of DiffUnit objects (either DiffBlock or DiffEdit)</p>
+	 *
+	 * @param diff
+	 * @param allowReplacements
+	 * @param shouldCombinePredicate indicates whether the two DiffEdits should be combined, if this method determines they can be combined (return <code>false</code> to prevent the combining)
+	 * @return
+	 * @since 0.13
+	 */
+	public static List<DiffUnit> combineToDiffBlocks(final List<DiffEdit> diff, final boolean allowReplacements,
+			final BiPredicate<DiffEdit, DiffEdit> shouldCombinePredicate) {
 		List<DiffUnit> diffBlocks = new ArrayList<>();
 
+		BiPredicate<DiffEdit, DiffEdit> usedShouldCombinePredicate = shouldCombinePredicate != null
+				? shouldCombinePredicate
+				: ALWAYS_SHOULD_COMBINE;
+
 		for (int i = 0; i < diff.size(); i++) {
 			DiffEdit diffEdit = diff.get(i);
 
-			if (isNextDiffPartOfBlock(diff, i, allowReplacements)) {
+			if (isNextDiffPartOfBlock(diff, i, allowReplacements, usedShouldCombinePredicate)) {
 				DiffType blockDiffType = diffEdit.getType();
 
 				List<DiffEdit> edits = new ArrayList<>();
@@ -997,7 +1020,7 @@ public static List<DiffUnit> combineToDiffBlocks(final List<DiffEdit> diff, fina
 					if (blockDiffType != REPLACEMENT_BLOCK && !blockDiffType.equals(nextDiffEdit.getType())) {
 						blockDiffType = REPLACEMENT_BLOCK;
 					}
-				} while (isNextDiffPartOfBlock(diff, i, allowReplacements));
+				} while (isNextDiffPartOfBlock(diff, i, allowReplacements, usedShouldCombinePredicate));
 
 				diffBlocks.add(new DiffBlock(blockDiffType, edits));
 			} else {
@@ -1017,7 +1040,7 @@ public static List<DiffUnit> combineToDiffBlocks(final List<DiffEdit> diff, fina
 	 * @return
 	 */
 	private static boolean isNextDiffPartOfBlock(final List<DiffEdit> diff, final int i,
-			final boolean allowReplacements) {
+			final boolean allowReplacements, final BiPredicate<DiffEdit, DiffEdit> shouldCombinePredicate) {
 
 		if (i + 1 >= diff.size()) {
 			return false;
@@ -1040,7 +1063,8 @@ private static boolean isNextDiffPartOfBlock(final List<DiffEdit> diff, final in
 			}
 		}
 
-		return hasConsecutiveLines(diffEdit, nextDiffEdit, isReplancement);
+		return hasConsecutiveLines(diffEdit, nextDiffEdit, isReplancement)
+				&& shouldCombinePredicate.test(diffEdit, nextDiffEdit);
 	}
 
 	private static boolean canBePartOfReplacement(final DiffEdit diffEdit) {

BEXCodeCompare/src/main/java/info/codesaway/bex/diff/DiffWithIndex.java

@@ -3,8 +3,9 @@
 import java.util.Optional;
 
 import info.codesaway.bex.BEXSide;
+import info.codesaway.bex.Indexed;
 
-public final class DiffWithIndex {
+public final class DiffWithIndex implements Indexed<DiffEdit> {
 	private final DiffEdit diffEdit;
 	private final int index;
 
@@ -17,6 +18,15 @@ public DiffEdit getDiffEdit() {
 		return this.diffEdit;
 	}
 
+	/**
+	 * @since 0.13
+	 */
+	@Override
+	public DiffEdit getValue() {
+		return this.getDiffEdit();
+	}
+
+	@Override
 	public int getIndex() {
 		return this.index;
 	}