documentation + minor fixes

Author: pmbittner

src/main/java/org/variantsync/diffdetective/analysis/HistoryAnalysis.java

@@ -90,7 +90,10 @@ public static void analyzeAsync(
         final InvocationCounter<RevCommit, RevCommit> numberOfTotalCommits = InvocationCounter.justCount();
         final Iterator<CommitHistoryAnalysisTask> tasks = new MappedIterator<>(
                 /// 1.) Retrieve COMMITS_TO_PROCESS_PER_THREAD commits from the differ and cluster them into one list.
-                new ClusteredIterator<>(differ.yieldRevCommitsAfter(numberOfTotalCommits), commitsToProcessPerThread),
+                new ClusteredIterator<>(
+                        differ.yieldRevCommitsAfter(numberOfTotalCommits),
+                        commitsToProcessPerThread
+                ),
                 /// 2.) Create a MiningTask for the list of commits. This task will then be processed by one
                 ///     particular thread.
                 commitList -> taskFactory.create(

src/main/java/org/variantsync/diffdetective/diff/GitDiffer.java

@@ -29,13 +29,7 @@
 import org.variantsync.functjonal.iteration.SideEffectIterator;
 import org.variantsync.functjonal.iteration.Yield;
 
-import java.io.BufferedReader;
-import java.io.ByteArrayOutputStream;
-import java.io.IOException;
-import java.io.InputStreamReader;
-import java.io.LineNumberReader;
-import java.io.StringReader;
-import java.io.UncheckedIOException;
+import java.io.*;
 import java.nio.charset.StandardCharsets;
 import java.util.ArrayList;
 import java.util.Iterator;
@@ -145,6 +139,8 @@ private Yield<RevCommit> yieldAllValidIn(final Iterator<RevCommit> commitsIterat
                     while (commitsIterator.hasNext()) {
                         final RevCommit c = commitsIterator.next();
                         // If this commit is filtered, go to the next one.
+                        // filter returns true if we want to include the commit
+                        // so if we do not want to filter it, we do not want to have it. Thus skip.
                         if (!diffFilter.filter(c)) {
                             continue;
                         }

src/main/java/org/variantsync/diffdetective/diff/difftree/DiffNode.java

@@ -9,8 +9,8 @@
 import org.variantsync.diffdetective.util.fide.FixTrueFalse;
 
 import java.util.*;
-import java.util.stream.Collectors;
 import java.util.function.Function;
+import java.util.stream.Collectors;
 
 import static org.variantsync.diffdetective.util.fide.FormulaUtils.negate;
 
@@ -528,7 +528,7 @@ private List<Node> getFeatureMappingClauses(Function<DiffNode, DiffNode> parentO
             List<Node> and = new ArrayList<>();
 
             if (isElif()) {
-                and.add(featureMapping);
+                and.add(getDirectFeatureMapping());
             }
 
             // Negate all previous cases
@@ -537,18 +537,19 @@ private List<Node> getFeatureMappingClauses(Function<DiffNode, DiffNode> parentO
                 if (ancestor.isElif()) {
                     and.add(negate(ancestor.getDirectFeatureMapping()));
                 } else {
-                    Assert.assertTrue(ancestor.isCode());
+                    throw new RuntimeException("Expected If or Elif above Else or Elif but got " + ancestor.codeType + " from " + ancestor);
+                    // Assert.assertTrue(ancestor.isCode());
                 }
                 ancestor = parentOf.apply(ancestor);
             }
             and.add(negate(ancestor.getDirectFeatureMapping()));
 
             return and;
         } else if (isCode()) {
-            return List.of(parent.getFeatureMapping(parentOf));
+            return parent.getFeatureMappingClauses(parentOf);
         }
 
-        return List.of(featureMapping);
+        return List.of(getDirectFeatureMapping());
     }
 
     private Node getFeatureMapping(Function<DiffNode, DiffNode> parentOf) {

src/main/java/org/variantsync/diffdetective/diff/difftree/transform/CutNonEditedSubtrees.java

@@ -22,7 +22,7 @@ public void visit(final DiffTreeTraversal traversal, final DiffNode subtree) {
             /*
              * Collapse all children c for which
              *   1. all children of c could be collapsed or c never had children
-             *   2. that was not relocated due to an edit.
+             *   2. that was not relocated due to an edit (beforeparent and afterparent are the same).
              *
              * Note: c satisfies 2 => c.isNon() and subtree.isNon()
              *       We thus only cut subtrees that (a) were not edited themselves and (b) were not relocated.

src/main/java/org/variantsync/diffdetective/load/GitLoader.java

@@ -56,7 +56,8 @@ public static Git fromRemote(Path localPath, URI remoteURI) {
 
         try {
             Logger.info("Cloning {} to {}.", remoteURI, localPath);
-            return Git.cloneRepository()
+            return Git
+                    .cloneRepository()
                     .setURI(remoteURI.toString())
                     .setDirectory(localPath.toFile())
                     .setProgressMonitor(new LoggingProgressMonitor())

src/main/java/org/variantsync/diffdetective/validation/Validation.java

@@ -99,7 +99,7 @@ public static void main(String[] args) throws IOException {
         final ParseOptions.DiffStoragePolicy diffStoragePolicy = ParseOptions.DiffStoragePolicy.DO_NOT_REMEMBER;
 
         final Path inputDir = Paths.get("..", "DiffDetectiveMining");
-        final Path outputDir = Paths.get("results", "difftrees");
+        final Path outputDir = Paths.get("results", "validation", "current");
 
         final List<Repository> repos;
         final List<DatasetDescription> datasets = DefaultDatasets.loadDefaultDatasets();