reduce sys::Sys requirements, add some tracing for otherwise silent errors (#114)

* reduce sys::Sys requirements, add some tracing for otherwise silent errors

* disable incorrect lint

* WIP: TODO: rewrite regex iterator

* finish regex implementation

---------

Co-authored-by: Jacob Kiesel <[email protected]>

Author: Xaeroxe

Cargo.toml

@@ -16,10 +16,9 @@ keywords = ["which", "which-rs", "unix", "command"]
 default = ["real-sys"]
 regex = ["dep:regex"]
 tracing = ["dep:tracing"]
-real-sys = ["env_home", "rustix", "winsafe"]
+real-sys = ["dep:env_home", "dep:rustix", "dep:winsafe"]
 
 [dependencies]
-either = "1.9.0"
 regex = { version = "1.10.2", optional = true }
 tracing = { version = "0.1.40", default-features = false, optional = true }
 

src/checker.rs

@@ -1,59 +1,42 @@
-use crate::finder::Checker;
 use crate::sys::Sys;
 use crate::sys::SysMetadata;
 use crate::{NonFatalError, NonFatalErrorHandler};
 use std::path::Path;
 
-pub struct ExecutableChecker<TSys: Sys> {
-    sys: TSys,
+pub fn is_valid<F: NonFatalErrorHandler>(
+    sys: impl Sys,
+    path: &Path,
+    nonfatal_error_handler: &mut F,
+) -> bool {
+    exists(&sys, path, nonfatal_error_handler) && is_executable(&sys, path, nonfatal_error_handler)
 }
 
-impl<TSys: Sys> ExecutableChecker<TSys> {
-    pub fn new(sys: TSys) -> Self {
-        Self { sys }
+fn is_executable<F: NonFatalErrorHandler>(
+    sys: impl Sys,
+    path: &Path,
+    nonfatal_error_handler: &mut F,
+) -> bool {
+    if sys.is_windows() && path.extension().is_some() {
+        true
+    } else {
+        let ret = sys
+            .is_valid_executable(path)
+            .map_err(|e| nonfatal_error_handler.handle(NonFatalError::Io(e)))
+            .unwrap_or(false);
+        #[cfg(feature = "tracing")]
+        tracing::trace!("{} EXEC_OK = {ret}", path.display());
+        ret
     }
 }
 
-impl<TSys: Sys> Checker for ExecutableChecker<TSys> {
-    fn is_valid<F: NonFatalErrorHandler>(
-        &self,
-        path: &Path,
-        nonfatal_error_handler: &mut F,
-    ) -> bool {
-        if self.sys.is_windows() && path.extension().is_some() {
-            true
-        } else {
-            let ret = self
-                .sys
-                .is_valid_executable(path)
-                .map_err(|e| nonfatal_error_handler.handle(NonFatalError::Io(e)))
-                .unwrap_or(false);
-            #[cfg(feature = "tracing")]
-            tracing::trace!("{} EXEC_OK = {ret}", path.display());
-            ret
-        }
-    }
-}
-
-pub struct ExistedChecker<TSys: Sys> {
-    sys: TSys,
-}
-
-impl<TSys: Sys> ExistedChecker<TSys> {
-    pub fn new(sys: TSys) -> Self {
-        Self { sys }
-    }
-}
-
-impl<TSys: Sys> Checker for ExistedChecker<TSys> {
-    fn is_valid<F: NonFatalErrorHandler>(
-        &self,
-        path: &Path,
-        nonfatal_error_handler: &mut F,
-    ) -> bool {
-        if self.sys.is_windows() {
-            let ret = self
-                .sys
+fn exists<F: NonFatalErrorHandler>(
+    sys: impl Sys,
+    path: &Path,
+    nonfatal_error_handler: &mut F,
+) -> bool {
+    {
+        if sys.is_windows() {
+            let ret = sys
                 .symlink_metadata(path)
                 .map(|metadata| {
                     #[cfg(feature = "tracing")]
@@ -71,13 +54,13 @@ impl<TSys: Sys> Checker for ExistedChecker<TSys> {
                 .unwrap_or(false);
             #[cfg(feature = "tracing")]
             tracing::trace!(
-                "{} has_extension = {}, ExistedChecker::is_valid() = {ret}",
+                "{} has_extension = {}, checker::exists() = {ret}",
                 path.display(),
                 path.extension().is_some()
             );
             ret
         } else {
-            let ret = self.sys.metadata(path).map(|metadata| metadata.is_file());
+            let ret = sys.metadata(path).map(|metadata| metadata.is_file());
             #[cfg(feature = "tracing")]
             tracing::trace!("{} is_file() = {ret:?}", path.display());
             match ret {
@@ -90,30 +73,3 @@ impl<TSys: Sys> Checker for ExistedChecker<TSys> {
         }
     }
 }
-
-pub struct CompositeChecker<TSys: Sys> {
-    existed_checker: ExistedChecker<TSys>,
-    executable_checker: ExecutableChecker<TSys>,
-}
-
-impl<TSys: Sys> CompositeChecker<TSys> {
-    pub fn new(sys: TSys) -> Self {
-        CompositeChecker {
-            executable_checker: ExecutableChecker::new(sys.clone()),
-            existed_checker: ExistedChecker::new(sys),
-        }
-    }
-}
-
-impl<TSys: Sys> Checker for CompositeChecker<TSys> {
-    fn is_valid<F: NonFatalErrorHandler>(
-        &self,
-        path: &Path,
-        nonfatal_error_handler: &mut F,
-    ) -> bool {
-        self.existed_checker.is_valid(path, nonfatal_error_handler)
-            && self
-                .executable_checker
-                .is_valid(path, nonfatal_error_handler)
-    }
-}