Use a BufferedReader for importing line graphs

Closing the `BufferedReader` is conventionally handled by the function
which opens it (unless otherwise noted), making the exception
handling less error prone.

Because streams do not handle `IOException`s it is necessary to wrap
them in `UncheckedIOException`s and unpack them outside the stream. The
Apache version `org.apache.commons.lang3.stream.Streams.FailableStream`
would have been a great substitute, but it doesn't provide a `flatMap`
method.

Because a `BufferedReader` can't be read twice, a utility method
`assertEqualToFile` is created which uses a new `BufferedReader` to
parse line endings correctly and efficiently (instead of using
`normalizedLineEndings` like the old `assertEqualFileContent` did).

Author: ibbem

src/main/java/org/variantsync/diffdetective/diff/difftree/serialize/LineGraphImport.java

@@ -5,6 +5,8 @@
 import org.variantsync.diffdetective.util.FileUtils;
 import org.variantsync.functjonal.Pair;
 
+import java.io.BufferedReader;
+import java.io.IOException;
 import java.nio.file.Files;
 import java.nio.file.Path;
 import java.util.ArrayList;
@@ -20,20 +22,25 @@
 public class LineGraphImport {
     //    public static Map<CodeType, Integer> countRootTypes = new HashMap<>();
 
-    public static List<DiffTree> fromFile(final Path path, final DiffTreeLineGraphImportOptions options) {
+    /**
+     * Transforms a line graph stored in a file into a list of {@link DiffTree DiffTrees}.
+     *
+     * @return All {@link DiffTree DiffTrees} contained in the line graph
+     */
+    public static List<DiffTree> fromFile(final Path path, final DiffTreeLineGraphImportOptions options) throws IOException {
         Assert.assertTrue(Files.isRegularFile(path));
         Assert.assertTrue(FileUtils.isLineGraph(path));
-        return fromLineGraph(FileUtils.readUTF8(path), options);
+        try (BufferedReader input = Files.newBufferedReader(path)) {
+            return fromLineGraph(input, options);
+        }
     }
 
 	/**
 	 * Transforms a line graph into a list of {@link DiffTree DiffTrees}.
 	 * 
 	 * @return All {@link DiffTree DiffTrees} contained in the line graph
 	 */
-	public static List<DiffTree> fromLineGraph(final String lineGraph, final DiffTreeLineGraphImportOptions options) {
-		java.util.Scanner input = new java.util.Scanner(lineGraph);
-		
+	public static List<DiffTree> fromLineGraph(final BufferedReader lineGraph, final DiffTreeLineGraphImportOptions options) throws IOException {
 		// All DiffTrees read from the line graph
 		List<DiffTree> diffTreeList = new ArrayList<>();
 
@@ -48,8 +55,8 @@ public static List<DiffTree> fromLineGraph(final String lineGraph, final DiffTre
 		String previousDiffTreeLine = "";
 
 		// Read the entire line graph 
-		while (input.hasNext()) {
-			String ln = input.nextLine();
+		String ln;
+		while ((ln = lineGraph.readLine()) != null) {
 			if (ln.startsWith(LineGraphConstants.LG_TREE_HEADER)) {
 				// the line represents a DiffTree
 
@@ -74,15 +81,9 @@ public static List<DiffTree> fromLineGraph(final String lineGraph, final DiffTre
 
 			} else if (ln.startsWith(LineGraphConstants.LG_EDGE)) {
 				// the line represent a connection with two DiffNodes
-                try {
-                    options.edgeFormat().connect(ln, diffNodes);
-                } catch (IllegalArgumentException e) {
-                    input.close();
-                    throw e;
-                }
+				options.edgeFormat().connect(ln, diffNodes);
 			} else if (!ln.isBlank()) {
 				// ignore blank lines and throw an exception otherwise
-				input.close();
 				String errorMessage = String.format(
 						"Line graph syntax error. Expects: \"%s\" (DiffTree), \"%s\" (DiffNode), \"%s\" (edge) or a blank space (delimiter). Faulty input: \"%s\".", 
 						LineGraphConstants.LG_TREE_HEADER,
@@ -92,7 +93,6 @@ public static List<DiffTree> fromLineGraph(final String lineGraph, final DiffTre
 				throw new IllegalArgumentException(errorMessage);
 			}
 		}
-		input.close();
 
 		if (!diffNodeList.isEmpty()) {
 			DiffTree curDiffTree = parseDiffTree(previousDiffTreeLine, diffNodeList, options); // parse to DiffTree

src/main/java/org/variantsync/diffdetective/mining/postprocessing/MiningPostprocessing.java

@@ -14,6 +14,7 @@
 import org.variantsync.functjonal.Pair;
 
 import java.io.IOException;
+import java.io.UncheckedIOException;
 import java.nio.file.Files;
 import java.nio.file.Path;
 import java.util.List;
@@ -85,10 +86,23 @@ public static void main(String[] args) throws IOException {
      */
     public static List<DiffTree> parseFrequentSubgraphsIn(final Path path) throws IOException {
         if (Files.isDirectory(path)) {
-            return Files.list(path)
-                    .filter(FileUtils::isLineGraph)
-                    .flatMap(file -> LineGraphImport.fromFile(file, IMPORT_OPTIONS).stream())
-                    .collect(Collectors.toList());
+            try {
+                return Files.list(path)
+                        .filter(FileUtils::isLineGraph)
+                        .flatMap(file -> {
+                            try {
+                                return LineGraphImport.fromFile(file, IMPORT_OPTIONS).stream();
+                            } catch (IOException e) {
+                                // Checked exceptions can't be propagated because {@code flatMap}
+                                // needs a {@code Function} which does not throw any checked
+                                // exceptions.
+                                throw new UncheckedIOException(e);
+                            }
+                        })
+                        .collect(Collectors.toList());
+            } catch (UncheckedIOException e) {
+                throw e.getCause();
+            }
         } else {
             return LineGraphImport.fromFile(path, IMPORT_OPTIONS);
         }

src/test/java/LineGraphTest.java

@@ -9,7 +9,9 @@
 import org.variantsync.diffdetective.diff.difftree.serialize.treeformat.CommitDiffDiffTreeLabelFormat;
 import org.variantsync.diffdetective.util.FileUtils;
 
+import java.io.BufferedReader;
 import java.io.IOException;
+import java.io.StringReader;
 import java.nio.file.Files;
 import java.nio.file.Path;
 import java.nio.file.Paths;
@@ -42,14 +44,16 @@ public static void init() throws IOException {
 	 * Test the import of a line graph.
 	 */
 	@Test
-	public void idempotentReadWrite() {
+	public void idempotentReadWrite() throws IOException {
         for (final Path testFile : TEST_FILES) {
             Logger.info("Testing {}", testFile);
-            final String lineGraph = FileUtils.readUTF8(testFile);
-            final List<DiffTree> diffTrees = LineGraphImport.fromLineGraph(lineGraph, IMPORT_OPTIONS);
+            List<DiffTree> diffTrees;
+            try (BufferedReader lineGraph = Files.newBufferedReader(testFile)) {
+                diffTrees = LineGraphImport.fromLineGraph(lineGraph, IMPORT_OPTIONS);
+            }
             assertConsistencyForAll(diffTrees);
             final String lineGraphResult = exportDiffTreeToLineGraph(diffTrees);
-            assertEqualFileContent(lineGraph, lineGraphResult);
+            TestUtils.assertEqualToFile(testFile, lineGraphResult);
         }
 	}
 
@@ -80,21 +84,4 @@ private static String exportDiffTreeToLineGraph(final List<DiffTree> treeList) {
         }
         return lineGraphOutput.toString();
 	}
-	
-	/**
-	 * Compare two line graphs.
-	 * 
-	 * @param originalLineGraph The original line graph
-	 * @param generatedLineGraph The generated line graph
-	 */
-	private static void assertEqualFileContent(final String originalLineGraph, final String generatedLineGraph) {
-        final String o = FileUtils.normalizedLineEndings(originalLineGraph);
-        final String g = FileUtils.normalizedLineEndings(generatedLineGraph);
-//        System.out.println("ORIGINAL");
-//        System.out.println(o);
-//        System.out.println("GENERATED");
-//        System.out.println(g);
-        assertEquals(o, g);
-	}
-	
 }

src/test/java/TestUtils.java

@@ -0,0 +1,23 @@
+import org.apache.commons.io.IOUtils;
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.StringReader;
+import java.nio.file.Files;
+import java.nio.file.Path;
+
+import static org.junit.Assert.assertTrue;
+
+public final class TestUtils {
+    /**
+     * Compare two line graphs.
+     *
+     * @param originalLineGraph The original line graph
+     * @param generatedLineGraph The generated line graph
+     */
+    public static void assertEqualToFile(final Path filePath, final String actual) throws IOException {
+        try (BufferedReader expected = Files.newBufferedReader(filePath)) {
+            assertTrue("expected content of " + filePath + " but was:<" + actual + ">",
+                    IOUtils.contentEqualsIgnoreEOL(expected, new StringReader(actual)));
+        }
+    }
+}