Feature/allow single submissions and path names

core/src/main/java/de/jplag/JPlag.java

@@ -1,18 +1,14 @@
 package de.jplag;
 
 import java.io.File;
-import java.util.ArrayList;
-import java.util.HashSet;
 import java.util.List;
 import java.util.ResourceBundle;
-import java.util.Set;
 
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
 import de.jplag.clustering.ClusteringFactory;
 import de.jplag.exceptions.ExitException;
-import de.jplag.exceptions.RootDirectoryException;
 import de.jplag.exceptions.SubmissionException;
 import de.jplag.merging.MatchMerging;
 import de.jplag.options.JPlagOptions;
@@ -107,30 +103,9 @@ private static void logSkippedSubmissions(SubmissionSet submissionSet, JPlagOpti
         }
     }
 
-    private static void checkForConfigurationConsistency(JPlagOptions options) throws RootDirectoryException {
+    private static void checkForConfigurationConsistency(JPlagOptions options) {
         if (options.normalize() && !options.language().supportsNormalization()) {
-            logger.error(String.format("The language %s cannot be used with normalization.", options.language().getName()));
+            logger.error("The language {} cannot be used with normalization.", options.language().getName());
         }
-
-        List<String> duplicateNames = getDuplicateSubmissionFolderNames(options);
-        if (duplicateNames.size() > 0) {
-            throw new RootDirectoryException(String.format("Duplicate root directory names found: %s", String.join(", ", duplicateNames)));
-        }
-    }
-
-    private static List<String> getDuplicateSubmissionFolderNames(JPlagOptions options) {
-        List<String> duplicateNames = new ArrayList<>();
-        Set<String> alreadyFoundNames = new HashSet<>();
-        for (File file : options.submissionDirectories()) {
-            if (!alreadyFoundNames.add(file.getName())) {
-                duplicateNames.add(file.getName());
-            }
-        }
-        for (File file : options.oldSubmissionDirectories()) {
-            if (!alreadyFoundNames.add(file.getName())) {
-                duplicateNames.add(file.getName());
-            }
-        }
-        return duplicateNames;
     }
 }

core/src/main/java/de/jplag/SubmissionSetBuilder.java

@@ -14,6 +14,8 @@
 import java.util.Optional;
 import java.util.Set;
 import java.util.function.Function;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
 
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
@@ -80,10 +82,13 @@ public SubmissionSet buildSubmissionSet() throws ExitException {
             submissionFiles.addAll(listSubmissionFiles(submissionDirectory, false));
         }
 
+        Set<File> allRootDirectories = submissionFiles.stream().map(SubmissionFileData::root).collect(Collectors.toSet());
+        Map<File, String> rootDirectoryNamePrefixesMapper = getRootDirectoryNamesPrefixesMapper(allRootDirectories);
+
         ProgressBar progressBar = ProgressBarLogger.createProgressBar(ProgressBarType.LOADING, submissionFiles.size());
         Map<File, Submission> foundSubmissions = new HashMap<>();
         for (SubmissionFileData submissionFile : submissionFiles) {
-            processSubmissionFile(submissionFile, multipleRoots, foundSubmissions);
+            processSubmissionFile(submissionFile, multipleRoots, rootDirectoryNamePrefixesMapper, foundSubmissions);
             progressBar.step();
         }
         progressBar.dispose();
@@ -103,6 +108,92 @@ public SubmissionSet buildSubmissionSet() throws ExitException {
         return new SubmissionSet(submissions, baseCodeSubmission.orElse(null), options);
     }
 
+    private static String[] getCanonicalPathComponents(File path) {
+        try {
+            return path.getCanonicalPath().split(File.separator.equals("\\") ? "\\\\" : File.separator);
+        } catch (Exception e) {
+            throw new RuntimeException("Error getting canonical path", e);
+        }
+    }
+
+    public static File getCommonAncestor(File firstPath, File secondPath) {
+        String[] firstComponents = getCanonicalPathComponents(firstPath);
+        String[] secondComponents = getCanonicalPathComponents(secondPath);
+
+        int minLength = Math.min(firstComponents.length, secondComponents.length);
+        int commonLength = 0;
+
+        for (int i = 0; i < minLength; i++) {
+            if (firstComponents[i].equals(secondComponents[i])) {
+                commonLength++;
+            } else {
+                break;
+            }
+        }
+
+        if (commonLength == 0) {
+            return null;
+        }
+
+        StringBuilder commonPath = new StringBuilder(firstComponents[0]);
+        for (int i = 1; i < commonLength; i++) {
+            commonPath.append(File.separator).append(firstComponents[i]);
+        }
+
+        return new File(commonPath.toString());
+    }
+
+    private String findCommonPathPrefix(List<File> canonicalPaths) {
+        if (canonicalPaths == null) {
+            return "";
+        }
+
+        File prefix = canonicalPaths.getFirst();
+        for (int i = 1; i < canonicalPaths.size(); i++) {
+            prefix = getCommonAncestor(prefix, canonicalPaths.get(i));
+        }
+
+        return prefix == null ? null : prefix.toString();
+    }
+
+    private String getPathPrefix(File path, String commonPrefix) {
+        String result = path.toString().substring(commonPrefix.length());
+        return result.startsWith(File.separator) ? result.substring(1) : result;
+    }
+
+    private Map<File, String> getRootDirectoryNamesPrefixesMapper(Set<File> allRootDirectories) {
+        Map<String, List<File>> conflicts = getRootDirectoryNameConflicts(allRootDirectories);
+
+        Map<File, String> result = new HashMap<>();
+        conflicts.forEach((name, paths) -> {
+            if (paths.size() > 1) {
+                String commonPrefix = findCommonPathPrefix(paths);
+                for (File path : paths) {
+                    result.put(path, getPathPrefix(path, commonPrefix));
+                }
+            } else {
+                result.put(paths.getFirst(), "");
+            }
+        });
+
+        return result;
+    }
+
+    private static Map<String, List<File>> getRootDirectoryNameConflicts(Set<File> allRootDirectories) {
+        Map<String, List<File>> conflicts = new HashMap<>();
+
+        for (File rootDir : allRootDirectories) {
+            String roodDirName = rootDir.getName();
+            if (conflicts.containsKey(roodDirName)) {
+                conflicts.get(roodDirName).add(rootDir);
+            } else {
+                conflicts.put(roodDirName, Stream.of(rootDir).collect(Collectors.toList()));
+            }
+        }
+
+        return conflicts;
+    }
+
     /**
      * Verify that the given root directories exist and have no duplicate entries.
      */
@@ -219,14 +310,17 @@ private Submission processSubmission(String submissionName, File submissionFile,
         return new Submission(submissionName, file, isNew, parseFilesRecursively(file), options.language());
     }
 
-    private void processSubmissionFile(SubmissionFileData file, boolean multipleRoots, Map<File, Submission> foundSubmissions) throws ExitException {
+    private void processSubmissionFile(SubmissionFileData file, boolean multipleRoots, Map<File, String> rootDirectoryNamePrefixesMapper,
+            Map<File, Submission> foundSubmissions) throws ExitException {
         if (isFileExcluded(file.submissionFile())) {
             logger.error("Exclude submission: {}", file.submissionFile().getName());
         } else if (file.submissionFile().isFile() && !hasValidSuffix(file.submissionFile())) {
             logger.error("Ignore submission with invalid suffix: {}", file.submissionFile().getName());
         } else {
-            String rootDirectoryPrefix = multipleRoots ? (file.root().getName() + File.separator) : "";
-            String submissionName = rootDirectoryPrefix + file.submissionFile().getName();
+            String rootDirectoryPrefix = rootDirectoryNamePrefixesMapper.get(file.root());
+            rootDirectoryPrefix = rootDirectoryPrefix.isEmpty() && multipleRoots ? file.root().getName() : rootDirectoryPrefix;
+            String submissionName = rootDirectoryPrefix.isEmpty() ? file.submissionFile().getName()
+                    : rootDirectoryPrefix + File.separator + file.submissionFile().getName();
             Submission submission = processSubmission(submissionName, file.submissionFile(), file.isNew());
             foundSubmissions.put(submission.getRoot(), submission);
         }

core/src/test/java/de/jplag/RootFolderTest.java

@@ -1,16 +1,15 @@
 package de.jplag;
 
-import static org.junit.jupiter.api.Assertions.assertEquals;
-import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.*;
 
 import java.io.File;
+import java.util.Arrays;
 import java.util.List;
 
 import org.junit.jupiter.api.DisplayName;
 import org.junit.jupiter.api.Test;
 
 import de.jplag.exceptions.ExitException;
-import de.jplag.exceptions.RootDirectoryException;
 
 /**
  * Test class for the multi-root feature and the old-new feature.
@@ -71,7 +70,7 @@ void testDisjunctNewAndOldRootDirectories() throws ExitException {
     void testOverlappingNewAndOldDirectoriesOverlap() throws ExitException {
         List<String> newDirectories = List.of(getBasePath(ROOT_2));
         List<String> oldDirectories = List.of(getBasePath(ROOT_2));
-        assertThrows(RootDirectoryException.class, () -> runJPlag(newDirectories, oldDirectories, it -> it));
+        assertDoesNotThrow(() -> runJPlag(newDirectories, oldDirectories, it -> it));
     }
 
     @Test
@@ -84,4 +83,33 @@ void testBasecodeInOldDirectory() throws ExitException {
         int numberOfExpectedComparison = 1 + ROOT_COUNT_2 * (ROOT_COUNT_1 - 1); // -1 for basecode
         assertEquals(numberOfExpectedComparison, result.getAllComparisons().size());
     }
+
+    @Test
+    @DisplayName("test multiple submissions with same folder name")
+    void testSubmissionsWithSameFolderName() throws ExitException {
+        String[] roots = new String[] {"A", "B", "base"};
+        List<String> submissions = Arrays.stream(roots).map(it -> getBasePath("basecode" + File.separator + it)).toList();
+        JPlagResult result = runJPlag(submissions, it -> it);
+        List<String> submissionNames = result.getSubmissions().getSubmissions().stream().map(Submission::getName).sorted().toList();
+        String conflictingFile = "TerrainType.java";
+
+        for (int i = 0; i < roots.length; i++) {
+            String expectedName = roots[i] + File.separator + conflictingFile;
+            String effectiveName = submissionNames.get(i);
+            assertEquals(expectedName, effectiveName);
+        }
+    }
+
+    @Test
+    @DisplayName("test single new submission")
+    void testSingleNewSubmission() throws ExitException {
+        List<String> newSubmissions = List.of(getBasePath("basecode" + File.separator + "A"));
+        List<String> oldSubmissions = List.of(getBasePath("basecode" + File.separator + "B"));
+        JPlagResult result = runJPlag(newSubmissions, oldSubmissions, it -> it);
+        long numberOfNewSubmissions = result.getSubmissions().getSubmissions().stream().filter(Submission::isNew).count();
+        long numberOfOldSubmissions = result.getSubmissions().getSubmissions().stream().filter(it -> !it.isNew()).count();
+        assertEquals(1, numberOfNewSubmissions);
+        assertEquals(1, numberOfOldSubmissions);
+    }
+
 }

core/src/test/java/de/jplag/reporting/reportobject/ReportObjectFactoryTest.java

@@ -6,6 +6,8 @@
 import java.io.File;
 import java.io.IOException;
 import java.io.RandomAccessFile;
+import java.util.List;
+import java.util.stream.Stream;
 
 import org.junit.jupiter.api.Assertions;
 import org.junit.jupiter.api.Test;
@@ -37,6 +39,27 @@ void testCreateAndSaveReportWithBasecode() throws ExitException, IOException {
         assertTrue(isArchive(testZip));
     }
 
+    @Test
+    void testWithSamenameSubmissions() throws ExitException, IOException {
+        File submission1 = new File(BASE_PATH, "basecode/A");
+        File submission2 = new File(BASE_PATH, "basecode/B");
+        File submission3 = new File(BASE_PATH, "basecode-sameNameOfSubdirectoryAndRootdirectory/A");
+        File submission4 = new File(BASE_PATH, "basecode-sameNameOfSubdirectoryAndRootdirectory/A");
+        List<String> submissions = Stream.of(submission1, submission2, submission3, submission4).map(File::toString).toList();
+        JPlagResult result = runJPlag(submissions, it -> it.withBaseCodeSubmissionDirectory(new File(BASE_PATH, BASECODE_BASE)));
+        File testZip = File.createTempFile("result", ".zip");
+        ReportObjectFactory reportObjectFactory = new ReportObjectFactory(testZip);
+        reportObjectFactory.createAndSaveReport(result);
+
+        assertNotNull(result);
+        assertTrue(isArchive(testZip));
+
+        String[] expectedSubmissionNames = new String[] {"B/TerrainType.java", "basecode/A/TerrainType.java"};
+        for (String expected : expectedSubmissionNames) {
+            assertTrue(result.getSubmissions().getSubmissions().stream().anyMatch(submission -> submission.getName().equals(expected)));
+        }
+    }
+
     /**
      * Checks if the given file is a valid archive
      * @param file The file to check