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

use std::collections::BTreeMap;
use std::sync::Arc;

use color_eyre::eyre::Result;
use console::style;

use crate::config::Config;
use crate::output::Output;
use crate::plugins::{Plugin, PluginName};
use crate::toolset::{ToolVersion, ToolsetBuilder};
use crate::ui::multi_progress_report::MultiProgressReport;
use crate::ui::prompt;

/// Delete unused versions of tools
///
/// rtx tracks which config files have been used in ~/.local/share/rtx/tracked_config_files
/// Versions which are no longer the latest specified in any of those configs are deleted.
/// Versions installed only with environment variables (`RTX_<PLUGIN>_VERSION`) will be deleted,
/// as will versions only referenced on the command line (`rtx exec <PLUGIN>@<VERSION>`).
#[derive(Debug, clap::Args)]
#[clap(verbatim_doc_comment, after_long_help = AFTER_LONG_HELP)]
pub struct Prune {
    /// Prune only versions from these plugins
    #[clap()]
    pub plugin: Option<Vec<PluginName>>,

    /// Do not actually delete anything
    #[clap(long, short = 'n')]
    pub dry_run: bool,
}

impl Prune {
    pub fn run(self, mut config: Config, _out: &mut Output) -> Result<()> {
        let ts = ToolsetBuilder::new().build(&mut config)?;
        let mut to_delete = ts
            .list_installed_versions(&config)?
            .into_iter()
            .map(|(p, tv)| (tv.to_string(), (p, tv)))
            .collect::<BTreeMap<String, (Arc<dyn Plugin>, ToolVersion)>>();

        if let Some(plugins) = &self.plugin {
            to_delete.retain(|_, (_, tv)| plugins.contains(&tv.plugin_name));
        }

        for cf in config.get_tracked_config_files()?.values() {
            let mut ts = cf.to_toolset().clone();
            ts.resolve(&mut config);
            for (_, tv) in ts.list_current_versions(&config) {
                to_delete.remove(&tv.to_string());
            }
        }

        self.delete(&config, to_delete.into_values().collect())
    }

    fn delete(
        &self,
        config: &Config,
        to_delete: Vec<(Arc<dyn Plugin>, ToolVersion)>,
    ) -> Result<()> {
        let mpr = MultiProgressReport::new(config.show_progress_bars());
        for (p, tv) in to_delete {
            let mut pr = mpr.add();
            if self.dry_run {
                pr.set_prefix(format!("{} {} ", pr.prefix(), style("[dryrun]").bold()));
            }
            if self.dry_run || config.settings.yes || prompt::confirm(&format!("remove {} ?", &tv))?
            {
                p.decorate_progress_bar(&mut pr, Some(&tv));
                p.uninstall_version(config, &tv, &pr, self.dry_run)?;
                pr.finish();
            }
        }
        Ok(())
    }
}

static AFTER_LONG_HELP: &str = color_print::cstr!(
    r#"<bold><underline>Examples:</underline></bold>
  $ <bold>rtx prune --dry-run</bold>
  rm -rf ~/.local/share/rtx/versions/node/20.0.0
  rm -rf ~/.local/share/rtx/versions/node/20.0.1
"#
);

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

    #[test]
    fn test_prune() {
        assert_cli!("prune", "--dry-run");
        assert_cli!("prune", "tiny");
        assert_cli!("prune");
        assert_cli!("install");
    }
}