Use Original SubmissionFiles in Report DTOs

jplag/src/main/java/de/jplag/reporting/jsonfactory/JsonWriter.java → jplag/src/main/java/de/jplag/reporting/jsonfactory/FileWriter.java

@@ -8,12 +8,18 @@
 
 import com.fasterxml.jackson.databind.ObjectMapper;
 
-public class JsonWriter {
-    private static final Logger logger = LoggerFactory.getLogger(JsonWriter.class);
+public class FileWriter {
+    private static final Logger logger = LoggerFactory.getLogger(FileWriter.class);
 
     private static final ObjectMapper objectMapper = new ObjectMapper();
 
-    public void saveFile(Object fileToSave, String folderPath, String fileName) {
+    /**
+     * Saves the provided object to the provided path under the provided name
+     * @param fileToSave The object to save
+     * @param folderPath The path to save the object to
+     * @param fileName The name to save the object under
+     */
+    public void saveAsJSON(Object fileToSave, String folderPath, String fileName) {
         try {
             objectMapper.writeValue(Path.of(folderPath, fileName).toFile(), fileToSave);
         } catch (IOException e) {

jplag/src/main/java/de/jplag/reporting/reportobject/ReportObjectFactory.java

@@ -1,14 +1,19 @@
 package de.jplag.reporting.reportobject;
 
+import java.io.File;
+import java.io.IOException;
+import java.nio.file.Files;
 import java.text.SimpleDateFormat;
-import java.util.ArrayList;
-import java.util.Date;
-import java.util.HashSet;
-import java.util.List;
+import java.util.*;
+import java.util.stream.Collectors;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 
 import de.jplag.JPlagComparison;
 import de.jplag.JPlagResult;
-import de.jplag.reporting.jsonfactory.JsonWriter;
+import de.jplag.Submission;
+import de.jplag.reporting.jsonfactory.FileWriter;
 import de.jplag.reporting.reportobject.mapper.ClusteringResultMapper;
 import de.jplag.reporting.reportobject.mapper.ComparisonReportMapper;
 import de.jplag.reporting.reportobject.mapper.MetricMapper;
@@ -19,26 +24,25 @@
  * Factory class, responsible for converting a JPlagResult object to Overview and Comparison DTO classes.
  */
 public class ReportObjectFactory {
+    private static final Logger logger = LoggerFactory.getLogger(ReportObjectFactory.class);
 
     private static final ClusteringResultMapper clusteringResultMapper = new ClusteringResultMapper();
     private static final MetricMapper metricMapper = new MetricMapper();
     private static final ComparisonReportMapper comparisonReportMapper = new ComparisonReportMapper();
-    private static final JsonWriter jsonWriter = new JsonWriter();
+    private static final FileWriter fileWriter = new FileWriter();
 
     /**
-     * Converts a JPlagResult to a JPlagReport.
      * @return JPlagReport for the given JPlagResult.
+     * @param result The JPlagResult to be converted into a report.
+     * @param path The Path to save the report to
      */
     public static void saveReport(JPlagResult result, String path) {
-        OverviewReport overviewReport = generateOverviewReport(result);
-        jsonWriter.saveFile(overviewReport, path, "overview.json");
+        writeOverview(result, path);
+        copySubmissionFilesToReport(path, result);
         comparisonReportMapper.writeComparisonReports(result, path);
     }
 
-    /**
-     * Generates an Overview DTO of a JPlagResult.
-     */
-    private static OverviewReport generateOverviewReport(JPlagResult result) {
+    private static void writeOverview(JPlagResult result, String path) {
         List<JPlagComparison> comparisons = getComparisons(result);
         OverviewReport overviewReport = new OverviewReport();
 
@@ -63,7 +67,41 @@ private static OverviewReport generateOverviewReport(JPlagResult result) {
         overviewReport.setMetrics(getMetrics(result));
         overviewReport.setClusters(clusteringResultMapper.map(result));
 
-        return overviewReport;
+        fileWriter.saveAsJSON(overviewReport, path, "overview.json");
+
+    }
+
+    private static void copySubmissionFilesToReport(String path, JPlagResult result) {
+        List<JPlagComparison> comparisons = result.getComparisons(result.getOptions().getMaximumNumberOfComparisons());
+        var submissions = getSubmissions(comparisons);
+        var submissionsPath = createDirectory(path, "Submissions");
+        for (var submission : submissions) {
+            File directory = createDirectory(submissionsPath.getPath(), submission.getName());
+            for (var file : submission.getFiles()) {
+                try {
+                    Files.copy(file.toPath(), (new File(directory, file.getName())).toPath());
+                } catch (IOException e) {
+                    throw new RuntimeException(e);
+                }
+            }
+        }
+    }
+
+    private static Set<Submission> getSubmissions(List<JPlagComparison> comparisons) {
+        var submissions = comparisons.stream().map(JPlagComparison::getFirstSubmission).collect(Collectors.toSet());
+        Set<Submission> secondSubmissions = comparisons.stream().map(JPlagComparison::getSecondSubmission).collect(Collectors.toSet());
+        submissions.addAll(secondSubmissions);
+        return submissions;
+    }
+
+    private static File createDirectory(String path, String name) {
+        File directory = new File(path.concat("/").concat(name));
+        if (!directory.exists()) {
+            if (!directory.mkdirs()) {
+                logger.error("Failed to create dir.");
+            }
+        }
+        return directory;
     }
 
     private static List<JPlagComparison> getComparisons(JPlagResult result) {

jplag/src/main/java/de/jplag/reporting/reportobject/mapper/ComparisonReportMapper.java

@@ -1,63 +1,34 @@
 package de.jplag.reporting.reportobject.mapper;
 
-import java.io.File;
-import java.io.IOException;
-import java.nio.file.Files;
 import java.util.List;
 import java.util.stream.Collectors;
 
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-import de.jplag.JPlagComparison;
-import de.jplag.JPlagResult;
-import de.jplag.Token;
-import de.jplag.TokenList;
-import de.jplag.reporting.jsonfactory.JsonWriter;
+import de.jplag.*;
+import de.jplag.reporting.jsonfactory.FileWriter;
 import de.jplag.reporting.reportobject.model.ComparisonReport;
 import de.jplag.reporting.reportobject.model.Match;
 
 public class ComparisonReportMapper {
 
-    private static final Logger logger = LoggerFactory.getLogger(ComparisonReportMapper.class);
-    private static final JsonWriter jsonWriter = new JsonWriter();
+    private static final FileWriter FILE_WRITER = new FileWriter();
 
     /**
      * Generates detailed ComparisonReport DTO for each comparison in a JPlagResult.
-     * @param jPlagResult The JPlagResult to generate the comparison reports from.
-     * contains information about a comparison between two submission - including their files. These files are not saved in
-     * plain text though, they are saved as numbers. these numbers are indices to the second DTO of the
-     * ComparisonReportMapperResult, the lineLookUpTable.
+     * @param jPlagResult The JPlagResult to generate the comparison reports from. contains information about a comparison
+     * between two submission. The JPlagResult is used to extract the information on matches between two submissions.
      */
     public void writeComparisonReports(JPlagResult jPlagResult, String path) {
-        int maxNumOfComparisons = jPlagResult.getOptions().getMaximumNumberOfComparisons();
-
-        List<JPlagComparison> comparisons = jPlagResult.getComparisons(maxNumOfComparisons);
-
-        var allSubmissions = comparisons.stream().map(JPlagComparison::getFirstSubmission).collect(Collectors.toSet());
-        for (var submission : allSubmissions) {
-
-            File directory = new File(path.concat("/").concat(submission.getName()));
-            if (!directory.exists()) {
-                if (!directory.mkdirs()) {
-                    logger.error("Failed to create dir.");
-                }
-            }
-            for (var file : submission.getFiles()) {
-
-                try {
-                    Files.copy(file.toPath(), (new File(directory, file.getName())).toPath());
-                } catch (IOException e) {
-                    throw new RuntimeException(e);
-                }
-            }
-        }
+        int numberOfComparisons = jPlagResult.getOptions().getMaximumNumberOfComparisons();
+        List<JPlagComparison> comparisons = jPlagResult.getComparisons(numberOfComparisons);
+        writeComparisons(jPlagResult, path, comparisons);
+    }
 
+    private void writeComparisons(JPlagResult jPlagResult, String path, List<JPlagComparison> comparisons) {
         for (JPlagComparison comparison : comparisons) {
             var comparisonReport = new ComparisonReport(comparison.getFirstSubmission().getName(), comparison.getSecondSubmission().getName(),
                     comparison.similarity(), convertMatchesToReportMatches(jPlagResult, comparison));
             String fileName = comparisonReport.firstSubmissionId().concat("-").concat(comparisonReport.secondSubmissionId()).concat(".json");
-            jsonWriter.saveFile(comparisonReport, path, fileName);
+            FILE_WRITER.saveAsJSON(comparisonReport, path, fileName);
         }
     }
 
@@ -67,13 +38,6 @@ private List<Match> convertMatchesToReportMatches(JPlagResult result, JPlagCompa
                 .collect(Collectors.toList());
     }
 
-    /**
-     * Converts a JPlag Match object to a Match DTO.
-     * @param comparison The comparison from which the match originates.
-     * @param match The match to be converted.
-     * @param usesIndex Indicates whether the language uses indexes.
-     * @return A Match DTO.
-     */
     private Match convertMatchToReportMatch(JPlagComparison comparison, de.jplag.Match match, Boolean usesIndex) {
         TokenList tokensFirst = comparison.getFirstSubmission().getTokenList();
         TokenList tokensSecond = comparison.getSecondSubmission().getTokenList();