Refactor filters in spawn_senders

CHANGELOG.md

@@ -19,6 +19,7 @@
 ## Other
 
 - Many documentation updates
+- Refactor filtering logic in `spawn_senders`, see #382 (@Asha20)
 
 # v8.2.1
 

src/filter/common.rs

@@ -0,0 +1,6 @@
+use crate::walk::DirEntry;
+
+pub trait Filter {
+    /// Whether the entry should be skipped or not.
+    fn should_skip(&self, entry: &DirEntry) -> bool;
+}

src/filter/extensions.rs

@@ -0,0 +1,30 @@
+use regex::bytes::RegexSet;
+
+use crate::filesystem;
+
+use super::common::Filter;
+
+pub struct Extensions {
+    extensions: Option<RegexSet>,
+}
+
+impl Extensions {
+    pub fn new(extensions: Option<RegexSet>) -> Self {
+        Self { extensions }
+    }
+}
+
+impl Filter for Extensions {
+    fn should_skip(&self, entry: &crate::walk::DirEntry) -> bool {
+        self.extensions
+            .as_ref()
+            .map(|exts_regex| {
+                entry
+                    .path()
+                    .file_name()
+                    .map(|path_str| !exts_regex.is_match(&filesystem::osstr_to_bytes(path_str)))
+                    .unwrap_or(true)
+            })
+            .unwrap_or_default()
+    }
+}

src/filter/filetypes.rs

@@ -0,0 +1,56 @@
+use crate::filesystem;
+use crate::walk;
+
+use super::Filter;
+
+/// Whether or not to show
+#[derive(Clone)]
+pub struct FileTypes {
+    pub files: bool,
+    pub directories: bool,
+    pub symlinks: bool,
+    pub sockets: bool,
+    pub pipes: bool,
+    pub executables_only: bool,
+    pub empty_only: bool,
+}
+
+impl Default for FileTypes {
+    fn default() -> FileTypes {
+        FileTypes {
+            files: false,
+            directories: false,
+            symlinks: false,
+            sockets: false,
+            pipes: false,
+            executables_only: false,
+            empty_only: false,
+        }
+    }
+}
+
+impl Filter for FileTypes {
+    fn should_skip(&self, entry: &walk::DirEntry) -> bool {
+        entry
+            .file_type()
+            .map(|ref entry_type| {
+                (!self.files && entry_type.is_file())
+                    || (!self.directories && entry_type.is_dir())
+                    || (!self.symlinks && entry_type.is_symlink())
+                    || (!self.sockets && filesystem::is_socket(*entry_type))
+                    || (!self.pipes && filesystem::is_pipe(*entry_type))
+                    || (self.executables_only
+                        && !entry
+                            .metadata()
+                            .map(|m| filesystem::is_executable(&m))
+                            .unwrap_or(false))
+                    || (self.empty_only && !filesystem::is_empty(&entry))
+                    || !(entry_type.is_file()
+                        || entry_type.is_dir()
+                        || entry_type.is_symlink()
+                        || filesystem::is_socket(*entry_type)
+                        || filesystem::is_pipe(*entry_type))
+            })
+            .unwrap_or(true)
+    }
+}

src/filter/min_depth.rs

@@ -0,0 +1,21 @@
+use crate::walk::DirEntry;
+
+use super::common::Filter;
+
+pub struct MinDepth {
+    min_depth: Option<usize>,
+}
+
+impl MinDepth {
+    pub fn new(min_depth: Option<usize>) -> Self {
+        Self { min_depth }
+    }
+}
+
+impl Filter for MinDepth {
+    fn should_skip(&self, entry: &DirEntry) -> bool {
+        self.min_depth
+            .map(|min_depth| entry.depth().map_or(true, |d| d < min_depth))
+            .unwrap_or_default()
+    }
+}

src/filter/mod.rs

@@ -1,9 +1,23 @@
 pub use self::size::SizeFilter;
 pub use self::time::TimeFilter;
 
+pub use self::common::Filter;
+pub use self::extensions::Extensions;
+pub use self::filetypes::FileTypes;
+pub use self::min_depth::MinDepth;
+pub use self::regex_match::RegexMatch;
+pub use self::skip_root::SkipRoot;
+
 #[cfg(unix)]
 pub use self::owner::OwnerFilter;
 
+mod common;
+mod extensions;
+mod filetypes;
+mod min_depth;
+mod regex_match;
+mod skip_root;
+
 mod size;
 mod time;
 

src/filter/regex_match.rs

@@ -0,0 +1,46 @@
+use std::{borrow::Cow, ffi::OsStr, sync::Arc};
+
+use regex::bytes::Regex;
+
+use crate::filesystem;
+
+use super::common::Filter;
+
+pub struct RegexMatch {
+    pattern: Arc<Regex>,
+    search_full_path: bool,
+}
+
+impl RegexMatch {
+    pub fn new(pattern: Arc<Regex>, search_full_path: bool) -> Self {
+        Self {
+            pattern,
+            search_full_path,
+        }
+    }
+}
+
+impl Filter for RegexMatch {
+    fn should_skip(&self, entry: &crate::walk::DirEntry) -> bool {
+        let entry_path = entry.path();
+
+        let search_str: Cow<OsStr> = if self.search_full_path {
+            let path_abs_buf = filesystem::path_absolute_form(entry_path)
+                .expect("Retrieving absolute path succeeds");
+            Cow::Owned(path_abs_buf.as_os_str().to_os_string())
+        } else {
+            match entry_path.file_name() {
+                Some(filename) => Cow::Borrowed(filename),
+                None => unreachable!(
+                    "Encountered file system entry without a file name. This should only \
+                     happen for paths like 'foo/bar/..' or '/' which are not supposed to \
+                     appear in a file system traversal."
+                ),
+            }
+        };
+
+        !self
+            .pattern
+            .is_match(&filesystem::osstr_to_bytes(search_str.as_ref()))
+    }
+}

src/filter/skip_root.rs

@@ -0,0 +1,9 @@
+use super::Filter;
+
+pub struct SkipRoot;
+
+impl Filter for SkipRoot {
+    fn should_skip(&self, entry: &crate::walk::DirEntry) -> bool {
+        entry.depth().map(|depth| depth == 0).unwrap_or(false)
+    }
+}

src/main.rs

@@ -3,7 +3,6 @@ mod error;
 mod exec;
 mod exit_codes;
 mod filesystem;
-mod filetypes;
 mod filter;
 mod options;
 mod output;
@@ -26,10 +25,9 @@ use regex::bytes::{RegexBuilder, RegexSetBuilder};
 use crate::error::print_error;
 use crate::exec::CommandTemplate;
 use crate::exit_codes::ExitCode;
-use crate::filetypes::FileTypes;
 #[cfg(unix)]
 use crate::filter::OwnerFilter;
-use crate::filter::{SizeFilter, TimeFilter};
+use crate::filter::{FileTypes, SizeFilter, TimeFilter};
 use crate::options::Options;
 use crate::regex_helper::{pattern_has_uppercase_char, pattern_matches_strings_with_leading_dot};
 

src/options.rs

@@ -4,7 +4,7 @@ use lscolors::LsColors;
 use regex::bytes::RegexSet;
 
 use crate::exec::CommandTemplate;
-use crate::filetypes::FileTypes;
+use crate::filter::FileTypes;
 #[cfg(unix)]
 use crate::filter::OwnerFilter;
 use crate::filter::{SizeFilter, TimeFilter};

src/walk.rs

@@ -1,5 +1,3 @@
-use std::borrow::Cow;
-use std::ffi::OsStr;
 use std::fs::{FileType, Metadata};
 use std::io;
 use std::path::{Path, PathBuf};
@@ -18,7 +16,7 @@ use regex::bytes::Regex;
 use crate::error::print_error;
 use crate::exec;
 use crate::exit_codes::{merge_exitcodes, ExitCode};
-use crate::filesystem;
+use crate::filter::{Extensions, Filter, MinDepth, RegexMatch, SkipRoot};
 use crate::options::Options;
 use crate::output;
 
@@ -347,10 +345,6 @@ fn spawn_senders(
             }
 
             let entry = match entry_o {
-                Ok(ref e) if e.depth() == 0 => {
-                    // Skip the root directory entry.
-                    return ignore::WalkState::Continue;
-                }
                 Ok(e) => DirEntry::Normal(e),
                 Err(ignore::Error::WithPath {
                     path,
@@ -383,52 +377,39 @@ fn spawn_senders(
                 }
             };
 
-            if let Some(min_depth) = config.min_depth {
-                if entry.depth().map_or(true, |d| d < min_depth) {
-                    return ignore::WalkState::Continue;
+            let filters: Vec<Option<Box<dyn Filter>>> = vec![
+                Some(Box::new(SkipRoot)),
+                Some(Box::new(MinDepth::new(config.min_depth))),
+                Some(Box::new(RegexMatch::new(
+                    pattern.clone(),
+                    config.search_full_path,
+                ))),
+                Some(Box::new(Extensions::new(config.extensions.clone()))),
+                config
+                    .file_types
+                    .clone()
+                    .map(|x| -> Box<dyn Filter> { Box::new(x) }),
+            ];
+
+            let result = filters.iter().find_map(|filter_opt| {
+                let should_skip = filter_opt
+                    .as_ref()
+                    .map(|filter| filter.should_skip(&entry))
+                    .unwrap_or(false);
+
+                match should_skip {
+                    true => Some(ignore::WalkState::Continue),
+                    false => None,
                 }
+            });
+
+            if let Some(x) = result {
+                return x;
             }
 
             // Check the name first, since it doesn't require metadata
             let entry_path = entry.path();
 
-            let search_str: Cow<OsStr> = if config.search_full_path {
-                let path_abs_buf = filesystem::path_absolute_form(entry_path)
-                    .expect("Retrieving absolute path succeeds");
-                Cow::Owned(path_abs_buf.as_os_str().to_os_string())
-            } else {
-                match entry_path.file_name() {
-                    Some(filename) => Cow::Borrowed(filename),
-                    None => unreachable!(
-                        "Encountered file system entry without a file name. This should only \
-                         happen for paths like 'foo/bar/..' or '/' which are not supposed to \
-                         appear in a file system traversal."
-                    ),
-                }
-            };
-
-            if !pattern.is_match(&filesystem::osstr_to_bytes(search_str.as_ref())) {
-                return ignore::WalkState::Continue;
-            }
-
-            // Filter out unwanted extensions.
-            if let Some(ref exts_regex) = config.extensions {
-                if let Some(path_str) = entry_path.file_name() {
-                    if !exts_regex.is_match(&filesystem::osstr_to_bytes(path_str)) {
-                        return ignore::WalkState::Continue;
-                    }
-                } else {
-                    return ignore::WalkState::Continue;
-                }
-            }
-
-            // Filter out unwanted file types.
-            if let Some(ref file_types) = config.file_types {
-                if file_types.should_ignore(&entry) {
-                    return ignore::WalkState::Continue;
-                }
-            }
-
             #[cfg(unix)]
             {
                 if let Some(ref owner_constraint) = config.owner_constraint {