Enum cli_xtask::subcommand::Subcommand

#[non_exhaustive]
pub enum Subcommand {
    Build(Build),
    Clippy(Clippy),
    Dist(Dist),
    DistArchive(DistArchive),
    DistBuild(DistBuild),
    DistBuildBin(DistBuildBin),
    DistBuildCompletion(DistBuildCompletion),
    DistBuildDoc(DistBuildDoc),
    DistBuildLicense(DistBuildLicense),
    DistBuildMan(DistBuildMan),
    DistBuildReadme(DistBuildReadme),
    DistClean(DistClean),
    Doc(Doc),
    Docsrs(Docsrs),
    Exec(Exec),
    Fmt(Fmt),
    Lint(Lint),
    PreRelease(PreRelease),
    SyncRdme(SyncRdme),
    Test(Test),
    Tidy(Tidy),
    Udeps(Udeps),
}

Subcommand definition for cargo xtask command.

cargo-xtask(1)

Rust project automation command

Usage: cargo xtask [OPTIONS] [COMMAND]

Commands:
  build                  `cargo build` with options useful for testing and continuous integration
  clippy                 `cargo clippy` with options useful for tesing and continuous integration
  dist                   Build the artifacs and create the archive file for distribution
  dist-archive           Create the archive file for distribution
  dist-build             Build all artifacts for distribution
  dist-build-bin         Build the release binaries for distribution
  dist-build-completion  Build the shell completion files for distribution
  dist-build-doc         Build the documentation for distribution
  dist-build-license     Build the license files for distribution
  dist-build-man         Build the man pages for distribution
  dist-build-readme      Build the readme files for distribution
  dist-clean             Remove the artifacts and archives for distribution
  doc                    `cargo doc` with options useful for testing and continuous integration
  docsrs                 `cargo doc` with docs.rs specific options
  exec                   Run commands on all workspaces in the current directory and subdirectories
  fmt                    `cargo fmt` with options useful for testing and continuous integration
  lint                   Run lint commands at once
  pre-release            Run pre-release checks
  sync-rdme              `cargo sync-rdme` with options useful for testing and continuous integration
  test                   `cargo test` with options useful for testing and continuous integration
  tidy                   Fix the package problems
  udeps                  `cargo udeps` with options useful for testing and continuous integration
  help                   Print this message or the help of the given subcommand(s)

Options:
  -v, --verbose...  More output per occurrence
  -q, --quiet...    Less output per occurrence
  -h, --help        Print help

Examples

You can use this struct to define a subcommand of your application:

use cli_xtask::{clap, config::Config, subcommand::Subcommand, Result};

#[derive(Debug, clap::Parser)]
struct App {
    #[clap(subcommand)]
    subcommand: Subcommand,
}

impl App {
    pub fn run(&self, config: &Config) -> Result<()> {
        self.subcommand.run(config)
    }
}

You can mix the subcommands defined in this enum with your own subcommands:

use cli_xtask::{clap, config::Config, Result};

#[derive(Debug, clap::Parser)]
struct App {
    #[clap(subcommand)]
    subcommand: YourOwnSubcommand,
}

#[derive(Debug, clap::Subcommand)]
enum YourOwnSubcommand {
    #[clap(flatten)]
    Predefined(cli_xtask::subcommand::Subcommand),
    Foo,
    Bar,
}

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Build(Build)

Available on crate feature subcommand-build only.

cargo build with options useful for testing and continuous integration.

Clippy(Clippy)

Available on crate feature subcommand-clippy only.

cargo clippy with options useful for tesing and continuous integration.

Dist(Dist)

Available on crate feature subcommand-dist only.

Build the artifacs and create the archive file for distribution.

DistArchive(DistArchive)

Available on crate feature subcommand-dist-archive only.

Create the archive file for distribution.

DistBuild(DistBuild)

Available on crate feature subcommand-dist-build-* only.

Build all artifacts for distribution.

DistBuildBin(DistBuildBin)

Available on crate feature subcommand-dist-build-bin only.

Build the release binaries for distribution.

DistBuildCompletion(DistBuildCompletion)

Available on crate feature subcommand-dist-build-completion only.

Build the shell completion files for distribution.

DistBuildDoc(DistBuildDoc)

Available on crate feature subcommand-dist-build-doc only.

Build the documentation for distribution.

DistBuildLicense(DistBuildLicense)

Available on crate feature subcommand-dist-build-license only.

Build the license files for distribution.

DistBuildMan(DistBuildMan)

Available on crate feature subcommand-dist-build-man only.

Build the man pages for distribution.

DistBuildReadme(DistBuildReadme)

Available on crate feature subcommand-dist-build-readme only.

Build the readme files for distribution.

DistClean(DistClean)

Available on crate feature subcommand-dist-clean only.

Remove the artifacts and archives for distribution.

Doc(Doc)

Available on crate feature subcommand-doc only.

cargo doc with options useful for testing and continuous integration.

Docsrs(Docsrs)

Available on crate feature subcommand-docsrs only.

cargo doc with docs.rs specific options.

Exec(Exec)

Available on crate feature subcommand-exec only.

Run commands on all workspaces in the current directory and subdirectories.

Fmt(Fmt)

Available on crate feature subcommand-fmt only.

cargo fmt with options useful for testing and continuous integration.

Lint(Lint)

Available on crate feature subcommand-lint only.

Run lint commands at once.

PreRelease(PreRelease)

Available on crate feature subcommand-pre-release only.

Run pre-release checks.

SyncRdme(SyncRdme)

Available on crate feature subcommand-syncrdme only.

cargo sync-rdme with options useful for testing and continuous integration.

Test(Test)

Available on crate feature subcommand-test only.

cargo test with options useful for testing and continuous integration.

Tidy(Tidy)

Available on crate feature subcommand-tidy only.

Fix the package problems.

Udeps(Udeps)

Available on crate feature subcommand-udeps only.

cargo udeps with options useful for testing and continuous integration.

Implementations

impl Subcommand

pub fn selected(&self) -> &dyn Run

Returns the selected subcommand.

pub fn run(&self, config: &Config<'_>) -> Result<()>

Runs the subcommand specified by the command line arguments.

Trait Implementations

impl Debug for Subcommand

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl FromArgMatches for Subcommand

fn from_arg_matches(__clap_arg_matches: &ArgMatches) -> Result<Self, Error>

Instantiate Self from [ArgMatches], parsing the arguments as needed.

fn from_arg_matches_mut( __clap_arg_matches: &mut ArgMatches ) -> Result<Self, Error>

Instantiate Self from [ArgMatches], parsing the arguments as needed.

fn update_from_arg_matches( &mut self, __clap_arg_matches: &ArgMatches ) -> Result<(), Error>

Assign values from ArgMatches to self.

fn update_from_arg_matches_mut<'b>( &mut self, __clap_arg_matches: &mut ArgMatches ) -> Result<(), Error>

Assign values from ArgMatches to self.

impl Run for Subcommand

fn run(&self, config: &Config<'_>) -> Result<()>

Runs the command or subcommand.

fn into_any(self: Box<Self>) -> Box<dyn Any>

Converts the Box<dyn Run> to Box<dyn Any>.

fn as_any(&self) -> &dyn Any

Converts the &dyn Run trait object to a concrete type.

fn as_any_mut(&mut self) -> &mut dyn Any

Converts the &dyn Run trait object to a mutable concrete type.

fn to_subcommands(&self) -> Option<SubcommandRun>

Returns the subcommands that this command will run.

impl Subcommand for Subcommand

fn augment_subcommands<'b>(__clap_app: Command) -> Command

Append to [Command] so it can instantiate Self.

fn augment_subcommands_for_update<'b>(__clap_app: Command) -> Command

Append to [Command] so it can update self.

fn has_subcommand(__clap_name: &str) -> bool

Test whether Self can parse a specific subcommand