Struct CommandOption

pub struct CommandOption { /* private fields */ }

Represents a command-line option.

Implementations

impl CommandOption

pub fn new<S: Into<String>>(name: S) -> Self

Constructs a new CommandOption.

Panics:

Panics if the name is empty.

Example

use clapi::{Command, CommandOption};

let result = Command::new("MyApp")
    .option(CommandOption::new("enable"))
    .parse_from(vec!["--enable"])
    .unwrap();

assert!(result.options().contains("enable"));

pub fn get_name(&self) -> &str

Returns the name of this option.

pub fn get_aliases(&self) -> Aliases<'_>

Returns an Iterator over the aliases of this option.

pub fn get_description(&self) -> Option<&str>

Returns a short description of this option or None if not set.

pub fn is_required(&self) -> bool

Returns true if this option is required.

pub fn is_hidden(&self) -> bool

Returns true if this option is no visible for help.

pub fn is_global(&self) -> bool

Returns true if this is an global option.

pub fn allow_multiple(&self) -> bool

Returns true if this option is allowed to appear multiple times.

pub fn is_assign_required(&self) -> bool

Returns true if the option requires an assign operator.

pub fn get_arg(&self) -> Option<&Argument>

Returns the Argument this option takes or None if have more than 1 argument.

pub fn get_args(&self) -> &ArgumentList

Returns the Arguments of this option.

pub fn take_args(&self) -> bool

Returns true if this option take arguments.

pub fn has_alias<S: AsRef<str>>(&self, alias: S) -> bool

Returns true if option contains the specified alias.

pub fn alias<S: Into<String>>(self, alias: S) -> Self

Adds a new alias to this option.

Panics:

Panics if the alias is empty.

Example

use clapi::{Command, CommandOption};

let result = Command::new("MyApp")
    .option(CommandOption::new("test").alias("t"))
    .parse_from(vec!["-t"])
    .unwrap();

assert!(result.options().contains("test"));

pub fn description<S: Into<String>>(self, description: S) -> Self

Sets a short description of this option.

Example

use clapi::CommandOption;

let option = CommandOption::new("test")
    .description("Enable tests");

assert_eq!(option.get_description(), Some("Enable tests"));

pub fn required(self, is_required: bool) -> Self

Specify if this option is required, by default is false.

Examples

use clapi::{Command, CommandOption, Argument};
use clapi::validator::validate_type;

let result = Command::new("MyApp")
    .option(CommandOption::new("test"))
    .option(CommandOption::new("number")
        .required(true)
        .arg(Argument::new()
            .validator(validate_type::<i64>())))
    .parse_from(vec!["--test", "--number", "10"])
    .unwrap();

assert!(result.options().get_arg("number").unwrap().contains("10"));
assert!(result.options().contains("test"));

Other example where the option is ommited

use clapi::{Command, CommandOption, Argument};
use clapi::validator::validate_type;

let result = Command::new("MyApp")
    .option(CommandOption::new("test"))
    .option(CommandOption::new("number")
        .required(true)
        .arg(Argument::new()
            .validator(validate_type::<i64>())))
    .parse_from(vec!["--test"]);

assert!(result.is_err());

pub fn hidden(self, is_hidden: bool) -> Self

Specify if this option is hidden for the help.

Example

use clapi::CommandOption;

let option = CommandOption::new("enable").hidden(true);
assert!(option.is_hidden());

pub fn multiple(self, allow_multiple: bool) -> Self

Specify if this option can appear multiple times.

Example

use clapi::{Command, CommandOption, Argument};

let result = Command::new("MyApp")
    .option(CommandOption::new("numbers")
        .multiple(true)
        .arg(Argument::new().min_values(1)))
    .parse_from(vec!["--numbers", "10", "--numbers", "20", "--numbers", "30"])
    .unwrap();

assert!(result.options().get_arg("numbers").unwrap().contains("10"));
assert!(result.options().get_arg("numbers").unwrap().contains("20"));
assert!(result.options().get_arg("numbers").unwrap().contains("30"));

pub fn global(self, is_global: bool) -> Self

Specify if this is a global option.

pub fn requires_assign(self, requires_assign: bool) -> Self

Specify if this option requires an assign operator.

Example

use clapi::{Command, CommandOption, Argument};

let result = Command::new("MyApp")
    .option(CommandOption::new("numbers")
        .requires_assign(true)
        .arg(Argument::new().min_values(1)))
    .parse_from(vec!["--numbers=10,20,30"])
    .unwrap();

assert!(result.options().get_arg("numbers").unwrap().contains("10"));
assert!(result.options().get_arg("numbers").unwrap().contains("20"));
assert!(result.options().get_arg("numbers").unwrap().contains("30"));

Using it like this will fail

use clapi::{Command, CommandOption, Argument};

let result = Command::new("MyApp")
    .option(CommandOption::new("numbers")
        .requires_assign(true)
        .arg(Argument::new().min_values(1)))
    .parse_from(vec!["--numbers", "10", "20", "30"]);

assert!(result.is_err());

pub fn arg(self, arg: Argument) -> Self

Adds a new Argument to this option.

Example

use clapi::{Command, CommandOption, Argument};

let result = Command::new("MyApp")
    .option(CommandOption::new("copy")
        .arg(Argument::with_name("from"))
        .arg(Argument::with_name("to")))
    .parse_from(vec!["--copy", "/src/file.txt", "/src/utils/"])
    .unwrap();

assert!(result.options().get_args("copy").unwrap().get("from").unwrap().contains("/src/file.txt"));
assert!(result.options().get_args("copy").unwrap().get("to").unwrap().contains("/src/utils/"));

pub fn args(self, args: ArgumentList) -> Self

Sets the arguments of this option.

Example

use clapi::{ArgumentList, Argument, CommandOption};

let mut args = ArgumentList::new();
args.add(Argument::with_name("from")).unwrap();
args.add(Argument::with_name("to")).unwrap();

let option = CommandOption::new("copy").args(args);
assert!(option.get_args().contains("from"));
assert!(option.get_args().contains("to"));

Trait Implementations

impl Clone for CommandOption

fn clone(&self) -> CommandOption

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for CommandOption

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for CommandOption

fn deserialize<D>( deserializer: D, ) -> Result<Self, <D as Deserializer<'de>>::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Hash for CommandOption

fn hash<H: Hasher>(&self, state: &mut H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for CommandOption

fn eq(&self, other: &Self) -> 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 CommandOption

fn serialize<S>( &self, serializer: S, ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for CommandOption