aikup 0.0.11

Manage multiple versions of aiken
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

use miette::IntoDiagnostic;

use crate::{
    ctx,
    utils::{read_parent_name_from_link, remove_file_if_exists, root_dir},
};

/// Remove all aiken versions
#[derive(clap::Args)]
pub struct Args {
    /// keep the version currently in use
    #[clap(short, long, default_value = "false")]
    keep_current: bool,
}

impl Args {
    pub async fn exec(self) -> miette::Result<()> {
        let ctx = ctx::instance();

        let aiken_root = root_dir()?;
        let versions_dir = aiken_root.join("versions");

        let bin_dir = aiken_root.join("bin");
        #[cfg(unix)]
        let sym_bin = bin_dir.join("aiken");

        #[cfg(windows)]
        let sym_bin = bin_dir.join("aiken.exe");

        let mut entries = tokio::fs::read_dir(&versions_dir).await.into_diagnostic()?;

        println!(
            "{} {}",
            ctx.aikup_label(),
            ctx.colors.info_text("removing versions")
        );

        #[cfg(unix)]
        let (_, current_version) = read_parent_name_from_link(&sym_bin)
            .await
            .unwrap_or_default();

        #[cfg(windows)]
        let current_version = tokio::fs::read_to_string(bin_dir.join("current"))
            .await
            .unwrap_or_default();

        if !self.keep_current {
            remove_file_if_exists(&sym_bin).await?;

            #[cfg(windows)]
            tokio::fs::remove_file(bin_dir.join("current"))
                .await
                .into_diagnostic()?;
        }

        while let Some(entry) = entries.next_entry().await.into_diagnostic()? {
            let path = entry.path();

            let display_name = path
                .file_name()
                .and_then(|l| l.to_str())
                .map(|l| l.to_string())
                .unwrap_or_default();

            let keep_entry = self.keep_current && display_name.contains(&current_version);

            if !keep_entry && path.is_dir() {
                tokio::fs::remove_dir_all(&path).await.into_diagnostic()?;

                println!(
                    "{} {} {}",
                    ctx.aikup_label(),
                    ctx.colors.error_text("removed"),
                    ctx.colors.version_text(display_name).italic().dim()
                );
            } else if path.is_file() {
                tokio::fs::remove_file(path).await.into_diagnostic()?;
            } else {
                println!(
                    "{} {} {}",
                    ctx.aikup_label(),
                    ctx.colors.success_text("kept"),
                    ctx.colors.version_text(display_name).italic().dim()
                );
            }
        }

        Ok(())
    }
}