Struct CommandNode 

pub struct CommandNode {

    pub id: CommandId,
    pub origin: Origin,
    pub path: Vec<String>,
    pub invocation: String,
    pub summary: String,
    pub description: Option<String>,
    pub runnable: bool,
    pub arguments: Vec<ArgumentSpec>,
    pub execution: Execution,
    pub effect: Effect,
    pub interactivity: Interactivity,
    pub stability: Stability,
    pub availability: Availability,
    pub group: Option<String>,
    pub tags: Vec<String>,
    pub aliases: Vec<String>,
    pub deprecation: Option<Deprecation>,
    pub provenance: Provenance,
    pub projections: Projections,
    pub entrypoint: Option<bool>,
}

One command, from whichever program offers it.

Fields

id: CommandId

The canonical identity.

origin: Origin

Which program runs it.

path: Vec<String>

The words after the program’s own name.

invocation: String

The command line a person types, rendered once here.

summary: String

One line.

description: Option<String>

The longer description, when the declaration carries one.

runnable: bool

Can it be run on its own, or does it only group the commands under it?

arguments: Vec<ArgumentSpec>

The arguments, in declaration order.

execution: Execution

How it is run.

effect: Effect

What it changes.

interactivity: Interactivity

How it behaves towards a terminal.

stability: Stability

Where it stands.

availability: Availability

Where it means anything.

group: Option<String>

The group a person finds it under, when the declaration has groups.

tags: Vec<String>

Free tags.

aliases: Vec<String>

Other names that resolve to this node, declared once here and honoured by every projection that has a use for one.

deprecation: Option<Deprecation>

Whether this is still the name to use.

provenance: Provenance

Where it came from.

projections: Projections

Where it appears.

entrypoint: Option<bool>

Is this command an entry point of its group — the one a newcomer is offered?

Implementations

impl CommandNode

pub fn haystack(&self) -> String

Everything a search matches on, lowered, joined.

Trait Implementations

impl Clone for CommandNode

fn clone(&self) -> CommandNode

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for CommandNode

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for CommandNode

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for CommandNode

impl JsonSchema for CommandNode

fn schema_name() -> Cow<'static, str>

The name of the generated JSON Schema.

fn schema_id() -> Cow<'static, str>

Returns a string that uniquely identifies the schema produced by this type.

fn json_schema(generator: &mut SchemaGenerator) -> Schema

Generates a JSON Schema for this type.

fn inline_schema() -> bool

Whether JSON Schemas generated for this type should be included directly in parent schemas, rather than being re-used where possible using the $ref keyword.

impl PartialEq for CommandNode

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for CommandNode

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 CommandNode