temp_deno_which 0.1.0

Temp fork with Sys impl of which crate until a new version is published
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119

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,
}

impl<TSys: Sys> ExecutableChecker<TSys> {
    pub fn new(sys: TSys) -> Self {
        Self { sys }
    }
}

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
                .symlink_metadata(path)
                .map(|metadata| {
                    #[cfg(feature = "tracing")]
                    tracing::trace!(
                        "{} is_file() = {}, is_symlink() = {}",
                        path.display(),
                        metadata.is_file(),
                        metadata.is_symlink()
                    );
                    metadata.is_file() || metadata.is_symlink()
                })
                .map_err(|e| {
                    nonfatal_error_handler.handle(NonFatalError::Io(e));
                })
                .unwrap_or(false);
            #[cfg(feature = "tracing")]
            tracing::trace!(
                "{} has_extension = {}, ExistedChecker::is_valid() = {ret}",
                path.display(),
                path.extension().is_some()
            );
            ret
        } else {
            let ret = self.sys.metadata(path).map(|metadata| metadata.is_file());
            #[cfg(feature = "tracing")]
            tracing::trace!("{} is_file() = {ret:?}", path.display());
            match ret {
                Ok(ret) => ret,
                Err(e) => {
                    nonfatal_error_handler.handle(NonFatalError::Io(e));
                    false
                }
            }
        }
    }
}

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)
    }
}