Crate getopts

Simple getopt alternative.

Construct a vector of options, either by using reqopt, optopt, and optflag or by building them from components yourself, and pass them to getopts, along with a vector of actual arguments (not including argv[0]). You’ll either get a failure code back, or a match. You’ll have to verify whether the amount of ‘free’ arguments in the match is what you expect. Use opt_* accessors to get argument values out of the matches object.

Single-character options are expected to appear on the command line with a single preceding dash; multiple-character options are expected to be proceeded by two dashes. Options that expect an argument accept their argument following either a space or an equals sign. Single-character options don’t require the space.

Usage

This crate is on crates.io and can be used by adding getopts to the dependencies in your project’s Cargo.toml.

[dependencies]
getopts = "0.2"

and this to your crate root:

extern crate getopts;

Example

The following example shows simple command line parsing for an application that requires an input file to be specified, accepts an optional output file name following -o, and accepts both -h and --help as optional flags.

extern crate getopts;
use getopts::Options;
use std::env;

fn do_work(inp: &str, out: Option<String>) {
    println!("{}", inp);
    match out {
        Some(x) => println!("{}", x),
        None => println!("No Output"),
    }
}

fn print_usage(program: &str, opts: Options) {
    let brief = format!("Usage: {} FILE [options]", program);
    print!("{}", opts.usage(&brief));
}

fn main() {
    let args: Vec<String> = env::args().collect();
    let program = args[0].clone();

    let mut opts = Options::new();
    opts.optopt("o", "", "set output file name", "NAME");
    opts.optflag("h", "help", "print this help menu");
    let matches = match opts.parse(&args[1..]) {
        Ok(m) => { m }
        Err(f) => { panic!(f.to_string()) }
    };
    if matches.opt_present("h") {
        print_usage(&program, opts);
        return;
    }
    let output = matches.opt_str("o");
    let input = if !matches.free.is_empty() {
        matches.free[0].clone()
    } else {
        print_usage(&program, opts);
        return;
    };
    do_work(&input, output);
}

Structs

• Matches
  The result of checking command line arguments. Contains a vector of matches and a vector of free strings.
• Opt 🔒
  A description of a possible option.
• OptGroup 🔒
  One group of options, e.g., both -h and --help, along with their shared description and properties.
• Options
  A description of the options that a program can handle.

Enums

• Fail
  The type returned when the command line does not conform to the expected format. Use the Debug implementation to output detailed information.
• HasArg
  Describes whether an option has an argument.
• Name 🔒
  Name of an option. Either a string or a single char.
• Occur
  Describes how often an option may occur.
• Optval 🔒
  Describes whether an option is given at all or has a value.
• ParsingStyle
  What parsing style to use when parsing arguments.

Functions

• each_split_within 🔒
  Splits a string into substrings with possibly internal whitespace, each of them at most lim bytes long, if possible. The substrings have leading and trailing whitespace removed, and are only cut at whitespace boundaries.
• find_opt 🔒
• format_option 🔒
• is_arg 🔒
• validate_names 🔒

Type Aliases

• Result
  The result of parsing a command line with a set of options.