Better handling of ignored comments in plugin

BEX Eclipse plugin scrolling improvements

Author: cross

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>

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/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));
+	}
 }

BEXCodeComparePlugin/.classpath

@@ -4,6 +4,6 @@
 	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.8"/>
 	<classpathentry kind="con" path="org.eclipse.pde.core.requiredPlugins"/>
 	<classpathentry kind="src" path="src"/>
-	<classpathentry kind="lib" path="lib/bex.jar"/>
+	<classpathentry kind="lib" path="lib/bex.jar" sourcepath="/BEXCodeCompare"/>
 	<classpathentry kind="output" path="bin"/>
 </classpath>