jarvy 0.5.0

Jarvy is a fast, cross-platform CLI that installs and manages developer tools across macOS and Linux.
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

//! cargo binary installation handler
//!
//! Provides installation of Rust binaries via `cargo install`.
//! Supports version pinning and feature selection.

use super::common::{PackageError, run_install_loop, validate_package_name};
use super::config::{CargoConfig, PackageSpec};

/// Handler for cargo binary installation
pub struct CargoHandler {
    config: CargoConfig,
}

impl CargoHandler {
    /// Create a new cargo handler
    pub fn new(config: CargoConfig) -> Self {
        Self { config }
    }

    /// Install all configured cargo binaries
    pub fn install(&self) -> Result<(), PackageError> {
        let locked = self.config.locked;
        run_install_loop(
            "cargo",
            "cargo",
            "[cargo]",
            "No cargo packages configured",
            &self.config.packages,
            move |name, spec| {
                // Reject names that look like cargo flags (`--git`,
                // `--root`) or direct-URL deps before they hit `cargo
                // install`. Name/version are validated by the shared
                // loop; features need an extra pass because they're
                // ecosystem-specific.
                for feature in spec.features() {
                    validate_package_name(feature, "[cargo features]")?;
                }
                Ok(build_install_args(name, spec, locked))
            },
        )
    }
}

/// Build the argv passed to `cargo`. Pinned by a unit test below.
pub(crate) fn build_install_args(name: &str, spec: &PackageSpec, locked: bool) -> Vec<String> {
    let mut args: Vec<String> = Vec::with_capacity(8);
    args.push("install".into());
    args.push(name.into());

    let version = spec.version();
    if version != "latest" {
        args.push("--version".into());
        args.push(version.into());
    }

    let features = spec.features();
    if !features.is_empty() {
        args.push("--features".into());
        args.push(features.join(","));
    }

    if locked {
        args.push("--locked".into());
    }

    args
}

#[cfg(test)]
mod tests {
    use super::*;
    use std::collections::HashMap;

    #[test]
    fn test_cargo_handler_empty() {
        let config = CargoConfig::default();
        let handler = CargoHandler::new(config);
        // Just verify it doesn't panic
        assert!(handler.config.packages.is_empty());
    }

    #[test]
    fn test_cargo_config_with_packages() {
        let mut packages = HashMap::new();
        packages.insert(
            "cargo-watch".to_string(),
            PackageSpec::Version("latest".to_string()),
        );
        packages.insert(
            "cargo-nextest".to_string(),
            PackageSpec::Version("0.9".to_string()),
        );

        let config = CargoConfig {
            packages,
            locked: true,
        };

        let handler = CargoHandler::new(config);
        assert!(handler.config.locked);
        assert_eq!(handler.config.packages.len(), 2);
    }
}