Some renames, basic Cambalache view

czkawka_core/src/bad_extensions.rs

@@ -409,36 +409,35 @@ impl BadExtensions {
 
                 // Check for all extensions that file can use(not sure if it is worth to do it)
                 let mut all_available_extensions: BTreeSet<&str> = Default::default();
-                let think_extension = match current_extension.is_empty() {
-                    true => String::new(),
-                    false => {
-                        for mim in mime_guess::from_ext(proper_extension) {
-                            if let Some(all_ext) = get_mime_extensions(&mim) {
-                                for ext in all_ext {
-                                    all_available_extensions.insert(ext);
-                                }
+                let think_extension = if current_extension.is_empty() {
+                    String::new()
+                } else {
+                    for mim in mime_guess::from_ext(proper_extension) {
+                        if let Some(all_ext) = get_mime_extensions(&mim) {
+                            for ext in all_ext {
+                                all_available_extensions.insert(ext);
                             }
                         }
-
-                        // Workarounds
-                        if let Some(vec_pre) = hashmap_workarounds.get(current_extension.as_str()) {
-                            for pre in vec_pre {
-                                if all_available_extensions.contains(pre) {
-                                    all_available_extensions.insert(current_extension.as_str());
-                                    break;
-                                }
-                            }
-                        }
-
-                        let mut guessed_multiple_extensions = format!("({proper_extension}) - ");
-                        for ext in &all_available_extensions {
-                            guessed_multiple_extensions.push_str(ext);
-                            guessed_multiple_extensions.push(',');
-                        }
-                        guessed_multiple_extensions.pop();
-
-                        guessed_multiple_extensions
                     }
+
+                    // Workarounds
+                    if let Some(vec_pre) = hashmap_workarounds.get(current_extension.as_str()) {
+                        for pre in vec_pre {
+                            if all_available_extensions.contains(pre) {
+                                all_available_extensions.insert(current_extension.as_str());
+                                break;
+                            }
+                        }
+                    }
+
+                    let mut guessed_multiple_extensions = format!("({proper_extension}) - ");
+                    for ext in &all_available_extensions {
+                        guessed_multiple_extensions.push_str(ext);
+                        guessed_multiple_extensions.push(',');
+                    }
+                    guessed_multiple_extensions.pop();
+
+                    guessed_multiple_extensions
                 };
 
                 if all_available_extensions.is_empty() {

czkawka_core/src/common_dir_traversal.rs

@@ -155,67 +155,80 @@ impl<'a, 'b> DirTraversalBuilder<'a, 'b, ()> {
 }
 
 impl<'a, 'b, F> DirTraversalBuilder<'a, 'b, F> {
+    #[must_use]
     pub fn root_dirs(mut self, dirs: Vec<PathBuf>) -> Self {
         self.root_dirs = dirs;
         self
     }
 
+    #[must_use]
     pub fn stop_receiver(mut self, stop_receiver: Option<&'a Receiver<()>>) -> Self {
         self.stop_receiver = stop_receiver;
         self
     }
 
+    #[must_use]
     pub fn progress_sender(mut self, progress_sender: Option<&'b futures::channel::mpsc::UnboundedSender<ProgressData>>) -> Self {
         self.progress_sender = progress_sender;
         self
     }
 
+    #[must_use]
     pub fn checking_method(mut self, checking_method: CheckingMethod) -> Self {
         self.checking_method = checking_method;
         self
     }
 
+    #[must_use]
     pub fn max_stage(mut self, max_stage: u8) -> Self {
         self.max_stage = max_stage;
         self
     }
 
+    #[must_use]
     pub fn minimal_file_size(mut self, minimal_file_size: u64) -> Self {
         self.minimal_file_size = Some(minimal_file_size);
         self
     }
 
+    #[must_use]
     pub fn maximal_file_size(mut self, maximal_file_size: u64) -> Self {
         self.maximal_file_size = Some(maximal_file_size);
         self
     }
 
+    #[must_use]
     pub fn collect(mut self, collect: Collect) -> Self {
         self.collect = collect;
         self
     }
 
+    #[must_use]
     pub fn directories(mut self, directories: Directories) -> Self {
         self.directories = Some(directories);
         self
     }
 
+    #[must_use]
     pub fn allowed_extensions(mut self, allowed_extensions: Extensions) -> Self {
         self.allowed_extensions = Some(allowed_extensions);
         self
     }
 
+    #[must_use]
     pub fn excluded_items(mut self, excluded_items: ExcludedItems) -> Self {
         self.excluded_items = Some(excluded_items);
         self
     }
 
+    #[must_use]
     pub fn recursive_search(mut self, recursive_search: bool) -> Self {
         self.recursive_search = recursive_search;
         self
     }
 
     #[cfg(target_family = "unix")]
+    #[must_use]
     pub fn exclude_other_filesystems(mut self, exclude_other_filesystems: bool) -> Self {
         match self.directories {
             Some(ref mut directories) => directories.set_exclude_other_filesystems(exclude_other_filesystems),

czkawka_core/src/common_directory.rs

@@ -25,7 +25,7 @@ impl Directories {
     }
 
     pub fn set_reference_directory(&mut self, reference_directory: Vec<PathBuf>) {
-        self.reference_directories = reference_directory
+        self.reference_directories = reference_directory;
     }
 
     /// Setting included directories, at least one must be provided or scan won't start
@@ -154,7 +154,7 @@ impl Directories {
 
     #[cfg(target_family = "unix")]
     pub fn set_exclude_other_filesystems(&mut self, exclude_other_filesystems: bool) {
-        self.exclude_other_filesystems = Some(exclude_other_filesystems)
+        self.exclude_other_filesystems = Some(exclude_other_filesystems);
     }
 
     /// Remove unused entries when included or excluded overlaps with each other or are duplicated etc.

czkawka_core/src/duplicate.rs

@@ -40,7 +40,6 @@ pub enum HashType {
 }
 
 impl HashType {
-    #[inline(always)]
     fn hasher(self: &HashType) -> Box<dyn MyHasher> {
         match self {
             HashType::Blake3 => Box::new(blake3::Hasher::new()),
@@ -867,7 +866,7 @@ impl DuplicateFinder {
                         if files_from_referenced_folders.is_empty() || normal_files.is_empty() {
                             continue;
                         } else {
-                            all_results_with_same_size.push((files_from_referenced_folders.pop().unwrap(), normal_files))
+                            all_results_with_same_size.push((files_from_referenced_folders.pop().unwrap(), normal_files));
                         }
                     }
                     if all_results_with_same_size.is_empty() {

czkawka_core/src/similar_images.rs

@@ -1116,7 +1116,7 @@ fn image_to_check<'a>(
         }
         // But when there is no record, just add it
         else {
-            need_to_add = true
+            need_to_add = true;
         }
     }
 

czkawka_core/src/similar_videos.rs

@@ -51,12 +51,12 @@ pub struct FileEntry {
 struct Hamming;
 
 impl bk_tree::Metric<Vec<u8>> for Hamming {
-    #[inline(always)]
+    #[inline]
     fn distance(&self, a: &Vec<u8>, b: &Vec<u8>) -> u32 {
         hamming::distance_fast(a, b).unwrap() as u32
     }
 
-    #[inline(always)]
+    #[inline]
     fn threshold_distance(&self, a: &Vec<u8>, b: &Vec<u8>, _threshold: u32) -> Option<u32> {
         Some(self.distance(a, b))
     }
@@ -137,7 +137,7 @@ impl SimilarVideos {
 
     pub fn set_tolerance(&mut self, tolerance: i32) {
         assert!((0..=MAX_TOLERANCE).contains(&tolerance));
-        self.tolerance = tolerance
+        self.tolerance = tolerance;
     }
     pub fn set_save_also_as_json(&mut self, save_also_as_json: bool) {
         self.save_also_as_json = save_also_as_json;