🪲 Fix Super-fast commit

src/main/java/org/fim/command/CommitCommand.java

@@ -31,6 +31,7 @@
 import org.fim.model.FileState;
 import org.fim.model.HashMode;
 import org.fim.model.Modification;
+import org.fim.model.ModificationCounts;
 import org.fim.model.State;
 import org.fim.util.Console;
 import org.fim.util.Logger;
@@ -41,9 +42,11 @@
 import java.util.Map;
 import java.util.stream.Collectors;
 
+import static org.fim.internal.StateComparator.resetFileStates;
 import static org.fim.model.HashMode.dontHash;
 import static org.fim.model.Modification.attributesModified;
 import static org.fim.model.Modification.dateModified;
+import static org.fim.model.Modification.deleted;
 import static org.fim.util.FileStateUtil.buildFileNamesMap;
 
 public class CommitCommand extends AbstractCommand {
@@ -162,7 +165,7 @@ private void retrieveMissingHash(Context context, State currentState, State last
                     throw new IllegalStateException(String.format("Not able to find file '%s' into the previous state", fileState.getFileName()));
                 }
                 fileState.setFileHash(lastFileState.getFileHash());
-            } else {
+            } else if (modification != deleted) {
                 // Hash changed, we need to compute all the mandatory hash
                 toReHash.add(fileState);
             }
@@ -175,9 +178,11 @@ private void retrieveMissingHash(Context context, State currentState, State last
     private State createConsolidatedState(Context context, State lastState, State currentState) {
         State filteredState = lastState.filterDirectory(context.getRepositoryRootDir(), context.getCurrentDirectory(), false);
 
+        resetFileStates(filteredState.getFileStates());
+
         State consolidatedState = currentState.clone();
         consolidatedState.getFileStates().addAll(filteredState.getFileStates());
-        consolidatedState.getModificationCounts().add(filteredState.getModificationCounts());
+        consolidatedState.setModificationCounts(new ModificationCounts(consolidatedState.getFileStates()));
         consolidatedState.getIgnoredFiles().addAll(lastState.getIgnoredFiles());
 
         return consolidatedState;

src/main/java/org/fim/internal/StateComparator.java

@@ -71,6 +71,21 @@ public StateComparator(Context context, State lastState, State currentState) {
         init();
     }
 
+    /**
+     * Remove modification, previousFileState and deleted entries
+     */
+    public static void resetFileStates(List<FileState> fileStates) {
+        for (Iterator<FileState> iter = fileStates.iterator(); iter.hasNext(); ) {
+            FileState fileState = iter.next();
+            if (fileState.getModification() == deleted) {
+                iter.remove();
+            } else {
+                fileState.setModification(null);
+                fileState.setPreviousFileState(null);
+            }
+        }
+    }
+
     private void init() {
         if (lastState != null && !lastState.getModelVersion().equals(currentState.getModelVersion())) {
             Logger.warning("Not able to compare with a State that have a different model version.");
@@ -104,14 +119,7 @@ private void makeLastStateComparable() {
             filterOut(lastState, SELinuxLabel.name());
         }
 
-        // Remove previousFileState and deleted entries
-        for (Iterator<FileState> iter = lastState.getFileStates().iterator(); iter.hasNext(); ) {
-            FileState fileState = iter.next();
-            fileState.setPreviousFileState(null);
-            if (fileState.getModification() == deleted) {
-                iter.remove();
-            }
-        }
+        resetFileStates(lastState.getFileStates());
 
         if (context.isDatesIgnored()) {
             FileTime noTime = new FileTime(0, 0);
@@ -294,6 +302,7 @@ private void searchForDeleted() {
             .filter(fileState -> !isFileIgnored(fileState))
             .forEach(fileState -> {
                 fileState.setModification(deleted);
+                fileState.restoreOriginalHash();
                 result.getDeleted().add(new Difference(null, fileState));
             });
     }

src/main/java/org/fim/model/ModificationCounts.java

@@ -18,6 +18,8 @@
  */
 package org.fim.model;
 
+import java.util.List;
+
 public class ModificationCounts {
     private int added;
     private int copied;
@@ -28,6 +30,53 @@ public class ModificationCounts {
     private int renamed;
     private int deleted;
 
+    public ModificationCounts() {
+        // Use the default values
+    }
+
+    public ModificationCounts(List<FileState> fileStates) {
+        fileStates.stream()
+            .filter(fileState -> fileState.getModification() != null)
+            .forEach(fileState -> {
+                switch (fileState.getModification()) {
+                    case added:
+                        added++;
+                        break;
+
+                    case copied:
+                        copied++;
+                        break;
+
+                    case duplicated:
+                        duplicated++;
+                        break;
+
+                    case dateModified:
+                        dateModified++;
+                        break;
+
+                    case contentModified:
+                        contentModified++;
+                        break;
+
+                    case attributesModified:
+                        attributesModified++;
+                        break;
+
+                    case renamed:
+                        renamed++;
+                        break;
+
+                    case deleted:
+                        deleted++;
+                        break;
+
+                    default:
+                        break;
+                }
+            });
+    }
+
     public int getAdded() {
         return added;
     }
@@ -91,15 +140,4 @@ public int getDeleted() {
     public void setDeleted(int deleted) {
         this.deleted = deleted;
     }
-
-    public void add(ModificationCounts modificationCounts) {
-        added += modificationCounts.getAdded();
-        copied += modificationCounts.getCopied();
-        duplicated += modificationCounts.getDuplicated();
-        dateModified += modificationCounts.getDateModified();
-        contentModified += modificationCounts.getContentModified();
-        attributesModified += modificationCounts.getAttributesModified();
-        renamed += modificationCounts.getRenamed();
-        deleted += modificationCounts.getDeleted();
-    }
 }

src/test/java/org/fim/FullScenarioTest.java

@@ -180,8 +180,7 @@ public void fullScenario() throws Exception {
         assertWeCanRollbackLastCommit(context, 1, 0);
 
         if (hashMode == hashAll || hashMode == hashMediumBlock) {
-            Context superFastModeContext = context.clone();
-            superFastModeContext.setHashMode(hashSmallBlock);
+            Context superFastModeContext = tool.createContext(hashSmallBlock, hashMode == hashAll);
             superFastModeContext.setComment("Using hash mode " + hashSmallBlock);
 
             // Commit using super-fast mode (hashSmallBlock)
@@ -202,6 +201,18 @@ public void fullScenario() throws Exception {
 
             assertThatUsingNormalHashModeNoModificationIsDetected(context);
 
+            // Commit a new file from the dir01 sub directory
+            tool.createFile(dir01.resolve("file15"));
+
+            Context fromSubDirectoryContext = tool.createInvokedFromSubDirContext(hashSmallBlock, "dir01", hashMode == hashAll);
+            superFastModeContext.setComment("From from sub directory dir01");
+
+            compareResult = (CompareResult) commitCommand.execute(fromSubDirectoryContext);
+            assertThat(compareResult.modifiedCount()).isEqualTo(1);
+            modificationCounts = compareResult.getModificationCounts();
+            assertThat(modificationCounts.getAdded()).isEqualTo(1);
+            assertLastStateContainSameModifications(context, modificationCounts);
+
             // Add two files
             tool.setFileContent("file13", "New file 13");
             tool.setFileContent("file14", "New file 14");
@@ -214,6 +225,13 @@ public void fullScenario() throws Exception {
             assertLastStateContainSameModifications(context, modificationCounts);
 
             assertThatUsingNormalHashModeNoModificationIsDetected(context);
+
+            logResult = (LogResult) logCommand.execute(context);
+            assertThat(logResult.getLogEntries().size()).isEqualTo(4);
+            modificationCounts = logResult.getLogEntries().get(2).getModificationCounts();
+            assertThat(modificationCounts.getAdded()).isEqualTo(1);
+            assertThat(modificationCounts.getDeleted()).isEqualTo(0);
+            assertThat(modificationCounts.getCopied()).isEqualTo(0);
         }
     }
 

src/test/java/org/fim/tooling/RepositoryTool.java

@@ -65,6 +65,13 @@ public Context createContext(HashMode hashMode, boolean verbose) {
         return context;
     }
 
+    public Context createInvokedFromSubDirContext(HashMode hashMode, String subDirectory, boolean verbose) {
+        Context context = createContext(hashMode, verbose);
+        context.setCurrentDirectory(context.getCurrentDirectory().resolve(subDirectory));
+        context.setInvokedFromSubDirectory(true);
+        return context;
+    }
+
     public void createASetOfFiles(int count) throws IOException {
         for (int index = 1; index <= count; index++) {
             createOneFile();