Crate noargs

Imperative command-line argument parser library with no dependencies, no macros, and no implicit I/O.

Features

• Supports the following argument types:
  • Positional arguments (Arg)
  • Named arguments with values (Opt)
  • Named arguments without values (Flag)
  • Subcommands (Cmd)
• Automatically generates help text
• Simple and minimal interface due to its imperative nature (no complex DSL)

Examples

The following code demonstrates the basic usage of noargs:

fn main() -> noargs::Result<()> {
    // Create `noargs::RawArgs` having the result of `std::env::args()`.
    let mut args = noargs::raw_args();

    // Set metadata for help
    args.metadata_mut().app_name = env!("CARGO_PKG_NAME");
    args.metadata_mut().app_description = env!("CARGO_PKG_DESCRIPTION");

    // Handle well-known flags
    if noargs::VERSION_FLAG.take(&mut args).is_present() {
        println!("{} {}", env!("CARGO_PKG_NAME"), env!("CARGO_PKG_VERSION"));
        return Ok(());
    }
    noargs::HELP_FLAG.take_help(&mut args);

    // Handle application specific args
    let foo: usize = noargs::opt("foo")
        .default("1").take(&mut args).then(|o| o.value().parse())?;
    let bar: bool = noargs::flag("bar")
        .take(&mut args).is_present();
    let baz: Option<String> = noargs::arg("[BAZ]")
        .take(&mut args).present_and_then(|a| a.value().parse())?;

    // Check unexpected args and build help text if need
    if let Some(help) = args.finish()? {
        print!("{help}");
        return Ok(());
    }

    // Do application logic

    Ok(())
}

The following example shows how to handle subcommands:

fn main() -> noargs::Result<()> {
    let mut args = noargs::raw_args();
    args.metadata_mut().app_name = env!("CARGO_PKG_NAME");
    args.metadata_mut().app_description = env!("CARGO_PKG_DESCRIPTION");

    // Handle well-known flags
    if noargs::VERSION_FLAG.take(&mut args).is_present() {
        println!("{} {}", env!("CARGO_PKG_NAME"), env!("CARGO_PKG_VERSION"));
        return Ok(());
    }
    noargs::HELP_FLAG.take_help(&mut args);

    // Handle subcommands
    if noargs::cmd("start")
        .doc("Start the service")
        .take(&mut args)
        .is_present()
    {
        let port: u16 = noargs::opt("port")
            .short('p')
            .default("8080")
            .take(&mut args)
            .then(|o| o.value().parse())?;

        println!("Starting service on port {}", port);
    } else if noargs::cmd("stop")
        .doc("Stop the service")
        .take(&mut args)
        .is_present()
    {
        println!("Stopping service");
    } else if let Some(help) = args.finish()? {
        print!("{help}");
        return Ok(());
    }

    Ok(())
}

Structs

ArgSpec

Specification for Arg.

CmdSpec

Specification for Cmd.

FlagSpec

Specification for Flag.

Metadata

Metadata of RawArgs.

OptSpec

Specification for Opt.

RawArgs

Raw arguments that will be converted into Arg, Opt, Flag and Cmd instances.

Enums

Arg

A positional argument.

Cmd

A subcommand.

Error

Possible errors.

Flag

A named argument without value.

Opt

A named argument with value.

Constants

HELP_FLAG

Well-known flag (--help, -h) for printing help information.

VERSION_FLAG

Well-known flag (--version) for printing version information.

Functions

arg

Makes an ArgSpec instance with a specified name.

cmd

Makes a CmdSpec instance with a specified name.

flag

Makes a FlagSpec instance with a specified name.

opt

Makes an OptSpec instance with a specified name.

raw_args

Makes an RawArgs instance initialized with command-line arguments.

Type Aliases

Result

A specialized std::result::Result type for the Error type.