TST

Author: qarmin

czkawka_core/src/common/directories.rs

@@ -28,19 +28,34 @@ impl Directories {
     pub(crate) fn set_reference_paths(&mut self, reference_paths: Vec<PathBuf>) -> Messages {
         self.reference_files = Vec::new();
         self.reference_directories = Vec::new();
-        self.process_paths(reference_paths, true, false)
+        let paths = if cfg!(target_family = "windows") {
+            reference_paths.into_iter().map(|p| normalize_windows_path(p)).collect()
+        } else {
+            reference_paths
+        };
+        self.process_paths(paths, true, false)
     }
 
     pub(crate) fn set_included_paths(&mut self, included_paths: Vec<PathBuf>) -> Messages {
         self.included_files = Vec::new();
         self.included_directories = Vec::new();
-        self.process_paths(included_paths, false, false)
+        let paths = if cfg!(target_family = "windows") {
+            included_paths.into_iter().map(|p| normalize_windows_path(p)).collect()
+        } else {
+            included_paths
+        };
+        self.process_paths(paths, false, false)
     }
 
     pub(crate) fn set_excluded_paths(&mut self, excluded_paths: Vec<PathBuf>) -> Messages {
         self.excluded_files = Vec::new();
         self.excluded_directories = Vec::new();
-        self.process_paths(excluded_paths, false, true)
+        let paths = if cfg!(target_family = "windows") {
+            excluded_paths.into_iter().map(|p| normalize_windows_path(p)).collect()
+        } else {
+            excluded_paths
+        };
+        self.process_paths(paths, false, true)
     }
 
     fn process_paths(&mut self, paths: Vec<PathBuf>, is_reference: bool, is_excluded: bool) -> Messages {
@@ -116,14 +131,16 @@ impl Directories {
         self.exclude_other_filesystems = Some(exclude_other_filesystems);
     }
 
-    pub(crate) fn optimize_directories(&mut self, recursive_search: bool) -> Result<Messages, Messages> {
+    pub(crate) fn optimize_directories(&mut self, recursive_search: bool, skip_exist_check: bool) -> Result<Messages, Messages> {
         let mut messages: Messages = Messages::new();
 
+        dbg!("1", &self);
         if self.included_directories.is_empty() && self.included_files.is_empty() {
             messages.critical = Some(flc!("core_missing_no_chosen_included_path"));
             return Err(messages);
         }
 
+        dbg!("2", &self);
         // Remove duplicated entries like: "/", "/"
         for items in &mut [
             &mut self.included_directories,
@@ -133,14 +150,10 @@ impl Directories {
             &mut self.excluded_files,
             &mut self.reference_files,
         ] {
-            if cfg!(target_family = "windows") {
-                items.iter_mut().for_each(|item| {
-                    *item = normalize_windows_path(item.clone());
-                });
-            }
             items.sort_unstable();
             items.dedup();
         }
+        dbg!("3", &self);
 
         // Optimize for duplicated included directories - "/", "/home". "/home/Pulpit" to "/"
         // Do not use when not using recursive search
@@ -150,41 +163,49 @@ impl Directories {
                 kk.retain(|item| !cloned.iter().any(|other_item| item != other_item && item.starts_with(other_item)));
             }
         }
+        dbg!("4", &self);
 
         // Remove included directories which are inside any excluded directory
         // Same with included files
         for kk in [&mut self.included_directories, &mut self.included_files] {
             kk.retain(|id| !self.excluded_directories.iter().any(|ed| id.starts_with(ed)));
         }
+        dbg!("5", &self);
 
         // Also check if files are not excluded directly
         {
             let kk = &mut self.included_files;
             kk.retain(|id| !self.excluded_directories.iter().any(|ed| id == ed));
         }
+        dbg!("6", &self);
 
         // Remove non existed directories and files
-        for kk in [
-            &mut self.excluded_files,
-            &mut self.excluded_directories,
-            &mut self.included_files,
-            &mut self.included_directories,
-        ] {
-            kk.retain(|path| path.exists());
+        if !skip_exist_check {
+            for kk in [
+                &mut self.excluded_files,
+                &mut self.excluded_directories,
+                &mut self.included_files,
+                &mut self.included_directories,
+            ] {
+                kk.retain(|path| path.exists());
+            }
         }
+        dbg!("7", &self);
 
         // Excluded paths must are inside included path, because otherwise they are pointless
         // So first, removing included files, that are inside excluded directories
         // So this will allow to remove excluded directories outside included directories
         self.included_files.retain(|ifile| !self.excluded_directories.iter().any(|ed| ifile.starts_with(ed)));
         self.excluded_directories.retain(|ed| self.included_directories.iter().any(|id| ed.starts_with(id)));
 
+        dbg!("8", &self);
         // Selecting Reference folders
         {
             self.reference_directories.retain(|folder| self.included_directories.iter().any(|e| folder.starts_with(e)));
             self.reference_files
                 .retain(|file| self.included_directories.iter().any(|e| file.starts_with(e)) || self.included_files.iter().any(|f| file == f));
         }
+        dbg!("9", &self);
 
         // Not needed, but better is to have sorted everything
         for items in &mut [
@@ -197,6 +218,7 @@ impl Directories {
         ] {
             items.sort_unstable();
         }
+        dbg!("10", &self);
 
         // Get device IDs for included directories, probably ther better solution would be to get one id per directory, but this is faster, but a little less precise
         #[cfg(target_family = "unix")]
@@ -208,15 +230,19 @@ impl Directories {
                 }
             }
         }
+        dbg!("11", &self);
 
         if self.included_directories.is_empty() && self.included_files.is_empty() {
-            messages.errors.push(flc!("core_missing_no_chosen_included_path"));
+            messages.critical = Some(flc!("core_missing_no_chosen_included_path"));
             return Err(messages);
         }
+        dbg!("12", &self);
 
         if self.reference_directories == self.included_directories && self.included_files == self.reference_files {
-            messages.warnings.push(flc!("core_reference_included_paths_same"));
+            messages.critical = Some(flc!("core_reference_included_paths_same"));
+            return Err(messages);
         }
+        dbg!("13", &self);
 
         Ok(messages)
     }
@@ -271,3 +297,39 @@ impl Directories {
             .collect::<Vec<(T, Vec<T>)>>()
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::path::PathBuf;
+
+    #[test]
+    fn test_no_included_paths_errors() {
+        let mut d = Directories::new();
+        let msgs = d.optimize_directories(true, true).unwrap_err();
+        assert!(msgs.critical.is_some());
+    }
+
+    #[test]
+    fn test_dedup_included_directories() {
+        let p = PathBuf::from("/this/path/does/not/exist/dedup");
+        let mut d = Directories::new();
+        d.included_directories.push(p.clone());
+        d.included_directories.push(p.clone());
+        let msgs = d.optimize_directories(true, true).unwrap();
+        assert_eq!(d.included_directories, vec![
+            p.clone(),
+        ]);
+    }
+
+    #[test]
+    fn test_excluded_removes_included_inside() {
+        let base = PathBuf::from("/this/base/does/not/exist");
+        let sub = base.join("sub");
+        let mut d = Directories::new();
+        d.included_directories.push(sub.clone());
+        d.excluded_directories.push(base.clone());
+        let _msgs = d.optimize_directories(true, true).unwrap_err();
+        assert_eq!(d.included_directories, Vec::<PathBuf>::new());
+    }
+}

czkawka_core/src/common/tool_data.rs

@@ -283,7 +283,7 @@ pub trait CommonData {
     fn prepare_items(&mut self, tool_extensions: Option<&[&str]>) -> Result<(), ()> {
         let recursive_search = self.get_cd().recursive_search;
         // Optimizes directories and removes recursive calls
-        match self.get_cd_mut().directories.optimize_directories(recursive_search) {
+        match self.get_cd_mut().directories.optimize_directories(recursive_search, false) {
             Ok(messages) => {
                 self.get_cd_mut().text_messages.extend_with_another_messages(messages);
             }