refactor: Make GitDiffer stateless

The `GitDiffer` class doesn't own (in the sense that the actual truth of
these members lies in the `Repository` class) any of its members.
Furthermore, it just bundles the same members as `Repository`, just
leaving those out, that are unneeded. The constructor of `GitDiffer`
even extracts these members from `Repository` and doesn't even allow
them to be past any other way. Furthermore, most of the interesting
functions are already static anyways.

A different approach would be to move all of methods into `Repository`.
However, there seems to be no reason to override any of the actual
diffing methods and the drawback would be a huge `Repository` class
which would serve a second purpose.

Author: ibbem

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

@@ -11,6 +11,7 @@
 
 import org.apache.commons.lang3.function.FailableBiConsumer;
 import org.apache.commons.lang3.function.FailableBiFunction;
+import org.eclipse.jgit.api.Git;
 import org.eclipse.jgit.revwalk.RevCommit;
 import org.tinylog.Logger;
 import org.variantsync.diffdetective.analysis.AnalysisResult.ResultKey;
@@ -60,7 +61,7 @@ public class Analysis {
     protected final List<Hooks> hooks;
     protected final Repository repository;
 
-    protected GitDiffer differ;
+    protected Git git;
     protected RevCommit currentCommit;
     protected CommitDiff currentCommitDiff;
     protected PatchDiff currentPatch;
@@ -307,16 +308,14 @@ public static void forEachRepository(
      * @param analysis the analysis to run
      */
     public static AnalysisResult forSingleCommit(final String commitHash, final Analysis analysis) {
-        analysis.differ = new GitDiffer(analysis.getRepository());
-
         final Clock clock = new Clock();
         // prepare tasks
         Logger.info(">>> Running Analysis on single commit {} in {}", commitHash, analysis.getRepository().getRepositoryName());
         clock.start();
 
         AnalysisResult result = null;
         try {
-            final RevCommit commit = analysis.differ.getCommit(commitHash);
+            final RevCommit commit = analysis.getRepository().getCommit(commitHash);
             analysis.processCommitBatch(List.of(commit));
             result = analysis.getResult();
         } catch (Exception e) {
@@ -397,7 +396,6 @@ public static AnalysisResult forEachCommit(
         final int nThreads
     ) {
         var analysis = analysisFactory.get();
-        analysis.differ = new GitDiffer(analysis.getRepository());
         analysis.result.append(RuntimeWithMultithreadingResult.KEY, new RuntimeWithMultithreadingResult());
 
         final Clock clock = new Clock();
@@ -409,14 +407,18 @@ public static AnalysisResult forEachCommit(
         final Iterator<Callable<AnalysisResult>> tasks = new MappedIterator<>(
                 /// 1.) Retrieve COMMITS_TO_PROCESS_PER_THREAD commits from the differ and cluster them into one list.
                 new ClusteredIterator<>(
-                        analysis.differ.yieldRevCommitsAfter(numberOfTotalCommits),
+                        analysis.getRepository().getDiffFilter().filter(
+                            new MappedIterator<>(
+                                analysis.getRepository().getCommits(),
+                                numberOfTotalCommits
+                            )
+                        ),
                         commitsToProcessPerThread
                 ),
                 /// 2.) Create a MiningTask for the list of commits. This task will then be processed by one
                 ///     particular thread.
                 commitList -> () -> {
                     Analysis thisThreadsAnalysis = analysisFactory.get();
-                    thisThreadsAnalysis.differ = analysis.differ;
                     thisThreadsAnalysis.processCommitBatch(commitList);
                     return thisThreadsAnalysis.getResult();
                 }
@@ -519,7 +521,7 @@ protected void processCommitBatch(List<RevCommit> commits) throws Exception {
 
     protected void processCommit() throws Exception {
         // parse the commit
-        final CommitDiffResult commitDiffResult = differ.createCommitDiff(currentCommit);
+        final CommitDiffResult commitDiffResult = GitDiffer.createCommitDiffFromFirstParent(repository, currentCommit);
 
         // report any errors that occurred and exit in case no VariationDiff could be parsed.
         getResult().reportDiffErrors(commitDiffResult.errors());

src/main/java/org/variantsync/diffdetective/datasets/Repository.java

@@ -1,14 +1,19 @@
 package org.variantsync.diffdetective.datasets;
 
 import org.eclipse.jgit.api.Git;
+import org.eclipse.jgit.api.errors.GitAPIException;
+import org.eclipse.jgit.lib.ObjectId;
+import org.eclipse.jgit.revwalk.RevCommit;
 import org.tinylog.Logger;
 import org.variantsync.diffdetective.diff.git.DiffFilter;
 import org.variantsync.diffdetective.load.GitLoader;
 import org.variantsync.diffdetective.util.IO;
 import org.variantsync.functjonal.Lazy;
 
+import java.io.IOException;
 import java.net.URI;
 import java.nio.file.Path;
+import java.util.Iterator;
 import java.util.Optional;
 
 /**
@@ -234,6 +239,26 @@ public void preload() {
 		getGitRepo();
 	}
 
+	/**
+	 * Returns a single commit from the repository.
+	 * Note that this commit may not be part of {@link #getCommits}.
+	 */
+	public RevCommit getCommit(String commitHash) throws IOException {
+		return getGitRepo().getRepository().parseCommit(ObjectId.fromString(commitHash));
+	}
+
+	/**
+	 * Returns all commits in the repository's history.
+	 */
+	public Iterator<RevCommit> getCommits() {
+		try {
+			return getGitRepo().log().call().iterator();
+		} catch (GitAPIException e) {
+			Logger.warn("Could not get log for git repository {}", getRepositoryName());
+			throw new RuntimeException(e);
+		}
+	}
+
 	/**
 	 * Loads this repository and returns a jgit representation to access it.
 	 */

src/main/java/org/variantsync/diffdetective/diff/git/DiffFilter.java

@@ -4,9 +4,11 @@
 import org.eclipse.jgit.diff.DiffEntry;
 import org.eclipse.jgit.revwalk.RevCommit;
 import org.variantsync.diffdetective.variation.diff.Time;
+import org.variantsync.functjonal.iteration.Yield;
 
 import java.util.ArrayList;
 import java.util.Arrays;
+import java.util.Iterator;
 import java.util.List;
 
 /**
@@ -330,6 +332,31 @@ public boolean filter(RevCommit commit) {
                 ;
     }
 
+    /**
+     * Filters all undesired commits from the given list of commits.
+     * @param commitsIterator Commits to filter.
+     * @return All commits from the given set that should not be filtered out.
+     */
+    public Iterator<RevCommit> filter(final Iterator<RevCommit> commitsIterator) {
+        return new Yield<>(
+                () -> {
+                    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 (!filter(c)) {
+                            continue;
+                        }
+
+                        return c;
+                    }
+
+                    return null;
+                }
+        );
+    }
+
     private boolean isAllowedPath(String filename) {
         return allowedPaths.stream().anyMatch(filename::matches);
     }