feat: additional error handling

Author: AlexanderSchultheiss

src/main/java/org/variantsync/vevos/extraction/FastPCAnalysis.java

@@ -58,6 +58,10 @@ private record ThreadBatch(HashMap<String, GroundTruth> groundTruthMapBefore,
     public void onFailedParse(Analysis analysis) {
         RevCommit commit = analysis.getCurrentCommit();
 
+        extractionFailed(commit);
+    }
+
+    private void extractionFailed(RevCommit commit) {
         synchronized (FastPCAnalysis.class) {
             Logger.warn("Was not able to extract ground truth for commit " + commit.getName());
             Serde.appendText(resultsRoot.resolve(ERROR_COMMIT_FILE), commit.getName() + "\n");
@@ -213,14 +217,23 @@ public boolean analyzeVariationDiff(Analysis analysis) {
         }
 
         analysis.getCurrentVariationDiff().forAll(node -> {
-            // Logger.debug("Node: {}", node);
-            // If the file is not completely new, we consider the before case
-            if (!(changeType == DiffEntry.ChangeType.ADD)) {
-                PCAnalysis.analyzeNode(fileGTBefore, node, Time.BEFORE);
-            }
-            if (!(changeType == DiffEntry.ChangeType.DELETE)) {
-                // If the file has not been deleted, we consider the after case
-                PCAnalysis.analyzeNode(fileGTAfter, node, Time.AFTER);
+            try {
+                // Logger.debug("Node: {}", node);
+                // If the file is not completely new, we consider the before case
+                if (!(changeType == DiffEntry.ChangeType.ADD)) {
+                    PCAnalysis.analyzeNode(fileGTBefore, node, Time.BEFORE);
+                }
+                if (!(changeType == DiffEntry.ChangeType.DELETE)) {
+                    // If the file has not been deleted, we consider the after case
+                    PCAnalysis.analyzeNode(fileGTAfter, node, Time.AFTER);
+                }
+            } catch (MatchingException e) {
+                Logger.error("unhandled exception while analyzing {} -> {} for commit {}.",
+                        fileNameBefore,
+                        fileNameAfter,
+                        analysis.getCurrentCommit().getName());
+                Logger.error(e);
+                extractionFailed(analysis.getCurrentCommit());
             }
         });
 

src/main/java/org/variantsync/vevos/extraction/FileGT.java

@@ -86,9 +86,15 @@ protected LineAnnotation insert(int index, LineAnnotation annotation) {
      * @param lineNumber The line number in the current version of the file
      * @param matchedLine The matching line number in the counterpart version of the file
      */
-    protected void setMatching(int lineNumber, int matchedLine) {
-        Assert.assertTrue(this.matching.get(lineNumber) == -1 || this.matching.get(lineNumber) == matchedLine,
-                "line number mismatch for file" + this.file + " -- " + this.matching.get(lineNumber) + " : " + lineNumber);
+    protected void setMatching(int lineNumber, int matchedLine) throws MatchingException {
+        if (this.file.equals("/dev/null")) {
+            // There are no valid matches for the 'null' file
+            return;
+        }
+        if (this.matching.get(lineNumber) != -1 && this.matching.get(lineNumber) != matchedLine) {
+            throw new MatchingException("line number mismatch for " + this.file + " -- " + lineNumber
+                    + " : (" + this.matching.get(lineNumber) + " vs. " + matchedLine + ")");
+        }
         this.matching.set(lineNumber, matchedLine);
     }
 
@@ -158,7 +164,7 @@ public Mutable insert(LineAnnotation line) {
          * @param currentRange The range of lines in the current file version
          * @param counterpartRange The range of lines in the counterpart file version
          */
-        public void setMatching(LineRange currentRange, LineRange counterpartRange) {
+        public void setMatching(LineRange currentRange, LineRange counterpartRange) throws MatchingException {
             Assert.assertTrue(!consumed);
             // They must span the same number of lines
             int lineNumber = currentRange.fromInclusive();
@@ -168,7 +174,10 @@ public void setMatching(LineRange currentRange, LineRange counterpartRange) {
 
             if (matchedLine != -1) {
                 // If there is a match, the matched regions must have the same size
-                Assert.assertEquals(endNumber-lineNumber, matchEnd-matchedLine);
+                if(endNumber-lineNumber != matchEnd-matchedLine) {
+                    throw new MatchingException("line number mismatch for file" + this.file + " -- ; " +
+                            "ranges have different size " + (endNumber-lineNumber) + " : " + (matchEnd-matchedLine));
+                }
                 // Set the matches
                 for (; lineNumber < currentRange.toExclusive(); lineNumber++, matchedLine++) {
                     this.setMatching(lineNumber, matchedLine);

src/main/java/org/variantsync/vevos/extraction/FullPCAnalysis.java

@@ -75,7 +75,14 @@ public boolean analyzeVariationDiff(Analysis analysis) throws Exception {
 
         analysis.getCurrentVariationDiff().forAll(node -> {
 //            Logger.debug("Node: {}", node);
-            PCAnalysis.analyzeNode(fileGT, node, Time.AFTER);
+            try {
+                PCAnalysis.analyzeNode(fileGT, node, Time.AFTER);
+            } catch (MatchingException e) {
+            Logger.error("unhandled exception while analyzing {} -> {} for commit {}.",
+                    fileNameBefore,
+                    fileNameAfter,
+                    analysis.getCurrentCommit().getName());
+        }
         });
 
         return true;

src/main/java/org/variantsync/vevos/extraction/MatchingException.java

@@ -0,0 +1,8 @@
+package org.variantsync.vevos.extraction;
+
+public class MatchingException extends Exception {
+
+    public MatchingException(String message) {
+        super(message);
+    }
+}

src/main/java/org/variantsync/vevos/extraction/PCAnalysis.java

@@ -18,7 +18,7 @@ public interface PCAnalysis {
      * @param node   The node that is to be analyzed
      * @param time Whether we should handle the node as before or after the edit
      */
-    static void analyzeNode(FileGT.Mutable fileGT, DiffNode<DiffLinesLabel> node, Time time) {
+    static void analyzeNode(FileGT.Mutable fileGT, DiffNode<DiffLinesLabel> node, Time time) throws MatchingException {
         if (time == Time.BEFORE && node.diffType == DiffType.ADD) {
             return;
         }