Struct Flag 

pub struct Flag {

    pub short: Option<char>,
    pub long: Option<String>,
    pub value_name: Option<String>,
    pub value_kind: ValueKind,
    pub choices: Vec<Text>,
    pub repeatable: bool,
    pub required: bool,
    pub negatable: bool,
    pub single_dash: bool,
    pub hidden: bool,
    pub deprecated: Option<Text>,
    pub inherited: bool,
    pub group: Option<String>,
    pub description: Option<Text>,
    pub default: Option<Text>,
    pub env_var: Option<String>,
    pub provenance: Provenance,
}

A single flag/option, e.g. -i, --interactive.

Fields

short: Option<char>

Short spelling, e.g. Some('i') for -i.

long: Option<String>

Long spelling, e.g. Some("interactive".into()) for --interactive.

value_name: Option<String>

The value placeholder, e.g. "FILE" in --output FILE.

value_kind: ValueKind

Whether this flag takes no value, a required value, or an optional one.

choices: Vec<Text>

Enumerated choices, e.g. {json|yaml|table} for --format.

repeatable: bool

True if this flag may be given more than once.

required: bool

True if this flag is required.

negatable: bool

True if the tool documents this boolean flag’s negation inline — GNU getopt_long’s --[no-]foo convention (git’s own --help formatter renders every negatable boolean this way). long always holds the base name ("foo", never "[no-]foo" or "no-foo"): this field is what lets the negatability survive the parse without smuggling [/] into the spelling users search and copy. See mandible-extract/src/help_text/grammar.rs’s try_long for where this is recognized, structurally, from the bracketed-prefix shape — never from a tool name.

single_dash: bool

True when Self::long is spelled with one dash rather than two — the single-dash long-option convention (qemu -help, find -name, gcc -fdump-scos, bpftrace -vv), which is a real and common shape that this model previously had no way to say.

long holds the bare name either way ("help", "vv"), so every identity, merge and search path keeps working unchanged; this field only decides how many dashes Self::spelling puts in front of it. Storing "-help" in long instead would have put a dash inside the spelling users search and copy, exactly the mistake Self::negatable’s own doc comment records for --[no-]foo.

Recognized structurally and never from a tool name: see help_text::sections::repair_repeated_character_flags for the one shape that currently sets it.

hidden: bool

True if this flag should be hidden by default.

deprecated: Option<Text>

Some(reason) when this flag is deprecated.

inherited: bool

True when this flag was declared on an ancestor node and propagated down (cobra “persistent flag” / carapace persistentflags). Rendered in a separate, dimmed group in the detail pane.

group: Option<String>

Display grouping from the source, e.g. tar’s "Main operation mode".

description: Option<Text>

The flag’s description.

default: Option<Text>

The flag’s default value, if documented.

env_var: Option<String>

An environment variable that also sets this flag, if documented.

provenance: Provenance

Which source(s) contributed this flag’s fields.

Implementations

impl Flag

pub fn long(name: impl Into<String>, provenance: Provenance) -> Flag

A minimal flag with only a long spelling.

pub fn key(&self) -> Option<FlagKey>

The canonical identity key used for cross-source matching and addressing: prefer the long name, fall back to the short letter. Returns None for a degenerate flag with neither (which cannot be addressed and is only matched positionally during merge).

pub fn matches_key(&self, key: &FlagKey) -> bool

True if key addresses this flag, checking both spellings regardless of which one is considered canonical.

pub fn spelling(&self) -> String

A human-readable spelling for display and clipboard copy, e.g. "-i, --interactive", "--output FILE", or "-S, --[no-]staged" for a negatable boolean — the [no-] is reconstructed for display from negatable, never stored in long itself (see the field’s doc comment).

A Self::single_dash flag renders with one dash (-help, -vv), reconstructed the same way and for the same reason: what a user has to type is a display concern, and putting it in long would corrupt the name every other code path matches on.

Trait Implementations

impl Clone for Flag

fn clone(&self) -> Flag

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Flag

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Flag

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<&Flag> for FlagSnapshot

fn from(f: &Flag) -> Self

Converts to this type from the input type.

impl PartialEq for Flag

fn eq(&self, other: &Flag) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl Serialize for Flag

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Flag