fix: perf issues with v1.1.0

Bring performance back

src/config.rs

@@ -145,21 +145,21 @@ impl Config {
         Some(true) == self.output_json || options.get_flag("output_json")
     }
 
-    pub fn get_modified_time_operator(&self, options: &ArgMatches) -> (Operater, i64) {
+    pub fn get_modified_time_operator(&self, options: &ArgMatches) -> Option<(Operater, i64)> {
         get_filter_time_operator(
             options.get_one::<String>("mtime"),
             get_current_date_epoch_seconds(),
         )
     }
 
-    pub fn get_accessed_time_operator(&self, options: &ArgMatches) -> (Operater, i64) {
+    pub fn get_accessed_time_operator(&self, options: &ArgMatches) -> Option<(Operater, i64)> {
         get_filter_time_operator(
             options.get_one::<String>("atime"),
             get_current_date_epoch_seconds(),
         )
     }
 
-    pub fn get_created_time_operator(&self, options: &ArgMatches) -> (Operater, i64) {
+    pub fn get_created_time_operator(&self, options: &ArgMatches) -> Option<(Operater, i64)> {
         get_filter_time_operator(
             options.get_one::<String>("ctime"),
             get_current_date_epoch_seconds(),
@@ -182,7 +182,7 @@ fn get_current_date_epoch_seconds() -> i64 {
 fn get_filter_time_operator(
     option_value: Option<&String>,
     current_date_epoch_seconds: i64,
-) -> (Operater, i64) {
+) -> Option<(Operater, i64)> {
     match option_value {
         Some(val) => {
             let time = current_date_epoch_seconds
@@ -192,12 +192,12 @@ fn get_filter_time_operator(
                     .abs()
                     * DAY_SECONDS;
             match val.chars().next().expect("Value should not be empty") {
-                '+' => (Operater::LessThan, time - DAY_SECONDS),
+                '+' => Some((Operater::LessThan, time - DAY_SECONDS)),
-                '-' => (Operater::GreaterThan, time),
+                '-' => Some((Operater::GreaterThan, time)),
-                _ => (Operater::Equal, time - DAY_SECONDS),
+                _ => Some((Operater::Equal, time - DAY_SECONDS)),
             }
         }
-        None => (Operater::GreaterThan, 0),
+        None => None,
     }
 }
 

src/dir_walker.rs

@@ -35,9 +35,9 @@ pub struct WalkData<'a> {
     pub filter_regex: &'a [Regex],
     pub invert_filter_regex: &'a [Regex],
     pub allowed_filesystems: HashSet<u64>,
-    pub filter_modified_time: (Operater, i64),
+    pub filter_modified_time: Option<(Operater, i64)>,
-    pub filter_accessed_time: (Operater, i64),
+    pub filter_accessed_time: Option<(Operater, i64)>,
-    pub filter_changed_time: (Operater, i64),
+    pub filter_changed_time: Option<(Operater, i64)>,
     pub use_apparent_size: bool,
     pub by_filecount: bool,
     pub ignore_hidden: bool,
@@ -116,27 +116,33 @@ fn ignore_file(entry: &DirEntry, walk_data: &WalkData) -> bool {
     let is_dot_file = entry.file_name().to_str().unwrap_or("").starts_with('.');
     let is_ignored_path = walk_data.ignore_directories.contains(&entry.path());
 
-    let size_inode_device = get_metadata(entry.path(), false);
+    if !walk_data.allowed_filesystems.is_empty() {
-    if let Some((_size, Some((_id, dev)), (modified_time, accessed_time, changed_time))) =
+        let size_inode_device = get_metadata(entry.path(), false);
-        size_inode_device
+        if let Some((_size, Some((_id, dev)), _gunk)) = size_inode_device {
-    {
+            if !walk_data.allowed_filesystems.contains(&dev) {
-        if !walk_data.allowed_filesystems.is_empty()
+                return true;
-            && !walk_data.allowed_filesystems.contains(&dev)
+            }
-        {
-            return true;
         }
-        if entry.path().is_file()
+    }
-            && [
+    if walk_data.filter_accessed_time.is_some()
-                (&walk_data.filter_modified_time, modified_time),
+        || walk_data.filter_modified_time.is_some()
-                (&walk_data.filter_accessed_time, accessed_time),
+        || walk_data.filter_changed_time.is_some()
-                (&walk_data.filter_changed_time, changed_time),
+    {
-            ]
+        let size_inode_device = get_metadata(entry.path(), false);
-            .iter()
+        if let Some((_, _, (modified_time, accessed_time, changed_time))) = size_inode_device {
-            .any(|(filter_time, actual_time)| {
+            if entry.path().is_file()
-                is_filtered_out_due_to_file_time(filter_time, *actual_time)
+                && [
-            })
+                    (&walk_data.filter_modified_time, modified_time),
-        {
+                    (&walk_data.filter_accessed_time, accessed_time),
-            return true;
+                    (&walk_data.filter_changed_time, changed_time),
+                ]
+                .iter()
+                .any(|(filter_time, actual_time)| {
+                    is_filtered_out_due_to_file_time(filter_time, *actual_time)
+                })
+            {
+                return true;
+            }
         }
     }
 

src/utils.rs

@@ -65,13 +65,17 @@ pub fn is_filtered_out_due_to_regex(filter_regex: &[Regex], dir: &Path) -> bool
     }
 }
 
-pub fn is_filtered_out_due_to_file_time(filter_time: &(Operater, i64), actual_time: i64) -> bool {
+pub fn is_filtered_out_due_to_file_time(
+    filter_time: &Option<(Operater, i64)>,
+    actual_time: i64,
+) -> bool {
     match filter_time {
-        (Operater::Equal, bound_time) => {
+        None => false,
+        Some((Operater::Equal, bound_time)) => {
             !(actual_time >= *bound_time && actual_time < *bound_time + DAY_SECONDS)
         }
-        (Operater::GreaterThan, bound_time) => actual_time < *bound_time,
+        Some((Operater::GreaterThan, bound_time)) => actual_time < *bound_time,
-        (Operater::LessThan, bound_time) => actual_time > *bound_time,
+        Some((Operater::LessThan, bound_time)) => actual_time > *bound_time,
     }
 }