Struct FlagSpec 

pub struct FlagSpec {
    pub name: &'static str,
    pub short: Option<char>,
    pub doc: &'static str,
    pub env: Option<&'static str>,
}

Specification for Flag.

Note that noargs does not support flags with only short names.

Fields

name: &'static str

Flag long name (usually kebab-case).

short: Option<char>

Flag short name.

doc: &'static str

Documentation.

env: Option<&'static str>

Environment variable name.

If a non-empty value is set to this variable, this flag is considered to be set.

Implementations

impl FlagSpec

pub const DEFAULT: Self

The default specification.

pub const fn new(name: &'static str) -> Self

Makes an FlagSpec instance with a specified name (equivalent to noargs::flag(name)).

pub const fn short(self, name: char) -> Self

Updates the value of FlagSpec::short.

Examples found in repository

examples/subcommands.rs (line 32)

fn try_run_hello(args: &mut noargs::RawArgs) -> noargs::Result<bool> {
    if !noargs::cmd("hello")
        .doc("Print a greeting")
        .take(args)
        .is_present()
    {
        return Ok(false);
    }

    let loud = noargs::flag("loud")
        .short('l')
        .doc("Print greeting in upper case")
        .take(args)
        .is_present();
    let name: String = noargs::arg("<NAME>")
        .doc("Name to greet")
        .example("Alice")
        .take(args)
        .then(|a| a.value().parse())?;

    if args.metadata().help_mode {
        return Ok(true);
    }

    let message = format!("Hello, {name}!");
    if loud {
        println!("{}", message.to_uppercase());
    } else {
        println!("{message}");
    }
    Ok(true)
}

fn try_run_sum(args: &mut noargs::RawArgs) -> noargs::Result<bool> {
    if !noargs::cmd("sum")
        .doc("Add two integers")
        .take(args)
        .is_present()
    {
        return Ok(false);
    }

    let repeat: usize = noargs::opt("repeat")
        .short('r')
        .ty("N")
        .doc("Print result multiple times")
        .default("1")
        .take(args)
        .then(|o| o.value().parse())?;
    let left: i64 = noargs::arg("<LEFT>")
        .doc("Left operand")
        .example("3")
        .take(args)
        .then(|a| a.value().parse())?;
    let right: i64 = noargs::arg("<RIGHT>")
        .doc("Right operand")
        .example("4")
        .take(args)
        .then(|a| a.value().parse())?;

    if args.metadata().help_mode {
        return Ok(true);
    }

    let total = left + right;
    for _ in 0..repeat {
        println!("{total}");
    }
    Ok(true)
}

fn try_run_echo(args: &mut noargs::RawArgs) -> noargs::Result<bool> {
    if !noargs::cmd("echo")
        .doc("Print a message")
        .take(args)
        .is_present()
    {
        return Ok(false);
    }

    let upper = noargs::flag("upper")
        .short('u')
        .doc("Uppercase the message")
        .take(args)
        .is_present();
    let text: String = noargs::arg("<TEXT>")
        .doc("Message text")
        .example("hello world")
        .take(args)
        .then(|a| a.value().parse())?;

    if args.metadata().help_mode {
        return Ok(true);
    }

    if upper {
        println!("{}", text.to_uppercase());
    } else {
        println!("{text}");
    }
    Ok(true)
}

examples/basics.rs (line 20)

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");

    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);

    // Important: call flag()/opt() before arg().
    // Otherwise values like "-v" — or any unknown "--bogus" — can be silently
    // consumed as positional arguments.
    //
    // Required option / positional: set example("...") so help mode renders
    // a meaningful Usage / Example line. Optional fields covered by default()
    // or present_and_then() do not need example().
    let verbose = noargs::flag("verbose")
        .short('v')
        .doc("Enable verbose output")
        .take(&mut args)
        .is_present();
    let dry_run = noargs::flag("dry-run")
        .doc("Print parsed values and exit without running processing")
        .take(&mut args)
        .is_present();
    let retries: usize = noargs::opt("retries")
        .short('r')
        .ty("N")
        .doc("How many times to retry")
        .default("1")
        .take(&mut args)
        .then(|o| o.value().parse())?;
    let endpoint: String = noargs::opt("endpoint")
        .ty("URL")
        .doc("Server endpoint")
        .env("NOARGS_ENDPOINT")
        .default("http://localhost:8080")
        .take(&mut args)
        .then(|o| o.value().parse())?;
    let format: String = noargs::opt("format")
        .ty("FORMAT")
        .doc("Output format")
        .example("json")
        .take(&mut args)
        .then(|o| o.value().parse())?;
    let timeout_secs: Option<u64> = noargs::opt("timeout")
        .ty("SECONDS")
        .doc("Optional timeout in seconds")
        .take(&mut args)
        .present_and_then(|o| o.value().parse())?;

    let input: String = noargs::arg("<INPUT>")
        .doc("Input file path")
        .example("input.txt")
        .take(&mut args)
        .then(|a| a.value().parse())?;
    // Optional positional with default(): the value is always a String —
    // absent uses "out.txt", present uses the given path.
    // For "absent vs present" distinction, use present_and_then() and bind
    // to Option<String> — see the README's [BAZ] example.
    let output: String = noargs::arg("[OUTPUT]")
        .doc("Output file path")
        .default("out.txt")
        .take(&mut args)
        .then(|a| a.value().parse())?;

    if let Some(help) = args.finish()? {
        // When help is requested, finish() returns the built help text.
        // Print it here and exit without running application logic.
        print!("{help}");
        return Ok(());
    }

    if dry_run {
        println!(
            "dry-run: verbose={verbose}, retries={retries}, endpoint={endpoint}, format={format}, timeout_secs={timeout_secs:?}, input={input}, output={output}"
        );
        return Ok(());
    }

    println!("processing: {input} -> {output}");
    println!("using endpoint={endpoint}, format={format}, retries={retries}");
    if verbose {
        println!("verbose: timeout_secs={timeout_secs:?}");
    }

    Ok(())
}

pub const fn doc(self, doc: &'static str) -> Self

Updates the value of FlagSpec::doc.

Examples found in repository

examples/subcommands.rs (line 33)

fn try_run_hello(args: &mut noargs::RawArgs) -> noargs::Result<bool> {
    if !noargs::cmd("hello")
        .doc("Print a greeting")
        .take(args)
        .is_present()
    {
        return Ok(false);
    }

    let loud = noargs::flag("loud")
        .short('l')
        .doc("Print greeting in upper case")
        .take(args)
        .is_present();
    let name: String = noargs::arg("<NAME>")
        .doc("Name to greet")
        .example("Alice")
        .take(args)
        .then(|a| a.value().parse())?;

    if args.metadata().help_mode {
        return Ok(true);
    }

    let message = format!("Hello, {name}!");
    if loud {
        println!("{}", message.to_uppercase());
    } else {
        println!("{message}");
    }
    Ok(true)
}

fn try_run_sum(args: &mut noargs::RawArgs) -> noargs::Result<bool> {
    if !noargs::cmd("sum")
        .doc("Add two integers")
        .take(args)
        .is_present()
    {
        return Ok(false);
    }

    let repeat: usize = noargs::opt("repeat")
        .short('r')
        .ty("N")
        .doc("Print result multiple times")
        .default("1")
        .take(args)
        .then(|o| o.value().parse())?;
    let left: i64 = noargs::arg("<LEFT>")
        .doc("Left operand")
        .example("3")
        .take(args)
        .then(|a| a.value().parse())?;
    let right: i64 = noargs::arg("<RIGHT>")
        .doc("Right operand")
        .example("4")
        .take(args)
        .then(|a| a.value().parse())?;

    if args.metadata().help_mode {
        return Ok(true);
    }

    let total = left + right;
    for _ in 0..repeat {
        println!("{total}");
    }
    Ok(true)
}

fn try_run_echo(args: &mut noargs::RawArgs) -> noargs::Result<bool> {
    if !noargs::cmd("echo")
        .doc("Print a message")
        .take(args)
        .is_present()
    {
        return Ok(false);
    }

    let upper = noargs::flag("upper")
        .short('u')
        .doc("Uppercase the message")
        .take(args)
        .is_present();
    let text: String = noargs::arg("<TEXT>")
        .doc("Message text")
        .example("hello world")
        .take(args)
        .then(|a| a.value().parse())?;

    if args.metadata().help_mode {
        return Ok(true);
    }

    if upper {
        println!("{}", text.to_uppercase());
    } else {
        println!("{text}");
    }
    Ok(true)
}

examples/basics.rs (line 21)

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");

    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);

    // Important: call flag()/opt() before arg().
    // Otherwise values like "-v" — or any unknown "--bogus" — can be silently
    // consumed as positional arguments.
    //
    // Required option / positional: set example("...") so help mode renders
    // a meaningful Usage / Example line. Optional fields covered by default()
    // or present_and_then() do not need example().
    let verbose = noargs::flag("verbose")
        .short('v')
        .doc("Enable verbose output")
        .take(&mut args)
        .is_present();
    let dry_run = noargs::flag("dry-run")
        .doc("Print parsed values and exit without running processing")
        .take(&mut args)
        .is_present();
    let retries: usize = noargs::opt("retries")
        .short('r')
        .ty("N")
        .doc("How many times to retry")
        .default("1")
        .take(&mut args)
        .then(|o| o.value().parse())?;
    let endpoint: String = noargs::opt("endpoint")
        .ty("URL")
        .doc("Server endpoint")
        .env("NOARGS_ENDPOINT")
        .default("http://localhost:8080")
        .take(&mut args)
        .then(|o| o.value().parse())?;
    let format: String = noargs::opt("format")
        .ty("FORMAT")
        .doc("Output format")
        .example("json")
        .take(&mut args)
        .then(|o| o.value().parse())?;
    let timeout_secs: Option<u64> = noargs::opt("timeout")
        .ty("SECONDS")
        .doc("Optional timeout in seconds")
        .take(&mut args)
        .present_and_then(|o| o.value().parse())?;

    let input: String = noargs::arg("<INPUT>")
        .doc("Input file path")
        .example("input.txt")
        .take(&mut args)
        .then(|a| a.value().parse())?;
    // Optional positional with default(): the value is always a String —
    // absent uses "out.txt", present uses the given path.
    // For "absent vs present" distinction, use present_and_then() and bind
    // to Option<String> — see the README's [BAZ] example.
    let output: String = noargs::arg("[OUTPUT]")
        .doc("Output file path")
        .default("out.txt")
        .take(&mut args)
        .then(|a| a.value().parse())?;

    if let Some(help) = args.finish()? {
        // When help is requested, finish() returns the built help text.
        // Print it here and exit without running application logic.
        print!("{help}");
        return Ok(());
    }

    if dry_run {
        println!(
            "dry-run: verbose={verbose}, retries={retries}, endpoint={endpoint}, format={format}, timeout_secs={timeout_secs:?}, input={input}, output={output}"
        );
        return Ok(());
    }

    println!("processing: {input} -> {output}");
    println!("using endpoint={endpoint}, format={format}, retries={retries}");
    if verbose {
        println!("verbose: timeout_secs={timeout_secs:?}");
    }

    Ok(())
}

pub const fn env(self, variable_name: &'static str) -> Self

Updates the value of FlagSpec::env.

pub fn take(self, args: &mut RawArgs) -> Flag

Takes the first Flag instance that satisfies this specification from the raw arguments.

Examples found in repository

examples/subcommands.rs (line 6)

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");

    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);

    // In real applications, split each `try_run_*` command into separate modules/files.
    let _ = try_run_hello(&mut args)? || try_run_sum(&mut args)? || try_run_echo(&mut args)?;

    if let Some(help) = args.finish()? {
        print!("{help}");
    }

    Ok(())
}

fn try_run_hello(args: &mut noargs::RawArgs) -> noargs::Result<bool> {
    if !noargs::cmd("hello")
        .doc("Print a greeting")
        .take(args)
        .is_present()
    {
        return Ok(false);
    }

    let loud = noargs::flag("loud")
        .short('l')
        .doc("Print greeting in upper case")
        .take(args)
        .is_present();
    let name: String = noargs::arg("<NAME>")
        .doc("Name to greet")
        .example("Alice")
        .take(args)
        .then(|a| a.value().parse())?;

    if args.metadata().help_mode {
        return Ok(true);
    }

    let message = format!("Hello, {name}!");
    if loud {
        println!("{}", message.to_uppercase());
    } else {
        println!("{message}");
    }
    Ok(true)
}

fn try_run_sum(args: &mut noargs::RawArgs) -> noargs::Result<bool> {
    if !noargs::cmd("sum")
        .doc("Add two integers")
        .take(args)
        .is_present()
    {
        return Ok(false);
    }

    let repeat: usize = noargs::opt("repeat")
        .short('r')
        .ty("N")
        .doc("Print result multiple times")
        .default("1")
        .take(args)
        .then(|o| o.value().parse())?;
    let left: i64 = noargs::arg("<LEFT>")
        .doc("Left operand")
        .example("3")
        .take(args)
        .then(|a| a.value().parse())?;
    let right: i64 = noargs::arg("<RIGHT>")
        .doc("Right operand")
        .example("4")
        .take(args)
        .then(|a| a.value().parse())?;

    if args.metadata().help_mode {
        return Ok(true);
    }

    let total = left + right;
    for _ in 0..repeat {
        println!("{total}");
    }
    Ok(true)
}

fn try_run_echo(args: &mut noargs::RawArgs) -> noargs::Result<bool> {
    if !noargs::cmd("echo")
        .doc("Print a message")
        .take(args)
        .is_present()
    {
        return Ok(false);
    }

    let upper = noargs::flag("upper")
        .short('u')
        .doc("Uppercase the message")
        .take(args)
        .is_present();
    let text: String = noargs::arg("<TEXT>")
        .doc("Message text")
        .example("hello world")
        .take(args)
        .then(|a| a.value().parse())?;

    if args.metadata().help_mode {
        return Ok(true);
    }

    if upper {
        println!("{}", text.to_uppercase());
    } else {
        println!("{text}");
    }
    Ok(true)
}

examples/arrays.rs (line 6)

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");

    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);

    // Same-name options can be collected by calling take() in a loop.
    let include_opt = noargs::opt("include")
        .short('I')
        .ty("PATH")
        .doc("Include path (can be specified multiple times)");
    let mut includes = Vec::<String>::new();
    while let Some(path) = include_opt
        .take(&mut args)
        .present_and_then(|o| o.value().parse())?
    {
        includes.push(path);
    }

    let label_opt = noargs::opt("label")
        .short('l')
        .ty("LABEL")
        .doc("Label value (can be specified multiple times)");
    let mut labels = Vec::<String>::new();
    while let Some(label) = label_opt
        .take(&mut args)
        .present_and_then(|o| o.value().parse())?
    {
        labels.push(label);
    }

    let output: String = noargs::opt("output")
        .short('o')
        .ty("PATH")
        .doc("Output path")
        .default("summary.txt")
        .take(&mut args)
        .then(|o| o.value().parse())?;

    // Positional arrays are handled with one required argument + optional rest.
    // Naming convention: use `<NAME>...` for required-many and `[NAME]...` for optional-many.
    // The `<>` / `[]` / `...` markers are cosmetic (used only in help output);
    // required-ness is enforced below: `.then()` makes the first input required,
    // the loop with `.present_and_then()` consumes zero or more rest inputs.
    let first_input: String = noargs::arg("<INPUT>")
        .doc("First input (required)")
        .example("a.txt")
        .take(&mut args)
        .then(|a| a.value().parse())?;
    let rest_input_arg = noargs::arg("[INPUT]...").doc("Additional inputs");
    let mut inputs = vec![first_input];
    while let Some(input) = rest_input_arg
        .take(&mut args)
        .present_and_then(|a| a.value().parse())?
    {
        inputs.push(input);
    }

    if let Some(help) = args.finish()? {
        print!("{help}");
        return Ok(());
    }

    println!("includes={includes:?}");
    println!("labels={labels:?}");
    println!("inputs={inputs:?}");
    println!("output={output}");
    Ok(())
}

examples/basics.rs (line 6)

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");

    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);

    // Important: call flag()/opt() before arg().
    // Otherwise values like "-v" — or any unknown "--bogus" — can be silently
    // consumed as positional arguments.
    //
    // Required option / positional: set example("...") so help mode renders
    // a meaningful Usage / Example line. Optional fields covered by default()
    // or present_and_then() do not need example().
    let verbose = noargs::flag("verbose")
        .short('v')
        .doc("Enable verbose output")
        .take(&mut args)
        .is_present();
    let dry_run = noargs::flag("dry-run")
        .doc("Print parsed values and exit without running processing")
        .take(&mut args)
        .is_present();
    let retries: usize = noargs::opt("retries")
        .short('r')
        .ty("N")
        .doc("How many times to retry")
        .default("1")
        .take(&mut args)
        .then(|o| o.value().parse())?;
    let endpoint: String = noargs::opt("endpoint")
        .ty("URL")
        .doc("Server endpoint")
        .env("NOARGS_ENDPOINT")
        .default("http://localhost:8080")
        .take(&mut args)
        .then(|o| o.value().parse())?;
    let format: String = noargs::opt("format")
        .ty("FORMAT")
        .doc("Output format")
        .example("json")
        .take(&mut args)
        .then(|o| o.value().parse())?;
    let timeout_secs: Option<u64> = noargs::opt("timeout")
        .ty("SECONDS")
        .doc("Optional timeout in seconds")
        .take(&mut args)
        .present_and_then(|o| o.value().parse())?;

    let input: String = noargs::arg("<INPUT>")
        .doc("Input file path")
        .example("input.txt")
        .take(&mut args)
        .then(|a| a.value().parse())?;
    // Optional positional with default(): the value is always a String —
    // absent uses "out.txt", present uses the given path.
    // For "absent vs present" distinction, use present_and_then() and bind
    // to Option<String> — see the README's [BAZ] example.
    let output: String = noargs::arg("[OUTPUT]")
        .doc("Output file path")
        .default("out.txt")
        .take(&mut args)
        .then(|a| a.value().parse())?;

    if let Some(help) = args.finish()? {
        // When help is requested, finish() returns the built help text.
        // Print it here and exit without running application logic.
        print!("{help}");
        return Ok(());
    }

    if dry_run {
        println!(
            "dry-run: verbose={verbose}, retries={retries}, endpoint={endpoint}, format={format}, timeout_secs={timeout_secs:?}, input={input}, output={output}"
        );
        return Ok(());
    }

    println!("processing: {input} -> {output}");
    println!("using endpoint={endpoint}, format={format}, retries={retries}");
    if verbose {
        println!("verbose: timeout_secs={timeout_secs:?}");
    }

    Ok(())
}

pub fn take_help(self, args: &mut RawArgs) -> Flag

Similar to FlagSpec::take(), but updates the help-related metadata of args when the flag is present.

Specifically, the following code is executed:

args.metadata_mut().help_mode = true;
args.metadata_mut().help_flag_name = Some(flag.spec().name);
if matches!(flag, Flag::Long { .. }) {
    args.metadata_mut().full_help = true;
}

Examples found in repository

examples/subcommands.rs (line 10)

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");

    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);

    // In real applications, split each `try_run_*` command into separate modules/files.
    let _ = try_run_hello(&mut args)? || try_run_sum(&mut args)? || try_run_echo(&mut args)?;

    if let Some(help) = args.finish()? {
        print!("{help}");
    }

    Ok(())
}

examples/arrays.rs (line 10)

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");

    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);

    // Same-name options can be collected by calling take() in a loop.
    let include_opt = noargs::opt("include")
        .short('I')
        .ty("PATH")
        .doc("Include path (can be specified multiple times)");
    let mut includes = Vec::<String>::new();
    while let Some(path) = include_opt
        .take(&mut args)
        .present_and_then(|o| o.value().parse())?
    {
        includes.push(path);
    }

    let label_opt = noargs::opt("label")
        .short('l')
        .ty("LABEL")
        .doc("Label value (can be specified multiple times)");
    let mut labels = Vec::<String>::new();
    while let Some(label) = label_opt
        .take(&mut args)
        .present_and_then(|o| o.value().parse())?
    {
        labels.push(label);
    }

    let output: String = noargs::opt("output")
        .short('o')
        .ty("PATH")
        .doc("Output path")
        .default("summary.txt")
        .take(&mut args)
        .then(|o| o.value().parse())?;

    // Positional arrays are handled with one required argument + optional rest.
    // Naming convention: use `<NAME>...` for required-many and `[NAME]...` for optional-many.
    // The `<>` / `[]` / `...` markers are cosmetic (used only in help output);
    // required-ness is enforced below: `.then()` makes the first input required,
    // the loop with `.present_and_then()` consumes zero or more rest inputs.
    let first_input: String = noargs::arg("<INPUT>")
        .doc("First input (required)")
        .example("a.txt")
        .take(&mut args)
        .then(|a| a.value().parse())?;
    let rest_input_arg = noargs::arg("[INPUT]...").doc("Additional inputs");
    let mut inputs = vec![first_input];
    while let Some(input) = rest_input_arg
        .take(&mut args)
        .present_and_then(|a| a.value().parse())?
    {
        inputs.push(input);
    }

    if let Some(help) = args.finish()? {
        print!("{help}");
        return Ok(());
    }

    println!("includes={includes:?}");
    println!("labels={labels:?}");
    println!("inputs={inputs:?}");
    println!("output={output}");
    Ok(())
}

examples/basics.rs (line 10)

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");

    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);

    // Important: call flag()/opt() before arg().
    // Otherwise values like "-v" — or any unknown "--bogus" — can be silently
    // consumed as positional arguments.
    //
    // Required option / positional: set example("...") so help mode renders
    // a meaningful Usage / Example line. Optional fields covered by default()
    // or present_and_then() do not need example().
    let verbose = noargs::flag("verbose")
        .short('v')
        .doc("Enable verbose output")
        .take(&mut args)
        .is_present();
    let dry_run = noargs::flag("dry-run")
        .doc("Print parsed values and exit without running processing")
        .take(&mut args)
        .is_present();
    let retries: usize = noargs::opt("retries")
        .short('r')
        .ty("N")
        .doc("How many times to retry")
        .default("1")
        .take(&mut args)
        .then(|o| o.value().parse())?;
    let endpoint: String = noargs::opt("endpoint")
        .ty("URL")
        .doc("Server endpoint")
        .env("NOARGS_ENDPOINT")
        .default("http://localhost:8080")
        .take(&mut args)
        .then(|o| o.value().parse())?;
    let format: String = noargs::opt("format")
        .ty("FORMAT")
        .doc("Output format")
        .example("json")
        .take(&mut args)
        .then(|o| o.value().parse())?;
    let timeout_secs: Option<u64> = noargs::opt("timeout")
        .ty("SECONDS")
        .doc("Optional timeout in seconds")
        .take(&mut args)
        .present_and_then(|o| o.value().parse())?;

    let input: String = noargs::arg("<INPUT>")
        .doc("Input file path")
        .example("input.txt")
        .take(&mut args)
        .then(|a| a.value().parse())?;
    // Optional positional with default(): the value is always a String —
    // absent uses "out.txt", present uses the given path.
    // For "absent vs present" distinction, use present_and_then() and bind
    // to Option<String> — see the README's [BAZ] example.
    let output: String = noargs::arg("[OUTPUT]")
        .doc("Output file path")
        .default("out.txt")
        .take(&mut args)
        .then(|a| a.value().parse())?;

    if let Some(help) = args.finish()? {
        // When help is requested, finish() returns the built help text.
        // Print it here and exit without running application logic.
        print!("{help}");
        return Ok(());
    }

    if dry_run {
        println!(
            "dry-run: verbose={verbose}, retries={retries}, endpoint={endpoint}, format={format}, timeout_secs={timeout_secs:?}, input={input}, output={output}"
        );
        return Ok(());
    }

    println!("processing: {input} -> {output}");
    println!("using endpoint={endpoint}, format={format}, retries={retries}");
    if verbose {
        println!("verbose: timeout_secs={timeout_secs:?}");
    }

    Ok(())
}

Trait Implementations

impl Clone for FlagSpec

fn clone(&self) -> FlagSpec

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for FlagSpec

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for FlagSpec

fn default() -> Self

Returns the “default value” for a type.

impl Hash for FlagSpec

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for FlagSpec

fn eq(&self, other: &FlagSpec) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Copy for FlagSpec

impl Eq for FlagSpec

impl StructuralPartialEq for FlagSpec