Merge branch 'mining' of github.com:VariantSync/DiffDetective into mining

Author: Christof Tinnes

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

@@ -6,6 +6,7 @@
 import org.variantsync.diffdetective.datasets.Repository;
 import org.variantsync.diffdetective.diff.GitDiffer;
 import org.variantsync.diffdetective.diff.difftree.serialize.DiffTreeLineGraphExportOptions;
+import org.variantsync.diffdetective.util.CSV;
 import org.variantsync.diffdetective.util.IO;
 import org.variantsync.diffdetective.util.StringUtils;
 
@@ -16,6 +17,7 @@
 
 public abstract class CommitHistoryAnalysisTask implements Callable<AnalysisResult> {
     public static final String COMMIT_TIME_FILE_EXTENSION = ".committimes.txt";
+    public static final String PATCH_STATISTICS_EXTENSION = ".patchStatistics.csv";
 
     public record Options(
         Repository repository,
@@ -65,4 +67,15 @@ public static void exportCommitTimes(final List<CommitProcessTime> commitTimes,
             System.exit(0);
         }
     }
+
+    public static void exportPatchStatistics(final List<PatchStatistics> commitTimes, final Path pathToOutputFile) {
+        final String csv = CSV.toCSV(commitTimes);
+
+        try {
+            IO.write(pathToOutputFile, csv);
+        } catch (IOException e) {
+            Logger.error(e);
+            System.exit(0);
+        }
+    }
 }

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

@@ -0,0 +1,34 @@
+package org.variantsync.diffdetective.analysis;
+
+import org.variantsync.diffdetective.pattern.elementary.ElementaryPattern;
+import org.variantsync.diffdetective.pattern.elementary.ElementaryPatternCatalogue;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.stream.Collectors;
+
+public class ElementaryPatternCount {
+    private final ElementaryPatternCatalogue catalogue;
+    private final Map<ElementaryPattern, Integer> patterncounts;
+
+    public ElementaryPatternCount(final ElementaryPatternCatalogue catalogue) {
+        this.catalogue = catalogue;
+        this.patterncounts = new HashMap<>();
+        catalogue.all().forEach(e -> patterncounts.put(e, 0));
+    }
+
+    public void increment(final ElementaryPattern pattern) {
+        patterncounts.computeIfPresent(pattern, (p, i) -> i + 1);
+    }
+
+    public String toCSV() {
+        return toCSV(";");
+    }
+
+    public String toCSV(final String delimiter) {
+        return catalogue.all().stream()
+                .map(patterncounts::get)
+                .map(Object::toString)
+                .collect(Collectors.joining(delimiter));
+    }
+}

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

@@ -0,0 +1,17 @@
+package org.variantsync.diffdetective.analysis;
+
+import org.variantsync.diffdetective.diff.PatchDiff;
+import org.variantsync.diffdetective.pattern.elementary.ElementaryPatternCatalogue;
+import org.variantsync.diffdetective.util.CSV;
+
+public record PatchStatistics(
+        PatchDiff patchDiff,
+        ElementaryPatternCount elementaryPatternCount) implements CSV {
+    public PatchStatistics(final PatchDiff patch, final ElementaryPatternCatalogue catalogue) {
+        this(patch, new ElementaryPatternCount(catalogue));
+    }
+
+    public String toCSV(final String delimiter) {
+        return patchDiff.getCommitHash() + delimiter + patchDiff.getFileName() + delimiter + elementaryPatternCount.toCSV(delimiter);
+    }
+}

src/main/java/org/variantsync/diffdetective/mining/MiningTask.java

@@ -2,10 +2,7 @@
 
 import org.eclipse.jgit.revwalk.RevCommit;
 import org.tinylog.Logger;
-import org.variantsync.diffdetective.analysis.AnalysisResult;
-import org.variantsync.diffdetective.analysis.CommitHistoryAnalysisTask;
-import org.variantsync.diffdetective.analysis.CommitProcessTime;
-import org.variantsync.diffdetective.analysis.HistoryAnalysis;
+import org.variantsync.diffdetective.analysis.*;
 import org.variantsync.diffdetective.diff.CommitDiff;
 import org.variantsync.diffdetective.diff.PatchDiff;
 import org.variantsync.diffdetective.diff.difftree.DiffTree;
@@ -14,6 +11,7 @@
 import org.variantsync.diffdetective.diff.difftree.transform.DiffTreeTransformer;
 import org.variantsync.diffdetective.diff.result.CommitDiffResult;
 import org.variantsync.diffdetective.metadata.ExplainedFilterSummary;
+import org.variantsync.diffdetective.pattern.elementary.ElementaryPattern;
 import org.variantsync.diffdetective.pattern.elementary.proposed.ProposedElementaryPatterns;
 import org.variantsync.diffdetective.util.Clock;
 import org.variantsync.diffdetective.util.FileUtils;
@@ -34,6 +32,7 @@ public AnalysisResult call() throws Exception {
         final Clock totalTime = new Clock();
 
         final List<CommitProcessTime> commitTimes = new ArrayList<>(HistoryAnalysis.COMMITS_TO_PROCESS_PER_THREAD_DEFAULT);
+        final List<PatchStatistics> patchStatistics = new ArrayList<>(HistoryAnalysis.COMMITS_TO_PROCESS_PER_THREAD_DEFAULT);
         final Clock commitProcessTimer = new Clock();
 
         totalTime.start();
@@ -61,6 +60,8 @@ public AnalysisResult call() throws Exception {
             // Count elementary patterns
             int numDiffTrees = 0;
             for (final PatchDiff patch : commitDiff.getPatchDiffs()) {
+                final PatchStatistics thisPatchesStatistics = new PatchStatistics(patch, ProposedElementaryPatterns.Instance);
+
                 if (patch.isValid()) {
                     final DiffTree t = patch.getDiffTree();
                     DiffTreeTransformer.apply(exportOptions.treePreProcessing(), t);
@@ -72,15 +73,19 @@ public AnalysisResult call() throws Exception {
 
                     t.forAll(node -> {
                         if (node.isCode()) {
+                            final ElementaryPattern nodePattern = ProposedElementaryPatterns.Instance.match(node);
                             miningResult.elementaryPatternCounts.reportOccurrenceFor(
-                                    ProposedElementaryPatterns.Instance.match(node),
+                                    nodePattern,
                                     commitDiff
                             );
+                            thisPatchesStatistics.elementaryPatternCount().increment(nodePattern);
                         }
                     });
 
                     ++numDiffTrees;
                 }
+
+                patchStatistics.add(thisPatchesStatistics);
             }
             miningResult.exportedTrees += numDiffTrees;
             miningResult.filterHits.append(new ExplainedFilterSummary(exportOptions.treeFilter()));
@@ -106,6 +111,7 @@ public AnalysisResult call() throws Exception {
         miningResult.runtimeInSeconds = totalTime.getPassedSeconds();
         miningResult.exportTo(FileUtils.addExtension(options.outputPath(), AnalysisResult.EXTENSION));
         exportCommitTimes(commitTimes, FileUtils.addExtension(options.outputPath(), COMMIT_TIME_FILE_EXTENSION));
+        exportPatchStatistics(patchStatistics, FileUtils.addExtension(options.outputPath(), PATCH_STATISTICS_EXTENSION));
         return miningResult;
     }
 }

src/main/java/org/variantsync/diffdetective/util/CSV.java

@@ -0,0 +1,25 @@
+package org.variantsync.diffdetective.util;
+
+import java.util.Collection;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+public interface CSV {
+    String DEFAULT_CSV_DELIMITER = ";";
+
+    default String toCSV() {
+        return toCSV(DEFAULT_CSV_DELIMITER);
+    }
+
+    String toCSV(final String delimiter);
+
+    static String toCSV(final Collection<? extends CSV> collection) {
+        return toCSV(collection.stream());
+    }
+
+    static String toCSV(final Stream<? extends CSV> collection) {
+        return collection
+                .map(CSV::toCSV)
+                .collect(Collectors.joining(StringUtils.LINEBREAK));
+    }
+}