looprs 0.5.1

Concise coding assistant REPL — core library
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

use std::path::{Path, PathBuf};

use super::registry::ToolResolver;

pub struct PathResolver;

impl ToolResolver for PathResolver {
    fn resolve(&self, tool: &str) -> Option<PathBuf> {
        find_in_path(tool)
    }
}

fn is_executable(path: &Path) -> bool {
    if !path.is_file() {
        return false;
    }

    #[cfg(unix)]
    {
        use std::os::unix::fs::PermissionsExt;
        std::fs::metadata(path)
            .map(|m| (m.permissions().mode() & 0o111) != 0)
            .unwrap_or(false)
    }

    #[cfg(not(unix))]
    {
        // Best-effort: on non-unix, existence is our proxy.
        true
    }
}

/// Resolve a tool by searching PATH.
pub fn find_in_path(tool: &str) -> Option<PathBuf> {
    if tool.is_empty() {
        return None;
    }

    let path = std::env::var_os("PATH")?;
    for dir in std::env::split_paths(&path) {
        let candidate = dir.join(tool);
        if is_executable(&candidate) {
            return Some(candidate);
        }
    }
    None
}

#[cfg(test)]
mod tests {
    use super::*;
    use std::sync::{Mutex, OnceLock};

    static ENV_LOCK: OnceLock<Mutex<()>> = OnceLock::new();

    #[test]
    fn find_in_path_handles_missing() {
        // Unlikely to exist.
        assert!(find_in_path("totally_nonexistent_tool_xyz").is_none());
    }

    #[test]
    fn find_in_path_finds_executable_in_temp_path() {
        #[cfg(unix)]
        {
            use std::os::unix::fs::PermissionsExt;

            let _lock = ENV_LOCK.get_or_init(|| Mutex::new(())).lock().unwrap();
            let old_path = std::env::var_os("PATH");

            let dir = tempfile::tempdir().unwrap();
            let tool_path = dir.path().join("mytool");
            std::fs::write(&tool_path, "#!/bin/sh\necho ok\n").unwrap();
            let mut perms = std::fs::metadata(&tool_path).unwrap().permissions();
            perms.set_mode(0o755);
            std::fs::set_permissions(&tool_path, perms).unwrap();

            // SAFETY: env mutation is guarded by ENV_LOCK.
            unsafe {
                std::env::set_var("PATH", dir.path());
            }

            let resolved = find_in_path("mytool");
            assert_eq!(resolved, Some(tool_path));

            // Restore PATH
            // SAFETY: env mutation is guarded by ENV_LOCK.
            unsafe {
                match old_path {
                    Some(v) => std::env::set_var("PATH", v),
                    None => std::env::remove_var("PATH"),
                }
            }
        }
    }
}