gvsn 1.0.1

A fast, cross-platform Go version manager written in Rust
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

//! `gvsn list` - show all locally installed Go versions.
//!
//! Installed versions are listed newest-first. The currently active version
//! is marked so the user can identify it at a glance.

use anyhow::Result;
use colored::Colorize;
use serde::Serialize;

use crate::{config::Config, toolchain};

/// One installed version as reported by `--json`.
#[derive(Serialize)]
struct InstalledVersion {
    tag: String,
    active: bool,
}

/// Prints all installed Go versions, sorted newest-first.
///
/// The active version (determined from `.go-version` or the global default)
/// is highlighted with a check mark and an `(active)` label. If no version is
/// active - for example because no global default has been set yet - all
/// versions are shown without highlighting.
///
/// When `json` is `true`, prints a JSON array of `{"tag", "active"}` objects
/// instead, with no other output, so the result can be piped into `jq` or
/// parsed by a script.
///
/// # Errors
///
/// Returns an error if the versions directory cannot be read, or (`json`
/// only) if the result cannot be serialised.
pub fn run(config: &Config, json: bool) -> Result<()> {
    let installed = toolchain::list_installed(config)?;
    let active = toolchain::active_version(config).map(|(v, _)| v).ok();

    if json {
        let entries: Vec<InstalledVersion> = installed
            .iter()
            .map(|v| InstalledVersion {
                tag: v.tag(),
                active: active.as_ref() == Some(v),
            })
            .collect();
        println!("{}", serde_json::to_string(&entries)?);
        return Ok(());
    }

    if installed.is_empty() {
        println!("No Go versions installed. Run 'gvsn install latest'.");
        return Ok(());
    }

    println!("Installed Go versions:");
    for v in &installed {
        if active.as_ref() == Some(v) {
            println!(
                "  {} {}  {}",
                "✓".green(),
                v.tag().bold(),
                "(active)".dimmed()
            );
        } else {
            println!("    {}", v.tag());
        }
    }
    Ok(())
}

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

    fn install_version(config: &Config, tag: &str) {
        std::fs::create_dir_all(config.version_dir(tag)).unwrap();
    }

    #[test]
    fn run_reports_no_versions_when_none_installed() {
        let dir = tempdir().unwrap();
        let config = Config {
            root: dir.path().to_path_buf(),
        };
        run(&config, false).unwrap();
    }

    #[test]
    fn run_lists_installed_versions_with_active_marked() {
        let dir = tempdir().unwrap();
        let config = Config {
            root: dir.path().to_path_buf(),
        };
        install_version(&config, "go1.22.4");
        install_version(&config, "go1.21.0");
        std::fs::write(config.version_file(), "go1.22.4").unwrap();

        run(&config, false).unwrap();
    }

    #[test]
    fn run_lists_installed_versions_without_active_version() {
        let dir = tempdir().unwrap();
        let config = Config {
            root: dir.path().to_path_buf(),
        };
        install_version(&config, "go1.22.4");
        // No global version file is set for this config. `active_version`
        // resolves from the real process working directory (not
        // `config.root`), so its outcome is environment-dependent here -
        // the important invariant under test is that `run` still succeeds
        // and lists the installed version either way.
        run(&config, false).unwrap();
    }

    #[test]
    fn run_json_emits_array_with_active_flag() {
        let dir = tempdir().unwrap();
        let config = Config {
            root: dir.path().to_path_buf(),
        };
        install_version(&config, "go1.22.4");
        install_version(&config, "go1.21.0");
        std::fs::write(config.version_file(), "go1.22.4").unwrap();

        run(&config, true).unwrap();
    }

    #[test]
    fn run_json_emits_empty_array_when_none_installed() {
        let dir = tempdir().unwrap();
        let config = Config {
            root: dir.path().to_path_buf(),
        };
        run(&config, true).unwrap();
    }
}