forklaunch 1.19.1

Launch faster with forklaunch
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

use std::io::Write;

use anyhow::{Result, bail};
use clap::{Arg, ArgMatches, Command};
use termcolor::{ColorChoice, ColorSpec, StandardStream, WriteColor};

use super::shared::fetch_releases;
use crate::{
    CliCommand,
    core::{
        command::command,
        validate::{require_auth, require_integration, require_manifest},
    },
};

fn print_field(out: &mut StandardStream, label: &str, value: &Option<String>) -> Result<()> {
    if let Some(v) = value {
        out.set_color(ColorSpec::new().set_bold(true))?;
        write!(out, "  {:<12}", label)?;
        out.reset()?;
        writeln!(out, "{}", v)?;
    }
    Ok(())
}

#[derive(Debug)]
pub(crate) struct InfoCommand;

impl InfoCommand {
    pub(crate) fn new() -> Self {
        Self {}
    }
}

impl CliCommand for InfoCommand {
    fn command(&self) -> Command {
        command("info", "Show details for a release (or the most recent releases)")
            .arg(
                Arg::new("version")
                    .long("version")
                    .short('v')
                    .help("Release version to show (omit to list the 5 most recent)"),
            )
            .arg(
                Arg::new("base_path")
                    .long("path")
                    .short('p')
                    .help("Path to application root (optional)"),
            )
    }

    fn handler(&self, matches: &ArgMatches) -> Result<()> {
        let _token = require_auth()?;
        let (_app_root, manifest) = require_manifest(matches)?;
        let app = require_integration(&manifest)?;
        let mut stdout = StandardStream::stdout(ColorChoice::Always);

        let releases = fetch_releases(&app, 50)?;

        match matches.get_one::<String>("version") {
            Some(version) => {
                let Some(release) = releases
                    .iter()
                    .find(|r| r.version.as_deref() == Some(version))
                else {
                    bail!(
                        "Release '{}' not found. Known versions: {}",
                        version,
                        releases
                            .iter()
                            .filter_map(|r| r.version.clone())
                            .take(10)
                            .collect::<Vec<_>>()
                            .join(", ")
                    );
                };
                writeln!(stdout)?;
                print_field(&mut stdout, "Version:", &release.version)?;
                print_field(&mut stdout, "Status:", &release.status)?;
                print_field(&mut stdout, "Created:", &release.created_at)?;
                print_field(&mut stdout, "Commit:", &release.git_commit)?;
                print_field(&mut stdout, "Branch:", &release.git_branch)?;
                print_field(&mut stdout, "By:", &release.released_by)?;
                print_field(&mut stdout, "Notes:", &release.notes)?;
                print_field(&mut stdout, "Id:", &release.id)?;
            }
            None => {
                writeln!(stdout)?;
                for release in releases.iter().take(5) {
                    writeln!(
                        stdout,
                        "  {}  {}  {}",
                        release.version.clone().unwrap_or_else(|| "?".into()),
                        release.status.clone().unwrap_or_default(),
                        release.created_at.clone().unwrap_or_default()
                    )?;
                }
                if releases.is_empty() {
                    log_info!(stdout, "No releases yet. Create one with: forklaunch release create --version <version>");
                }
            }
        }

        Ok(())
    }
}