argx 0.1.0

Expressive command-line parsing and configuration for Rust.
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
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90

//! Named and positional arguments, defaults, constraints, aliases, and finite values.
//!
//! This example collects the most common field-level features in one command instead of splitting
//! each attribute into its own executable. Hidden aliases remain accepted without appearing in
//! generated help, defaults are typed Rust expressions, and `requires` / `conflicts` are validated
//! after parsing.
//!
//! ```text
//! cargo run --example arguments -- input.txt --format json --colour always
//! cargo run --example arguments -- input.txt --endpoint https://example.invalid --token secret
//! cargo run --example arguments -- --help
//! ```

use std::path::PathBuf;

use argx::Parser;

/// Output format accepted by the command.
#[derive(Debug, argx::ValueEnum)]
enum Format {
    /// Human-readable text.
    Human,
    /// One JSON document.
    Json,
    /// Newline-delimited JSON.
    JsonLines,
}

/// Inspect one input using typed command-line arguments.
#[derive(Debug, Parser)]
struct Cli {
    /// Input file to inspect.
    input: PathBuf,

    /// Output format.
    #[argx(long, value_enum, default = Format::Human)]
    format: Format,

    /// Optional output color.
    #[argx(long, alias = "colour")]
    color: Option<String>,

    /// Tag to include; repeat the option to include more than one.
    #[argx(long)]
    tag: Vec<String>,

    /// Remote endpoint to call.
    #[argx(long, requires = ["token"])]
    endpoint: Option<String>,

    /// Authentication token used for remote calls.
    #[argx(long)]
    token: Option<String>,

    /// Write the result to a file.
    #[argx(long, conflicts = ["stdout"])]
    destination: Option<PathBuf>,

    /// Write the result to standard output.
    #[argx(long)]
    stdout: bool,
}

fn main() {
    let cli = Cli::parse();

    eprintln!("input: {}", cli.input.display());
    let format = match cli.format {
        Format::Human => "human",
        Format::Json => "json",
        Format::JsonLines => "json-lines",
    };
    eprintln!("format: {format}");
    if let Some(color) = cli.color {
        eprintln!("color: {color}");
    }
    for tag in cli.tag {
        eprintln!("tag: {tag}");
    }
    if let Some(endpoint) = cli.endpoint {
        eprintln!("endpoint: {endpoint}");
    }
    if cli.token.is_some() {
        eprintln!("token: provided");
    }
    if let Some(destination) = cli.destination {
        eprintln!("destination: {}", destination.display());
    }
    eprintln!("stdout: {}", cli.stdout);
}