cargo-gears 0.0.6

Command-line interface for Gears 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
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
111
112
113
114
115
116
117
118

mod build;
mod clean;
mod common;
mod config;
mod deploy;
mod generate;
mod help;
mod lint;
mod list;
mod manifest;
mod run;
mod source;
mod testing;
mod tools;

use std::convert::TryFrom;

#[derive(clap::Parser)]
#[command(version, about)]
#[command(propagate_version = true)]
#[command(name = "gears")]
#[command(arg_required_else_help = true)]
pub struct Cli {
    #[command(subcommand)]
    command: Commands,
}

#[derive(clap::Subcommand)]
#[command(disable_help_subcommand = true)]
enum Commands {
    /// Generate workspace, module, and config scaffolding
    Generate(generate::GenerateArgs),
    /// Alias for `generate workspace`
    New(generate::WorkspaceArgs),
    /// Utility to modify a provided configuration file
    Config(Box<config::ConfigArgs>),
    /// Resolve Rust source code from a crate or module path
    Src(source::SourceArgs),
    /// Schema, topic, and source-code help for developers and LLMs
    Help(help::HelpArgs),
    /// Orchestrate the linting process of the project
    Lint(lint::LintArgs),
    /// Inspect workspace gears, system gears, and project state
    #[command(name = "ls")]
    List(list::ListArgs),
    /// Inspect and validate Gears.toml manifests
    Manifest(manifest::ManifestArgs),
    /// Orchestrate the testing process of the project
    Test(testing::TestArgs),
    /// Handle the required or optional tools for the project
    Tools(tools::ToolsArgs),
    /// Generate an ephemeral cargo binary based on the provided configuration file
    Run(run::RunArgs),
    /// Same as run but stops at the build step
    Build(build::BuildArgs),
    /// Remove the generated server project and its workspace member entry
    Clean(clean::CleanArgs),
    /// Build a Docker image for the generated or provided server manifest
    Deploy(deploy::DeployArgs),
}

impl Cli {
    pub fn run(self) -> anyhow::Result<()> {
        match self.command {
            // Manifest-based commands: resolve CLI overrides, then run core logic.
            Commands::Lint(lint) => lint.resolve()?.run(),
            Commands::Test(test) => test.resolve()?.run(),
            Commands::Build(build) => build.resolve()?.run(),
            Commands::Clean(clean) => clean.resolve()?.run(),
            Commands::Deploy(deploy) => deploy.resolve()?.run(),
            Commands::Run(run) => run.resolve_and_run(),
            // Tools has its own subcommands (check-version) handled in the CLI layer.
            Commands::Tools(tools) => tools.run(),
            // Non-manifest commands: pass through to core.
            other => cargo_gears_core::GearsCommand::try_from(other)?.run(),
        }
    }
}

impl TryFrom<Commands> for cargo_gears_core::GearsCommand {
    type Error = anyhow::Error;

    fn try_from(cmd: Commands) -> Result<Self, Self::Error> {
        match cmd {
            Commands::Generate(generate) => Ok(Self::Generate(generate.into())),
            Commands::New(workspace) => {
                Ok(Self::Generate(cargo_gears_core::generate::GenerateParams {
                    command: cargo_gears_core::generate::GenerateCommand::Workspace(
                        workspace.into(),
                    ),
                }))
            }
            Commands::Config(config) => Ok(Self::Config((*config).into())),
            Commands::Src(src) => Ok(Self::Src(src.into())),
            Commands::Help(help) => Ok(help.into()),
            Commands::List(list) => Ok(Self::List(list.into())),
            Commands::Manifest(manifest) => Ok(Self::Manifest(manifest.into())),
            // Manifest-based commands and Tools should be resolved in Cli::run(), not converted here.
            Commands::Lint(_)
            | Commands::Test(_)
            | Commands::Build(_)
            | Commands::Clean(_)
            | Commands::Deploy(_)
            | Commands::Run(_)
            | Commands::Tools(_) => {
                anyhow::bail!("command should be dispatched directly in Cli::run()")
            }
        }
    }
}

impl TryFrom<Cli> for cargo_gears_core::GearsCommand {
    type Error = anyhow::Error;

    fn try_from(cli: Cli) -> Result<Self, Self::Error> {
        Self::try_from(cli.command)
    }
}