goup 1.7.0

A simple version manager for Go written in Rust! 🚀
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

use std::env;

use super::Command;
use crate::{
    env::*,
    progress::Spinner,
    shell, success,
    versions::{self, get_upstream_versions, Version},
    warning,
};
use clap::Args;
use console::style;

/// Check for updates.
#[derive(Args)]
pub struct Check {
    #[arg(short, long)]
    /// Only print when updates are available;
    /// Designed to be used in profile file.
    notify: bool,
}

impl Command for Check {
    fn run(&self) -> anyhow::Result<()> {
        check_env_applied(&shell::get_shell())?;

        let Some(current) = get_current_version()? else {
            warning!(
                "No version has been selected.\n\
                      Use `goup use` to select an SDK version."
            );
            return Ok(());
        };

        Spinner::new("Checking ...");

        let upstream_versions = get_upstream_versions()?;

        let new_minor = versions::get_new_minor(&upstream_versions, &current);
        let new_patch = versions::get_new_patch(&upstream_versions, &current);
        let new_pre = versions::get_new_pre(&upstream_versions, &current);

        if new_pre.is_none() && new_minor.is_none() && new_patch.is_none() {
            if !self.notify {
                success!("You are up to date with the latest upstream version!");
            }
        } else {
            success!("New Go versions are available!");
            checkprint("pre-release", &current, new_pre);
            checkprint("minor", &current, new_minor);
            checkprint("patch", &current, new_patch);

            if self.notify {
                let binname = env::current_exe()
                    .ok()
                    .and_then(|pb| pb.file_name().map(|s| s.to_string_lossy().to_string()))
                    .unwrap_or("goup".into());
                success!("\nUse `{binname} use` to upgrade.");
            }
        }

        Ok(())
    }
}

fn checkprint(typ: &str, current: &Version, v: Option<&Version>) {
    if let Some(new) = v {
        println!(
            "{}:  {} → {}",
            style(typ).magenta(),
            style(current.to_string()).dim(),
            style(new).cyan()
        );
    }
}