purge cache on delete (#119)

Author: houqp

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "kiorg"
-version = "1.5.0"
+version = "1.5.1"
 edition = "2024"
 rust-version = "1.87"
 authors = ["houqp"]

crates/kiorg/Cargo.toml

@@ -440,6 +440,8 @@ fn delete_async(app: &mut crate::app::Kiorg, entries_to_delete: Vec<PathBuf>) {
         let mut current_file = 0;
 
         for path in entries_to_delete {
+            crate::utils::preview_cache::delete_previews_for_path(&path);
+
             let result = if path.is_dir() {
                 delete_dir_with_progress(&path, &tx, &mut current_file, total_files)
             } else {

crates/kiorg/src/ui/popup/delete.rs

@@ -37,6 +37,9 @@ pub fn handle_rename_confirmation(app: &mut Kiorg, ctx: &Context) {
             {
                 app.notify_error(format!("Failed to rename: {e}"));
             } else {
+                // Delete preview cache for the old path (all associated versions)
+                crate::utils::preview_cache::delete_previews_for_path(&entry.meta.path);
+
                 // Record rename action in history
                 let old_path = entry.meta.path.clone();
                 tab.action_history.add_action(ActionType::Rename {

crates/kiorg/src/ui/popup/rename.rs

@@ -57,10 +57,14 @@ mod imp {
 
 pub use imp::{get_cache_dir, purge_cache_dir};
 
-pub fn calculate_cache_key(entry: &DirEntryMeta) -> String {
-    let path_str = entry.path.to_string_lossy();
+pub fn calculate_path_hash(path: &std::path::Path) -> u64 {
+    let path_str = path.to_string_lossy();
     let hasher = RandomState::with_seeds(0, 0, 0, 0);
-    let path_hash = hasher.hash_one(path_str.as_bytes());
+    hasher.hash_one(path_str.as_bytes())
+}
+
+pub fn calculate_cache_key(entry: &DirEntryMeta) -> String {
+    let path_hash = calculate_path_hash(&entry.path);
 
     let mtime = entry
         .modified
@@ -71,6 +75,29 @@ pub fn calculate_cache_key(entry: &DirEntryMeta) -> String {
     format!("{path_hash:x}.{mtime}")
 }
 
+pub fn delete_previews_for_path(path: &std::path::Path) {
+    let path_hash = calculate_path_hash(path);
+    let hash_hex = format!("{path_hash:x}");
+    let prefix = format!("{hash_hex}.");
+
+    if let Some(mut d) = get_cache_dir() {
+        if hash_hex.len() >= 2 {
+            d.push(&hash_hex[0..2]);
+        }
+        if d.exists() && d.is_dir() {
+            if let Ok(entries) = fs::read_dir(d) {
+                for entry in entries.flatten() {
+                    if let Some(file_name) = entry.file_name().to_str() {
+                        if file_name.starts_with(&prefix) {
+                            let _ = fs::remove_file(entry.path());
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
+
 pub fn get_cache_path(key: &str) -> Option<PathBuf> {
     get_cache_dir().map(|mut d| {
         if key.len() >= 2 {
@@ -170,4 +197,52 @@ mod tests {
             let _ = fs::remove_file(path);
         }
     }
+
+    #[test]
+    fn test_delete_previews_for_path() {
+        let path = PathBuf::from("/tmp/test_delete.txt");
+        let cached = CachedPreviewContent::Zip(vec![]);
+
+        // Create multiple cache entries for the same path with different mtimes
+        let mut keys = Vec::new();
+        for i in 0..3 {
+            let entry = DirEntryMeta {
+                path: path.clone(),
+                modified: std::time::SystemTime::UNIX_EPOCH + std::time::Duration::from_secs(i),
+            };
+            let key = calculate_cache_key(&entry);
+            save_preview(&key, &cached).expect("Failed to save");
+            assert!(get_cache_path(&key).unwrap().exists());
+            keys.push(key);
+        }
+
+        // Verify another path's cache is NOT deleted
+        let other_path = PathBuf::from("/tmp/other_file.txt");
+        let other_entry = DirEntryMeta {
+            path: other_path.clone(),
+            modified: std::time::SystemTime::now(),
+        };
+        let other_key = calculate_cache_key(&other_entry);
+        save_preview(&other_key, &cached).expect("Failed to save");
+        assert!(get_cache_path(&other_key).unwrap().exists());
+
+        delete_previews_for_path(&path);
+
+        // All keys for the target path should be gone
+        for key in keys {
+            assert!(
+                !get_cache_path(&key).unwrap().exists(),
+                "Cache key {key} should have been deleted"
+            );
+        }
+
+        // The other path's cache should still exist
+        assert!(
+            get_cache_path(&other_key).unwrap().exists(),
+            "Other path's cache should not have been deleted"
+        );
+
+        // Clean up other path's cache
+        let _ = fs::remove_file(get_cache_path(&other_key).unwrap());
+    }
 }