nanoargs 0.6.0

A minimal, zero-dependency argument parser for Rust CLI applications
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66

//! Example: Error handling — matching on ParseError variants
//!
//! Shows how to match on each `ParseError` variant to provide user-friendly
//! error messages. This example deliberately defines a minimal parser so you
//! can trigger every variant from the command line.
//!
//! Run with:
//!   cargo run --example error_handling -- --output out.txt input.txt   (success)
//!   cargo run --example error_handling                                 (MissingRequired)
//!   cargo run --example error_handling -- --output                     (MissingValue)
//!   cargo run --example error_handling -- --unknown                    (UnknownArgument)
//!   cargo run --example error_handling -- --output a --output b input.txt  (DuplicateOption)
//!   cargo run --example error_handling -- --port abc input.txt             (ValidationFailed)
//!   cargo run --example error_handling -- --help                       (HelpRequested)
//!   cargo run --example error_handling -- --version                    (VersionRequested)

use nanoargs::{range, ArgBuilder, Opt, ParseError, Pos};

fn main() {
    let parser = ArgBuilder::new()
        .name("error-demo")
        .description("Demonstrates ParseError variant handling")
        .version("0.1.0")
        .option(Opt::new("output").placeholder("FILE").desc("Output file").short('o').required())
        .option(
            Opt::new("port")
                .placeholder("NUM")
                .desc("Port number")
                .short('p')
                .default("8080")
                .validate(range(1, 65535)),
        )
        .positional(Pos::new("input").desc("Input file").required())
        .build()
        .unwrap();

    match parser.parse_env() {
        Ok(result) => {
            println!("output: {:?}", result.get_option("output"));
            println!("input:  {:?}", result.get_positionals());
        }
        Err(ParseError::HelpRequested(text)) => print!("{text}"),
        Err(ParseError::VersionRequested(text)) => println!("{text}"),
        Err(ParseError::MissingRequired(name)) => {
            eprintln!("Missing required argument: {name}");
            eprintln!("Hint: provide --{name} or see --help for usage.");
        }
        Err(ParseError::MissingValue(name)) => {
            eprintln!("Option --{name} requires a value.");
            eprintln!("Hint: use --{name} <value>.");
        }
        Err(ParseError::UnknownArgument(token)) => {
            eprintln!("Unknown argument: {token}");
            eprintln!("Hint: run with --help to see available options.");
        }
        Err(ParseError::DuplicateOption(name)) => {
            eprintln!("Option --{name} was provided more than once.");
            eprintln!("Hint: this option only accepts a single value.");
        }
        Err(ParseError::ValidationFailed { name, message }) => {
            eprintln!("Validation failed for {name}: {message}");
            eprintln!("Hint: check the allowed values with --help.");
        }
        Err(e) => eprintln!("error: {e}"),
    }
}