ccgo 3.4.1

A high-performance C++ cross-platform build CLI
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
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144

//! CLI argument parsing using clap derive macros

use anyhow::Result;
use clap::{Parser, Subcommand};

use crate::commands::{
    add::AddCommand, analytics::AnalyticsCommand, bench::BenchCommand, build::BuildCommand,
    check::CheckCommand, clean::CleanCommand, collection::CollectionCommand, doc::DocCommand,
    doctor::DoctorCommand, init::InitCommand, install::InstallCommand, new::NewCommand,
    package::PackageCommand, publish::PublishCommand, registry::RegistryCommand,
    remove::RemoveCommand, run::RunCommand, search::SearchCommand, tag::TagCommand,
    test::TestCommand, tree::TreeCommand, update::UpdateCommand, vendor::VendorCommand,
};

/// CCGO - C++ Cross-platform Build Tool
///
/// A high-performance CLI for building C++ libraries across multiple platforms.
#[derive(Parser, Debug)]
#[command(name = "ccgo")]
#[command(author, version, about, long_about = None)]
#[command(propagate_version = true)]
pub struct Cli {
    /// Enable verbose output
    #[arg(short, long, global = true)]
    pub verbose: bool,

    /// Disable colored output
    #[arg(long, global = true)]
    pub no_color: bool,

    #[command(subcommand)]
    pub command: Commands,
}

/// Available commands
#[derive(Subcommand, Debug)]
pub enum Commands {
    /// Build library for specific platform
    Build(BuildCommand),

    /// Create a new library project
    New(NewCommand),

    /// Initialize library project in current directory
    Init(InitCommand),

    /// Run an example or binary target
    Run(RunCommand),

    /// Run GoogleTest unit tests
    Test(TestCommand),

    /// Run Google Benchmark benchmarks
    Bench(BenchCommand),

    /// Generate Doxygen documentation
    Doc(DocCommand),

    /// Publish library to repository
    Publish(PublishCommand),

    /// Check compilation without generating binaries
    Check(CheckCommand),

    /// Diagnose platform dependencies and environment setup
    Doctor(DoctorCommand),

    /// Clean build artifacts
    Clean(CleanCommand),

    /// Create version tag from CCGO.toml
    Tag(TagCommand),

    /// Package SDK for distribution
    Package(PackageCommand),

    /// Install project dependencies
    Install(InstallCommand),

    /// Add a dependency to CCGO.toml
    Add(AddCommand),

    /// Remove a dependency from CCGO.toml
    Remove(RemoveCommand),

    /// Update dependencies to latest versions
    Update(UpdateCommand),

    /// Display dependency tree
    Tree(TreeCommand),

    /// Manage package collections
    Collection(CollectionCommand),

    /// Manage package registries (index repositories)
    Registry(RegistryCommand),

    /// Search for packages
    Search(SearchCommand),

    /// Vendor dependencies to local directory for offline builds
    Vendor(VendorCommand),

    /// View build performance analytics
    Analytics(AnalyticsCommand),
}

impl Cli {
    /// Execute the CLI command
    pub fn execute(self) -> Result<()> {
        // Set up terminal colors
        if self.no_color {
            console::set_colors_enabled(false);
            console::set_colors_enabled_stderr(false);
        }

        // Execute the subcommand
        match self.command {
            Commands::Build(cmd) => cmd.execute(self.verbose),
            Commands::New(cmd) => cmd.execute(self.verbose),
            Commands::Init(cmd) => cmd.execute(self.verbose),
            Commands::Run(cmd) => cmd.execute(self.verbose),
            Commands::Test(cmd) => cmd.execute(self.verbose),
            Commands::Bench(cmd) => cmd.execute(self.verbose),
            Commands::Doc(cmd) => cmd.execute(self.verbose),
            Commands::Publish(cmd) => cmd.execute(self.verbose),
            Commands::Check(cmd) => cmd.execute(self.verbose),
            Commands::Doctor(cmd) => cmd.execute(self.verbose),
            Commands::Clean(cmd) => cmd.execute(self.verbose),
            Commands::Tag(cmd) => cmd.execute(self.verbose),
            Commands::Package(cmd) => cmd.execute(self.verbose),
            Commands::Install(cmd) => cmd.execute(self.verbose),
            Commands::Add(cmd) => cmd.execute(self.verbose),
            Commands::Remove(cmd) => cmd.execute(self.verbose),
            Commands::Update(cmd) => cmd.execute(self.verbose),
            Commands::Tree(cmd) => cmd.execute(self.verbose),
            Commands::Collection(cmd) => cmd.execute(self.verbose),
            Commands::Registry(cmd) => cmd.execute(self.verbose),
            Commands::Search(cmd) => cmd.execute(self.verbose),
            Commands::Vendor(cmd) => cmd.execute(self.verbose),
            Commands::Analytics(cmd) => cmd.execute(self.verbose),
        }
    }
}