homeboy 0.17.0

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

use clap::Args;
use serde::Serialize;

use homeboy::component::{self, Component};
use homeboy::context::{self, ContextOutput};
use homeboy::module::{is_module_compatible, is_module_linked, is_module_ready, load_all_modules};
use homeboy::project::{self, Project};
use homeboy::server::{self, Server};

use super::CmdResult;

#[derive(Args)]
pub struct InitArgs {}

#[derive(Debug, Serialize)]
pub struct InitOutput {
    pub command: &'static str,
    pub context: ContextOutput,
    pub servers: Vec<Server>,
    pub projects: Vec<ProjectListItem>,
    pub components: Vec<Component>,
    pub modules: Vec<ModuleEntry>,
}

#[derive(Debug, Serialize)]
pub struct ProjectListItem {
    pub id: String,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub domain: Option<String>,
}

impl From<Project> for ProjectListItem {
    fn from(p: Project) -> Self {
        Self {
            id: p.id,
            domain: p.domain,
        }
    }
}

#[derive(Debug, Serialize)]
pub struct ModuleEntry {
    pub id: String,
    pub name: String,
    pub version: String,
    pub description: String,
    pub runtime: String,
    pub compatible: bool,
    pub ready: bool,
    pub linked: bool,
}

pub fn run_json(_args: InitArgs) -> CmdResult<InitOutput> {
    // Get context for current directory
    let (context_output, _) = context::run(None)?;

    // Get all servers
    let servers = server::list().unwrap_or_default();

    // Get all projects
    let projects: Vec<ProjectListItem> = project::list()
        .unwrap_or_default()
        .into_iter()
        .map(ProjectListItem::from)
        .collect();

    // Get all components
    let components = component::list().unwrap_or_default();

    // Get all modules with status info
    let all_modules = load_all_modules();
    let modules: Vec<ModuleEntry> = all_modules
        .iter()
        .map(|m| ModuleEntry {
            id: m.id.clone(),
            name: m.name.clone(),
            version: m.version.clone(),
            description: m
                .description
                .as_ref()
                .and_then(|d| d.lines().next())
                .unwrap_or("")
                .to_string(),
            runtime: if m.runtime.is_some() {
                "executable"
            } else {
                "platform"
            }
            .to_string(),
            compatible: is_module_compatible(m, None),
            ready: is_module_ready(m),
            linked: is_module_linked(&m.id),
        })
        .collect();

    Ok((
        InitOutput {
            command: "init",
            context: context_output,
            servers,
            projects,
            components,
            modules,
        },
        0,
    ))
}