homeboy 0.124.11

CLI for multi-component deployment and development workflow automation
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
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110

use clap::{Args, Subcommand};
use serde::Serialize;

use homeboy::component;
use homeboy::version::{read_component_version, read_version, VersionTargetInfo};

use super::CmdResult;

#[derive(Serialize)]
#[serde(untagged)]
pub enum VersionOutput {
    Show(VersionShowOutput),
}

#[derive(Args)]
pub struct VersionArgs {
    #[command(subcommand)]
    command: VersionCommand,
}

#[derive(Subcommand)]
enum VersionCommand {
    /// Show current version (default: discovered component, fallback: homeboy binary)
    Show {
        /// Component ID (optional - shows discovered component version, or homeboy binary version)
        component_id: Option<String>,

        /// Override local_path for version file lookup
        #[arg(long)]
        path: Option<String>,
    },
}

struct VersionShowArgs {
    /// Component ID (optional - shows discovered component version, or homeboy binary version)
    component_id: Option<String>,

    /// Override local_path for version file lookup
    path: Option<String>,
}

#[derive(Serialize)]
pub struct VersionShowOutput {
    command: String,
    #[serde(skip_serializing_if = "Option::is_none")]
    component_id: Option<String>,
    pub version: String,
    targets: Vec<VersionTargetInfo>,
}

pub fn run(args: VersionArgs, _global: &crate::commands::GlobalArgs) -> CmdResult<VersionOutput> {
    let VersionCommand::Show { component_id, path } = args.command;
    show(VersionShowArgs { component_id, path })
}

fn show(args: VersionShowArgs) -> CmdResult<VersionOutput> {
    let component_id = args.component_id;
    let path = args.path;

    let info = if let Some(ref p) = path {
        let comp = component::resolve_effective(component_id.as_deref(), Some(p), None)?;
        read_component_version(&comp)?
    } else if component_id.is_some() {
        // Explicit component ID or CWD discovery
        let comp = component::resolve_effective(component_id.as_deref(), None, None)?;
        read_component_version(&comp)?
    } else {
        // No component ID and no --path: try CWD discovery first,
        // fall back to showing homeboy binary version
        match component::resolve_effective(None, None, None) {
            Ok(comp) => read_component_version(&comp)?,
            Err(_) => read_version(None)?,
        }
    };

    let display_id = component_id.or_else(|| {
        // Include discovered component ID in output
        if info.targets.is_empty() {
            None
        } else {
            component::resolve_effective(None, None, None)
                .ok()
                .map(|c| c.id)
        }
    });

    Ok((
        VersionOutput::Show(VersionShowOutput {
            command: "version.show".to_string(),
            component_id: display_id,
            version: info.version,
            targets: info.targets,
        }),
        0,
    ))
}

pub fn show_version_output(component_id: &str) -> CmdResult<VersionShowOutput> {
    let info = read_version(Some(component_id))?;

    Ok((
        VersionShowOutput {
            command: "version.show".to_string(),
            component_id: Some(component_id.to_string()),
            version: info.version,
            targets: info.targets,
        },
        0,
    ))
}