Struct bpaf::Args

pub struct Args<'a> { /* private fields */ }

All currently present command line parameters with some extra metainfo

Use it for unit tests and manual parsing. For production use you would want to replace the program name with set_name, but for tests passing a slice of strings to run_inner is usually more convenient.

The easiest way to create Args is by using its From instance.

let parser = short('f')
    .switch()
    .to_options();
let value = parser
    .run_inner(Args::from(&["-f"]))
    .unwrap();
assert!(value);

// this also works
let value = parser.run_inner(&["-f"])
    .unwrap();
assert!(value);

Implementations

impl Args<'_>

pub fn set_comp(self, rev: usize) -> Self

Available on crate feature autocomplete only.

Enable completions with custom output revision style

Use revision 0 if you want to test completion mechanism

let parser = short('f').switch().to_options();
// ask bpaf to produce more input from "-", for
// suggesting new items use "" at the end
let r = parser.run_inner(Args::from(&["-"])
    .set_comp(0))
    .unwrap_err()
    .unwrap_stdout();
assert_eq!(r, "-f");

pub fn set_name(self, name: &str) -> Self

Add an application name for args created from custom input

let parser = short('f').switch().to_options();
let r = parser
    .run_inner(Args::from(&["--help"]).set_name("my_app"))
    .unwrap_err()
    .unwrap_stdout();

impl Args<'_>

pub fn current_args() -> Self

Get a list of command line arguments from OS

Trait Implementations

impl<'a> From<&'a [&'a OsStr]> for Args<'a>

fn from(value: &'a [&'a OsStr]) -> Self

Converts to this type from the input type.

impl<'a> From<&'a [&'a str]> for Args<'a>

fn from(value: &'a [&'a str]) -> Self

Converts to this type from the input type.

impl<const N: usize> From<&'static [&'static str; N]> for Args<'_>

fn from(value: &'static [&'static str; N]) -> Self

Converts to this type from the input type.

impl<'a> From<&'a [OsString]> for Args<'a>

fn from(value: &'a [OsString]) -> Self

Converts to this type from the input type.

impl<'a> From<&'a [String]> for Args<'a>

fn from(value: &'a [String]) -> Self

Converts to this type from the input type.