vx-paths 0.3.1

Cross-platform path management for vx tool installations
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
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152

//! Path resolver for finding and resolving tool paths

use crate::PathManager;
use anyhow::Result;
use std::path::PathBuf;

/// Resolves tool paths and finds installed tools
#[derive(Debug, Clone)]
pub struct PathResolver {
    manager: PathManager,
}

impl PathResolver {
    /// Create a new PathResolver
    pub fn new(manager: PathManager) -> Self {
        Self { manager }
    }

    /// Find all executable paths for a tool (all versions)
    pub fn find_tool_executables(&self, tool_name: &str) -> Result<Vec<PathBuf>> {
        let versions = self.manager.list_tool_versions(tool_name)?;
        let mut executables = Vec::new();

        for version in versions {
            let exe_path = self.manager.tool_executable_path(tool_name, &version);
            if exe_path.exists() {
                executables.push(exe_path);
            }
        }

        Ok(executables)
    }

    /// Find the latest executable for a tool
    pub fn find_latest_executable(&self, tool_name: &str) -> Result<Option<PathBuf>> {
        if let Some(latest_version) = self.manager.get_latest_tool_version(tool_name)? {
            let exe_path = self
                .manager
                .tool_executable_path(tool_name, &latest_version);
            if exe_path.exists() {
                return Ok(Some(exe_path));
            }
        }
        Ok(None)
    }

    /// Find executable for a specific tool version
    pub fn find_version_executable(&self, tool_name: &str, version: &str) -> Option<PathBuf> {
        let exe_path = self.manager.tool_executable_path(tool_name, version);
        if exe_path.exists() {
            Some(exe_path)
        } else {
            None
        }
    }

    /// Check if a tool is installed (any version)
    pub fn is_tool_installed(&self, tool_name: &str) -> Result<bool> {
        let versions = self.manager.list_tool_versions(tool_name)?;
        Ok(!versions.is_empty())
    }

    /// Get all installed tools with their versions
    pub fn get_installed_tools_with_versions(&self) -> Result<Vec<(String, Vec<String>)>> {
        let tools = self.manager.list_installed_tools()?;
        let mut result = Vec::new();

        for tool in tools {
            let versions = self.manager.list_tool_versions(&tool)?;
            result.push((tool, versions));
        }

        Ok(result)
    }

    /// Resolve tool path with version preference
    /// If version is specified, try to find that specific version
    /// Otherwise, return the latest version
    pub fn resolve_tool_path(
        &self,
        tool_name: &str,
        version: Option<&str>,
    ) -> Result<Option<PathBuf>> {
        match version {
            Some(v) => Ok(self.find_version_executable(tool_name, v)),
            None => self.find_latest_executable(tool_name),
        }
    }

    /// Get the path manager
    pub fn manager(&self) -> &PathManager {
        &self.manager
    }
}

impl Default for PathResolver {
    fn default() -> Self {
        Self::new(PathManager::default())
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use tempfile::TempDir;

    #[test]
    fn test_path_resolver() {
        let temp_dir = TempDir::new().unwrap();
        let manager = PathManager::with_base_dir(temp_dir.path()).unwrap();
        let resolver = PathResolver::new(manager);

        // Initially no tools
        assert!(!resolver.is_tool_installed("node").unwrap());
        assert_eq!(
            resolver.find_tool_executables("node").unwrap(),
            Vec::<PathBuf>::new()
        );
        assert_eq!(resolver.find_latest_executable("node").unwrap(), None);

        // Create a tool installation
        let _version_dir = resolver
            .manager()
            .create_tool_version_dir("node", "18.17.0")
            .unwrap();
        let exe_path = resolver.manager().tool_executable_path("node", "18.17.0");
        std::fs::write(&exe_path, "fake executable").unwrap();

        // Now it should be found
        assert!(resolver.is_tool_installed("node").unwrap());
        assert_eq!(
            resolver.find_tool_executables("node").unwrap(),
            vec![exe_path.clone()]
        );
        assert_eq!(
            resolver.find_latest_executable("node").unwrap(),
            Some(exe_path.clone())
        );
        assert_eq!(
            resolver.find_version_executable("node", "18.17.0"),
            Some(exe_path.clone())
        );
        assert_eq!(
            resolver.resolve_tool_path("node", None).unwrap(),
            Some(exe_path.clone())
        );
        assert_eq!(
            resolver.resolve_tool_path("node", Some("18.17.0")).unwrap(),
            Some(exe_path)
        );
    }
}