jaarg 0.2.0

It can parse your arguments you should use it it's called jaarg
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

/* jaarg - Argument parser
 * SPDX-FileCopyrightText: (C) 2025 Gay Pizza Specifications
 * SPDX-License-Identifier: MIT OR Apache-2.0
 */

extern crate std;

use crate::{
  ErrorUsageWriter, ErrorUsageWriterContext, HandlerResult, HelpWriter, HelpWriterContext, Opt, Opts,
  ParseControl, ParseError, ParseResult, StandardErrorUsageWriter, StandardFullHelpWriter, alloc::ParseMapResult
};
use std::path::Path;
use std::rc::Rc;
use std::{env, eprint, print};

impl<ID: 'static> Opts<ID> {
  /// Wrapper around [Opts::parse] that gathers arguments from the command line and prints errors to stderr.
  /// The errors are formatted in a standard user-friendly format.
  ///
  /// Requires `features = ["std"]`.
  pub fn parse_easy<'a>(&self, handler: impl FnMut(&str, &ID, &Opt<ID>, &str, &str) -> HandlerResult<'a, ParseControl>
  ) -> ParseResult {
    let (program_name, argv) = Self::easy_args();
    self.parse(&program_name, argv, handler,
      |name, e| self.eprint_usage::<StandardErrorUsageWriter<'_, ID>>(name, e))
  }

  /// Prints full help text for the options using the standard full.
  ///
  /// Requires `features = ["std"]`.
  pub fn print_full_help(&self, program_name: &str) {
    self.print_help::<StandardFullHelpWriter<'_, ID>>(program_name);
  }

  /// Print help text to stdout using the provided help writer.
  ///
  /// Requires `features = ["std"]`.
  pub fn print_help<'a, W: HelpWriter<'a, ID>>(&'a self, program_name: &'a str) {
    let ctx = HelpWriterContext { options: self, program_name };
    print!("{}", W::new(ctx));
  }

  /// Print help text to stderr using the provided help writer.
  ///
  /// Requires `features = ["std"]`.
  pub fn eprint_help<'a, W: HelpWriter<'a, ID>>(&'a self, program_name: &'a str) {
    let ctx = HelpWriterContext { options: self, program_name };
    eprint!("{}", W::new(ctx));
  }

  /// Print error & usage text to stderr using the provided error & usage writer.
  ///
  /// Requires `features = ["std"]`.
  pub fn eprint_usage<'a, W: ErrorUsageWriter<'a, ID>>(&'a self, program_name: &'a str, error: ParseError<'a>) {
    let ctx = ErrorUsageWriterContext { options: self, program_name, error };
    eprint!("{}", W::new(ctx));
  }

  fn easy_args() -> (Rc<str>, env::Args) {
    let mut argv = env::args();
    let argv0 = argv.next().unwrap();
    let program_name = Path::new(&argv0).file_name().unwrap().to_string_lossy();
    (program_name.into(), argv)
  }
}

impl Opts<&'static str> {
  /// Parse arguments from the command line and return the results in a [`alloc::collections::BTreeMap`].
  /// Help and errors are formatted in a standard user-friendly format.
  ///
  /// Requires `features = ["std"]`.
  pub fn parse_map_easy(&self) -> ParseMapResult {
    let (program_name, argv) = Self::easy_args();
    self.parse_map(&program_name, argv,
      |name| self.print_full_help(name),
      |name, e| self.eprint_usage::<StandardErrorUsageWriter<'_, &'static str>>(name, e))
  }
}