Struct FigueBuiltins 

pub struct FigueBuiltins {
    pub help: bool,
    pub version: bool,
    pub completions: Option<Shell>,
}

Standard CLI builtins that can be flattened into your Args struct.

This provides the standard --help, --version, and --completions flags that most CLI applications need. Flatten it into your Args struct:

use figue::{self as args, FigueBuiltins};
use facet::Facet;

#[derive(Facet, Debug)]
struct Args {
    /// Your actual arguments
    #[facet(args::positional)]
    input: String,

    /// Standard CLI options
    #[facet(flatten)]
    builtins: FigueBuiltins,
}

// The builtins are automatically available
let args: Args = figue::from_slice(&["myfile.txt"]).unwrap();
assert_eq!(args.input, "myfile.txt");
assert!(!args.builtins.help);
assert!(!args.builtins.version);

The driver automatically handles these fields:

• --help / -h: Shows help and exits with code 0
• --version / -V: Shows version and exits with code 0
• --completions <SHELL>: Generates shell completions and exits with code 0

Setting the Version

By default, --version displays “unknown” because figue cannot automatically capture your crate’s version at compile time. To display your crate’s version, configure it via the builder:

use figue::{self as args, builder, Driver, FigueBuiltins};
use facet::Facet;

#[derive(Facet)]
struct Args {
    #[facet(args::positional)]
    input: String,

    #[facet(flatten)]
    builtins: FigueBuiltins,
}

let config = figue::builder::<Args>()
    .unwrap()
    .cli(|cli| cli.args(std::env::args().skip(1)))
    .help(|h| h
        .program_name(env!("CARGO_PKG_NAME"))
        .version(env!("CARGO_PKG_VERSION")))
    .build();

let args: Args = figue::Driver::new(config).run().unwrap();
// use args...

The env!("CARGO_PKG_VERSION") macro is evaluated at your crate’s compile time, capturing the correct version from your Cargo.toml.

Handling Help and Version Manually

If you need to handle these cases yourself (e.g., for custom formatting), use into_result() instead of unwrap():

use figue::{self as args, FigueBuiltins, DriverError};
use facet::Facet;

#[derive(Facet)]
struct Args {
    #[facet(args::positional, default)]
    input: Option<String>,

    #[facet(flatten)]
    builtins: FigueBuiltins,
}

let result = figue::from_slice::<Args>(&["--help"]).into_result();
match result {
    Err(DriverError::Help { text }) => {
        assert!(text.contains("--help"));
    }
    _ => panic!("expected help"),
}

Fields

help: bool

Show help message and exit.

version: bool

Show version and exit.

completions: Option<Shell>

Generate shell completions.

Trait Implementations

impl Debug for FigueBuiltins

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

Formats the value using the given formatter.

impl Default for FigueBuiltins

fn default() -> FigueBuiltins

Returns the “default value” for a type.

impl<'ʄ> Facet<'ʄ> for FigueBuiltins

const SHAPE: &'static Shape

The shape of this type, including: whether it’s a Struct, an Enum, something else?