o2 0.0.1

A command-line tool for managing and deploying web applications.
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

use std::{fmt, sync::Arc};

use clap::{Command, Parser, Subcommand, ValueEnum};

mod formulation_provider;
mod providers;
mod registry;
use crate::registry::Registry;
use std::process::Command as Cmd;
struct FormulationCommands {
    commands: Arc<[Cmd]>,
    formulation: Formulation,
}

fn echo_cmd() -> Cmd {
    let mut echo_cmd = Cmd::new("bash");
    echo_cmd.arg("-c").arg("echo Hello from Bash!");
    echo_cmd
}

fn o2_rust_app_cmd() -> Cmd {
    let mut echo_cmd = Cmd::new("bash");
    echo_cmd.arg("-c").arg("echo Hello from Bash!");
    echo_cmd
}

#[derive(Debug, Subcommand)]
enum Commands {
    /// Create a new project
    #[command(arg_required_else_help = true, alias = "create")]
    New {
        /// The Forumulation name
        #[arg(value_enum)]
        formulation: Formulation,
    },
}

#[derive(Debug, Clone, ValueEnum)]
enum Formulation {
    O2AppRust,
}

impl fmt::Display for Commands {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match self {
            Self::New { formulation } => write!(f, "Generating {:#?}", formulation),
        }
    }
}

/// Simple program to greet a person
#[derive(Parser, Debug)]
#[command(version, name = "o2", about = "A fictional versioning CLI", long_about = None)]
struct O2 {
    #[command(subcommand)]
    command: Commands,
}

fn main() {
    // use super::echo_cmd; // Not needed, echo_cmd is in scope
    let args = O2::parse();
    let registry = Registry::new();
    if let Commands::New { formulation } = args.command {
        registry.process(formulation);
    }

    // let mut echo_cmd = Cmd::new("bash").arg("-c").arg("echo Hello from Bash!");

    // let cmds = FormulationCommands {
    //     formulation: Formulation::O2AppRust,
    //     commands: Arc::new([echo_cmd(), echo_cmd()]),
    // };

    // for mut cmd in cmds.commands {
    //     let status = cmd
    //         .spawn()
    //         .expect("Failed to spawn command")
    //         .wait()
    //         .expect("Failed to wait on child");
    //     println!("Command exited with status: {}", status);
    // }

    // println!("Hello {} !", args.command)
}