Struct broot::verb::VerbInvocation

pub struct VerbInvocation {
    pub name: String,
    pub args: Option<String>,
    pub bang: bool,
}

the verb and its arguments, making the invocation. When coming from parsing, the args is Some as soon as there’s a separator (i.e. it’s “” in “cp “)

Fields

name: String

args: Option<String>

bang: bool

Implementations

impl VerbInvocation

pub fn new<T: Into<String>>(name: T, args: Option<T>, bang: bool) -> Self

pub fn is_empty(&self) -> bool

Examples found in repository

src/command/parts.rs (line 32)

    pub fn has_not_empty_verb_invocation(&self) -> bool {
        self.verb_invocation
            .as_ref()
            .map_or(false, |vi| !vi.is_empty())
    }

src/command/completion.rs (line 246)

    pub fn for_input(
        parts: &CommandParts,
        con: &AppContext,
        sel_info: SelInfo<'_>,
    ) -> Self {
        info!("Looking for completions");
        match &parts.verb_invocation {
            Some(invocation) if !invocation.is_empty() => {
                match &invocation.args {
                    None => {
                        // looking into verb completion
                        Self::for_verb(&invocation.name, con, sel_info)
                    }
                    Some(args) if !args.is_empty() => {
                        // looking into arg completion
                        Self::for_arg(&invocation.name, args, con, sel_info)
                    }
                    _ => {
                        // nothing possible
                        Self::None
                    }
                }
            }
            _ => Self::None, // no possible completion if no verb invocation
        }
    }

pub fn complete_name(&self) -> String

build a new String

pub fn to_string_for_name(&self, name: &str) -> String

basically return the invocation but allow another name (the shortcut or a variant)

Examples found in repository

src/verb/invocation_parser.rs (line 118)

    pub fn check_args(
        &self,
        invocation: &VerbInvocation,
        _other_path: &Option<PathBuf>,
    ) -> Option<String> {
        match (&invocation.args, &self.args_parser) {
            (None, None) => None,
            (None, Some(ref regex)) => {
                if regex.is_match("") {
                    None
                } else {
                    Some(self.invocation_pattern.to_string_for_name(&invocation.name))
                }
            }
            (Some(ref s), Some(ref regex)) => {
                if regex.is_match(s) {
                    None
                } else {
                    Some(self.invocation_pattern.to_string_for_name(&invocation.name))
                }
            }
            (Some(_), None) => Some(format!("{} doesn't take arguments", invocation.name)),
        }
    }

Trait Implementations

impl Clone for VerbInvocation

fn clone(&self) -> VerbInvocation

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for VerbInvocation

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

Formats the value using the given formatter.

impl Display for VerbInvocation

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

Formats the value using the given formatter.

impl From<&str> for VerbInvocation

fn from(invocation: &str) -> Self

parse a string being or describing the invocation of a verb with its arguments and optional bang. The leading space or colon must have been stripped before.

impl PartialEq<VerbInvocation> for VerbInvocation

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl StructuralPartialEq for VerbInvocation