Struct UnknownArgumentValueParser 

pub struct UnknownArgumentValueParser { /* private fields */ }

When encountered, report ErrorKind::UnknownArgument

Useful to help users migrate, either from old versions or similar tools.

Examples

let cmd = Command::new("mycmd")
    .args([
        Arg::new("current-dir")
            .short('C'),
        Arg::new("current-dir-unknown")
            .long("cwd")
            .aliases(["current-dir", "directory", "working-directory", "root"])
            .value_parser(clap::builder::UnknownArgumentValueParser::suggest_arg("-C"))
            .hide(true),
    ]);

// Use a supported version of the argument
let matches = cmd.clone().try_get_matches_from(["mycmd", "-C", ".."]).unwrap();
assert!(matches.contains_id("current-dir"));
assert_eq!(
    matches.get_many::<String>("current-dir").unwrap_or_default().map(|v| v.as_str()).collect::<Vec<_>>(),
    vec![".."]
);

// Use one of the invalid versions
let err = cmd.try_get_matches_from(["mycmd", "--cwd", ".."]).unwrap_err();
assert_eq!(err.kind(), clap::error::ErrorKind::UnknownArgument);

Implementations

impl UnknownArgumentValueParser

pub fn suggest_arg(arg: impl Into<Str>) -> UnknownArgumentValueParser

Suggest an alternative argument

pub fn suggest(text: impl Into<StyledStr>) -> UnknownArgumentValueParser

Provide a general suggestion

pub fn and_suggest( self, text: impl Into<StyledStr>, ) -> UnknownArgumentValueParser

Extend the suggestions

Trait Implementations

impl Clone for UnknownArgumentValueParser

fn clone(&self) -> UnknownArgumentValueParser

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for UnknownArgumentValueParser

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

Formats the value using the given formatter.

impl TypedValueParser for UnknownArgumentValueParser

type Value = String

Argument’s value type

fn parse_ref( &self, cmd: &Command, arg: Option<&Arg>, value: &OsStr, ) -> Result<<UnknownArgumentValueParser as TypedValueParser>::Value, Error>

Parse the argument value

fn parse_ref_( &self, cmd: &Command, arg: Option<&Arg>, _value: &OsStr, source: ValueSource, ) -> Result<<UnknownArgumentValueParser as TypedValueParser>::Value, Error>

Parse the argument value

fn parse( &self, cmd: &Command, arg: Option<&Arg>, value: OsString, ) -> Result<Self::Value, Error>

Parse the argument value

fn parse_( &self, cmd: &Command, arg: Option<&Arg>, value: OsString, _source: ValueSource, ) -> Result<Self::Value, Error>

Parse the argument value

fn possible_values( &self, ) -> Option<Box<dyn Iterator<Item = PossibleValue> + '_>>

Reflect on enumerated value properties

fn map<T, F>(self, func: F) -> MapValueParser<Self, F>

where T: Send + Sync + Clone, F: Fn(Self::Value) -> T + Clone,

Adapt a TypedValueParser from one value to another

fn try_map<T, E, F>(self, func: F) -> TryMapValueParser<Self, F>

where F: Fn(Self::Value) -> Result<T, E> + Clone + Send + Sync + 'static, T: Send + Sync + Clone, E: Into<Box<dyn Error + Send + Sync>>,

Adapt a TypedValueParser from one value to another