Meta

qarmin · qarmin · commit 47ee0d4b6f27 · 2025-03-08T20:48:22.000+01:00
diff --git a/Cargo.toml b/Cargo.toml
@@ -20,7 +20,7 @@ resolver = "2"
 panic = "unwind"
 
 # Should find more panics, that now are hidden from user - in long term it should decrease bugs in app
-# There is one big disadvantage - in case of overflow/underflow entire app crashes and panic cannot be catched and app aborts
+# There is one big disadvantage - in case of overflow/underflow entire app crashes and not everywhere I catch this panic so app aborts
 # So feel free to disable it, if you want
 overflow-checks = true
 
diff --git a/czkawka_core/src/common_cache.rs b/czkawka_core/src/common_cache.rs
@@ -1,7 +1,10 @@
 use std::collections::BTreeMap;
+use std::fs;
 use std::io::{BufReader, BufWriter};
+use std::path::Path;
 
 use fun_time::fun_time;
+use humansize::{BINARY, format_size};
 use image::imageops::FilterType;
 use image_hasher::HashAlg;
 use log::{debug, error};
@@ -50,6 +53,10 @@ pub fn get_duplicate_cache_file(type_of_hash: &HashType, is_prehash: bool) -> St
     format!("cache_duplicates_{type_of_hash:?}{prehash_str}_{CACHE_DUPLICATE_VERSION}.bin")
 }
 
+fn get_cache_size(file_name: &Path) -> String {
+    fs::metadata(file_name).map_or_else(|_| "<unknown size>".to_string(), |metadata| format_size(metadata.len(), BINARY))
+}
+
 #[fun_time(message = "save_cache_to_file_generalized", level = "debug")]
 pub fn save_cache_to_file_generalized<T>(cache_file_name: &str, hashmap: &BTreeMap<String, T>, save_also_as_json: bool, minimum_file_size: u64) -> Messages
 where
@@ -68,7 +75,7 @@ where
                 debug!("Failed to save cache to file {cache_file:?}");
                 return text_messages;
             }
-            debug!("Saved binary to file {cache_file:?}");
+            debug!("Saved cache to binary file {cache_file:?} with size {}", get_cache_size(&cache_file));
         }
         if save_also_as_json {
             if let Some(file_handler_json) = file_handler_json {
@@ -78,7 +85,7 @@ where
                     debug!("Failed to save cache to file {cache_file_json:?}");
                     return text_messages;
                 }
-                debug!("Saved json to file {cache_file_json:?}");
+                debug!("Saved cache to json file {cache_file_json:?} with size {}", get_cache_size(&cache_file_json));
             }
         }
 
@@ -197,8 +204,10 @@ where
     let mut text_messages = Messages::new();
 
     if let Some(((file_handler, cache_file), (file_handler_json, cache_file_json))) = common::open_cache_folder(cache_file_name, false, true, &mut text_messages.warnings) {
+        let cache_full_name;
         let mut vec_loaded_entries: Vec<T>;
         if let Some(file_handler) = file_handler {
+            cache_full_name = cache_file.clone();
             let reader = BufReader::new(file_handler);
 
             // TODO cannot use limits
@@ -217,6 +226,7 @@ where
                 }
             };
         } else {
+            cache_full_name = cache_file_json.clone();
             let reader = BufReader::new(file_handler_json.expect("This cannot fail, because if file_handler is None, then this cannot be None"));
             vec_loaded_entries = match serde_json::from_reader(reader) {
                 Ok(t) => t,
@@ -265,7 +275,11 @@ where
 
         text_messages.messages.push(format!("Properly loaded {} cache entries.", vec_loaded_entries.len()));
 
-        debug!("Loaded cache from file {cache_file_name} (or json alternative) - {} results", vec_loaded_entries.len());
+        debug!(
+            "Loaded cache from file {cache_file_name} (or json alternative) - {} results - size {}",
+            vec_loaded_entries.len(),
+            get_cache_size(&cache_full_name)
+        );
         return (text_messages, Some(vec_loaded_entries));
     }
     debug!("Failed to load cache from file {cache_file_name} because not exists");
diff --git a/czkawka_core/src/tools/broken_files.rs b/czkawka_core/src/tools/broken_files.rs
@@ -8,7 +8,7 @@ use std::{fs, mem, panic};
 
 use crossbeam_channel::Sender;
 use fun_time::fun_time;
-use log::debug;
+use log::{debug, error};
 use pdf::PdfError;
 use pdf::PdfError::Try;
 use pdf::file::FileOptions;
@@ -458,15 +458,15 @@ fn check_extension_availability(
     audio_extensions: &HashSet<&&'static str>,
     pdf_extensions: &HashSet<&&'static str>,
 ) -> TypeOfFile {
-    let Some(extension) = full_name.extension() else {
-        debug_assert!(false, "Missing extension");
+    let Some(file_name) = full_name.file_name() else {
+        error!("Missing file name in file - \"{}\"", full_name.to_string_lossy());
+        debug_assert!(false, "Missing file name in file - \"{}\"", full_name.to_string_lossy());
         return TypeOfFile::Unknown;
     };
+    let Some(file_name_str) = file_name.to_str() else { return TypeOfFile::Unknown };
+    let Some(extension_idx) = file_name_str.rfind('.') else { return TypeOfFile::Unknown };
+    let extension_str = &file_name_str[extension_idx + 1..];
 
-    let Some(extension_str) = extension.to_str() else {
-        debug_assert!(false, "Extension not really fully str");
-        return TypeOfFile::Unknown;
-    };
     let extension_lowercase = extension_str.to_ascii_lowercase();
 
     if images_extensions.contains(&extension_lowercase.as_str()) {
@@ -478,8 +478,8 @@ fn check_extension_availability(
     } else if pdf_extensions.contains(&extension_lowercase.as_str()) {
         TypeOfFile::PDF
     } else {
-        eprintln!("File with unknown extension: \"{}\" - {extension_lowercase}", full_name.to_string_lossy());
-        debug_assert!(false, "File with unknown extension");
+        error!("File with unknown extension: \"{}\" - {extension_lowercase}", full_name.to_string_lossy());
+        debug_assert!(false, "File with unknown extension - \"{}\" - {extension_lowercase}", full_name.to_string_lossy());
         TypeOfFile::Unknown
     }
 }
@@ -520,3 +520,95 @@ impl CommonData for BrokenFiles {
         &mut self.common_data
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use std::collections::HashSet;
+    use std::path::Path;
+
+    use super::*;
+
+    #[test]
+    fn test_check_extension_availability_image() {
+        let images_extensions: HashSet<&&str> = ["jpg", "png", "gif"].iter().collect();
+        let zip_extensions: HashSet<&&str> = HashSet::new();
+        let audio_extensions: HashSet<&&str> = HashSet::new();
+        let pdf_extensions: HashSet<&&str> = HashSet::new();
+
+        let path = Path::new("test.jpg");
+        assert_eq!(
+            check_extension_availability(path, &images_extensions, &zip_extensions, &audio_extensions, &pdf_extensions),
+            TypeOfFile::Image
+        );
+    }
+
+    #[test]
+    fn test_check_extension_availability_zip() {
+        let images_extensions: HashSet<&&str> = HashSet::new();
+        let zip_extensions: HashSet<&&str> = ["zip", "rar"].iter().collect();
+        let audio_extensions: HashSet<&&str> = HashSet::new();
+        let pdf_extensions: HashSet<&&str> = HashSet::new();
+
+        let path = Path::new("test.zip");
+        assert_eq!(
+            check_extension_availability(path, &images_extensions, &zip_extensions, &audio_extensions, &pdf_extensions),
+            TypeOfFile::ArchiveZip
+        );
+    }
+
+    #[test]
+    fn test_check_extension_availability_audio() {
+        let images_extensions: HashSet<&&str> = HashSet::new();
+        let zip_extensions: HashSet<&&str> = HashSet::new();
+        let audio_extensions: HashSet<&&str> = ["mp3", "wav"].iter().collect();
+        let pdf_extensions: HashSet<&&str> = HashSet::new();
+
+        let path = Path::new("test.mp3");
+        assert_eq!(
+            check_extension_availability(path, &images_extensions, &zip_extensions, &audio_extensions, &pdf_extensions),
+            TypeOfFile::Audio
+        );
+    }
+
+    #[test]
+    fn test_check_extension_availability_pdf() {
+        let images_extensions: HashSet<&&str> = HashSet::new();
+        let zip_extensions: HashSet<&&str> = HashSet::new();
+        let audio_extensions: HashSet<&&str> = HashSet::new();
+        let pdf_extensions: HashSet<&&str> = std::iter::once(&"pdf").collect();
+
+        let path = Path::new("test.pdf");
+        assert_eq!(
+            check_extension_availability(path, &images_extensions, &zip_extensions, &audio_extensions, &pdf_extensions),
+            TypeOfFile::PDF
+        );
+    }
+
+    #[test]
+    fn test_check_extension_availability_no_extension() {
+        let images_extensions: HashSet<&&str> = HashSet::new();
+        let zip_extensions: HashSet<&&str> = HashSet::new();
+        let audio_extensions: HashSet<&&str> = HashSet::new();
+        let pdf_extensions: HashSet<&&str> = HashSet::new();
+
+        let path = Path::new("test");
+        assert_eq!(
+            check_extension_availability(path, &images_extensions, &zip_extensions, &audio_extensions, &pdf_extensions),
+            TypeOfFile::Unknown
+        );
+    }
+
+    #[test]
+    fn test_check_no_extension() {
+        let images_extensions: HashSet<&&str> = HashSet::new();
+        let zip_extensions: HashSet<&&str> = HashSet::new();
+        let audio_extensions: HashSet<&&str> = ["mp3", "wav"].iter().collect();
+        let pdf_extensions: HashSet<&&str> = HashSet::new();
+
+        let path = Path::new("/home/.mp3");
+        assert_eq!(
+            check_extension_availability(path, &images_extensions, &zip_extensions, &audio_extensions, &pdf_extensions),
+            TypeOfFile::Audio
+        );
+    }
+}
diff --git a/krokiet/src/connect_open.rs b/krokiet/src/connect_open.rs
@@ -1,8 +1,9 @@
-use crate::{Callabler, MainWindow};
 use czkawka_core::common::get_config_cache_path;
 use log::error;
 use slint::ComponentHandle;
 
+use crate::{Callabler, MainWindow};
+
 pub fn connect_open_items(app: &MainWindow) {
     app.global::<Callabler>().on_item_opened(move |path| {
         match open::that(&*path) {
diff --git a/krokiet/src/connect_rename.rs b/krokiet/src/connect_rename.rs
@@ -42,10 +42,10 @@ fn rename_selected_items(files_with_new_extensions: Vec<(String, String, String)
     let mut errors = vec![];
     for (folder, file_name, new_extension) in files_with_new_extensions {
         let file_stem = Path::new(&file_name).file_stem().map(|e| e.to_string_lossy().to_string()).unwrap_or_default();
-        let new_full_path = format!("{}{}{}.{}", folder, MAIN_SEPARATOR, file_stem, new_extension);
-        let old_full_path = format!("{}{}{}", folder, MAIN_SEPARATOR, file_name);
+        let new_full_path = format!("{folder}{MAIN_SEPARATOR}{file_stem}.{new_extension}");
+        let old_full_path = format!("{folder}{MAIN_SEPARATOR}{file_name}");
         if let Err(e) = fs::rename(&old_full_path, &new_full_path) {
-            errors.push(format!("Failed to rename file {} to {} with error {}", old_full_path, new_full_path, e));
+            errors.push(format!("Failed to rename file {old_full_path} to {new_full_path} with error {e}"));
         }
     }
     errors
diff --git a/krokiet/src/connect_select.rs b/krokiet/src/connect_select.rs
@@ -15,15 +15,15 @@ pub fn connect_select(app: &MainWindow) {
         let current_model = get_tool_model(&app, active_tab);
 
         let new_model = match select_mode {
-            SelectMode::SelectAll => select_all(current_model),
-            SelectMode::UnselectAll => deselect_all(current_model),
-            SelectMode::InvertSelection => invert_selection(current_model),
-            SelectMode::SelectTheBiggestSize => select_by_size_date(current_model, active_tab, true, true),
-            SelectMode::SelectTheSmallestSize => select_by_size_date(current_model, active_tab, false, true),
-            SelectMode::SelectTheBiggestResolution => select_by_resolution(current_model, active_tab, true),
-            SelectMode::SelectTheSmallestResolution => select_by_resolution(current_model, active_tab, false),
-            SelectMode::SelectNewest => select_by_size_date(current_model, active_tab, true, false),
-            SelectMode::SelectOldest => select_by_size_date(current_model, active_tab, false, false),
+            SelectMode::SelectAll => select_all(&current_model),
+            SelectMode::UnselectAll => deselect_all(&current_model),
+            SelectMode::InvertSelection => invert_selection(&current_model),
+            SelectMode::SelectTheBiggestSize => select_by_size_date(&current_model, active_tab, true, true),
+            SelectMode::SelectTheSmallestSize => select_by_size_date(&current_model, active_tab, false, true),
+            SelectMode::SelectTheBiggestResolution => select_by_resolution(&current_model, active_tab, true),
+            SelectMode::SelectTheSmallestResolution => select_by_resolution(&current_model, active_tab, false),
+            SelectMode::SelectNewest => select_by_size_date(&current_model, active_tab, true, false),
+            SelectMode::SelectOldest => select_by_size_date(&current_model, active_tab, false, false),
         };
         set_tool_model(&app, active_tab, new_model);
     });
@@ -96,7 +96,7 @@ fn translate_select_mode(select_mode: SelectMode) -> String {
 }
 
 // TODO, when model will be able to contain i64 instead two i32, this function could be merged with select_by_size_date
-fn select_by_resolution(model: ModelRc<MainListModel>, active_tab: CurrentTab, biggest: bool) -> ModelRc<MainListModel> {
+fn select_by_resolution(model: &ModelRc<MainListModel>, active_tab: CurrentTab, biggest: bool) -> ModelRc<MainListModel> {
     let is_header_mode = get_is_header_mode(active_tab);
     assert!(is_header_mode); // non header modes not really have reason to use this function
 
@@ -140,7 +140,7 @@ fn select_by_resolution(model: ModelRc<MainListModel>, active_tab: CurrentTab, b
     ModelRc::new(VecModel::from(old_data))
 }
 
-fn select_by_size_date(model: ModelRc<MainListModel>, active_tab: CurrentTab, biggest_newest: bool, size: bool) -> ModelRc<MainListModel> {
+fn select_by_size_date(model: &ModelRc<MainListModel>, active_tab: CurrentTab, biggest_newest: bool, size: bool) -> ModelRc<MainListModel> {
     let is_header_mode = get_is_header_mode(active_tab);
     assert!(is_header_mode); // non header modes not really have reason to use this function
 
@@ -187,7 +187,7 @@ fn select_by_size_date(model: ModelRc<MainListModel>, active_tab: CurrentTab, bi
     ModelRc::new(VecModel::from(old_data))
 }
 
-fn select_all(model: ModelRc<MainListModel>) -> ModelRc<MainListModel> {
+fn select_all(model: &ModelRc<MainListModel>) -> ModelRc<MainListModel> {
     let mut old_data = model.iter().collect::<Vec<_>>();
     for x in &mut old_data {
         if !x.header_row {
@@ -197,13 +197,13 @@ fn select_all(model: ModelRc<MainListModel>) -> ModelRc<MainListModel> {
     ModelRc::new(VecModel::from(old_data))
 }
 
-fn deselect_all(model: ModelRc<MainListModel>) -> ModelRc<MainListModel> {
+fn deselect_all(model: &ModelRc<MainListModel>) -> ModelRc<MainListModel> {
     let mut old_data = model.iter().collect::<Vec<_>>();
     old_data.iter_mut().for_each(|x| x.checked = false);
     ModelRc::new(VecModel::from(old_data))
 }
 
-fn invert_selection(model: ModelRc<MainListModel>) -> ModelRc<MainListModel> {
+fn invert_selection(model: &ModelRc<MainListModel>) -> ModelRc<MainListModel> {
     let mut old_data = model.iter().collect::<Vec<_>>();
     for x in &mut old_data {
         if !x.header_row {
diff --git a/krokiet/src/main.rs b/krokiet/src/main.rs
@@ -1,10 +1,9 @@
 // Remove console window in Windows OS
 #![windows_subsystem = "windows"]
 #![allow(unknown_lints)] // May be disabled, but locally I use nightly clippy
-#![allow(clippy::comparison_chain)]
 #![allow(clippy::collapsible_if)]
 #![allow(clippy::collapsible_else_if)]
-#![allow(clippy::should_panic_without_expect)]
+// #![warn(clippy::unwrap_used)] // Cannot use due unwrap used in a lot of places
 
 use std::rc::Rc;
 use std::sync::Arc;
diff --git a/krokiet/src/settings.rs b/krokiet/src/settings.rs
@@ -302,6 +302,7 @@ pub fn load_settings_from_file(app: &MainWindow) {
 
     // Validate here values and set "proper"
     // preset_names should have 10 items
+    #[allow(clippy::comparison_chain)]
     if base_settings.preset_names.len() > 10 {
         base_settings.preset_names.truncate(10);
     } else if base_settings.preset_names.len() < 10 {

Original file line number	Diff line number	Diff line change
`@@ -42,10 +42,10 @@ fn rename_selected_items(files_with_new_extensions: Vec<(String, String, String)`
`42`	`42`	`let mut errors = vec![];`
`43`	`43`	`for (folder, file_name, new_extension) in files_with_new_extensions {`
`44`	`44`	`let file_stem = Path::new(&file_name).file_stem().map(\|e\| e.to_string_lossy().to_string()).unwrap_or_default();`
`45`		`- let new_full_path = format!("{}{}{}.{}", folder, MAIN_SEPARATOR, file_stem, new_extension);`
`46`		`- let old_full_path = format!("{}{}{}", folder, MAIN_SEPARATOR, file_name);`
	`45`	`+ let new_full_path = format!("{folder}{MAIN_SEPARATOR}{file_stem}.{new_extension}");`
	`46`	`+ let old_full_path = format!("{folder}{MAIN_SEPARATOR}{file_name}");`
`47`	`47`	`if let Err(e) = fs::rename(&old_full_path, &new_full_path) {`
`48`		`- errors.push(format!("Failed to rename file {} to {} with error {}", old_full_path, new_full_path, e));`
	`48`	`+ errors.push(format!("Failed to rename file {old_full_path} to {new_full_path} with error {e}"));`
`49`	`49`	`}`
`50`	`50`	`}`
`51`	`51`	`errors`