Struct Parser 

pub struct Parser<C> { /* private fields */ }

The core parser.

Implementations

impl<C> Parser<C>

pub fn from_env(ctx: C) -> Self

Create a parser for parsing the process’ command line arguments.

Examples found in repository

examples/conflict.rs (line 35)

fn main() -> Result<(), Box<dyn std::error::Error>> {
  let help_spec = arg::Builder::new()
    .sopt('h')
    .lopt("help")
    .exit(true)
    .help(&["Show this help."])
    .build(help_proc);
  let coll_spec = arg::Builder::new()
    .sopt('h')
    .lopt("hulp")
    .exit(true)
    .help(&["Show this help."])
    .build(help_proc);


  let ctx = MyContext {
    ..Default::default()
  };
  let mut prsr = arg::Parser::from_env(ctx);

  prsr.add(help_spec)?;
  prsr.add(coll_spec)?;

  prsr.parse()?;

  //let ctx = prsr.into_ctx();
  if prsr.get_ctx().do_help == true {
    prsr.usage(&mut std::io::stdout());
    std::process::exit(0);
  }

  println!("{:?}", prsr.get_ctx());

  Ok(())
}

examples/remaining.rs (line 58)

fn main() -> Result<(), Box<dyn std::error::Error>> {
  let help_spec = arg::Builder::new()
    .sopt('h')
    .lopt("help")
    .exit(true)
    .help(&["Show this help."])
    .build(help_proc);
  let exec_spec = arg::Builder::new()
    .name("exec")
    .nargs(arg::Nargs::Count(1), &["PRG"])
    .help(&["The executable to run."])
    .build(exec_proc);
  let eargs_spec = arg::Builder::new()
    .name("execargs")
    .nargs(arg::Nargs::Remainder, &["PRGARG"])
    .help(&["arguments to pass to the executable."])
    .build(eargs_proc);

  let ctx = MyContext {
    ..Default::default()
  };
  let mut prsr = arg::Parser::from_env(ctx);

  prsr.add(help_spec)?;
  prsr.add(exec_spec)?;
  prsr.add(eargs_spec)?;

  prsr.parse()?;

  if prsr.get_ctx().do_help == true {
    prsr.usage(&mut std::io::stdout());
    std::process::exit(0);
  }

  let ctx = prsr.into_ctx();

  println!("{:?}", &ctx);

  Ok(())
}

examples/hidden.rs (line 47)

fn main() -> Result<(), Box<dyn std::error::Error>> {
  let help_spec = arg::Builder::new()
    .sopt('h')
    .lopt("help")
    .exit(true)
    .help(&["Show this help."])
    .build(
      |_spec: &arg::Spec<MyContext>,
       ctx: &mut MyContext,
       _args: &Vec<String>| ctx.do_help = true
    );
  let version_spec = arg::Builder::new()
    .sopt('V')
    .lopt("version")
    .exit(true)
    .help(&["Output tool version and exit."])
    .build(
      |_spec: &arg::Spec<MyContext>,
       ctx: &mut MyContext,
       _args: &Vec<String>| ctx.do_version = true
    );
  let secret_spec = arg::Builder::new()
    .sopt('s')
    .lopt("secret")
    .hidden(true)
    .help(&["A hidden option."])
    .build(
      |_spec: &arg::Spec<MyContext>,
       ctx: &mut MyContext,
       _args: &Vec<String>| ctx.do_secret = true
    );


  let ctx = MyContext {
    ..Default::default()
  };
  let mut prsr = arg::Parser::from_env(ctx);

  prsr.add(help_spec)?;
  prsr.add(version_spec)?;
  prsr.add(secret_spec)?;

  prsr.parse()?;

  if prsr.get_ctx().do_help == true {
    prsr.usage(&mut std::io::stdout());
    std::process::exit(0);
  }

  let ctx = prsr.into_ctx();

  println!("{:?}", &ctx);

  Ok(())
}

examples/usage.rs (line 56)

fn main() -> Result<(), Box<dyn std::error::Error>> {
  let help_spec = arg::Builder::new()
    .sopt('h')
    .lopt("help")
    .exit(true)
    .help(&["Show this help."])
    .build(|_spec, ctx: &mut MyContext, _args| {
      ctx.do_help = true;
    });
  let version_spec = arg::Builder::new()
    .sopt('V')
    .lopt("version")
    .exit(true)
    .help(&["Output tool version and exit."])
    .build(
      |_spec: &arg::Spec<MyContext>,
       ctx: &mut MyContext,
       _args: &Vec<String>| ctx.do_version = true
    );
  let tophelp_spec = arg::Builder::new()
    .sopt('t')
    .lopt("tophelp")
    .help(&["Show top help."])
    .build(|_spec, ctx: &mut MyContext, _args| {
      ctx.tophelp = true;
    });
  let bottomhelp_spec = arg::Builder::new()
    .sopt('b')
    .lopt("bottomhelp")
    .help(&["Show bottom help."])
    .build(|_spec, ctx: &mut MyContext, _args| {
      ctx.bottomhelp = true;
    });

  let ctx = MyContext {
    ..Default::default()
  };
  let mut prsr = arg::Parser::from_env(ctx);

  prsr.add(help_spec)?;
  prsr.add(version_spec)?;
  prsr.add(tophelp_spec)?;
  prsr.add(bottomhelp_spec)?;

  prsr.parse()?;

  if prsr.get_ctx().do_help == true {
    prsr.usage(&mut std::io::stdout());
    std::process::exit(0);
  }

  if prsr.get_ctx().do_version == true {
    const VERSION: &'static str = env!("CARGO_PKG_VERSION");
    println!("usage {}", VERSION);
    std::process::exit(0);
  }

  let ctx = prsr.into_ctx();

  println!("{:?}", &ctx);

  usage_test(ctx)?;

  Ok(())
}

examples/simple.rs (line 122)

fn main() -> Result<(), Box<dyn std::error::Error>> {
  let help_spec = arg::Builder::new()
    .sopt('h')
    .lopt("help")
    .exit(true)
    .help(&["Show this help."])
    .build(help_proc);
  let verbose_spec = arg::Builder::new()
    .sopt('v')
    .lopt("verbose")
    .help(&["Increase level of verbosity.", "Be quiet by default."])
    .build(verbose_proc);
  let version_spec = arg::Builder::new()
    .sopt('V')
    .lopt("version")
    .exit(true)
    .help(&["Output tool version and exit."])
    .build(
      |_spec: &arg::Spec<MyContext>,
       ctx: &mut MyContext,
       _args: &Vec<String>| ctx.do_version = true
    );
  let file_spec = arg::Builder::new()
    .sopt('f')
    .lopt("file")
    .help(&["Use data in FILE."])
    .nargs(arg::Nargs::Count(1), &["FILE"])
    .build(file_proc);
  let param_spec = arg::Builder::new()
    .sopt('p')
    .lopt("param")
    .help(&["Add a key/value parameter field. The key must be unique."])
    .nargs(arg::Nargs::Count(2), &["KEY", "VALUE"])
    .build(param_proc);
  let cmd_spec = arg::Builder::new()
    .name("command")
    .required(true)
    .nargs(arg::Nargs::Count(1), &["COMMAND"])
    .help(&["The command to run."])
    .build(cmd_proc);
  let subcmd_spec = arg::Builder::new()
    .name("subcmd")
    .nargs(arg::Nargs::Count(1), &["SUBCMD"])
    .help(&["Command-specific sub-command."])
    .build(subcmd_proc);


  let ctx = MyContext {
    ..Default::default()
  };
  let mut prsr = arg::Parser::from_env(ctx);

  prsr.add(help_spec)?;
  prsr.add(verbose_spec)?;
  prsr.add(version_spec)?;
  prsr.add(file_spec)?;
  prsr.add(param_spec)?;
  prsr.add(cmd_spec)?;
  prsr.add(subcmd_spec)?;

  prsr.parse()?;

  if prsr.get_ctx().do_help == true {
    prsr.usage(&mut std::io::stdout());
    std::process::exit(0);
  }

  let ctx = prsr.into_ctx();

  println!("{:?}", &ctx);

  Ok(())
}

pub fn from_args<I, S>(argv0: &str, args: I, ctx: C) -> Self

where I: IntoIterator<Item = S>, S: AsRef<str>,

Examples found in repository

examples/usage.rs (line 140)

fn usage_test(ctx: MyContext) -> Result<(), Box<dyn std::error::Error>> {
  let help_spec = arg::Builder::new()
    .sopt('h')
    .lopt("help")
    .exit(true)
    .help(&["Show this help."])
    .build(|_spec, ctx: &mut MyContext, _args| {
      ctx.do_help = true;
    });
  let version_spec = arg::Builder::new()
    .sopt('V')
    .lopt("version")
    .exit(true)
    .help(&["Output tool version and exit."])
    .build(
      |_spec: &arg::Spec<MyContext>,
       ctx: &mut MyContext,
       _args: &Vec<String>| ctx.do_version = true
    );
  let file_spec = arg::Builder::new()
    .sopt('f')
    .lopt("file")
    .help(&["Use data in FILE."])
    .nargs(arg::Nargs::Count(1), &["FILE"])
    .build(|_spec, ctx: &mut MyContext, args| {
      ctx.fname = args[0].clone();
    });
  let param_spec = arg::Builder::new()
    .sopt('p')
    .lopt("param")
    .help(&["Add a key/value parameter field. The key must be unique."])
    .nargs(arg::Nargs::Count(2), &["KEY", "VALUE"])
    .build(|_spec, ctx: &mut MyContext, args| {
      ctx.params.insert(args[0].clone(), args[1].clone());
    });
  let cmd_spec = arg::Builder::new()
    .name("command")
    .required(true)
    .nargs(arg::Nargs::Count(1), &["COMMAND"])
    .help(&["The command to run."])
    .build(|_spec, ctx: &mut MyContext, args| {
      ctx.cmd = args[0].clone();
    });
  let subcmd_spec = arg::Builder::new()
    .name("subcmd")
    .nargs(arg::Nargs::Count(1), &["SUBCMD"])
    .help(&["Command-specific sub-command."])
    .build(|_spec, ctx: &mut MyContext, args| {
      ctx.subcmd = args[0].clone();
    });

  let ctx2 = MyContext {
    ..Default::default()
  };
  let mut prsr = arg::Parser::from_args("hello", &["--help"], ctx2);

  if ctx.tophelp {
    prsr.set_tophelp(&[
      "\"You know,\" said Arthur, \"it's at times like this, when I'm \
       trapped in a Vogon airlock with a man from Betelgeuse, and about to \
       die of asphyxiation in deep space that I really wish I'd listened to \
       what my mother told me when I was young.\"",
      "\"Why, what did she tell you?\"",
      "\"I don't know, I didn't listen.\""
    ]);
  }
  if ctx.bottomhelp {
    prsr.set_bottomhelp(&[
      "\"So this is it,\" said Arthur, \"We are going to die.\"",
      "\"Yes,\" said Ford, \"except... no! Wait a minute!\" He suddenly \
       lunged across the chamber at something behind Arthur's line of \
       vision. \"What's this switch?\" he cried.",
      "\"What? Where?\" cried Arthur, twisting round.",
      "\"No, I was only fooling,\" said Ford, \"we are going to die after \
       all.\""
    ]);
  }

  prsr.add(help_spec)?;
  prsr.add(version_spec)?;
  prsr.add(file_spec)?;
  prsr.add(param_spec)?;
  prsr.add(cmd_spec)?;
  prsr.add(subcmd_spec)?;

  prsr.parse()?;

  if prsr.get_ctx().do_help == true {
    prsr.usage(&mut std::io::stdout());
    std::process::exit(0);
  }

  let ctx = prsr.into_ctx();

  println!("{:?}", &ctx);

  Ok(())
}

pub fn add(&mut self, spec: Spec<C>) -> Result<(), ErrKind<C>>

Examples found in repository

examples/conflict.rs (line 37)

fn main() -> Result<(), Box<dyn std::error::Error>> {
  let help_spec = arg::Builder::new()
    .sopt('h')
    .lopt("help")
    .exit(true)
    .help(&["Show this help."])
    .build(help_proc);
  let coll_spec = arg::Builder::new()
    .sopt('h')
    .lopt("hulp")
    .exit(true)
    .help(&["Show this help."])
    .build(help_proc);


  let ctx = MyContext {
    ..Default::default()
  };
  let mut prsr = arg::Parser::from_env(ctx);

  prsr.add(help_spec)?;
  prsr.add(coll_spec)?;

  prsr.parse()?;

  //let ctx = prsr.into_ctx();
  if prsr.get_ctx().do_help == true {
    prsr.usage(&mut std::io::stdout());
    std::process::exit(0);
  }

  println!("{:?}", prsr.get_ctx());

  Ok(())
}

examples/remaining.rs (line 60)

fn main() -> Result<(), Box<dyn std::error::Error>> {
  let help_spec = arg::Builder::new()
    .sopt('h')
    .lopt("help")
    .exit(true)
    .help(&["Show this help."])
    .build(help_proc);
  let exec_spec = arg::Builder::new()
    .name("exec")
    .nargs(arg::Nargs::Count(1), &["PRG"])
    .help(&["The executable to run."])
    .build(exec_proc);
  let eargs_spec = arg::Builder::new()
    .name("execargs")
    .nargs(arg::Nargs::Remainder, &["PRGARG"])
    .help(&["arguments to pass to the executable."])
    .build(eargs_proc);

  let ctx = MyContext {
    ..Default::default()
  };
  let mut prsr = arg::Parser::from_env(ctx);

  prsr.add(help_spec)?;
  prsr.add(exec_spec)?;
  prsr.add(eargs_spec)?;

  prsr.parse()?;

  if prsr.get_ctx().do_help == true {
    prsr.usage(&mut std::io::stdout());
    std::process::exit(0);
  }

  let ctx = prsr.into_ctx();

  println!("{:?}", &ctx);

  Ok(())
}

examples/hidden.rs (line 49)

fn main() -> Result<(), Box<dyn std::error::Error>> {
  let help_spec = arg::Builder::new()
    .sopt('h')
    .lopt("help")
    .exit(true)
    .help(&["Show this help."])
    .build(
      |_spec: &arg::Spec<MyContext>,
       ctx: &mut MyContext,
       _args: &Vec<String>| ctx.do_help = true
    );
  let version_spec = arg::Builder::new()
    .sopt('V')
    .lopt("version")
    .exit(true)
    .help(&["Output tool version and exit."])
    .build(
      |_spec: &arg::Spec<MyContext>,
       ctx: &mut MyContext,
       _args: &Vec<String>| ctx.do_version = true
    );
  let secret_spec = arg::Builder::new()
    .sopt('s')
    .lopt("secret")
    .hidden(true)
    .help(&["A hidden option."])
    .build(
      |_spec: &arg::Spec<MyContext>,
       ctx: &mut MyContext,
       _args: &Vec<String>| ctx.do_secret = true
    );


  let ctx = MyContext {
    ..Default::default()
  };
  let mut prsr = arg::Parser::from_env(ctx);

  prsr.add(help_spec)?;
  prsr.add(version_spec)?;
  prsr.add(secret_spec)?;

  prsr.parse()?;

  if prsr.get_ctx().do_help == true {
    prsr.usage(&mut std::io::stdout());
    std::process::exit(0);
  }

  let ctx = prsr.into_ctx();

  println!("{:?}", &ctx);

  Ok(())
}

examples/usage.rs (line 58)

fn main() -> Result<(), Box<dyn std::error::Error>> {
  let help_spec = arg::Builder::new()
    .sopt('h')
    .lopt("help")
    .exit(true)
    .help(&["Show this help."])
    .build(|_spec, ctx: &mut MyContext, _args| {
      ctx.do_help = true;
    });
  let version_spec = arg::Builder::new()
    .sopt('V')
    .lopt("version")
    .exit(true)
    .help(&["Output tool version and exit."])
    .build(
      |_spec: &arg::Spec<MyContext>,
       ctx: &mut MyContext,
       _args: &Vec<String>| ctx.do_version = true
    );
  let tophelp_spec = arg::Builder::new()
    .sopt('t')
    .lopt("tophelp")
    .help(&["Show top help."])
    .build(|_spec, ctx: &mut MyContext, _args| {
      ctx.tophelp = true;
    });
  let bottomhelp_spec = arg::Builder::new()
    .sopt('b')
    .lopt("bottomhelp")
    .help(&["Show bottom help."])
    .build(|_spec, ctx: &mut MyContext, _args| {
      ctx.bottomhelp = true;
    });

  let ctx = MyContext {
    ..Default::default()
  };
  let mut prsr = arg::Parser::from_env(ctx);

  prsr.add(help_spec)?;
  prsr.add(version_spec)?;
  prsr.add(tophelp_spec)?;
  prsr.add(bottomhelp_spec)?;

  prsr.parse()?;

  if prsr.get_ctx().do_help == true {
    prsr.usage(&mut std::io::stdout());
    std::process::exit(0);
  }

  if prsr.get_ctx().do_version == true {
    const VERSION: &'static str = env!("CARGO_PKG_VERSION");
    println!("usage {}", VERSION);
    std::process::exit(0);
  }

  let ctx = prsr.into_ctx();

  println!("{:?}", &ctx);

  usage_test(ctx)?;

  Ok(())
}


fn usage_test(ctx: MyContext) -> Result<(), Box<dyn std::error::Error>> {
  let help_spec = arg::Builder::new()
    .sopt('h')
    .lopt("help")
    .exit(true)
    .help(&["Show this help."])
    .build(|_spec, ctx: &mut MyContext, _args| {
      ctx.do_help = true;
    });
  let version_spec = arg::Builder::new()
    .sopt('V')
    .lopt("version")
    .exit(true)
    .help(&["Output tool version and exit."])
    .build(
      |_spec: &arg::Spec<MyContext>,
       ctx: &mut MyContext,
       _args: &Vec<String>| ctx.do_version = true
    );
  let file_spec = arg::Builder::new()
    .sopt('f')
    .lopt("file")
    .help(&["Use data in FILE."])
    .nargs(arg::Nargs::Count(1), &["FILE"])
    .build(|_spec, ctx: &mut MyContext, args| {
      ctx.fname = args[0].clone();
    });
  let param_spec = arg::Builder::new()
    .sopt('p')
    .lopt("param")
    .help(&["Add a key/value parameter field. The key must be unique."])
    .nargs(arg::Nargs::Count(2), &["KEY", "VALUE"])
    .build(|_spec, ctx: &mut MyContext, args| {
      ctx.params.insert(args[0].clone(), args[1].clone());
    });
  let cmd_spec = arg::Builder::new()
    .name("command")
    .required(true)
    .nargs(arg::Nargs::Count(1), &["COMMAND"])
    .help(&["The command to run."])
    .build(|_spec, ctx: &mut MyContext, args| {
      ctx.cmd = args[0].clone();
    });
  let subcmd_spec = arg::Builder::new()
    .name("subcmd")
    .nargs(arg::Nargs::Count(1), &["SUBCMD"])
    .help(&["Command-specific sub-command."])
    .build(|_spec, ctx: &mut MyContext, args| {
      ctx.subcmd = args[0].clone();
    });

  let ctx2 = MyContext {
    ..Default::default()
  };
  let mut prsr = arg::Parser::from_args("hello", &["--help"], ctx2);

  if ctx.tophelp {
    prsr.set_tophelp(&[
      "\"You know,\" said Arthur, \"it's at times like this, when I'm \
       trapped in a Vogon airlock with a man from Betelgeuse, and about to \
       die of asphyxiation in deep space that I really wish I'd listened to \
       what my mother told me when I was young.\"",
      "\"Why, what did she tell you?\"",
      "\"I don't know, I didn't listen.\""
    ]);
  }
  if ctx.bottomhelp {
    prsr.set_bottomhelp(&[
      "\"So this is it,\" said Arthur, \"We are going to die.\"",
      "\"Yes,\" said Ford, \"except... no! Wait a minute!\" He suddenly \
       lunged across the chamber at something behind Arthur's line of \
       vision. \"What's this switch?\" he cried.",
      "\"What? Where?\" cried Arthur, twisting round.",
      "\"No, I was only fooling,\" said Ford, \"we are going to die after \
       all.\""
    ]);
  }

  prsr.add(help_spec)?;
  prsr.add(version_spec)?;
  prsr.add(file_spec)?;
  prsr.add(param_spec)?;
  prsr.add(cmd_spec)?;
  prsr.add(subcmd_spec)?;

  prsr.parse()?;

  if prsr.get_ctx().do_help == true {
    prsr.usage(&mut std::io::stdout());
    std::process::exit(0);
  }

  let ctx = prsr.into_ctx();

  println!("{:?}", &ctx);

  Ok(())
}

examples/simple.rs (line 124)

fn main() -> Result<(), Box<dyn std::error::Error>> {
  let help_spec = arg::Builder::new()
    .sopt('h')
    .lopt("help")
    .exit(true)
    .help(&["Show this help."])
    .build(help_proc);
  let verbose_spec = arg::Builder::new()
    .sopt('v')
    .lopt("verbose")
    .help(&["Increase level of verbosity.", "Be quiet by default."])
    .build(verbose_proc);
  let version_spec = arg::Builder::new()
    .sopt('V')
    .lopt("version")
    .exit(true)
    .help(&["Output tool version and exit."])
    .build(
      |_spec: &arg::Spec<MyContext>,
       ctx: &mut MyContext,
       _args: &Vec<String>| ctx.do_version = true
    );
  let file_spec = arg::Builder::new()
    .sopt('f')
    .lopt("file")
    .help(&["Use data in FILE."])
    .nargs(arg::Nargs::Count(1), &["FILE"])
    .build(file_proc);
  let param_spec = arg::Builder::new()
    .sopt('p')
    .lopt("param")
    .help(&["Add a key/value parameter field. The key must be unique."])
    .nargs(arg::Nargs::Count(2), &["KEY", "VALUE"])
    .build(param_proc);
  let cmd_spec = arg::Builder::new()
    .name("command")
    .required(true)
    .nargs(arg::Nargs::Count(1), &["COMMAND"])
    .help(&["The command to run."])
    .build(cmd_proc);
  let subcmd_spec = arg::Builder::new()
    .name("subcmd")
    .nargs(arg::Nargs::Count(1), &["SUBCMD"])
    .help(&["Command-specific sub-command."])
    .build(subcmd_proc);


  let ctx = MyContext {
    ..Default::default()
  };
  let mut prsr = arg::Parser::from_env(ctx);

  prsr.add(help_spec)?;
  prsr.add(verbose_spec)?;
  prsr.add(version_spec)?;
  prsr.add(file_spec)?;
  prsr.add(param_spec)?;
  prsr.add(cmd_spec)?;
  prsr.add(subcmd_spec)?;

  prsr.parse()?;

  if prsr.get_ctx().do_help == true {
    prsr.usage(&mut std::io::stdout());
    std::process::exit(0);
  }

  let ctx = prsr.into_ctx();

  println!("{:?}", &ctx);

  Ok(())
}

pub fn get_arg0(&self) -> &str

pub fn get_remaining_args(&mut self) -> Vec<String>

pub fn have_capture_rest(&self) -> bool

pub fn set_tophelp<I, S>(&mut self, p: I)

where I: IntoIterator<Item = S>, S: ToString,

Examples found in repository

examples/usage.rs (lines 143-150)

fn usage_test(ctx: MyContext) -> Result<(), Box<dyn std::error::Error>> {
  let help_spec = arg::Builder::new()
    .sopt('h')
    .lopt("help")
    .exit(true)
    .help(&["Show this help."])
    .build(|_spec, ctx: &mut MyContext, _args| {
      ctx.do_help = true;
    });
  let version_spec = arg::Builder::new()
    .sopt('V')
    .lopt("version")
    .exit(true)
    .help(&["Output tool version and exit."])
    .build(
      |_spec: &arg::Spec<MyContext>,
       ctx: &mut MyContext,
       _args: &Vec<String>| ctx.do_version = true
    );
  let file_spec = arg::Builder::new()
    .sopt('f')
    .lopt("file")
    .help(&["Use data in FILE."])
    .nargs(arg::Nargs::Count(1), &["FILE"])
    .build(|_spec, ctx: &mut MyContext, args| {
      ctx.fname = args[0].clone();
    });
  let param_spec = arg::Builder::new()
    .sopt('p')
    .lopt("param")
    .help(&["Add a key/value parameter field. The key must be unique."])
    .nargs(arg::Nargs::Count(2), &["KEY", "VALUE"])
    .build(|_spec, ctx: &mut MyContext, args| {
      ctx.params.insert(args[0].clone(), args[1].clone());
    });
  let cmd_spec = arg::Builder::new()
    .name("command")
    .required(true)
    .nargs(arg::Nargs::Count(1), &["COMMAND"])
    .help(&["The command to run."])
    .build(|_spec, ctx: &mut MyContext, args| {
      ctx.cmd = args[0].clone();
    });
  let subcmd_spec = arg::Builder::new()
    .name("subcmd")
    .nargs(arg::Nargs::Count(1), &["SUBCMD"])
    .help(&["Command-specific sub-command."])
    .build(|_spec, ctx: &mut MyContext, args| {
      ctx.subcmd = args[0].clone();
    });

  let ctx2 = MyContext {
    ..Default::default()
  };
  let mut prsr = arg::Parser::from_args("hello", &["--help"], ctx2);

  if ctx.tophelp {
    prsr.set_tophelp(&[
      "\"You know,\" said Arthur, \"it's at times like this, when I'm \
       trapped in a Vogon airlock with a man from Betelgeuse, and about to \
       die of asphyxiation in deep space that I really wish I'd listened to \
       what my mother told me when I was young.\"",
      "\"Why, what did she tell you?\"",
      "\"I don't know, I didn't listen.\""
    ]);
  }
  if ctx.bottomhelp {
    prsr.set_bottomhelp(&[
      "\"So this is it,\" said Arthur, \"We are going to die.\"",
      "\"Yes,\" said Ford, \"except... no! Wait a minute!\" He suddenly \
       lunged across the chamber at something behind Arthur's line of \
       vision. \"What's this switch?\" he cried.",
      "\"What? Where?\" cried Arthur, twisting round.",
      "\"No, I was only fooling,\" said Ford, \"we are going to die after \
       all.\""
    ]);
  }

  prsr.add(help_spec)?;
  prsr.add(version_spec)?;
  prsr.add(file_spec)?;
  prsr.add(param_spec)?;
  prsr.add(cmd_spec)?;
  prsr.add(subcmd_spec)?;

  prsr.parse()?;

  if prsr.get_ctx().do_help == true {
    prsr.usage(&mut std::io::stdout());
    std::process::exit(0);
  }

  let ctx = prsr.into_ctx();

  println!("{:?}", &ctx);

  Ok(())
}

pub fn append_tophelp<I, S>(&mut self, p: I)

where I: IntoIterator<Item = S>, S: ToString,

pub fn set_bottomhelp<I, S>(&mut self, p: I)

where I: IntoIterator<Item = S>, S: ToString,

Examples found in repository

examples/usage.rs (lines 153-161)

fn usage_test(ctx: MyContext) -> Result<(), Box<dyn std::error::Error>> {
  let help_spec = arg::Builder::new()
    .sopt('h')
    .lopt("help")
    .exit(true)
    .help(&["Show this help."])
    .build(|_spec, ctx: &mut MyContext, _args| {
      ctx.do_help = true;
    });
  let version_spec = arg::Builder::new()
    .sopt('V')
    .lopt("version")
    .exit(true)
    .help(&["Output tool version and exit."])
    .build(
      |_spec: &arg::Spec<MyContext>,
       ctx: &mut MyContext,
       _args: &Vec<String>| ctx.do_version = true
    );
  let file_spec = arg::Builder::new()
    .sopt('f')
    .lopt("file")
    .help(&["Use data in FILE."])
    .nargs(arg::Nargs::Count(1), &["FILE"])
    .build(|_spec, ctx: &mut MyContext, args| {
      ctx.fname = args[0].clone();
    });
  let param_spec = arg::Builder::new()
    .sopt('p')
    .lopt("param")
    .help(&["Add a key/value parameter field. The key must be unique."])
    .nargs(arg::Nargs::Count(2), &["KEY", "VALUE"])
    .build(|_spec, ctx: &mut MyContext, args| {
      ctx.params.insert(args[0].clone(), args[1].clone());
    });
  let cmd_spec = arg::Builder::new()
    .name("command")
    .required(true)
    .nargs(arg::Nargs::Count(1), &["COMMAND"])
    .help(&["The command to run."])
    .build(|_spec, ctx: &mut MyContext, args| {
      ctx.cmd = args[0].clone();
    });
  let subcmd_spec = arg::Builder::new()
    .name("subcmd")
    .nargs(arg::Nargs::Count(1), &["SUBCMD"])
    .help(&["Command-specific sub-command."])
    .build(|_spec, ctx: &mut MyContext, args| {
      ctx.subcmd = args[0].clone();
    });

  let ctx2 = MyContext {
    ..Default::default()
  };
  let mut prsr = arg::Parser::from_args("hello", &["--help"], ctx2);

  if ctx.tophelp {
    prsr.set_tophelp(&[
      "\"You know,\" said Arthur, \"it's at times like this, when I'm \
       trapped in a Vogon airlock with a man from Betelgeuse, and about to \
       die of asphyxiation in deep space that I really wish I'd listened to \
       what my mother told me when I was young.\"",
      "\"Why, what did she tell you?\"",
      "\"I don't know, I didn't listen.\""
    ]);
  }
  if ctx.bottomhelp {
    prsr.set_bottomhelp(&[
      "\"So this is it,\" said Arthur, \"We are going to die.\"",
      "\"Yes,\" said Ford, \"except... no! Wait a minute!\" He suddenly \
       lunged across the chamber at something behind Arthur's line of \
       vision. \"What's this switch?\" he cried.",
      "\"What? Where?\" cried Arthur, twisting round.",
      "\"No, I was only fooling,\" said Ford, \"we are going to die after \
       all.\""
    ]);
  }

  prsr.add(help_spec)?;
  prsr.add(version_spec)?;
  prsr.add(file_spec)?;
  prsr.add(param_spec)?;
  prsr.add(cmd_spec)?;
  prsr.add(subcmd_spec)?;

  prsr.parse()?;

  if prsr.get_ctx().do_help == true {
    prsr.usage(&mut std::io::stdout());
    std::process::exit(0);
  }

  let ctx = prsr.into_ctx();

  println!("{:?}", &ctx);

  Ok(())
}

pub fn append_bottomhelp<I, S>(&mut self, p: I)

where I: IntoIterator<Item = S>, S: ToString,

pub fn parse(&mut self) -> Result<Option<Rc<RefCell<Spec<C>>>>, ErrKind<C>>

Examples found in repository

examples/conflict.rs (line 40)

fn main() -> Result<(), Box<dyn std::error::Error>> {
  let help_spec = arg::Builder::new()
    .sopt('h')
    .lopt("help")
    .exit(true)
    .help(&["Show this help."])
    .build(help_proc);
  let coll_spec = arg::Builder::new()
    .sopt('h')
    .lopt("hulp")
    .exit(true)
    .help(&["Show this help."])
    .build(help_proc);


  let ctx = MyContext {
    ..Default::default()
  };
  let mut prsr = arg::Parser::from_env(ctx);

  prsr.add(help_spec)?;
  prsr.add(coll_spec)?;

  prsr.parse()?;

  //let ctx = prsr.into_ctx();
  if prsr.get_ctx().do_help == true {
    prsr.usage(&mut std::io::stdout());
    std::process::exit(0);
  }

  println!("{:?}", prsr.get_ctx());

  Ok(())
}

examples/remaining.rs (line 64)

fn main() -> Result<(), Box<dyn std::error::Error>> {
  let help_spec = arg::Builder::new()
    .sopt('h')
    .lopt("help")
    .exit(true)
    .help(&["Show this help."])
    .build(help_proc);
  let exec_spec = arg::Builder::new()
    .name("exec")
    .nargs(arg::Nargs::Count(1), &["PRG"])
    .help(&["The executable to run."])
    .build(exec_proc);
  let eargs_spec = arg::Builder::new()
    .name("execargs")
    .nargs(arg::Nargs::Remainder, &["PRGARG"])
    .help(&["arguments to pass to the executable."])
    .build(eargs_proc);

  let ctx = MyContext {
    ..Default::default()
  };
  let mut prsr = arg::Parser::from_env(ctx);

  prsr.add(help_spec)?;
  prsr.add(exec_spec)?;
  prsr.add(eargs_spec)?;

  prsr.parse()?;

  if prsr.get_ctx().do_help == true {
    prsr.usage(&mut std::io::stdout());
    std::process::exit(0);
  }

  let ctx = prsr.into_ctx();

  println!("{:?}", &ctx);

  Ok(())
}

examples/hidden.rs (line 53)

fn main() -> Result<(), Box<dyn std::error::Error>> {
  let help_spec = arg::Builder::new()
    .sopt('h')
    .lopt("help")
    .exit(true)
    .help(&["Show this help."])
    .build(
      |_spec: &arg::Spec<MyContext>,
       ctx: &mut MyContext,
       _args: &Vec<String>| ctx.do_help = true
    );
  let version_spec = arg::Builder::new()
    .sopt('V')
    .lopt("version")
    .exit(true)
    .help(&["Output tool version and exit."])
    .build(
      |_spec: &arg::Spec<MyContext>,
       ctx: &mut MyContext,
       _args: &Vec<String>| ctx.do_version = true
    );
  let secret_spec = arg::Builder::new()
    .sopt('s')
    .lopt("secret")
    .hidden(true)
    .help(&["A hidden option."])
    .build(
      |_spec: &arg::Spec<MyContext>,
       ctx: &mut MyContext,
       _args: &Vec<String>| ctx.do_secret = true
    );


  let ctx = MyContext {
    ..Default::default()
  };
  let mut prsr = arg::Parser::from_env(ctx);

  prsr.add(help_spec)?;
  prsr.add(version_spec)?;
  prsr.add(secret_spec)?;

  prsr.parse()?;

  if prsr.get_ctx().do_help == true {
    prsr.usage(&mut std::io::stdout());
    std::process::exit(0);
  }

  let ctx = prsr.into_ctx();

  println!("{:?}", &ctx);

  Ok(())
}

examples/usage.rs (line 63)

fn main() -> Result<(), Box<dyn std::error::Error>> {
  let help_spec = arg::Builder::new()
    .sopt('h')
    .lopt("help")
    .exit(true)
    .help(&["Show this help."])
    .build(|_spec, ctx: &mut MyContext, _args| {
      ctx.do_help = true;
    });
  let version_spec = arg::Builder::new()
    .sopt('V')
    .lopt("version")
    .exit(true)
    .help(&["Output tool version and exit."])
    .build(
      |_spec: &arg::Spec<MyContext>,
       ctx: &mut MyContext,
       _args: &Vec<String>| ctx.do_version = true
    );
  let tophelp_spec = arg::Builder::new()
    .sopt('t')
    .lopt("tophelp")
    .help(&["Show top help."])
    .build(|_spec, ctx: &mut MyContext, _args| {
      ctx.tophelp = true;
    });
  let bottomhelp_spec = arg::Builder::new()
    .sopt('b')
    .lopt("bottomhelp")
    .help(&["Show bottom help."])
    .build(|_spec, ctx: &mut MyContext, _args| {
      ctx.bottomhelp = true;
    });

  let ctx = MyContext {
    ..Default::default()
  };
  let mut prsr = arg::Parser::from_env(ctx);

  prsr.add(help_spec)?;
  prsr.add(version_spec)?;
  prsr.add(tophelp_spec)?;
  prsr.add(bottomhelp_spec)?;

  prsr.parse()?;

  if prsr.get_ctx().do_help == true {
    prsr.usage(&mut std::io::stdout());
    std::process::exit(0);
  }

  if prsr.get_ctx().do_version == true {
    const VERSION: &'static str = env!("CARGO_PKG_VERSION");
    println!("usage {}", VERSION);
    std::process::exit(0);
  }

  let ctx = prsr.into_ctx();

  println!("{:?}", &ctx);

  usage_test(ctx)?;

  Ok(())
}


fn usage_test(ctx: MyContext) -> Result<(), Box<dyn std::error::Error>> {
  let help_spec = arg::Builder::new()
    .sopt('h')
    .lopt("help")
    .exit(true)
    .help(&["Show this help."])
    .build(|_spec, ctx: &mut MyContext, _args| {
      ctx.do_help = true;
    });
  let version_spec = arg::Builder::new()
    .sopt('V')
    .lopt("version")
    .exit(true)
    .help(&["Output tool version and exit."])
    .build(
      |_spec: &arg::Spec<MyContext>,
       ctx: &mut MyContext,
       _args: &Vec<String>| ctx.do_version = true
    );
  let file_spec = arg::Builder::new()
    .sopt('f')
    .lopt("file")
    .help(&["Use data in FILE."])
    .nargs(arg::Nargs::Count(1), &["FILE"])
    .build(|_spec, ctx: &mut MyContext, args| {
      ctx.fname = args[0].clone();
    });
  let param_spec = arg::Builder::new()
    .sopt('p')
    .lopt("param")
    .help(&["Add a key/value parameter field. The key must be unique."])
    .nargs(arg::Nargs::Count(2), &["KEY", "VALUE"])
    .build(|_spec, ctx: &mut MyContext, args| {
      ctx.params.insert(args[0].clone(), args[1].clone());
    });
  let cmd_spec = arg::Builder::new()
    .name("command")
    .required(true)
    .nargs(arg::Nargs::Count(1), &["COMMAND"])
    .help(&["The command to run."])
    .build(|_spec, ctx: &mut MyContext, args| {
      ctx.cmd = args[0].clone();
    });
  let subcmd_spec = arg::Builder::new()
    .name("subcmd")
    .nargs(arg::Nargs::Count(1), &["SUBCMD"])
    .help(&["Command-specific sub-command."])
    .build(|_spec, ctx: &mut MyContext, args| {
      ctx.subcmd = args[0].clone();
    });

  let ctx2 = MyContext {
    ..Default::default()
  };
  let mut prsr = arg::Parser::from_args("hello", &["--help"], ctx2);

  if ctx.tophelp {
    prsr.set_tophelp(&[
      "\"You know,\" said Arthur, \"it's at times like this, when I'm \
       trapped in a Vogon airlock with a man from Betelgeuse, and about to \
       die of asphyxiation in deep space that I really wish I'd listened to \
       what my mother told me when I was young.\"",
      "\"Why, what did she tell you?\"",
      "\"I don't know, I didn't listen.\""
    ]);
  }
  if ctx.bottomhelp {
    prsr.set_bottomhelp(&[
      "\"So this is it,\" said Arthur, \"We are going to die.\"",
      "\"Yes,\" said Ford, \"except... no! Wait a minute!\" He suddenly \
       lunged across the chamber at something behind Arthur's line of \
       vision. \"What's this switch?\" he cried.",
      "\"What? Where?\" cried Arthur, twisting round.",
      "\"No, I was only fooling,\" said Ford, \"we are going to die after \
       all.\""
    ]);
  }

  prsr.add(help_spec)?;
  prsr.add(version_spec)?;
  prsr.add(file_spec)?;
  prsr.add(param_spec)?;
  prsr.add(cmd_spec)?;
  prsr.add(subcmd_spec)?;

  prsr.parse()?;

  if prsr.get_ctx().do_help == true {
    prsr.usage(&mut std::io::stdout());
    std::process::exit(0);
  }

  let ctx = prsr.into_ctx();

  println!("{:?}", &ctx);

  Ok(())
}

examples/simple.rs (line 132)

fn main() -> Result<(), Box<dyn std::error::Error>> {
  let help_spec = arg::Builder::new()
    .sopt('h')
    .lopt("help")
    .exit(true)
    .help(&["Show this help."])
    .build(help_proc);
  let verbose_spec = arg::Builder::new()
    .sopt('v')
    .lopt("verbose")
    .help(&["Increase level of verbosity.", "Be quiet by default."])
    .build(verbose_proc);
  let version_spec = arg::Builder::new()
    .sopt('V')
    .lopt("version")
    .exit(true)
    .help(&["Output tool version and exit."])
    .build(
      |_spec: &arg::Spec<MyContext>,
       ctx: &mut MyContext,
       _args: &Vec<String>| ctx.do_version = true
    );
  let file_spec = arg::Builder::new()
    .sopt('f')
    .lopt("file")
    .help(&["Use data in FILE."])
    .nargs(arg::Nargs::Count(1), &["FILE"])
    .build(file_proc);
  let param_spec = arg::Builder::new()
    .sopt('p')
    .lopt("param")
    .help(&["Add a key/value parameter field. The key must be unique."])
    .nargs(arg::Nargs::Count(2), &["KEY", "VALUE"])
    .build(param_proc);
  let cmd_spec = arg::Builder::new()
    .name("command")
    .required(true)
    .nargs(arg::Nargs::Count(1), &["COMMAND"])
    .help(&["The command to run."])
    .build(cmd_proc);
  let subcmd_spec = arg::Builder::new()
    .name("subcmd")
    .nargs(arg::Nargs::Count(1), &["SUBCMD"])
    .help(&["Command-specific sub-command."])
    .build(subcmd_proc);


  let ctx = MyContext {
    ..Default::default()
  };
  let mut prsr = arg::Parser::from_env(ctx);

  prsr.add(help_spec)?;
  prsr.add(verbose_spec)?;
  prsr.add(version_spec)?;
  prsr.add(file_spec)?;
  prsr.add(param_spec)?;
  prsr.add(cmd_spec)?;
  prsr.add(subcmd_spec)?;

  prsr.parse()?;

  if prsr.get_ctx().do_help == true {
    prsr.usage(&mut std::io::stdout());
    std::process::exit(0);
  }

  let ctx = prsr.into_ctx();

  println!("{:?}", &ctx);

  Ok(())
}

pub fn next(&mut self) -> Result<Option<Rc<RefCell<Spec<C>>>>, ErrKind<C>>

pub fn num_remaining_args(&self) -> usize

pub fn num_remaining_posargspecs(&self) -> usize

pub fn validate(&self) -> Result<(), ErrKind<C>>

pub fn usage(&self, out: &mut dyn Write)

Print out help text for parser options.

Hidden options will not be displayed.

The overall format for the help text is:

Usage: <cmd> [options] [positional arguments]

[top help]

[options]

[positional arguments]

[bottom help]

Examples found in repository

examples/conflict.rs (line 44)

fn main() -> Result<(), Box<dyn std::error::Error>> {
  let help_spec = arg::Builder::new()
    .sopt('h')
    .lopt("help")
    .exit(true)
    .help(&["Show this help."])
    .build(help_proc);
  let coll_spec = arg::Builder::new()
    .sopt('h')
    .lopt("hulp")
    .exit(true)
    .help(&["Show this help."])
    .build(help_proc);


  let ctx = MyContext {
    ..Default::default()
  };
  let mut prsr = arg::Parser::from_env(ctx);

  prsr.add(help_spec)?;
  prsr.add(coll_spec)?;

  prsr.parse()?;

  //let ctx = prsr.into_ctx();
  if prsr.get_ctx().do_help == true {
    prsr.usage(&mut std::io::stdout());
    std::process::exit(0);
  }

  println!("{:?}", prsr.get_ctx());

  Ok(())
}

examples/remaining.rs (line 67)

fn main() -> Result<(), Box<dyn std::error::Error>> {
  let help_spec = arg::Builder::new()
    .sopt('h')
    .lopt("help")
    .exit(true)
    .help(&["Show this help."])
    .build(help_proc);
  let exec_spec = arg::Builder::new()
    .name("exec")
    .nargs(arg::Nargs::Count(1), &["PRG"])
    .help(&["The executable to run."])
    .build(exec_proc);
  let eargs_spec = arg::Builder::new()
    .name("execargs")
    .nargs(arg::Nargs::Remainder, &["PRGARG"])
    .help(&["arguments to pass to the executable."])
    .build(eargs_proc);

  let ctx = MyContext {
    ..Default::default()
  };
  let mut prsr = arg::Parser::from_env(ctx);

  prsr.add(help_spec)?;
  prsr.add(exec_spec)?;
  prsr.add(eargs_spec)?;

  prsr.parse()?;

  if prsr.get_ctx().do_help == true {
    prsr.usage(&mut std::io::stdout());
    std::process::exit(0);
  }

  let ctx = prsr.into_ctx();

  println!("{:?}", &ctx);

  Ok(())
}

examples/hidden.rs (line 56)

fn main() -> Result<(), Box<dyn std::error::Error>> {
  let help_spec = arg::Builder::new()
    .sopt('h')
    .lopt("help")
    .exit(true)
    .help(&["Show this help."])
    .build(
      |_spec: &arg::Spec<MyContext>,
       ctx: &mut MyContext,
       _args: &Vec<String>| ctx.do_help = true
    );
  let version_spec = arg::Builder::new()
    .sopt('V')
    .lopt("version")
    .exit(true)
    .help(&["Output tool version and exit."])
    .build(
      |_spec: &arg::Spec<MyContext>,
       ctx: &mut MyContext,
       _args: &Vec<String>| ctx.do_version = true
    );
  let secret_spec = arg::Builder::new()
    .sopt('s')
    .lopt("secret")
    .hidden(true)
    .help(&["A hidden option."])
    .build(
      |_spec: &arg::Spec<MyContext>,
       ctx: &mut MyContext,
       _args: &Vec<String>| ctx.do_secret = true
    );


  let ctx = MyContext {
    ..Default::default()
  };
  let mut prsr = arg::Parser::from_env(ctx);

  prsr.add(help_spec)?;
  prsr.add(version_spec)?;
  prsr.add(secret_spec)?;

  prsr.parse()?;

  if prsr.get_ctx().do_help == true {
    prsr.usage(&mut std::io::stdout());
    std::process::exit(0);
  }

  let ctx = prsr.into_ctx();

  println!("{:?}", &ctx);

  Ok(())
}

examples/usage.rs (line 66)

fn main() -> Result<(), Box<dyn std::error::Error>> {
  let help_spec = arg::Builder::new()
    .sopt('h')
    .lopt("help")
    .exit(true)
    .help(&["Show this help."])
    .build(|_spec, ctx: &mut MyContext, _args| {
      ctx.do_help = true;
    });
  let version_spec = arg::Builder::new()
    .sopt('V')
    .lopt("version")
    .exit(true)
    .help(&["Output tool version and exit."])
    .build(
      |_spec: &arg::Spec<MyContext>,
       ctx: &mut MyContext,
       _args: &Vec<String>| ctx.do_version = true
    );
  let tophelp_spec = arg::Builder::new()
    .sopt('t')
    .lopt("tophelp")
    .help(&["Show top help."])
    .build(|_spec, ctx: &mut MyContext, _args| {
      ctx.tophelp = true;
    });
  let bottomhelp_spec = arg::Builder::new()
    .sopt('b')
    .lopt("bottomhelp")
    .help(&["Show bottom help."])
    .build(|_spec, ctx: &mut MyContext, _args| {
      ctx.bottomhelp = true;
    });

  let ctx = MyContext {
    ..Default::default()
  };
  let mut prsr = arg::Parser::from_env(ctx);

  prsr.add(help_spec)?;
  prsr.add(version_spec)?;
  prsr.add(tophelp_spec)?;
  prsr.add(bottomhelp_spec)?;

  prsr.parse()?;

  if prsr.get_ctx().do_help == true {
    prsr.usage(&mut std::io::stdout());
    std::process::exit(0);
  }

  if prsr.get_ctx().do_version == true {
    const VERSION: &'static str = env!("CARGO_PKG_VERSION");
    println!("usage {}", VERSION);
    std::process::exit(0);
  }

  let ctx = prsr.into_ctx();

  println!("{:?}", &ctx);

  usage_test(ctx)?;

  Ok(())
}


fn usage_test(ctx: MyContext) -> Result<(), Box<dyn std::error::Error>> {
  let help_spec = arg::Builder::new()
    .sopt('h')
    .lopt("help")
    .exit(true)
    .help(&["Show this help."])
    .build(|_spec, ctx: &mut MyContext, _args| {
      ctx.do_help = true;
    });
  let version_spec = arg::Builder::new()
    .sopt('V')
    .lopt("version")
    .exit(true)
    .help(&["Output tool version and exit."])
    .build(
      |_spec: &arg::Spec<MyContext>,
       ctx: &mut MyContext,
       _args: &Vec<String>| ctx.do_version = true
    );
  let file_spec = arg::Builder::new()
    .sopt('f')
    .lopt("file")
    .help(&["Use data in FILE."])
    .nargs(arg::Nargs::Count(1), &["FILE"])
    .build(|_spec, ctx: &mut MyContext, args| {
      ctx.fname = args[0].clone();
    });
  let param_spec = arg::Builder::new()
    .sopt('p')
    .lopt("param")
    .help(&["Add a key/value parameter field. The key must be unique."])
    .nargs(arg::Nargs::Count(2), &["KEY", "VALUE"])
    .build(|_spec, ctx: &mut MyContext, args| {
      ctx.params.insert(args[0].clone(), args[1].clone());
    });
  let cmd_spec = arg::Builder::new()
    .name("command")
    .required(true)
    .nargs(arg::Nargs::Count(1), &["COMMAND"])
    .help(&["The command to run."])
    .build(|_spec, ctx: &mut MyContext, args| {
      ctx.cmd = args[0].clone();
    });
  let subcmd_spec = arg::Builder::new()
    .name("subcmd")
    .nargs(arg::Nargs::Count(1), &["SUBCMD"])
    .help(&["Command-specific sub-command."])
    .build(|_spec, ctx: &mut MyContext, args| {
      ctx.subcmd = args[0].clone();
    });

  let ctx2 = MyContext {
    ..Default::default()
  };
  let mut prsr = arg::Parser::from_args("hello", &["--help"], ctx2);

  if ctx.tophelp {
    prsr.set_tophelp(&[
      "\"You know,\" said Arthur, \"it's at times like this, when I'm \
       trapped in a Vogon airlock with a man from Betelgeuse, and about to \
       die of asphyxiation in deep space that I really wish I'd listened to \
       what my mother told me when I was young.\"",
      "\"Why, what did she tell you?\"",
      "\"I don't know, I didn't listen.\""
    ]);
  }
  if ctx.bottomhelp {
    prsr.set_bottomhelp(&[
      "\"So this is it,\" said Arthur, \"We are going to die.\"",
      "\"Yes,\" said Ford, \"except... no! Wait a minute!\" He suddenly \
       lunged across the chamber at something behind Arthur's line of \
       vision. \"What's this switch?\" he cried.",
      "\"What? Where?\" cried Arthur, twisting round.",
      "\"No, I was only fooling,\" said Ford, \"we are going to die after \
       all.\""
    ]);
  }

  prsr.add(help_spec)?;
  prsr.add(version_spec)?;
  prsr.add(file_spec)?;
  prsr.add(param_spec)?;
  prsr.add(cmd_spec)?;
  prsr.add(subcmd_spec)?;

  prsr.parse()?;

  if prsr.get_ctx().do_help == true {
    prsr.usage(&mut std::io::stdout());
    std::process::exit(0);
  }

  let ctx = prsr.into_ctx();

  println!("{:?}", &ctx);

  Ok(())
}

examples/simple.rs (line 135)

fn main() -> Result<(), Box<dyn std::error::Error>> {
  let help_spec = arg::Builder::new()
    .sopt('h')
    .lopt("help")
    .exit(true)
    .help(&["Show this help."])
    .build(help_proc);
  let verbose_spec = arg::Builder::new()
    .sopt('v')
    .lopt("verbose")
    .help(&["Increase level of verbosity.", "Be quiet by default."])
    .build(verbose_proc);
  let version_spec = arg::Builder::new()
    .sopt('V')
    .lopt("version")
    .exit(true)
    .help(&["Output tool version and exit."])
    .build(
      |_spec: &arg::Spec<MyContext>,
       ctx: &mut MyContext,
       _args: &Vec<String>| ctx.do_version = true
    );
  let file_spec = arg::Builder::new()
    .sopt('f')
    .lopt("file")
    .help(&["Use data in FILE."])
    .nargs(arg::Nargs::Count(1), &["FILE"])
    .build(file_proc);
  let param_spec = arg::Builder::new()
    .sopt('p')
    .lopt("param")
    .help(&["Add a key/value parameter field. The key must be unique."])
    .nargs(arg::Nargs::Count(2), &["KEY", "VALUE"])
    .build(param_proc);
  let cmd_spec = arg::Builder::new()
    .name("command")
    .required(true)
    .nargs(arg::Nargs::Count(1), &["COMMAND"])
    .help(&["The command to run."])
    .build(cmd_proc);
  let subcmd_spec = arg::Builder::new()
    .name("subcmd")
    .nargs(arg::Nargs::Count(1), &["SUBCMD"])
    .help(&["Command-specific sub-command."])
    .build(subcmd_proc);


  let ctx = MyContext {
    ..Default::default()
  };
  let mut prsr = arg::Parser::from_env(ctx);

  prsr.add(help_spec)?;
  prsr.add(verbose_spec)?;
  prsr.add(version_spec)?;
  prsr.add(file_spec)?;
  prsr.add(param_spec)?;
  prsr.add(cmd_spec)?;
  prsr.add(subcmd_spec)?;

  prsr.parse()?;

  if prsr.get_ctx().do_help == true {
    prsr.usage(&mut std::io::stdout());
    std::process::exit(0);
  }

  let ctx = prsr.into_ctx();

  println!("{:?}", &ctx);

  Ok(())
}

pub fn print_usage(&self, out: &mut dyn Write)

Print the “Usage” part of the help.

The output format is:

Usage: <command> [arguments] [positional arguments]

pub fn print_tophelp(&self, out: &mut dyn Write)

pub fn print_bottomhelp(&self, out: &mut dyn Write)

pub fn print_opts(&self, out: &mut dyn Write)

Print the help section for “options”. Options are arguments that have a short and/or long option name.

pub fn print_posargs(&self, out: &mut dyn Write)

Print the help section for positional arguments.

pub fn did_fail(&self) -> bool

pub fn get_ctx(&self) -> &C

Examples found in repository

examples/conflict.rs (line 43)

fn main() -> Result<(), Box<dyn std::error::Error>> {
  let help_spec = arg::Builder::new()
    .sopt('h')
    .lopt("help")
    .exit(true)
    .help(&["Show this help."])
    .build(help_proc);
  let coll_spec = arg::Builder::new()
    .sopt('h')
    .lopt("hulp")
    .exit(true)
    .help(&["Show this help."])
    .build(help_proc);


  let ctx = MyContext {
    ..Default::default()
  };
  let mut prsr = arg::Parser::from_env(ctx);

  prsr.add(help_spec)?;
  prsr.add(coll_spec)?;

  prsr.parse()?;

  //let ctx = prsr.into_ctx();
  if prsr.get_ctx().do_help == true {
    prsr.usage(&mut std::io::stdout());
    std::process::exit(0);
  }

  println!("{:?}", prsr.get_ctx());

  Ok(())
}

examples/remaining.rs (line 66)

fn main() -> Result<(), Box<dyn std::error::Error>> {
  let help_spec = arg::Builder::new()
    .sopt('h')
    .lopt("help")
    .exit(true)
    .help(&["Show this help."])
    .build(help_proc);
  let exec_spec = arg::Builder::new()
    .name("exec")
    .nargs(arg::Nargs::Count(1), &["PRG"])
    .help(&["The executable to run."])
    .build(exec_proc);
  let eargs_spec = arg::Builder::new()
    .name("execargs")
    .nargs(arg::Nargs::Remainder, &["PRGARG"])
    .help(&["arguments to pass to the executable."])
    .build(eargs_proc);

  let ctx = MyContext {
    ..Default::default()
  };
  let mut prsr = arg::Parser::from_env(ctx);

  prsr.add(help_spec)?;
  prsr.add(exec_spec)?;
  prsr.add(eargs_spec)?;

  prsr.parse()?;

  if prsr.get_ctx().do_help == true {
    prsr.usage(&mut std::io::stdout());
    std::process::exit(0);
  }

  let ctx = prsr.into_ctx();

  println!("{:?}", &ctx);

  Ok(())
}

examples/hidden.rs (line 55)

fn main() -> Result<(), Box<dyn std::error::Error>> {
  let help_spec = arg::Builder::new()
    .sopt('h')
    .lopt("help")
    .exit(true)
    .help(&["Show this help."])
    .build(
      |_spec: &arg::Spec<MyContext>,
       ctx: &mut MyContext,
       _args: &Vec<String>| ctx.do_help = true
    );
  let version_spec = arg::Builder::new()
    .sopt('V')
    .lopt("version")
    .exit(true)
    .help(&["Output tool version and exit."])
    .build(
      |_spec: &arg::Spec<MyContext>,
       ctx: &mut MyContext,
       _args: &Vec<String>| ctx.do_version = true
    );
  let secret_spec = arg::Builder::new()
    .sopt('s')
    .lopt("secret")
    .hidden(true)
    .help(&["A hidden option."])
    .build(
      |_spec: &arg::Spec<MyContext>,
       ctx: &mut MyContext,
       _args: &Vec<String>| ctx.do_secret = true
    );


  let ctx = MyContext {
    ..Default::default()
  };
  let mut prsr = arg::Parser::from_env(ctx);

  prsr.add(help_spec)?;
  prsr.add(version_spec)?;
  prsr.add(secret_spec)?;

  prsr.parse()?;

  if prsr.get_ctx().do_help == true {
    prsr.usage(&mut std::io::stdout());
    std::process::exit(0);
  }

  let ctx = prsr.into_ctx();

  println!("{:?}", &ctx);

  Ok(())
}

examples/usage.rs (line 65)

fn main() -> Result<(), Box<dyn std::error::Error>> {
  let help_spec = arg::Builder::new()
    .sopt('h')
    .lopt("help")
    .exit(true)
    .help(&["Show this help."])
    .build(|_spec, ctx: &mut MyContext, _args| {
      ctx.do_help = true;
    });
  let version_spec = arg::Builder::new()
    .sopt('V')
    .lopt("version")
    .exit(true)
    .help(&["Output tool version and exit."])
    .build(
      |_spec: &arg::Spec<MyContext>,
       ctx: &mut MyContext,
       _args: &Vec<String>| ctx.do_version = true
    );
  let tophelp_spec = arg::Builder::new()
    .sopt('t')
    .lopt("tophelp")
    .help(&["Show top help."])
    .build(|_spec, ctx: &mut MyContext, _args| {
      ctx.tophelp = true;
    });
  let bottomhelp_spec = arg::Builder::new()
    .sopt('b')
    .lopt("bottomhelp")
    .help(&["Show bottom help."])
    .build(|_spec, ctx: &mut MyContext, _args| {
      ctx.bottomhelp = true;
    });

  let ctx = MyContext {
    ..Default::default()
  };
  let mut prsr = arg::Parser::from_env(ctx);

  prsr.add(help_spec)?;
  prsr.add(version_spec)?;
  prsr.add(tophelp_spec)?;
  prsr.add(bottomhelp_spec)?;

  prsr.parse()?;

  if prsr.get_ctx().do_help == true {
    prsr.usage(&mut std::io::stdout());
    std::process::exit(0);
  }

  if prsr.get_ctx().do_version == true {
    const VERSION: &'static str = env!("CARGO_PKG_VERSION");
    println!("usage {}", VERSION);
    std::process::exit(0);
  }

  let ctx = prsr.into_ctx();

  println!("{:?}", &ctx);

  usage_test(ctx)?;

  Ok(())
}


fn usage_test(ctx: MyContext) -> Result<(), Box<dyn std::error::Error>> {
  let help_spec = arg::Builder::new()
    .sopt('h')
    .lopt("help")
    .exit(true)
    .help(&["Show this help."])
    .build(|_spec, ctx: &mut MyContext, _args| {
      ctx.do_help = true;
    });
  let version_spec = arg::Builder::new()
    .sopt('V')
    .lopt("version")
    .exit(true)
    .help(&["Output tool version and exit."])
    .build(
      |_spec: &arg::Spec<MyContext>,
       ctx: &mut MyContext,
       _args: &Vec<String>| ctx.do_version = true
    );
  let file_spec = arg::Builder::new()
    .sopt('f')
    .lopt("file")
    .help(&["Use data in FILE."])
    .nargs(arg::Nargs::Count(1), &["FILE"])
    .build(|_spec, ctx: &mut MyContext, args| {
      ctx.fname = args[0].clone();
    });
  let param_spec = arg::Builder::new()
    .sopt('p')
    .lopt("param")
    .help(&["Add a key/value parameter field. The key must be unique."])
    .nargs(arg::Nargs::Count(2), &["KEY", "VALUE"])
    .build(|_spec, ctx: &mut MyContext, args| {
      ctx.params.insert(args[0].clone(), args[1].clone());
    });
  let cmd_spec = arg::Builder::new()
    .name("command")
    .required(true)
    .nargs(arg::Nargs::Count(1), &["COMMAND"])
    .help(&["The command to run."])
    .build(|_spec, ctx: &mut MyContext, args| {
      ctx.cmd = args[0].clone();
    });
  let subcmd_spec = arg::Builder::new()
    .name("subcmd")
    .nargs(arg::Nargs::Count(1), &["SUBCMD"])
    .help(&["Command-specific sub-command."])
    .build(|_spec, ctx: &mut MyContext, args| {
      ctx.subcmd = args[0].clone();
    });

  let ctx2 = MyContext {
    ..Default::default()
  };
  let mut prsr = arg::Parser::from_args("hello", &["--help"], ctx2);

  if ctx.tophelp {
    prsr.set_tophelp(&[
      "\"You know,\" said Arthur, \"it's at times like this, when I'm \
       trapped in a Vogon airlock with a man from Betelgeuse, and about to \
       die of asphyxiation in deep space that I really wish I'd listened to \
       what my mother told me when I was young.\"",
      "\"Why, what did she tell you?\"",
      "\"I don't know, I didn't listen.\""
    ]);
  }
  if ctx.bottomhelp {
    prsr.set_bottomhelp(&[
      "\"So this is it,\" said Arthur, \"We are going to die.\"",
      "\"Yes,\" said Ford, \"except... no! Wait a minute!\" He suddenly \
       lunged across the chamber at something behind Arthur's line of \
       vision. \"What's this switch?\" he cried.",
      "\"What? Where?\" cried Arthur, twisting round.",
      "\"No, I was only fooling,\" said Ford, \"we are going to die after \
       all.\""
    ]);
  }

  prsr.add(help_spec)?;
  prsr.add(version_spec)?;
  prsr.add(file_spec)?;
  prsr.add(param_spec)?;
  prsr.add(cmd_spec)?;
  prsr.add(subcmd_spec)?;

  prsr.parse()?;

  if prsr.get_ctx().do_help == true {
    prsr.usage(&mut std::io::stdout());
    std::process::exit(0);
  }

  let ctx = prsr.into_ctx();

  println!("{:?}", &ctx);

  Ok(())
}

examples/simple.rs (line 134)

fn main() -> Result<(), Box<dyn std::error::Error>> {
  let help_spec = arg::Builder::new()
    .sopt('h')
    .lopt("help")
    .exit(true)
    .help(&["Show this help."])
    .build(help_proc);
  let verbose_spec = arg::Builder::new()
    .sopt('v')
    .lopt("verbose")
    .help(&["Increase level of verbosity.", "Be quiet by default."])
    .build(verbose_proc);
  let version_spec = arg::Builder::new()
    .sopt('V')
    .lopt("version")
    .exit(true)
    .help(&["Output tool version and exit."])
    .build(
      |_spec: &arg::Spec<MyContext>,
       ctx: &mut MyContext,
       _args: &Vec<String>| ctx.do_version = true
    );
  let file_spec = arg::Builder::new()
    .sopt('f')
    .lopt("file")
    .help(&["Use data in FILE."])
    .nargs(arg::Nargs::Count(1), &["FILE"])
    .build(file_proc);
  let param_spec = arg::Builder::new()
    .sopt('p')
    .lopt("param")
    .help(&["Add a key/value parameter field. The key must be unique."])
    .nargs(arg::Nargs::Count(2), &["KEY", "VALUE"])
    .build(param_proc);
  let cmd_spec = arg::Builder::new()
    .name("command")
    .required(true)
    .nargs(arg::Nargs::Count(1), &["COMMAND"])
    .help(&["The command to run."])
    .build(cmd_proc);
  let subcmd_spec = arg::Builder::new()
    .name("subcmd")
    .nargs(arg::Nargs::Count(1), &["SUBCMD"])
    .help(&["Command-specific sub-command."])
    .build(subcmd_proc);


  let ctx = MyContext {
    ..Default::default()
  };
  let mut prsr = arg::Parser::from_env(ctx);

  prsr.add(help_spec)?;
  prsr.add(verbose_spec)?;
  prsr.add(version_spec)?;
  prsr.add(file_spec)?;
  prsr.add(param_spec)?;
  prsr.add(cmd_spec)?;
  prsr.add(subcmd_spec)?;

  prsr.parse()?;

  if prsr.get_ctx().do_help == true {
    prsr.usage(&mut std::io::stdout());
    std::process::exit(0);
  }

  let ctx = prsr.into_ctx();

  println!("{:?}", &ctx);

  Ok(())
}

pub fn into_ctx(self) -> C

Examples found in repository

examples/remaining.rs (line 71)

fn main() -> Result<(), Box<dyn std::error::Error>> {
  let help_spec = arg::Builder::new()
    .sopt('h')
    .lopt("help")
    .exit(true)
    .help(&["Show this help."])
    .build(help_proc);
  let exec_spec = arg::Builder::new()
    .name("exec")
    .nargs(arg::Nargs::Count(1), &["PRG"])
    .help(&["The executable to run."])
    .build(exec_proc);
  let eargs_spec = arg::Builder::new()
    .name("execargs")
    .nargs(arg::Nargs::Remainder, &["PRGARG"])
    .help(&["arguments to pass to the executable."])
    .build(eargs_proc);

  let ctx = MyContext {
    ..Default::default()
  };
  let mut prsr = arg::Parser::from_env(ctx);

  prsr.add(help_spec)?;
  prsr.add(exec_spec)?;
  prsr.add(eargs_spec)?;

  prsr.parse()?;

  if prsr.get_ctx().do_help == true {
    prsr.usage(&mut std::io::stdout());
    std::process::exit(0);
  }

  let ctx = prsr.into_ctx();

  println!("{:?}", &ctx);

  Ok(())
}

examples/hidden.rs (line 60)

fn main() -> Result<(), Box<dyn std::error::Error>> {
  let help_spec = arg::Builder::new()
    .sopt('h')
    .lopt("help")
    .exit(true)
    .help(&["Show this help."])
    .build(
      |_spec: &arg::Spec<MyContext>,
       ctx: &mut MyContext,
       _args: &Vec<String>| ctx.do_help = true
    );
  let version_spec = arg::Builder::new()
    .sopt('V')
    .lopt("version")
    .exit(true)
    .help(&["Output tool version and exit."])
    .build(
      |_spec: &arg::Spec<MyContext>,
       ctx: &mut MyContext,
       _args: &Vec<String>| ctx.do_version = true
    );
  let secret_spec = arg::Builder::new()
    .sopt('s')
    .lopt("secret")
    .hidden(true)
    .help(&["A hidden option."])
    .build(
      |_spec: &arg::Spec<MyContext>,
       ctx: &mut MyContext,
       _args: &Vec<String>| ctx.do_secret = true
    );


  let ctx = MyContext {
    ..Default::default()
  };
  let mut prsr = arg::Parser::from_env(ctx);

  prsr.add(help_spec)?;
  prsr.add(version_spec)?;
  prsr.add(secret_spec)?;

  prsr.parse()?;

  if prsr.get_ctx().do_help == true {
    prsr.usage(&mut std::io::stdout());
    std::process::exit(0);
  }

  let ctx = prsr.into_ctx();

  println!("{:?}", &ctx);

  Ok(())
}

examples/usage.rs (line 76)

fn main() -> Result<(), Box<dyn std::error::Error>> {
  let help_spec = arg::Builder::new()
    .sopt('h')
    .lopt("help")
    .exit(true)
    .help(&["Show this help."])
    .build(|_spec, ctx: &mut MyContext, _args| {
      ctx.do_help = true;
    });
  let version_spec = arg::Builder::new()
    .sopt('V')
    .lopt("version")
    .exit(true)
    .help(&["Output tool version and exit."])
    .build(
      |_spec: &arg::Spec<MyContext>,
       ctx: &mut MyContext,
       _args: &Vec<String>| ctx.do_version = true
    );
  let tophelp_spec = arg::Builder::new()
    .sopt('t')
    .lopt("tophelp")
    .help(&["Show top help."])
    .build(|_spec, ctx: &mut MyContext, _args| {
      ctx.tophelp = true;
    });
  let bottomhelp_spec = arg::Builder::new()
    .sopt('b')
    .lopt("bottomhelp")
    .help(&["Show bottom help."])
    .build(|_spec, ctx: &mut MyContext, _args| {
      ctx.bottomhelp = true;
    });

  let ctx = MyContext {
    ..Default::default()
  };
  let mut prsr = arg::Parser::from_env(ctx);

  prsr.add(help_spec)?;
  prsr.add(version_spec)?;
  prsr.add(tophelp_spec)?;
  prsr.add(bottomhelp_spec)?;

  prsr.parse()?;

  if prsr.get_ctx().do_help == true {
    prsr.usage(&mut std::io::stdout());
    std::process::exit(0);
  }

  if prsr.get_ctx().do_version == true {
    const VERSION: &'static str = env!("CARGO_PKG_VERSION");
    println!("usage {}", VERSION);
    std::process::exit(0);
  }

  let ctx = prsr.into_ctx();

  println!("{:?}", &ctx);

  usage_test(ctx)?;

  Ok(())
}


fn usage_test(ctx: MyContext) -> Result<(), Box<dyn std::error::Error>> {
  let help_spec = arg::Builder::new()
    .sopt('h')
    .lopt("help")
    .exit(true)
    .help(&["Show this help."])
    .build(|_spec, ctx: &mut MyContext, _args| {
      ctx.do_help = true;
    });
  let version_spec = arg::Builder::new()
    .sopt('V')
    .lopt("version")
    .exit(true)
    .help(&["Output tool version and exit."])
    .build(
      |_spec: &arg::Spec<MyContext>,
       ctx: &mut MyContext,
       _args: &Vec<String>| ctx.do_version = true
    );
  let file_spec = arg::Builder::new()
    .sopt('f')
    .lopt("file")
    .help(&["Use data in FILE."])
    .nargs(arg::Nargs::Count(1), &["FILE"])
    .build(|_spec, ctx: &mut MyContext, args| {
      ctx.fname = args[0].clone();
    });
  let param_spec = arg::Builder::new()
    .sopt('p')
    .lopt("param")
    .help(&["Add a key/value parameter field. The key must be unique."])
    .nargs(arg::Nargs::Count(2), &["KEY", "VALUE"])
    .build(|_spec, ctx: &mut MyContext, args| {
      ctx.params.insert(args[0].clone(), args[1].clone());
    });
  let cmd_spec = arg::Builder::new()
    .name("command")
    .required(true)
    .nargs(arg::Nargs::Count(1), &["COMMAND"])
    .help(&["The command to run."])
    .build(|_spec, ctx: &mut MyContext, args| {
      ctx.cmd = args[0].clone();
    });
  let subcmd_spec = arg::Builder::new()
    .name("subcmd")
    .nargs(arg::Nargs::Count(1), &["SUBCMD"])
    .help(&["Command-specific sub-command."])
    .build(|_spec, ctx: &mut MyContext, args| {
      ctx.subcmd = args[0].clone();
    });

  let ctx2 = MyContext {
    ..Default::default()
  };
  let mut prsr = arg::Parser::from_args("hello", &["--help"], ctx2);

  if ctx.tophelp {
    prsr.set_tophelp(&[
      "\"You know,\" said Arthur, \"it's at times like this, when I'm \
       trapped in a Vogon airlock with a man from Betelgeuse, and about to \
       die of asphyxiation in deep space that I really wish I'd listened to \
       what my mother told me when I was young.\"",
      "\"Why, what did she tell you?\"",
      "\"I don't know, I didn't listen.\""
    ]);
  }
  if ctx.bottomhelp {
    prsr.set_bottomhelp(&[
      "\"So this is it,\" said Arthur, \"We are going to die.\"",
      "\"Yes,\" said Ford, \"except... no! Wait a minute!\" He suddenly \
       lunged across the chamber at something behind Arthur's line of \
       vision. \"What's this switch?\" he cried.",
      "\"What? Where?\" cried Arthur, twisting round.",
      "\"No, I was only fooling,\" said Ford, \"we are going to die after \
       all.\""
    ]);
  }

  prsr.add(help_spec)?;
  prsr.add(version_spec)?;
  prsr.add(file_spec)?;
  prsr.add(param_spec)?;
  prsr.add(cmd_spec)?;
  prsr.add(subcmd_spec)?;

  prsr.parse()?;

  if prsr.get_ctx().do_help == true {
    prsr.usage(&mut std::io::stdout());
    std::process::exit(0);
  }

  let ctx = prsr.into_ctx();

  println!("{:?}", &ctx);

  Ok(())
}

examples/simple.rs (line 139)

fn main() -> Result<(), Box<dyn std::error::Error>> {
  let help_spec = arg::Builder::new()
    .sopt('h')
    .lopt("help")
    .exit(true)
    .help(&["Show this help."])
    .build(help_proc);
  let verbose_spec = arg::Builder::new()
    .sopt('v')
    .lopt("verbose")
    .help(&["Increase level of verbosity.", "Be quiet by default."])
    .build(verbose_proc);
  let version_spec = arg::Builder::new()
    .sopt('V')
    .lopt("version")
    .exit(true)
    .help(&["Output tool version and exit."])
    .build(
      |_spec: &arg::Spec<MyContext>,
       ctx: &mut MyContext,
       _args: &Vec<String>| ctx.do_version = true
    );
  let file_spec = arg::Builder::new()
    .sopt('f')
    .lopt("file")
    .help(&["Use data in FILE."])
    .nargs(arg::Nargs::Count(1), &["FILE"])
    .build(file_proc);
  let param_spec = arg::Builder::new()
    .sopt('p')
    .lopt("param")
    .help(&["Add a key/value parameter field. The key must be unique."])
    .nargs(arg::Nargs::Count(2), &["KEY", "VALUE"])
    .build(param_proc);
  let cmd_spec = arg::Builder::new()
    .name("command")
    .required(true)
    .nargs(arg::Nargs::Count(1), &["COMMAND"])
    .help(&["The command to run."])
    .build(cmd_proc);
  let subcmd_spec = arg::Builder::new()
    .name("subcmd")
    .nargs(arg::Nargs::Count(1), &["SUBCMD"])
    .help(&["Command-specific sub-command."])
    .build(subcmd_proc);


  let ctx = MyContext {
    ..Default::default()
  };
  let mut prsr = arg::Parser::from_env(ctx);

  prsr.add(help_spec)?;
  prsr.add(verbose_spec)?;
  prsr.add(version_spec)?;
  prsr.add(file_spec)?;
  prsr.add(param_spec)?;
  prsr.add(cmd_spec)?;
  prsr.add(subcmd_spec)?;

  prsr.parse()?;

  if prsr.get_ctx().do_help == true {
    prsr.usage(&mut std::io::stdout());
    std::process::exit(0);
  }

  let ctx = prsr.into_ctx();

  println!("{:?}", &ctx);

  Ok(())
}

Trait Implementations

impl<C> Iterator for Parser<C>

type Item = Rc<RefCell<Spec<C>>>

The type of the elements being iterated over.

fn next(&mut self) -> Option<Self::Item>

Advances the iterator and returns the next value.

fn next_chunk<const N: usize>( &mut self, ) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>

where Self: Sized,

🔬This is a nightly-only experimental API. (iter_next_chunk)

Advances the iterator and returns an array containing the next N values.

fn size_hint(&self) -> (usize, Option<usize>)

Returns the bounds on the remaining length of the iterator.

fn count(self) -> usize

where Self: Sized,

Consumes the iterator, counting the number of iterations and returning it.

fn last(self) -> Option<Self::Item>

where Self: Sized,

Consumes the iterator, returning the last element.

fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>

🔬This is a nightly-only experimental API. (iter_advance_by)

Advances the iterator by n elements.

fn nth(&mut self, n: usize) -> Option<Self::Item>

Returns the nth element of the iterator.

fn step_by(self, step: usize) -> StepBy<Self>

where Self: Sized,

Creates an iterator starting at the same point, but stepping by the given amount at each iteration.

fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>

where Self: Sized, U: IntoIterator<Item = Self::Item>,

Takes two iterators and creates a new iterator over both in sequence.

fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>

where Self: Sized, U: IntoIterator,

‘Zips up’ two iterators into a single iterator of pairs.

fn intersperse(self, separator: Self::Item) -> Intersperse<Self>

where Self: Sized, Self::Item: Clone,

🔬This is a nightly-only experimental API. (iter_intersperse)

Creates a new iterator which places a copy of separator between adjacent items of the original iterator.

fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>

where Self: Sized, G: FnMut() -> Self::Item,

🔬This is a nightly-only experimental API. (iter_intersperse)

Creates a new iterator which places an item generated by separator between adjacent items of the original iterator.

fn map<B, F>(self, f: F) -> Map<Self, F>

where Self: Sized, F: FnMut(Self::Item) -> B,

Takes a closure and creates an iterator which calls that closure on each element.

fn for_each<F>(self, f: F)

where Self: Sized, F: FnMut(Self::Item),

Calls a closure on each element of an iterator.

fn filter<P>(self, predicate: P) -> Filter<Self, P>

where Self: Sized, P: FnMut(&Self::Item) -> bool,

Creates an iterator which uses a closure to determine if an element should be yielded.

fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>

where Self: Sized, F: FnMut(Self::Item) -> Option<B>,

Creates an iterator that both filters and maps.

fn enumerate(self) -> Enumerate<Self>

where Self: Sized,

Creates an iterator which gives the current iteration count as well as the next value.

fn peekable(self) -> Peekable<Self>

where Self: Sized,

Creates an iterator which can use the peek and peek_mut methods to look at the next element of the iterator without consuming it. See their documentation for more information.

fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>

where Self: Sized, P: FnMut(&Self::Item) -> bool,

Creates an iterator that skips elements based on a predicate.

fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>

where Self: Sized, P: FnMut(&Self::Item) -> bool,

Creates an iterator that yields elements based on a predicate.

fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>

where Self: Sized, P: FnMut(Self::Item) -> Option<B>,

Creates an iterator that both yields elements based on a predicate and maps.

fn skip(self, n: usize) -> Skip<Self>

where Self: Sized,

Creates an iterator that skips the first n elements.

fn take(self, n: usize) -> Take<Self>

where Self: Sized,

Creates an iterator that yields the first n elements, or fewer if the underlying iterator ends sooner.

fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>

where Self: Sized, F: FnMut(&mut St, Self::Item) -> Option<B>,

An iterator adapter which, like fold, holds internal state, but unlike fold, produces a new iterator.

fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>

where Self: Sized, U: IntoIterator, F: FnMut(Self::Item) -> U,

Creates an iterator that works like map, but flattens nested structure.

fn flatten(self) -> Flatten<Self>

where Self: Sized, Self::Item: IntoIterator,

Creates an iterator that flattens nested structure.

fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>

where Self: Sized, F: FnMut(&[Self::Item; N]) -> R,

🔬This is a nightly-only experimental API. (iter_map_windows)

Calls the given function f for each contiguous window of size N over self and returns an iterator over the outputs of f. Like slice::windows(), the windows during mapping overlap as well.

fn fuse(self) -> Fuse<Self>

where Self: Sized,

Creates an iterator which ends after the first None.

fn inspect<F>(self, f: F) -> Inspect<Self, F>

where Self: Sized, F: FnMut(&Self::Item),

Does something with each element of an iterator, passing the value on.

fn by_ref(&mut self) -> &mut Self

where Self: Sized,

Creates a “by reference” adapter for this instance of Iterator.

fn collect<B>(self) -> B

where B: FromIterator<Self::Item>, Self: Sized,

Transforms an iterator into a collection.

fn try_collect<B>( &mut self, ) -> <<Self::Item as Try>::Residual as Residual<B>>::TryType

where Self: Sized, Self::Item: Try, <Self::Item as Try>::Residual: Residual<B>, B: FromIterator<<Self::Item as Try>::Output>,

🔬This is a nightly-only experimental API. (iterator_try_collect)

Fallibly transforms an iterator into a collection, short circuiting if a failure is encountered.

fn collect_into<E>(self, collection: &mut E) -> &mut E

where E: Extend<Self::Item>, Self: Sized,

🔬This is a nightly-only experimental API. (iter_collect_into)

Collects all the items from an iterator into a collection.

fn partition<B, F>(self, f: F) -> (B, B)

where Self: Sized, B: Default + Extend<Self::Item>, F: FnMut(&Self::Item) -> bool,

Consumes an iterator, creating two collections from it.

fn is_partitioned<P>(self, predicate: P) -> bool

where Self: Sized, P: FnMut(Self::Item) -> bool,

🔬This is a nightly-only experimental API. (iter_is_partitioned)

Checks if the elements of this iterator are partitioned according to the given predicate, such that all those that return true precede all those that return false.

fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R

where Self: Sized, F: FnMut(B, Self::Item) -> R, R: Try<Output = B>,

An iterator method that applies a function as long as it returns successfully, producing a single, final value.

fn try_for_each<F, R>(&mut self, f: F) -> R

where Self: Sized, F: FnMut(Self::Item) -> R, R: Try<Output = ()>,

An iterator method that applies a fallible function to each item in the iterator, stopping at the first error and returning that error.

fn fold<B, F>(self, init: B, f: F) -> B

where Self: Sized, F: FnMut(B, Self::Item) -> B,

Folds every element into an accumulator by applying an operation, returning the final result.

fn reduce<F>(self, f: F) -> Option<Self::Item>

where Self: Sized, F: FnMut(Self::Item, Self::Item) -> Self::Item,

Reduces the elements to a single one, by repeatedly applying a reducing operation.

fn try_reduce<R>( &mut self, f: impl FnMut(Self::Item, Self::Item) -> R, ) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType

where Self: Sized, R: Try<Output = Self::Item>, <R as Try>::Residual: Residual<Option<Self::Item>>,

🔬This is a nightly-only experimental API. (iterator_try_reduce)

Reduces the elements to a single one by repeatedly applying a reducing operation. If the closure returns a failure, the failure is propagated back to the caller immediately.

fn all<F>(&mut self, f: F) -> bool

where Self: Sized, F: FnMut(Self::Item) -> bool,

Tests if every element of the iterator matches a predicate.

fn any<F>(&mut self, f: F) -> bool

where Self: Sized, F: FnMut(Self::Item) -> bool,

Tests if any element of the iterator matches a predicate.

fn find<P>(&mut self, predicate: P) -> Option<Self::Item>

where Self: Sized, P: FnMut(&Self::Item) -> bool,

Searches for an element of an iterator that satisfies a predicate.

fn find_map<B, F>(&mut self, f: F) -> Option<B>

where Self: Sized, F: FnMut(Self::Item) -> Option<B>,

Applies function to the elements of iterator and returns the first non-none result.

fn try_find<R>( &mut self, f: impl FnMut(&Self::Item) -> R, ) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType

where Self: Sized, R: Try<Output = bool>, <R as Try>::Residual: Residual<Option<Self::Item>>,

🔬This is a nightly-only experimental API. (try_find)

Applies function to the elements of iterator and returns the first true result or the first error.

fn position<P>(&mut self, predicate: P) -> Option<usize>

where Self: Sized, P: FnMut(Self::Item) -> bool,

Searches for an element in an iterator, returning its index.

fn max(self) -> Option<Self::Item>

where Self: Sized, Self::Item: Ord,

Returns the maximum element of an iterator.

fn min(self) -> Option<Self::Item>

where Self: Sized, Self::Item: Ord,

Returns the minimum element of an iterator.

fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>

where B: Ord, Self: Sized, F: FnMut(&Self::Item) -> B,

Returns the element that gives the maximum value from the specified function.

fn max_by<F>(self, compare: F) -> Option<Self::Item>

where Self: Sized, F: FnMut(&Self::Item, &Self::Item) -> Ordering,

Returns the element that gives the maximum value with respect to the specified comparison function.

fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>

where B: Ord, Self: Sized, F: FnMut(&Self::Item) -> B,

Returns the element that gives the minimum value from the specified function.

fn min_by<F>(self, compare: F) -> Option<Self::Item>

where Self: Sized, F: FnMut(&Self::Item, &Self::Item) -> Ordering,

Returns the element that gives the minimum value with respect to the specified comparison function.

fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)

where FromA: Default + Extend<A>, FromB: Default + Extend<B>, Self: Sized + Iterator<Item = (A, B)>,

Converts an iterator of pairs into a pair of containers.

fn copied<'a, T>(self) -> Copied<Self>

where T: Copy + 'a, Self: Sized + Iterator<Item = &'a T>,

Creates an iterator which copies all of its elements.

fn cloned<'a, T>(self) -> Cloned<Self>

where T: Clone + 'a, Self: Sized + Iterator<Item = &'a T>,

Creates an iterator which clones all of its elements.

fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>

where Self: Sized,

🔬This is a nightly-only experimental API. (iter_array_chunks)

Returns an iterator over N elements of the iterator at a time.

fn sum<S>(self) -> S

where Self: Sized, S: Sum<Self::Item>,

Sums the elements of an iterator.

fn product<P>(self) -> P

where Self: Sized, P: Product<Self::Item>,

Iterates over the entire iterator, multiplying all the elements

fn cmp<I>(self, other: I) -> Ordering

where I: IntoIterator<Item = Self::Item>, Self::Item: Ord, Self: Sized,

Lexicographically compares the elements of this Iterator with those of another.

fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering

where Self: Sized, I: IntoIterator, F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,

🔬This is a nightly-only experimental API. (iter_order_by)

Lexicographically compares the elements of this Iterator with those of another with respect to the specified comparison function.

fn partial_cmp<I>(self, other: I) -> Option<Ordering>

where I: IntoIterator, Self::Item: PartialOrd<<I as IntoIterator>::Item>, Self: Sized,

Lexicographically compares the PartialOrd elements of this Iterator with those of another. The comparison works like short-circuit evaluation, returning a result without comparing the remaining elements. As soon as an order can be determined, the evaluation stops and a result is returned.

fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>

where Self: Sized, I: IntoIterator, F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,

🔬This is a nightly-only experimental API. (iter_order_by)

Lexicographically compares the elements of this Iterator with those of another with respect to the specified comparison function.

fn eq<I>(self, other: I) -> bool

where I: IntoIterator, Self::Item: PartialEq<<I as IntoIterator>::Item>, Self: Sized,

Determines if the elements of this Iterator are equal to those of another.

fn eq_by<I, F>(self, other: I, eq: F) -> bool

where Self: Sized, I: IntoIterator, F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,

🔬This is a nightly-only experimental API. (iter_order_by)

Determines if the elements of this Iterator are equal to those of another with respect to the specified equality function.

fn ne<I>(self, other: I) -> bool

where I: IntoIterator, Self::Item: PartialEq<<I as IntoIterator>::Item>, Self: Sized,

Determines if the elements of this Iterator are not equal to those of another.

fn lt<I>(self, other: I) -> bool

where I: IntoIterator, Self::Item: PartialOrd<<I as IntoIterator>::Item>, Self: Sized,

Determines if the elements of this Iterator are lexicographically less than those of another.

fn le<I>(self, other: I) -> bool

where I: IntoIterator, Self::Item: PartialOrd<<I as IntoIterator>::Item>, Self: Sized,

Determines if the elements of this Iterator are lexicographically less or equal to those of another.

fn gt<I>(self, other: I) -> bool

where I: IntoIterator, Self::Item: PartialOrd<<I as IntoIterator>::Item>, Self: Sized,

Determines if the elements of this Iterator are lexicographically greater than those of another.

fn ge<I>(self, other: I) -> bool

where I: IntoIterator, Self::Item: PartialOrd<<I as IntoIterator>::Item>, Self: Sized,

Determines if the elements of this Iterator are lexicographically greater than or equal to those of another.

fn is_sorted(self) -> bool

where Self: Sized, Self::Item: PartialOrd,

Checks if the elements of this iterator are sorted.

fn is_sorted_by<F>(self, compare: F) -> bool

where Self: Sized, F: FnMut(&Self::Item, &Self::Item) -> bool,

Checks if the elements of this iterator are sorted using the given comparator function.

fn is_sorted_by_key<F, K>(self, f: F) -> bool

where Self: Sized, F: FnMut(Self::Item) -> K, K: PartialOrd,

Checks if the elements of this iterator are sorted using the given key extraction function.