🪲 Detect correctly renamed files

evrignaud · Apr 30, 2016 · 4606de1 · 4606de1
1 parent f7d5ee4
commit 4606de1
Show file tree

Hide file tree

Showing 2 changed files with 51 additions and 8 deletions.
diff --git a/src/main/java/org/fim/internal/StateComparator.java b/src/main/java/org/fim/internal/StateComparator.java
@@ -208,16 +208,18 @@ private void searchForSameFileNames() {
     }
 
     private void searchForDifferences() {
-        Map<Long, FileState> notFoundInCurrentFileStateHashCodeMap = buildHashCodeMap(notFoundInCurrentFileState);
+        ListMultimap<FileHash, FileState> notFoundInCurrentFileStateList = buildFileHashList(notFoundInCurrentFileState);
+        Map<FileHash, FileState> foundInPreviousState = new HashMap<>();
 
-        List<FileState> samePreviousHash;
+        List<FileState> samePreviousHashes;
         for (FileState fileState : addedOrModified) {
             if ((fileState.getFileLength() > 0) &&
                 (context.getHashMode() != dontHash) &&
-                ((samePreviousHash = findFilesWithSameHash(fileState, previousFileStates)).size() > 0)) {
-                FileState originalFileState = samePreviousHash.get(0);
-                long originalFileStateHashCode = originalFileState.longHashCode();
-                if (notFoundInCurrentFileStateHashCodeMap.containsKey(originalFileStateHashCode)) {
+                ((samePreviousHashes = findFilesWithSameHash(fileState, previousFileStates)).size() > 0)) {
+                FileState originalFileState = samePreviousHashes.get(0);
+                FileHash originalFileHash = originalFileState.getFileHash();
+                if (notFoundInCurrentFileStateList.containsKey(originalFileHash) ||
+                    foundInPreviousState.containsKey(originalFileHash)) {
                     result.getRenamed().add(new Difference(originalFileState, fileState));
                     fileState.setModification(Modification.renamed);
                 } else {
@@ -229,14 +231,18 @@ private void searchForDifferences() {
                         fileState.setModification(Modification.duplicated);
                     }
                 }
-                notFoundInCurrentFileStateHashCodeMap.remove(originalFileStateHashCode);
+                List<FileState> removed = notFoundInCurrentFileStateList.removeAll(originalFileHash);
+                if (removed != null && removed.size() > 0) {
+                    // Used to check other duplicated files that have been renamed
+                    foundInPreviousState.put(originalFileHash, originalFileState);
+                }
             } else {
                 result.getAdded().add(new Difference(null, fileState));
                 fileState.setModification(Modification.added);
             }
         }
         addedOrModified.clear();
-        notFoundInCurrentFileState = new ArrayList<>(notFoundInCurrentFileStateHashCodeMap.values());
+        notFoundInCurrentFileState = new ArrayList<>(notFoundInCurrentFileStateList.values());
     }
 
     private Map<String, FileState> buildFileNamesMap(Collection<FileState> fileStates) {
@@ -265,6 +271,14 @@ private Map<Long, FileState> buildHashCodeMap(Collection<FileState> fileStates)
         return hashCodeMap;
     }
 
+    private ListMultimap<FileHash, FileState> buildFileHashList(Collection<FileState> fileStates) {
+        ListMultimap<FileHash, FileState> fileHashMap = ArrayListMultimap.create();
+        for (FileState fileState : fileStates) {
+            fileHashMap.put(fileState.getFileHash(), fileState);
+        }
+        return fileHashMap;
+    }
+
     private void checkAllFilesManagedCorrectly() {
         if (addedOrModified.size() != 0) {
             throw new IllegalStateException(String.format("Comparison algorithm error: addedOrModified size=%d", addedOrModified.size()));

diff --git a/src/test/java/org/fim/internal/StateComparatorTest.java b/src/test/java/org/fim/internal/StateComparatorTest.java
@@ -143,6 +143,35 @@ public void weCanCopyAFileAndChangeContent() {
         }
     }
 
+    @Test
+    public void weCanCorrectlyDetectRenamedFiles() {
+        s1 = s1.copy("file_01", "dup_file_01");
+        s2 = s1.rename("file_01", "new_file_01")
+            .rename("dup_file_01", "new_dup_file_01");
+
+        detectAndAssertRenamedFiles();
+    }
+
+    @Test
+    public void weCanCorrectlyDetectRenamedFilesThatHaveDateChanged() {
+        s1 = s1.copy("file_01", "dup_file_01");
+        s2 = s1.rename("file_01", "new_file_01").touch("new_file_01")
+            .rename("dup_file_01", "new_dup_file_01").touch("new_dup_file_01");
+        detectAndAssertRenamedFiles();
+    }
+
+    private void detectAndAssertRenamedFiles() {
+        CompareResult result = new StateComparator(context, s1, s2).compare();
+        if (hashMode == dontHash) {
+            assertGotOnlyModifications(result, added, deleted);
+            assertFilesModified(result, added, "new_file_01", "new_dup_file_01");
+            assertFilesModified(result, deleted, "file_01", "dup_file_01");
+        } else {
+            assertGotOnlyModifications(result, renamed);
+            assertFilesModified(result, renamed, new FileNameDiff("dup_file_01", "new_file_01"), new FileNameDiff("dup_file_01", "new_dup_file_01"));
+        }
+    }
+
     @Test
     public void emptyFilesAreNeverSeenAsDuplicates() {
         s1 = s1.addEmptyFiles("empty_file_01");