|
1 | 1 | use crate::finder::Checker; |
| 2 | +use crate::sys::Sys; |
| 3 | +use crate::sys::SysMetadata; |
2 | 4 | use crate::{NonFatalError, NonFatalErrorHandler}; |
3 | | -use std::fs; |
4 | 5 | use std::path::Path; |
5 | 6 |
|
6 | | -pub struct ExecutableChecker; |
| 7 | +pub struct ExecutableChecker<TSys: Sys> { |
| 8 | + sys: TSys, |
| 9 | +} |
7 | 10 |
|
8 | | -impl ExecutableChecker { |
9 | | - pub fn new() -> ExecutableChecker { |
10 | | - ExecutableChecker |
| 11 | +impl<TSys: Sys> ExecutableChecker<TSys> { |
| 12 | + pub fn new(sys: TSys) -> Self { |
| 13 | + Self { sys } |
11 | 14 | } |
12 | 15 | } |
13 | 16 |
|
14 | | -impl Checker for ExecutableChecker { |
15 | | - #[cfg(any(unix, target_os = "wasi", target_os = "redox"))] |
| 17 | +impl<TSys: Sys> Checker for ExecutableChecker<TSys> { |
16 | 18 | fn is_valid<F: NonFatalErrorHandler>( |
17 | 19 | &self, |
18 | 20 | path: &Path, |
19 | 21 | nonfatal_error_handler: &mut F, |
20 | 22 | ) -> bool { |
21 | | - use std::io; |
22 | | - |
23 | | - use rustix::fs as rfs; |
24 | | - let ret = rfs::access(path, rfs::Access::EXEC_OK) |
25 | | - .map_err(|e| { |
26 | | - nonfatal_error_handler.handle(NonFatalError::Io(io::Error::from_raw_os_error( |
27 | | - e.raw_os_error(), |
28 | | - ))) |
29 | | - }) |
30 | | - .is_ok(); |
31 | | - #[cfg(feature = "tracing")] |
32 | | - tracing::trace!("{} EXEC_OK = {ret}", path.display()); |
33 | | - ret |
34 | | - } |
35 | | - |
36 | | - #[cfg(windows)] |
37 | | - fn is_valid<F: NonFatalErrorHandler>( |
38 | | - &self, |
39 | | - _path: &Path, |
40 | | - _nonfatal_error_handler: &mut F, |
41 | | - ) -> bool { |
42 | | - true |
| 23 | + if self.sys.is_windows() && path.extension().is_some() { |
| 24 | + true |
| 25 | + } else { |
| 26 | + let ret = self |
| 27 | + .sys |
| 28 | + .is_valid_executable(path) |
| 29 | + .map_err(|e| nonfatal_error_handler.handle(NonFatalError::Io(e))) |
| 30 | + .unwrap_or(false); |
| 31 | + #[cfg(feature = "tracing")] |
| 32 | + tracing::trace!("{} EXEC_OK = {ret}", path.display()); |
| 33 | + ret |
| 34 | + } |
43 | 35 | } |
44 | 36 | } |
45 | 37 |
|
46 | | -pub struct ExistedChecker; |
47 | | - |
48 | | -impl ExistedChecker { |
49 | | - pub fn new() -> ExistedChecker { |
50 | | - ExistedChecker |
51 | | - } |
| 38 | +pub struct ExistedChecker<TSys: Sys> { |
| 39 | + sys: TSys, |
52 | 40 | } |
53 | 41 |
|
54 | | -impl Checker for ExistedChecker { |
55 | | - #[cfg(target_os = "windows")] |
56 | | - fn is_valid<F: NonFatalErrorHandler>( |
57 | | - &self, |
58 | | - path: &Path, |
59 | | - nonfatal_error_handler: &mut F, |
60 | | - ) -> bool { |
61 | | - let ret = fs::symlink_metadata(path) |
62 | | - .map(|metadata| { |
63 | | - let file_type = metadata.file_type(); |
64 | | - #[cfg(feature = "tracing")] |
65 | | - tracing::trace!( |
66 | | - "{} is_file() = {}, is_symlink() = {}", |
67 | | - path.display(), |
68 | | - file_type.is_file(), |
69 | | - file_type.is_symlink() |
70 | | - ); |
71 | | - file_type.is_file() || file_type.is_symlink() |
72 | | - }) |
73 | | - .map_err(|e| { |
74 | | - nonfatal_error_handler.handle(NonFatalError::Io(e)); |
75 | | - }) |
76 | | - .unwrap_or(false) |
77 | | - && (path.extension().is_some() || matches_arch(path, nonfatal_error_handler)); |
78 | | - #[cfg(feature = "tracing")] |
79 | | - tracing::trace!( |
80 | | - "{} has_extension = {}, ExistedChecker::is_valid() = {ret}", |
81 | | - path.display(), |
82 | | - path.extension().is_some() |
83 | | - ); |
84 | | - ret |
| 42 | +impl<TSys: Sys> ExistedChecker<TSys> { |
| 43 | + pub fn new(sys: TSys) -> Self { |
| 44 | + Self { sys } |
85 | 45 | } |
| 46 | +} |
86 | 47 |
|
87 | | - #[cfg(not(target_os = "windows"))] |
| 48 | +impl<TSys: Sys> Checker for ExistedChecker<TSys> { |
88 | 49 | fn is_valid<F: NonFatalErrorHandler>( |
89 | 50 | &self, |
90 | 51 | path: &Path, |
91 | 52 | nonfatal_error_handler: &mut F, |
92 | 53 | ) -> bool { |
93 | | - let ret = fs::metadata(path).map(|metadata| metadata.is_file()); |
94 | | - #[cfg(feature = "tracing")] |
95 | | - tracing::trace!("{} is_file() = {ret:?}", path.display()); |
96 | | - match ret { |
97 | | - Ok(ret) => ret, |
98 | | - Err(e) => { |
99 | | - nonfatal_error_handler.handle(NonFatalError::Io(e)); |
100 | | - false |
| 54 | + if self.sys.is_windows() { |
| 55 | + let ret = self |
| 56 | + .sys |
| 57 | + .symlink_metadata(path) |
| 58 | + .map(|metadata| { |
| 59 | + #[cfg(feature = "tracing")] |
| 60 | + tracing::trace!( |
| 61 | + "{} is_file() = {}, is_symlink() = {}", |
| 62 | + path.display(), |
| 63 | + metadata.is_file(), |
| 64 | + metadata.is_symlink() |
| 65 | + ); |
| 66 | + metadata.is_file() || metadata.is_symlink() |
| 67 | + }) |
| 68 | + .map_err(|e| { |
| 69 | + nonfatal_error_handler.handle(NonFatalError::Io(e)); |
| 70 | + }) |
| 71 | + .unwrap_or(false); |
| 72 | + #[cfg(feature = "tracing")] |
| 73 | + tracing::trace!( |
| 74 | + "{} has_extension = {}, ExistedChecker::is_valid() = {ret}", |
| 75 | + path.display(), |
| 76 | + path.extension().is_some() |
| 77 | + ); |
| 78 | + ret |
| 79 | + } else { |
| 80 | + let ret = self.sys.metadata(path).map(|metadata| metadata.is_file()); |
| 81 | + #[cfg(feature = "tracing")] |
| 82 | + tracing::trace!("{} is_file() = {ret:?}", path.display()); |
| 83 | + match ret { |
| 84 | + Ok(ret) => ret, |
| 85 | + Err(e) => { |
| 86 | + nonfatal_error_handler.handle(NonFatalError::Io(e)); |
| 87 | + false |
| 88 | + } |
101 | 89 | } |
102 | 90 | } |
103 | 91 | } |
104 | 92 | } |
105 | 93 |
|
106 | | -#[cfg(target_os = "windows")] |
107 | | -fn matches_arch<F: NonFatalErrorHandler>(path: &Path, nonfatal_error_handler: &mut F) -> bool { |
108 | | - use std::io; |
109 | | - |
110 | | - let ret = winsafe::GetBinaryType(&path.display().to_string()) |
111 | | - .map_err(|e| { |
112 | | - nonfatal_error_handler.handle(NonFatalError::Io(io::Error::from_raw_os_error( |
113 | | - e.raw() as i32 |
114 | | - ))) |
115 | | - }) |
116 | | - .is_ok(); |
117 | | - #[cfg(feature = "tracing")] |
118 | | - tracing::trace!("{} matches_arch() = {ret}", path.display()); |
119 | | - ret |
120 | | -} |
121 | | - |
122 | | -pub struct CompositeChecker { |
123 | | - existed_checker: ExistedChecker, |
124 | | - executable_checker: ExecutableChecker, |
| 94 | +pub struct CompositeChecker<TSys: Sys> { |
| 95 | + existed_checker: ExistedChecker<TSys>, |
| 96 | + executable_checker: ExecutableChecker<TSys>, |
125 | 97 | } |
126 | 98 |
|
127 | | -impl CompositeChecker { |
128 | | - pub fn new() -> CompositeChecker { |
| 99 | +impl<TSys: Sys> CompositeChecker<TSys> { |
| 100 | + pub fn new(sys: TSys) -> Self { |
129 | 101 | CompositeChecker { |
130 | | - executable_checker: ExecutableChecker::new(), |
131 | | - existed_checker: ExistedChecker::new(), |
| 102 | + executable_checker: ExecutableChecker::new(sys.clone()), |
| 103 | + existed_checker: ExistedChecker::new(sys), |
132 | 104 | } |
133 | 105 | } |
134 | 106 | } |
135 | 107 |
|
136 | | -impl Checker for CompositeChecker { |
| 108 | +impl<TSys: Sys> Checker for CompositeChecker<TSys> { |
137 | 109 | fn is_valid<F: NonFatalErrorHandler>( |
138 | 110 | &self, |
139 | 111 | path: &Path, |
|
0 commit comments