Struct Group 

pub struct Group {
    pub command: Command,
    pub commands: HashMap<String, Arc<dyn CommandLike>>,
    pub chain: bool,
    pub invoke_without_command: bool,
    pub result_callback: Option<ResultCallback>,
    pub subcommand_required: bool,
    pub subcommand_metavar: String,
    /* private fields */
}

A command group that contains and dispatches to subcommands.

Groups are the primary way to organize CLI applications with multiple commands. They can be nested to create complex command hierarchies.

Features

• Subcommand registration and dispatch
• Optional group callback (runs before subcommand)
• Chain mode for executing multiple subcommands
• Automatic help generation with command listing

Example

use click::group::Group;
use click::command::Command;

let cli = Group::new("myapp")
    .help("My application")
    .invoke_without_command(true)
    .callback(|_ctx| {
        println!("No subcommand provided");
        Ok(())
    })
    .command(
        Command::new("hello")
            .help("Say hello")
            .build()
    )
    .build();

Fields

command: Command

The underlying command (for the group’s own options/arguments).

commands: HashMap<String, Arc<dyn CommandLike>>

Registered subcommands (name -> Command or Group).

chain: bool

Whether to execute multiple subcommands in sequence.

invoke_without_command: bool

Whether to invoke the group callback even if no subcommand is provided.

result_callback: Option<ResultCallback>

Optional callback to process subcommand results.

subcommand_required: bool

Whether a subcommand is required (error if not provided).

Defaults to true unless invoke_without_command is true.

subcommand_metavar: String

The metavar to show for subcommands in usage.

Implementations

impl Group

pub fn new(name: &str) -> GroupBuilder

Create a new group builder with the given name.

Example

use click::group::Group;

let group = Group::new("mygroup")
    .help("My command group")
    .build();

pub fn add_command( &mut self, cmd: impl CommandLike + 'static, name: Option<&str>, )

Add a subcommand to this group.

If name is provided, it overrides the command’s own name.

Example

use click::group::Group;
use click::command::Command;

let mut group = Group::new("cli").build();
group.add_command(Command::new("hello").build(), None);
group.add_command(Command::new("greet").build(), Some("hi")); // registered as "hi"

assert!(group.get_command("hello").is_some());
assert!(group.get_command("hi").is_some());
assert!(group.get_command("greet").is_none()); // not found by original name

pub fn add_command_shared( &mut self, cmd: Arc<dyn CommandLike>, name: Option<&str>, )

Add a subcommand to this group using a shared command object.

This makes it possible to register the same command under multiple names (aliases) while still being able to query alias metadata.

pub fn get_command(&self, name: &str) -> Option<&dyn CommandLike>

Get a subcommand by name.

Example

use click::group::Group;
use click::command::Command;

let group = Group::new("cli")
    .command(Command::new("hello").build())
    .build();

assert!(group.get_command("hello").is_some());
assert!(group.get_command("unknown").is_none());

pub fn list_command_entries(&self) -> Vec<(String, &dyn CommandLike)>

List all command registrations as (registered_name, command) pairs.

This is useful when you need both the registered key and the canonical name stored inside the command itself (command.name()).

pub fn list_command_aliases(&self, name: &str) -> Vec<String>

List other registered names (aliases) that map to the same command.

Returns an empty list if the command is not found or if it has no aliases.

pub fn list_commands(&self) -> Vec<&str>

List all subcommand names (sorted alphabetically).

Example

use click::group::Group;
use click::command::Command;

let group = Group::new("cli")
    .command(Command::new("build").build())
    .command(Command::new("init").build())
    .command(Command::new("deploy").build())
    .build();

let commands = group.list_commands();
assert_eq!(commands, vec!["build", "deploy", "init"]);

pub fn resolve_command<'a>( &'a self, ctx: &Context, args: &[String], ) -> Result<Option<(&'a str, &'a dyn CommandLike, Vec<String>)>, ClickError>

Resolve a command from arguments.

Returns the command name, the command, and the remaining arguments. Returns an error if the command is not found (unless in resilient parsing mode).

Arguments

• ctx - The current context
• args - The arguments to parse

pub fn format_commands(&self, _ctx: &Context) -> String

Format the commands section for help output.

Returns a formatted string listing all visible subcommands.

Trait Implementations

impl CommandLike for Group

fn name(&self) -> Option<&str>

Get the name of this command.

fn make_context( &self, info_name: &str, args: Vec<String>, parent: Option<Arc<Context>>, ) -> Result<Context, ClickError>

Create a context for executing this command.

fn invoke(&self, ctx: &Context) -> Result<(), ClickError>

Invoke the command with the given context.

fn main(&self, args: Vec<String>) -> Result<(), ClickError>

Main entry point - make context, parse args, and invoke.

fn get_help(&self, ctx: &Context) -> String

Get the full help text for this command.

fn get_short_help(&self) -> String

Get the short help text for command listings.

fn is_hidden(&self) -> bool

Check if this command is hidden from help output.

fn get_usage(&self, ctx: &Context) -> String

Get the usage line for this command.

fn as_any(&self) -> &dyn Any

Convert to Any for downcasting.

impl Debug for Group

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

Formats the value using the given formatter.

impl Default for Group

fn default() -> Self

Returns the “default value” for a type.