rtx-cli 2023.12.21

Polyglot runtime manager (asdf rust clone)
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

use std::sync::Arc;

use color_eyre::eyre::Result;
use rayon::prelude::*;

use crate::cli::args::tool::ToolArg;
use crate::cli::args::tool::ToolArgParser;
use crate::config::Config;
use crate::output::Output;
use crate::plugins::Plugin;
use crate::toolset::ToolVersionRequest;

/// List runtime versions available for install
///
/// note that the results are cached for 24 hours
/// run `rtx cache clean` to clear the cache and get fresh results
#[derive(Debug, clap::Args)]
#[clap(verbatim_doc_comment, after_long_help = AFTER_LONG_HELP, aliases = ["list-all", "list-remote"])]
pub struct LsRemote {
    /// Plugin to get versions for
    #[clap(value_name = "TOOL@VERSION", value_parser = ToolArgParser, required_unless_present = "all")]
    plugin: Option<ToolArg>,

    /// Show all installed plugins and versions
    #[clap(long, verbatim_doc_comment, conflicts_with_all = ["plugin", "prefix"])]
    all: bool,

    /// The version prefix to use when querying the latest version
    /// same as the first argument after the "@"
    #[clap(verbatim_doc_comment)]
    prefix: Option<String>,
}

impl LsRemote {
    pub fn run(self, mut config: Config, out: &mut Output) -> Result<()> {
        if let Some(plugin) = self.get_plugin(&mut config)? {
            self.run_single(config, out, plugin)
        } else {
            self.run_all(config, out)
        }
    }

    fn run_single(self, config: Config, out: &mut Output, plugin: Arc<dyn Plugin>) -> Result<()> {
        let prefix = match &self.plugin {
            Some(tool_arg) => match &tool_arg.tvr {
                Some(ToolVersionRequest::Version(_, v)) => Some(v.clone()),
                _ => self.prefix.clone(),
            },
            _ => self.prefix.clone(),
        };

        let versions = plugin.list_remote_versions(&config.settings)?;
        let versions = match prefix {
            Some(prefix) => versions
                .into_iter()
                .filter(|v| v.starts_with(&prefix))
                .collect(),
            None => versions,
        };

        for version in versions {
            rtxprintln!(out, "{}", version);
        }

        Ok(())
    }

    fn run_all(self, config: Config, out: &mut Output) -> Result<()> {
        let versions = config
            .plugins
            .values()
            .par_bridge()
            .map(|p| {
                let versions = p.list_remote_versions(&config.settings)?;
                Ok((p, versions))
            })
            .collect::<Result<Vec<_>>>()?;
        for (plugin, versions) in versions {
            for v in versions {
                rtxprintln!(out, "{}@{v}", plugin);
            }
        }
        Ok(())
    }

    fn get_plugin(&self, config: &mut Config) -> Result<Option<Arc<dyn Plugin>>> {
        match &self.plugin {
            Some(tool_arg) => {
                let plugin = config.get_or_create_plugin(&tool_arg.plugin);
                plugin.ensure_installed(config, None, false)?;
                Ok(Some(plugin))
            }
            None => Ok(None),
        }
    }
}

static AFTER_LONG_HELP: &str = color_print::cstr!(
    r#"<bold><underline>Examples:</underline></bold>
  $ <bold>rtx ls-remote node</bold>
  18.0.0
  20.0.0

  $ <bold>rtx ls-remote node@20</bold>
  20.0.0
  20.1.0

  $ <bold>rtx ls-remote node 20</bold>
  20.0.0
  20.1.0
"#
);

#[cfg(test)]
mod tests {
    use crate::assert_cli_snapshot;

    #[test]
    fn test_list_remote() {
        assert_cli_snapshot!("list-remote", "dummy");
    }

    #[test]
    fn test_ls_remote_prefix() {
        assert_cli_snapshot!("list-remote", "dummy", "1");
        assert_cli_snapshot!("list-remote", "dummy@2");
    }
}