Refactor filters in spawn_senders

CHANGELOG.md

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

src/config.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/filter/common.rs

@@ -0,0 +1,28 @@
+use crate::walk::DirEntry;
+
+use super::{Extensions, FileTypes, MinDepth, RegexMatch, SkipRoot};
+
+pub trait Filter: Send + Sync {
+ /// Whether the entry should be skipped or not.
+ fn should_skip(&self, entry: &DirEntry) -> bool;
+}
+
+pub enum FilterKind<'a> {
+ SkipRoot(SkipRoot),
+ MinDepth(MinDepth),
+ RegexMatch(RegexMatch),
+ Extensions(Extensions<'a>),
+ FileTypes(FileTypes),
+}
+
+impl<'a> FilterKind<'a> {
+ pub fn should_skip(&self, entry: &DirEntry) -> bool {
+ match self {
+ FilterKind::SkipRoot(f) => f.should_skip(entry),
+ FilterKind::MinDepth(f) => f.should_skip(entry),
+ FilterKind::RegexMatch(f) => f.should_skip(entry),
+ FilterKind::Extensions(f) => f.should_skip(entry),
+ FilterKind::FileTypes(f) => f.should_skip(entry),
+ }
+ }
+}

src/filter/extensions.rs

@@ -0,0 +1,30 @@
+use regex::bytes::RegexSet;
+
+use crate::filesystem;
+
+use super::common::Filter;
+
+pub struct Extensions<'a> {
+ extensions: Option<&'a RegexSet>,
+}
+
+impl<'a> Extensions<'a> {
+ pub fn new(extensions: Option<&'a 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(filesystem::is_executable)
+ .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,24 @@
 pub use self::size::SizeFilter;
 pub use self::time::TimeFilter;
 
+pub(super) use self::common::Filter;
+pub use self::common::FilterKind;
+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

@@ -4,7 +4,6 @@ mod error;
 mod exec;
 mod exit_codes;
 mod filesystem;
-mod filetypes;
 mod filter;
 mod output;
 mod regex_helper;
@@ -27,10 +26,9 @@ use crate::config::Config;
 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::regex_helper::{pattern_has_uppercase_char, pattern_matches_strings_with_leading_dot};
 
 // We use jemalloc for performance reasons, see https://github.com/sharkdp/fd/pull/481