Merge pull request #106 from CodesAway/dev-0.12.0

Dev 0.12.0

Author: CodesAway

BEXCodeCompare/pom.xml

@@ -4,7 +4,7 @@
 	<modelVersion>4.0.0</modelVersion>
 	<groupId>info.codesaway</groupId>
 	<artifactId>bex</artifactId>
-	<version>0.11.0</version>
+	<version>0.12.0</version>
 	<name>Be Enhanced Code Compare (BEϽC)</name>
 	<description>An enhanced code compare, utilities, and code matching</description>
 	<properties>
@@ -22,7 +22,7 @@
 		<dependency>
 			<groupId>info.codesaway</groupId>
 			<artifactId>regexplus</artifactId>
-			<version>1.2.0</version>
+			<version>2.0.0</version>
 		</dependency>
 		<dependency>
 			<groupId>com.github.spotbugs</groupId>
@@ -111,7 +111,10 @@
 					<plugin>
 						<groupId>org.apache.maven.plugins</groupId>
 						<artifactId>maven-javadoc-plugin</artifactId>
-						<version>2.9.1</version>
+						<version>3.2.0</version>
+						<configuration>
+							<source>8</source>
+						</configuration>
 						<executions>
 							<execution>
 								<id>attach-javadocs</id>

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

@@ -170,10 +170,10 @@ private int getIndex(final int key) {
 	 *
 	 * @param key the value to be searched for
 	 * @return index of the search key, if it is contained in the array;
-	 *         otherwise, <tt>(-(<i>insertion point</i>) - 1)</tt>.  The
+	 *         otherwise, <code>(-(<i>insertion point</i>) - 1)</code>.  The
 	 *         <i>insertion point</i> is defined as the point at which the
 	 *         key would be inserted into the array: the index of the first
-	 *         element greater than the key, or <tt>a.length</tt> if all
+	 *         element greater than the key, or <code>a.length</code> if all
 	 *         elements in the array are less than the specified key.  Note
 	 *         that this guarantees that the return value will be &gt;= 0 if
 	 *         and only if the key is found.

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

@@ -80,6 +80,17 @@ public static IntBEXRange closedOpen(final int start, final int end) {
 		return new IntBEXRange(start, end, false);
 	}
 
+	/**
+	 * Closed range containing a single value
+	 * @param value the value
+	 * @return a closed range containing a single value
+	 * @since 0.12
+	 * @see #closed(int, int)
+	 */
+	public static IntBEXRange singleton(final int value) {
+		return closed(value, value);
+	}
+
 	@Override
 	public boolean hasInclusiveStart() {
 		return this.hasInclusiveStart;

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

@@ -1,9 +1,11 @@
 package info.codesaway.bex.diff;
 
+import static info.codesaway.bex.BEXPairs.bexPair;
 import static info.codesaway.bex.BEXPairs.mapGet;
 import static info.codesaway.bex.BEXSide.BEX_SIDES;
 import static info.codesaway.bex.BEXSide.LEFT;
 import static info.codesaway.bex.BEXSide.RIGHT;
+import static info.codesaway.bex.IntBEXRange.closed;
 import static info.codesaway.bex.diff.BasicDiffType.REPLACEMENT_BLOCK;
 import static info.codesaway.bex.util.BEXUtilities.firstNonNull;
 import static info.codesaway.bex.util.BEXUtilities.not;
@@ -38,6 +40,7 @@
 import info.codesaway.bex.BEXPairValue;
 import info.codesaway.bex.BEXSide;
 import info.codesaway.bex.IntPair;
+import info.codesaway.bex.IntRange;
 import info.codesaway.bex.diff.patience.FrequencyCount;
 import info.codesaway.bex.diff.patience.PatienceMatch;
 import info.codesaway.bex.diff.substitution.RefactoringDiffType;
@@ -268,35 +271,35 @@ public static List<DiffEdit> handleImports(final List<DiffEdit> diff) {
 				.filter(DiffWithIndex::isInsertOrDelete)
 				.filter(d -> d.getDiffEdit().getText().trim().startsWith("import"))
 				.collect(toList());
-	
+
 		// Group imports by classname
 		Map<String, List<DiffWithIndex>> importsByClassName = new HashMap<>();
 		Map<DiffWithIndex, MatchResult> matchResults = new HashMap<>();
-	
+
 		for (DiffWithIndex possibleImport : possibleImports) {
 			Matcher matcher = IMPORT_MATCHER.get().reset(possibleImport.getDiffEdit().getText());
-	
+
 			if (!matcher.find()) {
 				continue;
 			}
-	
+
 			matchResults.put(possibleImport, matcher.toMatchResult());
 			importsByClassName.computeIfAbsent(matcher.group("class"), k -> new ArrayList<>()).add(possibleImport);
 		}
-	
+
 		// Check results
 		for (Entry<String, List<DiffWithIndex>> entry : importsByClassName.entrySet()) {
 			List<DiffWithIndex> list = entry.getValue();
 			if (list.size() != 2) {
 				continue;
 			}
-	
+
 			DiffWithIndex firstDiff = list.get(0);
 			DiffWithIndex secondDiff = list.get(1);
-	
+
 			DiffWithIndex left = null;
 			DiffWithIndex right = null;
-	
+
 			if (firstDiff.hasLeftLine()) {
 				if (secondDiff.hasRightLine()) {
 					left = firstDiff;
@@ -306,21 +309,21 @@ public static List<DiffEdit> handleImports(final List<DiffEdit> diff) {
 				left = secondDiff;
 				right = firstDiff;
 			}
-	
+
 			if (left != null && right != null) {
 				ImportSameClassnameDiffType diffType = determineImportSameClassnameDiffType(matchResults.get(left),
 						matchResults.get(right), true);
-	
+
 				//				System.out.println(entry);
-	
+
 				if (diffType != null) {
 					DiffEdit diffEdit = new DiffEdit(diffType, left.getLeftLine(), right.getRightLine());
 					diff.set(left.getIndex(), diffEdit);
 					diff.set(right.getIndex(), diffEdit);
 				}
 			}
 		}
-	
+
 		return diff;
 	}*/
 
@@ -904,6 +907,58 @@ private static List<DiffEdit> sort(final List<DiffEdit> diff) {
 		return results;
 	}
 
+	/**
+	 * Determines the range which encloses all the lines of the specified DiffUnit
+	 *
+	 * <p>If the DiffUnit does not consist of sequential lines, the range will enclose all the lines,
+	 * even though each value in the range will not have a corresponding line in the DiffUnit</p>
+	 *
+	 * @param diffUnit the DiffUnit
+	 * @return the range of lines (left / right) in the specified DiffUnit
+	 * @since 0.12
+	 */
+	public static BEXPair<IntRange> determineEnclosedRange(final DiffUnit diffUnit) {
+		return determineEnclosedRange(diffUnit.getEdits());
+	}
+
+	/**
+	 * Determines the range which encloses all the lines of the specified edits
+	 *
+	 * <p>If the edits do not consist of sequential lines, the range will enclose all the lines,
+	 * even though each value in the range will not have a corresponding line in the edits</p>
+	 *
+	 * @param diffEdits the edits
+	 * @return the range of lines (left / right) in the specified edits
+	 * @since 0.12
+	 */
+	public static BEXPair<IntRange> determineEnclosedRange(final Collection<DiffEdit> diffEdits) {
+		int minLeft = diffEdits.stream()
+				.filter(DiffEdit::hasLeftLine)
+				.mapToInt(DiffEdit::getLeftLineNumber)
+				.min()
+				.orElse(-1);
+
+		int maxLeft = diffEdits.stream()
+				.filter(DiffEdit::hasLeftLine)
+				.mapToInt(DiffEdit::getLeftLineNumber)
+				.max()
+				.orElse(-1);
+
+		int minRight = diffEdits.stream()
+				.filter(DiffEdit::hasRightLine)
+				.mapToInt(DiffEdit::getRightLineNumber)
+				.min()
+				.orElse(-1);
+
+		int maxRight = diffEdits.stream()
+				.filter(DiffEdit::hasRightLine)
+				.mapToInt(DiffEdit::getRightLineNumber)
+				.max()
+				.orElse(-1);
+
+		return bexPair(closed(minLeft, maxLeft), closed(minRight, maxRight));
+	}
+
 	/**
 	 * Combines consecutive DiffEdit to form DiffBlock when possible
 	 *

BEXCodeCompare/src/main/java/info/codesaway/bex/matching/BEXMatcher.java

@@ -852,10 +852,10 @@ public String replaceAll(final Function<BEXMatchResult, String> replacementFunct
 	 * replaced in the result by the replacement string. The replacement string
 	 * may contain references to captured subsequences as in the {@link #appendReplacement appendReplacement} method.</p>
 	 *
-	 * <p>Given the pattern <tt>dog</tt>, the input
-	 * <tt>"zzzdogzzzdogzzz"</tt>, and the replacement string <tt>"cat"</tt>, an
+	 * <p>Given the pattern <code>dog</code>, the input
+	 * <code>"zzzdogzzzdogzzz"</code>, and the replacement string <code>"cat"</code>, an
 	 * invocation of this method on a matcher for that expression would yield
-	 * the string <tt>"zzzcatzzzdogzzz"</tt>.</p>
+	 * the string <code>"zzzcatzzzdogzzz"</code>.</p>
 	 *
 	 * <p>Invoking this method changes this matcher's state. If the matcher
 	 * is to be used in further matching operations then it should first be
@@ -977,7 +977,7 @@ && isWordCharacter(nextChar(replacement, cursor + 1))) {
 	 * <p>It reads characters from the input sequence, starting at the append
 	 * position, and appends them to the given string buffer. It stops after
 	 * reading the last character preceding the previous match, that is, the
-	 * character at index {@link #start()}&nbsp;<tt>-</tt>&nbsp;<tt>1</tt>.</p>
+	 * character at index {@link #start()}&nbsp;<code>-</code>&nbsp;<code>1</code>.</p>
 	 * </li>
 	 *
 	 * <li>
@@ -996,8 +996,8 @@ && isWordCharacter(nextChar(replacement, cursor + 1))) {
 	 *
 	 * <p>This method is intended to be used in a loop together with the {@link #appendTail appendTail} and
 	 * {@link #find find} methods. The
-	 * following code, for example, writes <tt>one dog two dogs in the
-	 * yard</tt> to the standard-outputSyntax stream:</p>
+	 * following code, for example, writes <code>one dog two dogs in the
+	 * yard</code> to the standard-outputSyntax stream:</p>
 	 *
 	 * <blockquote>
 	 *

BEXCodeCompare/src/main/java/info/codesaway/bex/matching/BEXMatchingLanguage.java

@@ -29,7 +29,7 @@ public enum BEXMatchingLanguage implements MatchingLanguage {
 	 * SQL Matching language
 	 * @since 0.11
 	 */
-	SQL(BEXMatchingUtilities::parseSQLTextStates, "@", true, bexPair("BEGIN", "END")),
+	SQL(BEXMatchingUtilities::parseSQLTextStates, "@#$", true, bexPair("BEGIN", "END")),
 
 	// End of enum
 	;
@@ -92,11 +92,11 @@ public MatchingDelimiterState findEndDelimiter(final BEXPair<String> lastDelimit
 
 			BiPredicate<String, String> equals = this.hasCaseInsensitiveDelimiters
 					? String::equalsIgnoreCase
-					: String::equals;
+							: String::equals;
 
 			MatchingDelimiterResult result = lastDelimiter != null && equals.test(s, lastDelimiter.getRight())
 					? MatchingDelimiterResult.FOUND
-					: MatchingDelimiterResult.MISMATCHED;
+							: MatchingDelimiterResult.MISMATCHED;
 
 			return new MatchingDelimiterState(result, s);
 		}

BEXCodeCompare/src/test/java/info/codesaway/bex/diff/DiffHelperTests.java

@@ -1,17 +1,21 @@
 package info.codesaway.bex.diff;
 
 import static com.google.common.collect.Maps.immutableEntry;
+import static info.codesaway.bex.BEXPairs.bexPair;
+import static info.codesaway.bex.IntBEXRange.closed;
 import static info.codesaway.bex.diff.BasicDiffType.DELETE;
 import static info.codesaway.bex.diff.BasicDiffType.EQUAL;
 import static info.codesaway.bex.diff.BasicDiffType.INSERT;
 import static info.codesaway.bex.diff.BasicDiffType.MOVE_LEFT;
 import static info.codesaway.bex.diff.BasicDiffType.MOVE_RIGHT;
+import static org.assertj.core.api.Assertions.assertThat;
 import static org.junit.jupiter.api.Assertions.assertEquals;
 
 import java.util.Arrays;
 import java.util.List;
 import java.util.Map.Entry;
 
+import org.junit.jupiter.api.Disabled;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.MethodSource;
@@ -20,6 +24,9 @@
 import com.google.common.collect.Streams;
 import com.google.common.primitives.ImmutableIntArray;
 
+import info.codesaway.bex.BEXPair;
+import info.codesaway.bex.IntBEXPair;
+import info.codesaway.bex.IntRange;
 import info.codesaway.bex.diff.myers.MyersLinearDiff;
 import info.codesaway.bex.diff.patience.PatienceDiff;
 import info.codesaway.bex.diff.patience.PatienceMatch;
@@ -119,4 +126,38 @@ public void testCombineToDiffBlocks() {
 
 		assertEquals(expected, diffUnits);
 	}
+
+	@Test
+	public void testDetermineEnclosedRange() {
+		List<DiffLine> leftLines = ImmutableList.of(new DiffLine(0, "a"), new DiffLine(1, "b"), new DiffLine(2, "c"));
+		List<DiffLine> rightLines = ImmutableList.of(new DiffLine(3, "a"), new DiffLine(4, "b"), new DiffLine(5, "c"));
+
+		List<DiffEdit> diff = ImmutableList.of(
+				new DiffEdit(MOVE_LEFT, leftLines.get(0), rightLines.get(0)),
+				new DiffEdit(MOVE_LEFT, leftLines.get(1), rightLines.get(1)),
+				new DiffEdit(MOVE_LEFT, leftLines.get(2), rightLines.get(2)));
+
+		List<DiffUnit> diffUnits = DiffHelper.combineToDiffBlocks(diff);
+
+		DiffUnit diffUnit = diffUnits.get(0);
+
+		BEXPair<IntRange> enclosedRange = DiffHelper.determineEnclosedRange(diffUnit);
+		BEXPair<IntRange> expectedRange = bexPair(closed(0, 2), closed(3, 5));
+		assertThat(enclosedRange).isEqualTo(expectedRange);
+	}
+
+	@Test
+	@Disabled("Not sure if I plan or need to add functionality for consecutive ranges")
+	public void testHasConsecutiveRanges() {
+		IntRange left1 = closed(0, 2);
+		IntRange left2 = closed(3, 5);
+
+		IntRange right1 = closed(1, 5);
+		IntRange right2 = closed(6, 10);
+
+		IntBEXPair line1 = IntBEXPair.of(left1.getEnd(), right1.getEnd());
+		IntBEXPair line2 = IntBEXPair.of(left2.getStart(), right2.getStart());
+
+		System.out.println(DiffHelper.isConsecutive(line1, line2, false));
+	}
 }