Mirrors/clap
2
0
Fork 0
mirror of https://github.com/clap-rs/clap synced 2024-11-10 06:44:16 +00:00
Code Issues Projects Releases Packages Wiki Activity

refactor: remove code going to other crates and deprecations

Browse source
This commit is contained in:
Kevin K 2018-10-19 16:42:13 -04:00
parent eaa0700e7e
commit 03333800fe
63 changed files with 790 additions and 3359 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
README.md
View file

@ -289,7 +289,7 @@ fn main() {
.about("controls testing features")
.version("1.3")
.author("Someone E. <someone_else@other.com>")
.arg_from_usage("-d, --debug 'Print debug information'"))
.arg("-d, --debug 'Print debug information'"))
.get_matches();
// Same as previous example...

10
benches/03_complex.rs
View file

@ -4,7 +4,7 @@
extern crate clap;
extern crate test;
use clap::{App, AppSettings, Arg, ArgSettings, SubCommand};
use clap::{App, AppSettings, Arg, ArgSettings, };
use test::Bencher;
@ -39,12 +39,12 @@ macro_rules! create_app {
Arg::from("--maxvals3 [maxvals]... 'Tests 3 max vals'").max_values(3),
])
.subcommand(
SubCommand::with_name("subcmd")
App::new("subcmd")
.about("tests subcommands")
.version("0.1")
.author("Kevin K. <kbknapp@gmail.com>")
.arg_from_usage("-o --option [scoption]... 'tests options'")
.arg_from_usage("[scpositional] 'tests positionals'"),
.arg("-o --option [scoption]... 'tests options'")
.arg("[scpositional] 'tests positionals'"),
)
}};
}
@ -146,7 +146,7 @@ fn create_app_builder(b: &mut Bencher) {
.max_values(3),
)
.subcommand(
SubCommand::with_name("subcmd")
App::new("subcmd")
.about("tests subcommands")
.version("0.1")
.author("Kevin K. <kbknapp@gmail.com>")

8
benches/04_new_help.rs
View file

@ -8,7 +8,7 @@ use test::Bencher;
use std::io::Cursor;
use clap::App;
use clap::{Arg, ArgSettings, SubCommand};
use clap::{Arg, ArgSettings, };
fn build_help(app: &mut App) -> String {
let mut buf = Cursor::new(Vec::with_capacity(50));
@ -28,9 +28,9 @@ fn app_example1<'b, 'c>() -> App<'b, 'c> {
-d... 'Turn debugging information on'",
)
.subcommand(
SubCommand::with_name("test")
App::new("test")
.about("does testing things")
.arg_from_usage("-l, --list 'lists test values'"),
.arg("-l, --list 'lists test values'"),
)
}
@ -59,7 +59,7 @@ fn app_example3<'b, 'c>() -> App<'b, 'c> {
.index(1)
.setting(ArgSettings::Required),
])
.arg_from_usage("--license 'display the license file'")
.arg("--license 'display the license file'")
.args_from_usage(
"[output] 'Supply an output file to use'
-i, --int=[IFACE] 'Set an interface to use'",

88
benches/06_rustup.rs
View file

@ -7,7 +7,7 @@
extern crate clap;
extern crate test;
use clap::{App, AppSettings, Arg, ArgGroup, ArgSettings, Shell, SubCommand};
use clap::{App, AppSettings, Arg, ArgGroup, ArgSettings, Shell, };
use test::Bencher;
@ -34,16 +34,16 @@ pub fn build_cli() -> App<'static, 'static> {
.help("Enable verbose output")
.short('v')
.long("verbose"))
.subcommand(SubCommand::with_name("show")
.subcommand(App::new("show")
.about("Show the active and installed toolchains")
.after_help(SHOW_HELP))
.subcommand(SubCommand::with_name("install")
.subcommand(App::new("install")
.about("Update Rust toolchains")
.after_help(TOOLCHAIN_INSTALL_HELP)
.setting(AppSettings::Hidden) // synonym for 'toolchain install'
.arg(Arg::with_name("toolchain")
.setting(ArgSettings::Required)))
.subcommand(SubCommand::with_name("update")
.subcommand(App::new("update")
.about("Update Rust toolchains")
.after_help(UPDATE_HELP)
.arg(Arg::with_name("toolchain").setting(ArgSettings::Required))
@ -51,85 +51,85 @@ pub fn build_cli() -> App<'static, 'static> {
.help("Don't perform self update when running the `rustup` command")
.long("no-self-update")
.setting(ArgSettings::Hidden)))
.subcommand(SubCommand::with_name("default")
.subcommand(App::new("default")
.about("Set the default toolchain")
.after_help(DEFAULT_HELP)
.arg(Arg::with_name("toolchain").setting(ArgSettings::Required)))
.subcommand(SubCommand::with_name("toolchain")
.subcommand(App::new("toolchain")
.about("Modify or query the installed toolchains")
.after_help(TOOLCHAIN_HELP)
.setting(AppSettings::DeriveDisplayOrder)
// .setting(AppSettings::SubcommandRequiredElseHelp)
.subcommand(SubCommand::with_name("list").about("List installed toolchains"))
.subcommand(SubCommand::with_name("install")
.subcommand(App::new("list").about("List installed toolchains"))
.subcommand(App::new("install")
.about("Install or update a given toolchain")
.arg(Arg::with_name("toolchain").setting(ArgSettings::Required)))
.subcommand(SubCommand::with_name("uninstall")
.subcommand(App::new("uninstall")
.about("Uninstall a toolchain")
.arg(Arg::with_name("toolchain").setting(ArgSettings::Required)))
.subcommand(SubCommand::with_name("link")
.subcommand(App::new("link")
.about("Create a custom toolchain by symlinking to a directory")
.arg(Arg::with_name("toolchain").setting(ArgSettings::Required))
.arg(Arg::with_name("path").setting(ArgSettings::Required)))
.subcommand(SubCommand::with_name("update")
.subcommand(App::new("update")
.setting(AppSettings::Hidden) // synonym for 'install'
.arg(Arg::with_name("toolchain")
.setting(ArgSettings::Required)))
.subcommand(SubCommand::with_name("add")
.subcommand(App::new("add")
.setting(AppSettings::Hidden) // synonym for 'install'
.arg(Arg::with_name("toolchain")
.setting(ArgSettings::Required)))
.subcommand(SubCommand::with_name("remove")
.subcommand(App::new("remove")
.setting(AppSettings::Hidden) // synonym for 'uninstall'
.arg(Arg::with_name("toolchain")
.setting(ArgSettings::Required))))
.subcommand(SubCommand::with_name("target")
.subcommand(App::new("target")
.about("Modify a toolchain's supported targets")
.setting(AppSettings::VersionlessSubcommands)
.setting(AppSettings::DeriveDisplayOrder)
// .setting(AppSettings::SubcommandRequiredElseHelp)
.subcommand(SubCommand::with_name("list")
.subcommand(App::new("list")
.about("List installed and available targets")
.arg(Arg::with_name("toolchain")
.long("toolchain")
.setting(ArgSettings::TakesValue)))
.subcommand(SubCommand::with_name("add")
.subcommand(App::new("add")
.about("Add a target to a Rust toolchain")
.arg(Arg::with_name("target").setting(ArgSettings::Required))
.arg(Arg::with_name("toolchain")
.long("toolchain")
.setting(ArgSettings::TakesValue)))
.subcommand(SubCommand::with_name("remove")
.subcommand(App::new("remove")
.about("Remove a target from a Rust toolchain")
.arg(Arg::with_name("target").setting(ArgSettings::Required))
.arg(Arg::with_name("toolchain")
.long("toolchain")
.setting(ArgSettings::TakesValue)))
.subcommand(SubCommand::with_name("install")
.subcommand(App::new("install")
.setting(AppSettings::Hidden) // synonym for 'add'
.arg(Arg::with_name("target")
.setting(ArgSettings::Required))
.arg(Arg::with_name("toolchain")
.long("toolchain")
.setting(ArgSettings::TakesValue)))
.subcommand(SubCommand::with_name("uninstall")
.subcommand(App::new("uninstall")
.setting(AppSettings::Hidden) // synonym for 'remove'
.arg(Arg::with_name("target")
.setting(ArgSettings::Required))
.arg(Arg::with_name("toolchain")
.long("toolchain")
.setting(ArgSettings::TakesValue))))
.subcommand(SubCommand::with_name("component")
.subcommand(App::new("component")
.about("Modify a toolchain's installed components")
.setting(AppSettings::VersionlessSubcommands)
.setting(AppSettings::DeriveDisplayOrder)
// .setting(AppSettings::SubcommandRequiredElseHelp)
.subcommand(SubCommand::with_name("list")
.subcommand(App::new("list")
.about("List installed and available components")
.arg(Arg::with_name("toolchain")
.long("toolchain")
.setting(ArgSettings::TakesValue)))
.subcommand(SubCommand::with_name("add")
.subcommand(App::new("add")
.about("Add a component to a Rust toolchain")
.arg(Arg::with_name("component").setting(ArgSettings::Required))
.arg(Arg::with_name("toolchain")
@ -138,7 +138,7 @@ pub fn build_cli() -> App<'static, 'static> {
.arg(Arg::with_name("target")
.long("target")
.setting(ArgSettings::TakesValue)))
.subcommand(SubCommand::with_name("remove")
.subcommand(App::new("remove")
.about("Remove a component from a Rust toolchain")
.arg(Arg::with_name("component").setting(ArgSettings::Required))
.arg(Arg::with_name("toolchain")
@ -147,17 +147,17 @@ pub fn build_cli() -> App<'static, 'static> {
.arg(Arg::with_name("target")
.long("target")
.setting(ArgSettings::TakesValue))))
.subcommand(SubCommand::with_name("override")
.subcommand(App::new("override")
.about("Modify directory toolchain overrides")
.after_help(OVERRIDE_HELP)
.setting(AppSettings::VersionlessSubcommands)
.setting(AppSettings::DeriveDisplayOrder)
// .setting(AppSettings::SubcommandRequiredElseHelp)
.subcommand(SubCommand::with_name("list").about("List directory toolchain overrides"))
.subcommand(SubCommand::with_name("set")
.subcommand(App::new("list").about("List directory toolchain overrides"))
.subcommand(App::new("set")
.about("Set the override toolchain for a directory")
.arg(Arg::with_name("toolchain").setting(ArgSettings::Required)))
.subcommand(SubCommand::with_name("unset")
.subcommand(App::new("unset")
.about("Remove the override toolchain for a directory")
.after_help(OVERRIDE_UNSET_HELP)
.arg(Arg::with_name("path")
@ -167,11 +167,11 @@ pub fn build_cli() -> App<'static, 'static> {
.arg(Arg::with_name("nonexistent")
.long("nonexistent")
.help("Remove override toolchain for all nonexistent directories")))
.subcommand(SubCommand::with_name("add")
.subcommand(App::new("add")
.setting(AppSettings::Hidden) // synonym for 'set'
.arg(Arg::with_name("toolchain")
.setting(ArgSettings::Required)))
.subcommand(SubCommand::with_name("remove")
.subcommand(App::new("remove")
.setting(AppSettings::Hidden) // synonym for 'unset'
.about("Remove the override toolchain for a directory")
.arg(Arg::with_name("path")
@ -180,17 +180,17 @@ pub fn build_cli() -> App<'static, 'static> {
.arg(Arg::with_name("nonexistent")
.long("nonexistent")
.help("Remove override toolchain for all nonexistent directories"))))
.subcommand(SubCommand::with_name("run")
.subcommand(App::new("run")
.about("Run a command with an environment configured for a given toolchain")
.after_help(RUN_HELP)
.setting(AppSettings::TrailingVarArg)
.arg(Arg::with_name("toolchain").setting(ArgSettings::Required))
.arg(Arg::with_name("command")
.settings(&[ArgSettings::Required, ArgSettings::MultipleValues, ArgSettings::MultipleOccurrences])))
.subcommand(SubCommand::with_name("which")
.subcommand(App::new("which")
.about("Display which binary will be run for a given command")
.arg(Arg::with_name("command").setting(ArgSettings::Required)))
.subcommand(SubCommand::with_name("doc")
.subcommand(App::new("doc")
.about("Open the documentation for the current toolchain")
.after_help(DOC_HELP)
.arg(Arg::with_name("book")
@ -200,37 +200,37 @@ pub fn build_cli() -> App<'static, 'static> {
.long("std")
.help("Standard library API documentation"))
.group(ArgGroup::with_name("page").args(&["book", "std"])))
.subcommand(SubCommand::with_name("man")
.subcommand(App::new("man")
.about("View the man page for a given command")
.arg(Arg::with_name("command").setting(ArgSettings::Required))
.arg(Arg::with_name("toolchain")
.long("toolchain")
.setting(ArgSettings::TakesValue)))
.subcommand(SubCommand::with_name("self")
.subcommand(App::new("self")
.about("Modify the rustup installation")
.setting(AppSettings::VersionlessSubcommands)
.setting(AppSettings::DeriveDisplayOrder)
.subcommand(SubCommand::with_name("update")
.subcommand(App::new("update")
.about("Download and install updates to rustup"))
.subcommand(SubCommand::with_name("uninstall")
.subcommand(App::new("uninstall")
.about("Uninstall rustup.")
.arg(Arg::with_name("no-prompt").short('y')))
.subcommand(SubCommand::with_name("upgrade-data")
.subcommand(App::new("upgrade-data")
.about("Upgrade the internal data format.")))
.subcommand(SubCommand::with_name("telemetry")
.subcommand(App::new("telemetry")
.about("rustup telemetry commands")
.setting(AppSettings::Hidden)
.setting(AppSettings::VersionlessSubcommands)
.setting(AppSettings::DeriveDisplayOrder)
.subcommand(SubCommand::with_name("enable").about("Enable rustup telemetry"))
.subcommand(SubCommand::with_name("disable").about("Disable rustup telemetry"))
.subcommand(SubCommand::with_name("analyze").about("Analyze stored telemetry")))
.subcommand(SubCommand::with_name("set")
.subcommand(App::new("enable").about("Enable rustup telemetry"))
.subcommand(App::new("disable").about("Disable rustup telemetry"))
.subcommand(App::new("analyze").about("Analyze stored telemetry")))
.subcommand(App::new("set")
.about("Alter rustup settings")
.subcommand(SubCommand::with_name("default-host")
.subcommand(App::new("default-host")
.about("The triple used to identify toolchains when not specified")
.arg(Arg::with_name("host_triple").setting(ArgSettings::Required))))
.subcommand(SubCommand::with_name("completions")
.subcommand(App::new("completions")
.about("Generate completion scripts for your shell")
.after_help(COMPLETIONS_HELP)
.setting(AppSettings::ArgRequiredElseHelp)

19
clap-test.rs
View file

@ -5,7 +5,7 @@ mod test {
use regex::Regex;
use clap::{App, Arg, SubCommand, ArgGroup};
use clap::{App, Arg, ArgGroup};
fn compare<S, S2>(l: S, r: S2) -> bool
where S: AsRef<str>,
@ -31,7 +31,7 @@ mod test {
pub fn compare_output(l: App, args: &str, right: &str, stderr: bool) -> bool {
let mut buf = Cursor::new(Vec::with_capacity(50));
let res = l.get_matches_from_safe(args.split(' ').collect::<Vec<_>>());
let res = l.try_get_matches_from(args.split(' ').collect::<Vec<_>>());
let err = res.unwrap_err();
err.write_to(&mut buf).unwrap();
let content = buf.into_inner();
@ -43,7 +43,7 @@ mod test {
pub fn compare_output2(l: App, args: &str, right1: &str, right2: &str, stderr: bool) -> bool {
let mut buf = Cursor::new(Vec::with_capacity(50));
let res = l.get_matches_from_safe(args.split(' ').collect::<Vec<_>>());
let res = l.try_get_matches_from(args.split(' ').collect::<Vec<_>>());
let err = res.unwrap_err();
err.write_to(&mut buf).unwrap();
let content = buf.into_inner();
@ -55,15 +55,14 @@ mod test {
// Legacy tests from the pyhton script days
pub fn complex_app() -> App<'static, 'static> {
let args = "-o --option=[opt]... 'tests options'
[positional] 'tests positionals'";
let opt3_vals = ["fast", "slow"];
let pos3_vals = ["vi", "emacs"];
App::new("clap-test")
.version("v1.4.8")
.about("tests clap library")
.author("Kevin K. <kbknapp@gmail.com>")
.args_from_usage(args)
.arg("-o --option=[opt]... 'tests options'")
.arg("[positional] 'tests positionals'")
.arg(Arg::from("-f --flag... 'tests flags'")
.global(true))
.args(&[
@ -77,12 +76,12 @@ mod test {
Arg::from("--minvals2 [minvals]... 'Tests 2 min vals'").min_values(2),
Arg::from("--maxvals3 [maxvals]... 'Tests 3 max vals'").max_values(3)
])
.subcommand(SubCommand::with_name("subcmd")
.subcommand(App::new("subcmd")
.about("tests subcommands")
.version("0.1")
.author("Kevin K. <kbknapp@gmail.com>")
.arg_from_usage("-o --option [scoption]... 'tests options'")
.arg_from_usage("-s --subcmdarg [subcmdarg] 'tests other args'")
.arg_from_usage("[scpositional] 'tests positionals'"))
.arg("-o --option [scoption]... 'tests options'")
.arg("-s --subcmdarg [subcmdarg] 'tests other args'")
.arg("[scpositional] 'tests positionals'"))
}
}

4
clap_test/src/lib.rs
View file

@ -33,7 +33,7 @@ where
pub fn compare_output(l: App, args: &str, right: &str, stderr: bool) -> bool {
let mut buf = Cursor::new(Vec::with_capacity(50));
let res = l.get_matches_from_safe(args.split(' ').collect::<Vec<_>>());
let res = l.try_get_matches_from(args.split(' ').collect::<Vec<_>>());
let err = res.unwrap_err();
err.write_to(&mut buf).unwrap();
let content = buf.into_inner();
@ -50,7 +50,7 @@ pub fn compare_output(l: App, args: &str, right: &str, stderr: bool) -> bool {
pub fn compare_output2(l: App, args: &str, right1: &str, right2: &str, stderr: bool) -> bool {
let mut buf = Cursor::new(Vec::with_capacity(50));
let res = l.get_matches_from_safe(args.split(' ').collect::<Vec<_>>());
let res = l.try_get_matches_from(args.split(' ').collect::<Vec<_>>());
let err = res.unwrap_err();
err.write_to(&mut buf).unwrap();
let content = buf.into_inner();

14
examples/01a_quick_example.rs
View file

@ -1,6 +1,6 @@
extern crate clap;
use clap::{App, SubCommand};
use clap::{App, };
fn main() {
// This example shows how to create an application with several arguments using usage strings, which can be
@ -35,15 +35,13 @@ fn main() {
.version("1.0")
.author("Kevin K. <kbknapp@gmail.com>")
.about("Does awesome things")
.args_from_usage(
"-c, --config=[FILE] 'Sets a custom config file'
<output> 'Sets an optional output file'
-d... 'Turn debugging information on'",
)
.arg("-c, --config=[FILE] 'Sets a custom config file'")
.arg("<output> 'Sets an optional output file'")
.arg("-d... 'Turn debugging information on'")
.subcommand(
SubCommand::with_name("test")
App::new("test")
.about("does testing things")
.arg_from_usage("-l, --list 'lists test values'"),
.arg("-l, --list 'lists test values'"),
)
.get_matches();

4
examples/01b_quick_example.rs
View file

@ -1,6 +1,6 @@
extern crate clap;
use clap::{App, Arg, SubCommand};
use clap::{App, Arg, };
fn main() {
// This method shows the traditional, and slightly more configurable way to set up arguments. This method is
@ -57,7 +57,7 @@ fn main() {
.help("Turn debugging information on"),
)
.subcommand(
SubCommand::with_name("test")
App::new("test")
.about("does testing things")
.arg(Arg::with_name("list").short('l').help("lists test values")),
)

2
examples/02_apps.rs
View file

@ -11,7 +11,7 @@ fn main() {
// another option, usage(), which is an exception to the rule. This should only be used when
// the default usage string automatically generated by clap doesn't suffice.
//
// You also set all the valid arguments your App should accept via the arg(), args(), arg_from_usage()
// You also set all the valid arguments your App should accept via the arg(), args(), arg()
// and args_from_usage() (as well as subcommands via the subcommand() and subcommands() methods) which
// will be covered later.
//

12
examples/03_args.rs
View file

@ -5,14 +5,14 @@ use clap::{App, Arg};
fn main() {
// Args describe a possible valid argument which may be supplied by the user at runtime. There
// are three different types of arguments (flags, options, and positional) as well as a fourth
// special type of argument, called SubCommands (which will be discussed separately).
// special type of argument, called s (which will be discussed separately).
//
// Args are described in the same manner as Apps using the "builder pattern" with multiple
// methods describing various settings for the individual arguments. Or by supplying a "usage"
// string. Both methods have their pros and cons.
//
// Arguments can be added to applications in two manners, one at a time with the arg(), and
// arg_from_usage() method, or multiple arguments at once via a Vec<Arg> inside the args() method,
// arg() method, or multiple arguments at once via a Vec<Arg> inside the args() method,
// or a single &str describing multiple Args (one per line) supplied to args_from_usage().
//
// There are various options which can be set for a given argument, some apply to any of the
@ -49,16 +49,16 @@ fn main() {
// *Note* the following two examples are convenience methods, if you wish
// to still get the full configurability of Arg::with_name() and the readability
// of arg_from_usage(), you can instantiate a new Arg with Arg::from() and
// of arg(), you can instantiate a new Arg with Arg::from() and
// still be able to set all the additional properties, just like Arg::with_name()
//
//
// One "Flag" using a usage string
.arg_from_usage("--license 'display the license file'")
.arg("--license 'display the license file'")
// Two args, one "Positional", and one "Option" using a usage string
.args_from_usage("[output] 'Supply an output file to use'
-i, --int=[IFACE] 'Set an interface to use'")
.arg("[output] 'Supply an output file to use'")
.arg("-i, --int=[IFACE] 'Set an interface to use'")
.get_matches();
// Here are some examples of using the arguments defined above. Keep in mind that this is only

10
examples/08_subcommands.rs
View file

@ -1,10 +1,10 @@
extern crate clap;
use clap::{App, Arg, SubCommand};
use clap::{App, Arg, };
fn main() {
// SubCommands function exactly like sub-Apps, because that's exactly what they are. Each
// instance of a SubCommand can have it's own version, author(s), Args, and even it's own
// s function exactly like sub-Apps, because that's exactly what they are. Each
// instance of a can have it's own version, author(s), Args, and even it's own
// subcommands.
//
// # Help and Version
@ -16,14 +16,14 @@ fn main() {
// subcommand along with "-h" and "--help" (applies to sub-subcommands as well).
//
// Just like arg() and args(), subcommands can be specified one at a time via subcommand() or
// multiple ones at once with a Vec<SubCommand> provided to subcommands().
// multiple ones at once with a Vec<> provided to subcommands().
let matches = App::new("MyApp")
// Normal App and Arg configuration goes here...
// In the following example assume we wanted an application which
// supported an "add" subcommand, this "add" subcommand also took
// one positional argument of a file to add:
.subcommand(SubCommand::with_name("add") // The name we call argument with
.subcommand(App::new("add") // The name we call argument with
.about("Adds files to myapp") // The message displayed in "myapp -h"
// or "myapp help"
.version("0.1") // Subcommands can have independent version

5
examples/12_typed_values.rs
View file

@ -28,9 +28,8 @@ fn main() {
let matches = App::new("myapp")
// Create two arguments, a required positional which accepts multiple values
// and an optional '-l value'
.args_from_usage(
"<seq>... 'A sequence of whole positive numbers, i.e. 20 25 30'
-l [len] 'A length to use, defaults to 10 when omitted'")
.arg("<seq>... 'A sequence of whole positive numbers, i.e. 20 25 30'")
.arg("-l [len] 'A length to use, defaults to 10 when omitted'")
.get_matches();
// Here we get a value of type u32 from our optional -l argument.

2
examples/13a_enum_values_automatic.rs
View file

@ -49,7 +49,7 @@ fn main() {
// not, the valid values will ALWAYS be displayed on a failed parse.
.possible_values(&enum_vals))
// For the second positional, lets not use possible_values() just to show the difference
.arg_from_usage("<oof> 'The Oof to use'")
.arg("<oof> 'The Oof to use'")
.get_matches();
let t = value_t!(m.value_of("foo"), Foo).unwrap_or_else(|e| e.exit());

8
examples/14_groups.rs
View file

@ -28,10 +28,10 @@ fn main() {
// Create application like normal
let matches = App::new("myapp")
// Add the version arguments
.args_from_usage("--set-ver [ver] 'set version manually'
--major 'auto inc major'
--minor 'auto inc minor'
--patch 'auto inc patch'")
.arg("--set-ver [ver] 'set version manually'")
.arg("--major 'auto inc major'")
.arg("--minor 'auto inc minor'")
.arg("--patch 'auto inc patch'")
// Create a group, make it required, and add the above arguments
.group(ArgGroup::with_name("vers")
.required(true)

6
examples/16_app_settings.rs
View file

@ -1,6 +1,6 @@
extern crate clap;
use clap::{App, AppSettings, SubCommand};
use clap::{App, AppSettings, };
fn main() {
// You can use AppSettings to change the application level behavior of clap. .setting() function
@ -15,11 +15,11 @@ fn main() {
.setting(AppSettings::SubcommandsNegateReqs)
// Negates requirement of parent command.
.arg_from_usage("<input> 'input file to use'")
.arg("<input> 'input file to use'")
// Required positional argument called input. This
// will be only required if subcommand is not present.
.subcommand(SubCommand::with_name("test")
.subcommand(App::new("test")
.about("does some testing"))
// if program is invoked with subcommand, you do not
// need to specify the <input> argument anymore due to

2
examples/18_builder_macro.rs
View file

@ -15,7 +15,7 @@ fn main() {
};
// External module may contain this subcommand. If this exists in another module, a function is
// required to access it. Recommend `fn clap() -> Clap::SubCommand`.
// required to access it. Recommend `fn clap() -> Clap::`.
let external_sub_command = clap_app!( @subcommand foo =>
(@arg bar: -b "Bar")
);

14
examples/20_subcommands.rs
View file

@ -1,5 +1,5 @@
// Working with subcommands is simple. There are a few key points to remember when working with
// subcommands in clap. First, SubCommands are really just Apps. This means they can have their own
// subcommands in clap. First, s are really just Apps. This means they can have their own
// settings, version, authors, args, and even their own subcommands. The next thing to remember is
// that subcommands are set up in a tree like heirachy.
//
@ -41,7 +41,7 @@
extern crate clap;
use clap::{App, AppSettings, Arg, SubCommand};
use clap::{App, AppSettings, Arg, };
fn main() {
let matches = App::new("git")
@ -49,28 +49,28 @@ fn main() {
.version("1.0")
.author("Me")
.subcommand(
SubCommand::with_name("clone").about("clones repos").arg(
App::new("clone").about("clones repos").arg(
Arg::with_name("repo")
.help("The repo to clone")
.required(true),
),
)
.subcommand(
SubCommand::with_name("push")
App::new("push")
.about("pushes things")
.setting(AppSettings::SubcommandRequiredElseHelp)
.subcommand(
SubCommand::with_name("remote") // Subcommands can have thier own subcommands,
App::new("remote") // Subcommands can have thier own subcommands,
// which in turn have their own subcommands
.about("pushes remote things")
.arg(Arg::with_name("repo")
.required(true)
.help("The remote repo to push things to")),
)
.subcommand(SubCommand::with_name("local").about("pushes local things")),
.subcommand(App::new("local").about("pushes local things")),
)
.subcommand(
SubCommand::with_name("add")
App::new("add")
.about("adds things")
.author("Someone Else") // Subcommands can list different authors
.version("v2.0 (I'm versioned differently") // or different version from their parents

4
examples/21_aliases.rs
View file

@ -1,11 +1,11 @@
extern crate clap;
use clap::{App, Arg, SubCommand};
use clap::{App, Arg, };
fn main() {
let matches = App::new("MyApp")
.subcommand(
SubCommand::with_name("ls")
App::new("ls")
.aliases(&["list", "dir"])
.about("Adds files to myapp")
.version("0.1")

372
src/build/app/mod.rs
View file

@ -17,7 +17,6 @@ use yaml_rust::Yaml;
// Internal
use build::{Arg, ArgGroup, ArgSettings};
use completions::{ComplGen, Shell};
use output::fmt::ColorWhen;
use output::{Help, Usage};
use parse::errors::Result as ClapResult;
@ -180,7 +179,7 @@ impl<'a, 'b> App<'a, 'b> {
/// **Pro-tip:** When building things such as third party `cargo` subcommands, this setting
/// **should** be used!
///
/// **NOTE:** This command **should not** be used for [`SubCommand`]s.
/// **NOTE:** This command **should not** be used for [``]s.
///
/// # Examples
///
@ -190,7 +189,7 @@ impl<'a, 'b> App<'a, 'b> {
/// .bin_name("my_binary")
/// # ;
/// ```
/// [`SubCommand`]: ./struct.SubCommand.html
/// [``]: ./struct..html
pub fn bin_name<S: Into<String>>(mut self, name: S) -> Self {
self.bin_name = Some(name.into());
self
@ -469,7 +468,7 @@ impl<'a, 'b> App<'a, 'b> {
self
}
/// Enables a single command, or [`SubCommand`], level settings.
/// Enables a single command, or [``], level settings.
///
/// See [`AppSettings`] for a full list of possibilities and examples.
///
@ -482,14 +481,14 @@ impl<'a, 'b> App<'a, 'b> {
/// .setting(AppSettings::WaitOnError)
/// # ;
/// ```
/// [`SubCommand`]: ./struct.SubCommand.html
/// [``]: ./struct..html
/// [`AppSettings`]: ./enum.AppSettings.html
pub fn setting(mut self, setting: AppSettings) -> Self {
self.settings.set(setting);
self
}
/// Disables a single command, or [`SubCommand`], level setting.
/// Disables a single command, or [``], level setting.
///
/// See [`AppSettings`] for a full list of possibilities and examples.
///
@ -501,11 +500,12 @@ impl<'a, 'b> App<'a, 'b> {
/// .unset_setting(AppSettings::ColorAuto)
/// # ;
/// ```
/// [`SubCommand`]: ./struct.SubCommand.html
/// [``]: ./struct..html
/// [`AppSettings`]: ./enum.AppSettings.html
/// [global]: ./struct.App.html#method.global_setting
pub fn unset_setting(mut self, setting: AppSettings) -> Self {
self.settings.unset(setting);
self.g_settings.unset(setting);
self
}
@ -683,7 +683,7 @@ impl<'a, 'b> App<'a, 'b> {
self
}
/// Allows adding a [`SubCommand`] alias, which function as "hidden" subcommands that
/// Allows adding a [``] alias, which function as "hidden" subcommands that
/// automatically dispatch as if this subcommand was used. This is more efficient, and easier
/// than creating multiple hidden subcommands as one only needs to check for the existence of
/// this command, and not all variants.
@ -691,14 +691,14 @@ impl<'a, 'b> App<'a, 'b> {
/// # Examples
///
/// ```no_run
/// # use clap::{App, Arg, SubCommand};
/// # use clap::{App, Arg, };
/// let m = App::new("myprog")
/// .subcommand(SubCommand::with_name("test")
/// .subcommand(App::new("test")
/// .alias("do-stuff"))
/// .get_matches_from(vec!["myprog", "do-stuff"]);
/// assert_eq!(m.subcommand_name(), Some("test"));
/// ```
/// [`SubCommand`]: ./struct.SubCommand.html
/// [``]: ./struct..html
pub fn alias<S: Into<&'b str>>(mut self, name: S) -> Self {
if let Some(ref mut als) = self.aliases {
als.push((name.into(), false));
@ -708,7 +708,7 @@ impl<'a, 'b> App<'a, 'b> {
self
}
/// Allows adding [`SubCommand`] aliases, which function as "hidden" subcommands that
/// Allows adding [``] aliases, which function as "hidden" subcommands that
/// automatically dispatch as if this subcommand was used. This is more efficient, and easier
/// than creating multiple hidden subcommands as one only needs to check for the existence of
/// this command, and not all variants.
@ -716,9 +716,9 @@ impl<'a, 'b> App<'a, 'b> {
/// # Examples
///
/// ```rust
/// # use clap::{App, Arg, SubCommand};
/// # use clap::{App, Arg, };
/// let m = App::new("myprog")
/// .subcommand(SubCommand::with_name("test")
/// .subcommand(App::new("test")
/// .aliases(&["do-stuff", "do-tests", "tests"]))
/// .arg(Arg::with_name("input")
/// .help("the file to add")
@ -727,7 +727,7 @@ impl<'a, 'b> App<'a, 'b> {
/// .get_matches_from(vec!["myprog", "do-tests"]);
/// assert_eq!(m.subcommand_name(), Some("test"));
/// ```
/// [`SubCommand`]: ./struct.SubCommand.html
/// [``]: ./struct..html
pub fn aliases(mut self, names: &[&'b str]) -> Self {
if let Some(ref mut als) = self.aliases {
for n in names {
@ -739,20 +739,20 @@ impl<'a, 'b> App<'a, 'b> {
self
}
/// Allows adding a [`SubCommand`] alias that functions exactly like those defined with
/// Allows adding a [``] alias that functions exactly like those defined with
/// [`App::alias`], except that they are visible inside the help message.
///
/// # Examples
///
/// ```no_run
/// # use clap::{App, Arg, SubCommand};
/// # use clap::{App, Arg, };
/// let m = App::new("myprog")
/// .subcommand(SubCommand::with_name("test")
/// .subcommand(App::new("test")
/// .visible_alias("do-stuff"))
/// .get_matches_from(vec!["myprog", "do-stuff"]);
/// assert_eq!(m.subcommand_name(), Some("test"));
/// ```
/// [`SubCommand`]: ./struct.SubCommand.html
/// [``]: ./struct..html
/// [`App::alias`]: ./struct.App.html#method.alias
pub fn visible_alias<S: Into<&'b str>>(mut self, name: S) -> Self {
if let Some(ref mut als) = self.aliases {
@ -763,20 +763,20 @@ impl<'a, 'b> App<'a, 'b> {
self
}
/// Allows adding multiple [`SubCommand`] aliases that functions exactly like those defined
/// Allows adding multiple [``] aliases that functions exactly like those defined
/// with [`App::aliases`], except that they are visible inside the help message.
///
/// # Examples
///
/// ```no_run
/// # use clap::{App, Arg, SubCommand};
/// # use clap::{App, Arg, };
/// let m = App::new("myprog")
/// .subcommand(SubCommand::with_name("test")
/// .subcommand(App::new("test")
/// .visible_aliases(&["do-stuff", "tests"]))
/// .get_matches_from(vec!["myprog", "do-stuff"]);
/// assert_eq!(m.subcommand_name(), Some("test"));
/// ```
/// [`SubCommand`]: ./struct.SubCommand.html
/// [``]: ./struct..html
/// [`App::aliases`]: ./struct.App.html#method.aliases
pub fn visible_aliases(mut self, names: &[&'b str]) -> Self {
if let Some(ref mut als) = self.aliases {
@ -860,7 +860,7 @@ impl<'a, 'b> App<'a, 'b> {
self
}
/// Adds a [`SubCommand`] to the list of valid possibilities. Subcommands are effectively
/// Adds a [``] to the list of valid possibilities. Subcommands are effectively
/// sub-[`App`]s, because they can contain their own arguments, subcommands, version, usage,
/// etc. They also function just like [`App`]s, in that they get their own auto generated help,
/// version, and usage.
@ -868,14 +868,14 @@ impl<'a, 'b> App<'a, 'b> {
/// # Examples
///
/// ```no_run
/// # use clap::{App, Arg, SubCommand};
/// # use clap::{App, Arg, };
/// App::new("myprog")
/// .subcommand(SubCommand::with_name("config")
/// .subcommand(App::new("config")
/// .about("Controls configuration features")
/// .arg_from_usage("<config> 'Required configuration file to use'"))
/// .arg("<config> 'Required configuration file to use'"))
/// # ;
/// ```
/// [`SubCommand`]: ./struct.SubCommand.html
/// [``]: ./struct..html
/// [`App`]: ./struct.App.html
pub fn subcommand(mut self, subcmd: App<'a, 'b>) -> Self {
self.subcommands.push(subcmd);
@ -883,20 +883,20 @@ impl<'a, 'b> App<'a, 'b> {
}
/// Adds multiple subcommands to the list of valid possibilities by iterating over an
/// [`IntoIterator`] of [`SubCommand`]s
/// [`IntoIterator`] of [``]s
///
/// # Examples
///
/// ```rust
/// # use clap::{App, Arg, SubCommand};
/// # use clap::{App, Arg, };
/// # App::new("myprog")
/// .subcommands( vec![
/// SubCommand::with_name("config").about("Controls configuration functionality")
/// App::new("config").about("Controls configuration functionality")
/// .arg(Arg::with_name("config_file").index(1)),
/// SubCommand::with_name("debug").about("Controls debug functionality")])
/// App::new("debug").about("Controls debug functionality")])
/// # ;
/// ```
/// [`SubCommand`]: ./struct.SubCommand.html
/// [``]: ./struct..html
/// [`IntoIterator`]: https://doc.rust-lang.org/std/iter/trait.IntoIterator.html
pub fn subcommands<I>(mut self, subcmds: I) -> Self
where
@ -908,7 +908,7 @@ impl<'a, 'b> App<'a, 'b> {
self
}
/// Allows custom ordering of [`SubCommand`]s within the help message. Subcommands with a lower
/// Allows custom ordering of [``]s within the help message. Subcommands with a lower
/// value will be displayed first in the help message. This is helpful when one would like to
/// emphasise frequently used subcommands, or prioritize those towards the top of the list.
/// Duplicate values **are** allowed. Subcommands with duplicate display orders will be
@ -919,15 +919,15 @@ impl<'a, 'b> App<'a, 'b> {
/// # Examples
///
/// ```rust
/// # use clap::{App, SubCommand};
/// # use clap::{App, };
/// let m = App::new("cust-ord")
/// .subcommand(SubCommand::with_name("alpha") // typically subcommands are grouped
/// .subcommand(App::new("alpha") // typically subcommands are grouped
/// // alphabetically by name. Subcommands
/// // without a display_order have a value of
/// // 999 and are displayed alphabetically with
/// // all other 999 subcommands
/// .about("Some help and text"))
/// .subcommand(SubCommand::with_name("beta")
/// .subcommand(App::new("beta")
/// .display_order(1) // In order to force this subcommand to appear *first*
/// // all we have to do is give it a value lower than 999.
/// // Any other subcommands with a value of 1 will be displayed
@ -954,7 +954,7 @@ impl<'a, 'b> App<'a, 'b> {
/// beta I should be first!
/// alpha Some help and text
/// ```
/// [`SubCommand`]: ./struct.SubCommand.html
/// [``]: ./struct..html
pub fn display_order(mut self, ord: usize) -> Self {
self.disp_ord = ord;
self
@ -1313,7 +1313,7 @@ impl<'a, 'b> App<'a, 'b> {
/// .unwrap_or_else( |e| { panic!("An error occurs: {}", e) });
/// ```
/// [`App::get_matches_from`]: ./struct.App.html#method.get_matches_from
/// [`App::try_get_matches`]: ./struct.App.html#method.get_matches_safe
/// [`App::try_get_matches`]: ./struct.App.html#method.try_get_matches
/// [`ErrorKind::HelpDisplayed`]: ./enum.ErrorKind.html#variant.HelpDisplayed
/// [`ErrorKind::VersionDisplayed`]: ./enum.ErrorKind.html#variant.VersionDisplayed
/// [`Error::exit`]: ./struct.Error.html#method.exit
@ -1528,34 +1528,24 @@ impl<'a, 'b> App<'a, 'b> {
pub(crate) fn _create_help_and_version(&mut self) {
debugln!("App::_create_help_and_version;");
// name is "hclap_help" because flags are sorted by name
if !self.contains_long("help") {
if !self.args.iter().any(|x| x.name == "help") {
debugln!("App::_create_help_and_version: Building --help");
if self.help_short.is_none() && !self.contains_short('h') {
self.help_short = Some('h');
}
let mut arg = Arg::with_name("hclap_help")
let help = Arg::with_name("help")
.short('h')
.long("help")
.help(self.help_message.unwrap_or("Prints help information"));
.help("Prints help information");
// we have to set short manually because we're dealing with char's
arg.short = self.help_short;
self.args.push(arg);
self.args.push(help);
} else {
self.settings.unset(AppSettings::NeedsLongHelp);
}
if !self.is_set(AppSettings::DisableVersion) && !self.contains_long("version") {
if !self.args.iter().any(|x| x.name == "version") {
debugln!("App::_create_help_and_version: Building --version");
if self.version_short.is_none() && !self.contains_short('V') {
self.version_short = Some('V');
}
// name is "vclap_version" because flags are sorted by name
let mut arg = Arg::with_name("vclap_version")
let version = Arg::with_name("version")
.short('V')
.long("version")
.help(self.version_message.unwrap_or("Prints version information"));
// we have to set short manually because we're dealing with char's
arg.short = self.version_short;
self.args.push(arg);
.help("Prints version information");
self.args.push(version);
} else {
self.settings.unset(AppSettings::NeedsLongVersion);
}
@ -1870,271 +1860,9 @@ impl<'a, 'b> App<'a, 'b> {
}
}
// @TODO @v3-beta: remove
// Deprecations
impl<'a, 'b> App<'a, 'b> {
/// **Deprecated:** Use `App::global_setting( SettingOne | SettingTwo )` instead
#[deprecated(
since = "2.33.0",
note = "Use `App::global_setting( SettingOne | SettingTwo )` instead"
)]
pub fn global_settings(mut self, settings: &[AppSettings]) -> Self {
for s in settings {
self.settings.set(*s);
self.g_settings.set(*s)
}
self
}
/// **Deprecated:** Use `App::setting( SettingOne | SettingTwo )` instead
#[deprecated(
since = "2.33.0",
note = "Use `App::setting( SettingOne | SettingTwo )` instead"
)]
pub fn settings(mut self, settings: &[AppSettings]) -> Self {
for s in settings {
self.settings.set(*s);
}
self
}
/// **Deprecated:** Use `App::unset_setting( SettingOne | SettingTwo )` instead
#[deprecated(
since = "2.33.0",
note = "Use `App::unset_setting( SettingOne | SettingTwo )` instead"
)]
pub fn unset_settings(mut self, settings: &[AppSettings]) -> Self {
for s in settings {
self.settings.unset(*s);
self.g_settings.unset(*s);
}
self
}
/// **Deprecated:** Use explicit `App::author()` and `App::version()` calls instead.
#[deprecated(
since = "2.14.1",
note = "Can never work; use explicit App::author() and \
App::version() calls instead. Will be removed in v3.0-beta"
)]
pub fn with_defaults<S: Into<String>>(n: S) -> Self {
App {
name: n.into(),
author: Some("Kevin K. <kbknapp@gmail.com>"),
version: Some("2.19.2"),
..Default::default()
}
}
/// **Deprecated:** Use
#[deprecated(
since = "2.30.0",
note = "Use App::from instead. Will be removed in v3.0-beta"
)]
#[cfg(feature = "yaml")]
pub fn from_yaml(yaml: &'a Yaml) -> App<'a, 'a> { App::from(yaml) }
/// **Deprecated:** Use
#[deprecated(
since = "2.30.0",
note = "Use `App::mut_arg(\"help\", |a| a.short(\"H\"))` instead. Will be removed in v3.0-beta"
)]
pub fn help_short<S: AsRef<str> + 'b>(mut self, s: S) -> Self {
let c = s
.as_ref()
.trim_left_matches(|c| c == '-')
.chars()
.nth(0)
.unwrap_or('h');
self.help_short = Some(c);
self
}
/// **Deprecated:** Use
#[deprecated(
since = "2.30.0",
note = "Use `App::mut_arg(\"version\", |a| a.short(\"v\"))` instead. Will be removed in v3.0-beta"
)]
pub fn version_short<S: AsRef<str>>(mut self, s: S) -> Self {
let c = s
.as_ref()
.trim_left_matches(|c| c == '-')
.chars()
.nth(0)
.unwrap_or('V');
self.version_short = Some(c);
self
}
/// **Deprecated:** Use
#[deprecated(
since = "2.30.0",
note = "Use `App::mut_arg(\"help\", |a| a.help(\"Some message\"))` instead. Will be removed in v3.0-beta"
)]
pub fn help_message<S: Into<&'a str>>(mut self, s: S) -> Self {
self.help_message = Some(s.into());
self
}
/// **Deprecated:** Use
#[deprecated(
since = "2.30.0",
note = "Use `App::mut_arg(\"version\", |a| a.short(\"Some message\"))` instead. Will be removed in v3.0-beta"
)]
pub fn version_message<S: Into<&'a str>>(mut self, s: S) -> Self {
self.version_message = Some(s.into());
self
}
/// **Deprecated:** Use
#[deprecated(
since = "2.30.0",
note = "Renamed to `App::override_usage`. Will be removed in v3.0-beta"
)]
pub fn usage<S: Into<&'b str>>(mut self, usage: S) -> Self {
self.usage_str = Some(usage.into());
self
}
/// **Deprecated:** Use
#[deprecated(
since = "2.30.0",
note = "Renamed to `App::override_help`. Will be removed in v3.0-beta"
)]
pub fn help<S: Into<&'b str>>(mut self, help: S) -> Self {
self.help_str = Some(help.into());
self
}
/// **Deprecated:** Use
#[deprecated(
since = "2.30.0",
note = "Renamed to `App::help_template`. Will be removed in v3.0-beta"
)]
pub fn template<S: Into<&'b str>>(mut self, s: S) -> Self {
self.template = Some(s.into());
self
}
/// **Deprecated:** Use
#[deprecated(
since = "2.30.0",
note = "Use `App::arg(Arg::from(&str)` instead. Will be removed in v3.0-beta"
)]
pub fn arg_from_usage(mut self, usage: &'a str) -> Self {
self.args.push(Arg::from(usage));
self
}
/// **Deprecated:** Use
#[deprecated(
since = "2.30.0",
note = "Use `App::args(&str)` instead. Will be removed in v3.0-beta"
)]
pub fn args_from_usage(mut self, usage: &'a str) -> Self {
for line in usage.lines() {
let l = line.trim();
if l.is_empty() {
continue;
}
self.args.push(Arg::from(l));
}
self
}
/// **Deprecated:** Use
#[allow(deprecated)]
#[deprecated(
since = "2.30.0",
note = "Use `clap_generate crate and clap_generate::generate_completions` instead. Will be removed in v3.0-beta"
)]
pub fn gen_completions<T: Into<OsString>, S: Into<String>>(
&mut self,
bin_name: S,
for_shell: Shell,
out_dir: T,
) {
use std::error::Error;
let out_dir = PathBuf::from(out_dir.into());
let name = &*self.bin_name.as_ref().unwrap().clone();
let file_name = match for_shell {
Shell::Bash => format!("{}.bash", name),
Shell::Fish => format!("{}.fish", name),
Shell::Zsh => format!("_{}", name),
Shell::PowerShell => format!("_{}.ps1", name),
Shell::Elvish => format!("{}.elv", name),
_ => panic!("Unsupported shell type for completion generation"),
};
let mut file = match File::create(out_dir.join(file_name)) {
Err(why) => panic!("couldn't create completion file: {}", why.description()),
Ok(file) => file,
};
self.gen_completions_to(bin_name.into(), for_shell, &mut file)
}
/// **Deprecated:** Use
#[deprecated(
since = "2.30.0",
note = "Use `clap_generate crate and clap_generate::generate_completions_to` instead. Will be removed in v3.0-beta"
)]
pub fn gen_completions_to<W: Write, S: Into<String>>(
&mut self,
bin_name: S,
for_shell: Shell,
buf: &mut W,
) {
self.bin_name = Some(bin_name.into());
if !self.is_set(AppSettings::Propagated) {
self._build(Propagation::Full);
self._build_bin_names();
}
ComplGen::new(self).generate(for_shell, buf)
}
/// **Deprecated:** Use
#[deprecated(
since = "2.30.0",
note = "Renamed `App::try_get_matches` to be consistent with Rust naming conventions. Will be removed in v3.0-beta"
)]
pub fn get_matches_safe(self) -> ClapResult<ArgMatches<'a>> {
// Start the parsing
self.try_get_matches_from(&mut env::args_os())
}
/// **Deprecated:** Use
#[deprecated(
since = "2.30.0",
note = "Renamed `App::try_get_matches_from` to be consistent with Rust naming conventions. Will be removed in v3.0-beta"
)]
pub fn get_matches_from_safe<I, T>(mut self, itr: I) -> ClapResult<ArgMatches<'a>>
where
I: IntoIterator<Item = T>,
T: Into<OsString> + Clone,
{
self.try_get_matches_from_mut(itr)
}
/// **Deprecated:** Use
#[deprecated(
since = "2.30.0",
note = "Renamed `App::try_get_matches_from_mut` to be consistent with Rust naming conventions. Will be removed in v3.0-beta"
)]
pub fn get_matches_from_safe_borrow<I, T>(&mut self, itr: I) -> ClapResult<ArgMatches<'a>>
where
I: IntoIterator<Item = T>,
T: Into<OsString> + Clone,
{
self.try_get_matches_from_mut(itr)
}
}
#[cfg(feature = "yaml")]
impl<'a> From<&'a Yaml> for App<'a, 'a> {
fn from(mut yaml: &'a Yaml) -> Self {
use parse::SubCommand;
// We WANT this to panic on error...so expect() is good.
let mut is_sc = None;
let mut a = if let Some(name) = yaml["name"].as_str() {
@ -2264,7 +1992,7 @@ impl<'a> From<&'a Yaml> for App<'a, 'a> {
}
if let Some(v) = yaml["subcommands"].as_vec() {
for sc_yaml in v {
a = a.subcommand(SubCommand::from_yaml(sc_yaml));
a = a.subcommand(::from_yaml(sc_yaml));
}
}
if let Some(v) = yaml["groups"].as_vec() {

144
src/build/app/settings.rs
View file

@ -138,7 +138,7 @@ pub enum AppSettings {
/// UTF-8 values
///
/// **NOTE:** This rule only applies to argument values, as flags, options, and
/// [`SubCommand`]s themselves only allow valid UTF-8 code points.
/// [``]s themselves only allow valid UTF-8 code points.
///
/// # Platform Specific
///
@ -154,8 +154,8 @@ pub enum AppSettings {
///
/// let r = App::new("myprog")
/// //.setting(AppSettings::AllowInvalidUtf8)
/// .arg_from_usage("<arg> 'some positional arg'")
/// .get_matches_from_safe(
/// .arg("<arg> 'some positional arg'")
/// .try_get_matches_from(
/// vec![
/// OsString::from("myprog"),
/// OsString::from_vec(vec![0xe9])]);
@ -168,7 +168,7 @@ pub enum AppSettings {
/// [`ArgMatches::os_values_of`]: ./struct.ArgMatches.html#method.os_values_of
/// [`ArgMatches::lossy_value_of`]: ./struct.ArgMatches.html#method.lossy_value_of
/// [`ArgMatches::lossy_values_of`]: ./struct.ArgMatches.html#method.lossy_values_of
/// [`SubCommand`]: ./struct.SubCommand.html
/// [``]: ./struct..html
AllowInvalidUtf8,
/// Specifies that leading hyphens are allowed in argument *values*, such as negative numbers
@ -213,7 +213,7 @@ pub enum AppSettings {
/// .version("v1.1")
/// .setting(AppSettings::AllowNegativeNumbers)
/// .arg(Arg::with_name("num"))
/// .get_matches_from_safe(vec![
/// .try_get_matches_from(vec![
/// "myprog", "-20"
/// ]);
/// assert!(res.is_ok());
@ -332,7 +332,7 @@ pub enum AppSettings {
/// Specifies that an unexpected positional argument,
/// which would otherwise cause a [`ErrorKind::UnknownArgument`] error,
/// should instead be treated as a [`SubCommand`] within the [`ArgMatches`] struct.
/// should instead be treated as a [``] within the [`ArgMatches`] struct.
///
/// **NOTE:** Use this setting with caution,
/// as a truly unexpected argument (i.e. one that is *NOT* an external subcommand)
@ -362,7 +362,7 @@ pub enum AppSettings {
/// }
/// ```
/// [`ErrorKind::UnknownArgument`]: ./enum.ErrorKind.html#variant.UnknownArgument
/// [`SubCommand`]: ./struct.SubCommand.html
/// [``]: ./struct..html
/// [`ArgMatches`]: ./struct.ArgMatches.html
AllowExternalSubcommands,
@ -384,14 +384,14 @@ pub enum AppSettings {
/// .setting(AppSettings::ArgsNegateSubcommands)
/// # ;
/// ```
/// [subcommands]: ./struct.SubCommand.html
/// [subcommands]: ./struct..html
/// [argument]: ./struct.Arg.html
ArgsNegateSubcommands,
/// Specifies that the help text should be displayed (and then exit gracefully),
/// if no arguments are present at runtime (i.e. an empty run such as, `$ myprog`.
///
/// **NOTE:** [`SubCommand`]s count as arguments
/// **NOTE:** [``]s count as arguments
///
/// **NOTE:** Setting [`Arg::default_value`] effectively disables this option as it will
/// ensure that some argument is always present.
@ -404,7 +404,7 @@ pub enum AppSettings {
/// .setting(AppSettings::ArgRequiredElseHelp)
/// # ;
/// ```
/// [`SubCommand`]: ./struct.SubCommand.html
/// [``]: ./struct..html
/// [`Arg::default_value`]: ./struct.Arg.html#method.default_value
ArgRequiredElseHelp,
@ -419,7 +419,7 @@ pub enum AppSettings {
/// # Examples
///
/// ```no_run
/// # use clap::{App, Arg, SubCommand, AppSettings};
/// # use clap::{App, Arg, AppSettings};
/// App::new("myprog")
/// .setting(AppSettings::ColoredHelp)
/// .get_matches();
@ -439,7 +439,7 @@ pub enum AppSettings {
/// # Examples
///
/// ```no_run
/// # use clap::{App, Arg, SubCommand, AppSettings};
/// # use clap::{App, Arg, AppSettings};
/// App::new("myprog")
/// .setting(AppSettings::ColorAuto)
/// .get_matches();
@ -457,7 +457,7 @@ pub enum AppSettings {
/// # Examples
///
/// ```no_run
/// # use clap::{App, Arg, SubCommand, AppSettings};
/// # use clap::{App, Arg, AppSettings};
/// App::new("myprog")
/// .setting(AppSettings::ColorAlways)
/// .get_matches();
@ -475,7 +475,7 @@ pub enum AppSettings {
/// # Examples
///
/// ```no_run
/// # use clap::{App, Arg, SubCommand, AppSettings};
/// # use clap::{App, Arg, AppSettings};
/// App::new("myprog")
/// .setting(AppSettings::ColorNever)
/// .get_matches();
@ -487,7 +487,7 @@ pub enum AppSettings {
/// # Examples
///
/// ```no_run
/// # use clap::{App, Arg, SubCommand, AppSettings};
/// # use clap::{App, Arg, AppSettings};
/// App::new("myprog")
/// .setting(AppSettings::DontCollapseArgsInUsage)
/// .get_matches();
@ -504,7 +504,7 @@ pub enum AppSettings {
/// # Examples
///
/// ```no_run
/// # use clap::{App, Arg, SubCommand, AppSettings};
/// # use clap::{App, Arg, AppSettings};
/// App::new("myprog")
/// .setting(AppSettings::DontDelimitTrailingValues)
/// .get_matches();
@ -518,23 +518,23 @@ pub enum AppSettings {
/// # Examples
///
/// ```rust
/// # use clap::{App, AppSettings, ErrorKind, SubCommand};
/// # use clap::{App, AppSettings, ErrorKind, };
/// let res = App::new("myprog")
/// .version("v1.1")
/// .setting(AppSettings::DisableHelpSubcommand)
/// // Normally, creating a subcommand causes a `help` subcommand to automaticaly
/// // be generated as well
/// .subcommand(SubCommand::with_name("test"))
/// .get_matches_from_safe(vec![
/// .subcommand(App::new("test"))
/// .try_get_matches_from(vec![
/// "myprog", "help"
/// ]);
/// assert!(res.is_err());
/// assert_eq!(res.unwrap_err().kind, ErrorKind::UnknownArgument);
/// ```
/// [`SubCommand`]: ./struct.SubCommand.html
/// [``]: ./struct..html
DisableHelpSubcommand,
/// Disables `-V` and `--version` [`App`] without affecting any of the [`SubCommand`]s
/// Disables `-V` and `--version` [`App`] without affecting any of the [``]s
/// (Defaults to `false`; application *does* have a version flag)
///
/// # Examples
@ -544,7 +544,7 @@ pub enum AppSettings {
/// let res = App::new("myprog")
/// .version("v1.1")
/// .setting(AppSettings::DisableVersion)
/// .get_matches_from_safe(vec![
/// .try_get_matches_from(vec![
/// "myprog", "-V"
/// ]);
/// assert!(res.is_err());
@ -552,36 +552,36 @@ pub enum AppSettings {
/// ```
///
/// ```rust
/// # use clap::{App, SubCommand, AppSettings, ErrorKind};
/// # use clap::{App, AppSettings, ErrorKind};
/// let res = App::new("myprog")
/// .version("v1.1")
/// .setting(AppSettings::DisableVersion)
/// .subcommand(SubCommand::with_name("test"))
/// .get_matches_from_safe(vec![
/// .subcommand(App::new("test"))
/// .try_get_matches_from(vec![
/// "myprog", "test", "-V"
/// ]);
/// assert!(res.is_err());
/// assert_eq!(res.unwrap_err().kind, ErrorKind::VersionDisplayed);
/// ```
/// [`SubCommand`]: ./struct.SubCommand.html
/// [``]: ./struct..html
/// [`App`]: ./struct.App.html
DisableVersion,
/// Displays the arguments and [`SubCommand`]s in the help message in the order that they were
/// Displays the arguments and [``]s in the help message in the order that they were
/// declared in, and not alphabetically which is the default.
///
/// # Examples
///
/// ```no_run
/// # use clap::{App, Arg, SubCommand, AppSettings};
/// # use clap::{App, Arg, AppSettings};
/// App::new("myprog")
/// .setting(AppSettings::DeriveDisplayOrder)
/// .get_matches();
/// ```
/// [`SubCommand`]: ./struct.SubCommand.html
/// [``]: ./struct..html
DeriveDisplayOrder,
/// Specifies to use the version of the current command for all child [`SubCommand`]s.
/// Specifies to use the version of the current command for all child [``]s.
/// (Defaults to `false`; subcommands have independent version strings from their parents.)
///
/// **NOTE:** The version for the current command **and** this setting must be set **prior** to
@ -590,30 +590,30 @@ pub enum AppSettings {
/// # Examples
///
/// ```no_run
/// # use clap::{App, Arg, SubCommand, AppSettings};
/// # use clap::{App, Arg, AppSettings};
/// App::new("myprog")
/// .version("v1.1")
/// .setting(AppSettings::GlobalVersion)
/// .subcommand(SubCommand::with_name("test"))
/// .subcommand(App::new("test"))
/// .get_matches();
/// // running `$ myprog test --version` will display
/// // "myprog-test v1.1"
/// ```
/// [`SubCommand`]: ./struct.SubCommand.html
/// [``]: ./struct..html
GlobalVersion,
/// Specifies that this [`SubCommand`] should be hidden from help messages
/// Specifies that this [``] should be hidden from help messages
///
/// # Examples
///
/// ```rust
/// # use clap::{App, Arg, AppSettings, SubCommand};
/// # use clap::{App, Arg, AppSettings, };
/// App::new("myprog")
/// .subcommand(SubCommand::with_name("test")
/// .subcommand(App::new("test")
/// .setting(AppSettings::Hidden))
/// # ;
/// ```
/// [`SubCommand`]: ./struct.SubCommand.html
/// [``]: ./struct..html
Hidden,
/// Tells `clap` *not* to print possible values when displaying help information.
@ -635,16 +635,16 @@ pub enum AppSettings {
/// # Examples
///
/// ```no_run
/// # use clap::{App, Arg, SubCommand, AppSettings};
/// # use clap::{App, Arg, AppSettings};
/// let m = App::new("prog")
/// .setting(AppSettings::InferSubcommands)
/// .subcommand(SubCommand::with_name("test"))
/// .subcommand(App::new("test"))
/// .get_matches_from(vec![
/// "prog", "te"
/// ]);
/// assert_eq!(m.subcommand_name(), Some("test"));
/// ```
/// [`subcommands`]: ./struct.SubCommand.html
/// [`subcommands`]: ./struct..html
/// [positional/free arguments]: ./struct.Arg.html#method.index
/// [aliases]: ./struct.App.html#method.alias
/// [`AppSeettings::ArgsNegateSubcommands`]: ./enum.AppSettings.html#variant.ArgsNegateSubcommands
@ -673,7 +673,7 @@ pub enum AppSettings {
/// # Examples
///
/// ```no_run
/// # use clap::{App, Arg, SubCommand, AppSettings};
/// # use clap::{App, Arg, AppSettings};
/// App::new("myprog")
/// .setting(AppSettings::NextLineHelp)
/// .get_matches();
@ -689,11 +689,11 @@ pub enum AppSettings {
/// # Examples
///
/// ```rust
/// # use clap::{App, Arg, AppSettings, SubCommand};
/// # use clap::{App, Arg, AppSettings, };
/// let m = App::new("myprog")
/// .arg(Arg::from("[cmd] 'command to run'")
/// .global(true))
/// .subcommand(SubCommand::with_name("foo"))
/// .subcommand(App::new("foo"))
/// .get_matches_from(vec!["myprog", "set", "foo"]);
///
/// assert_eq!(m.value_of("cmd"), Some("set"));
@ -705,11 +705,11 @@ pub enum AppSettings {
/// propagated down.
///
/// ```rust
/// # use clap::{App, Arg, AppSettings, SubCommand};
/// # use clap::{App, Arg, AppSettings, };
/// let m = App::new("myprog")
/// .arg(Arg::from("[cmd] 'command to run'")
/// .global(true))
/// .subcommand(SubCommand::with_name("foo"))
/// .subcommand(App::new("foo"))
/// .get_matches_from(vec!["myprog", "set"]);
///
/// assert_eq!(m.value_of("cmd"), Some("set"));
@ -722,7 +722,7 @@ pub enum AppSettings {
)]
PropagateGlobalValuesDown,
/// Allows [`SubCommand`]s to override all requirements of the parent command.
/// Allows [``]s to override all requirements of the parent command.
/// For example if you had a subcommand or top level application with a required argument
/// that is only required as long as there is no subcommand present,
/// using this setting would allow you to set those arguments to [`Arg::required(true)`]
@ -735,12 +735,12 @@ pub enum AppSettings {
/// This first example shows that it is an error to not use a required argument
///
/// ```rust
/// # use clap::{App, Arg, AppSettings, SubCommand, ErrorKind};
/// # use clap::{App, Arg, AppSettings, ErrorKind};
/// let err = App::new("myprog")
/// .setting(AppSettings::SubcommandsNegateReqs)
/// .arg(Arg::with_name("opt").required(true))
/// .subcommand(SubCommand::with_name("test"))
/// .get_matches_from_safe(vec![
/// .subcommand(App::new("test"))
/// .try_get_matches_from(vec![
/// "myprog"
/// ]);
/// assert!(err.is_err());
@ -752,23 +752,23 @@ pub enum AppSettings {
/// valid subcommand is used.
///
/// ```rust
/// # use clap::{App, Arg, AppSettings, SubCommand, ErrorKind};
/// # use clap::{App, Arg, AppSettings, ErrorKind};
/// let noerr = App::new("myprog")
/// .setting(AppSettings::SubcommandsNegateReqs)
/// .arg(Arg::with_name("opt").required(true))
/// .subcommand(SubCommand::with_name("test"))
/// .get_matches_from_safe(vec![
/// .subcommand(App::new("test"))
/// .try_get_matches_from(vec![
/// "myprog", "test"
/// ]);
/// assert!(noerr.is_ok());
/// # ;
/// ```
/// [`Arg::required(true)`]: ./struct.Arg.html#method.required
/// [`SubCommand`]: ./struct.SubCommand.html
/// [``]: ./struct..html
SubcommandsNegateReqs,
/// Specifies that the help text should be displayed (before exiting gracefully) if no
/// [`SubCommand`]s are present at runtime (i.e. an empty run such as `$ myprog`).
/// [``]s are present at runtime (i.e. an empty run such as `$ myprog`).
///
/// **NOTE:** This should *not* be used with [`AppSettings::SubcommandRequired`] as they do
/// nearly same thing; this prints the help text, and the other prints an error.
@ -785,7 +785,7 @@ pub enum AppSettings {
/// .setting(AppSettings::SubcommandRequiredElseHelp)
/// # ;
/// ```
/// [`SubCommand`]: ./struct.SubCommand.html
/// [``]: ./struct..html
/// [`AppSettings::SubcommandRequired`]: ./enum.AppSettings.html#variant.SubcommandRequired
/// [`AppSettings::ArgRequiredElseHelp`]: ./enum.AppSettings.html#variant.ArgRequiredElseHelp
SubcommandRequiredElseHelp,
@ -794,7 +794,7 @@ pub enum AppSettings {
/// with a [`ErrorKind::InvalidUtf8`] error.
///
/// **NOTE:** This rule only applies to argument values; Things such as flags, options, and
/// [`SubCommand`]s themselves only allow valid UTF-8 code points.
/// [``]s themselves only allow valid UTF-8 code points.
///
/// # Platform Specific
///
@ -810,8 +810,8 @@ pub enum AppSettings {
///
/// let m = App::new("myprog")
/// .setting(AppSettings::StrictUtf8)
/// .arg_from_usage("<arg> 'some positional arg'")
/// .get_matches_from_safe(
/// .arg("<arg> 'some positional arg'")
/// .try_get_matches_from(
/// vec![
/// OsString::from("myprog"),
/// OsString::from_vec(vec![0xe9])]);
@ -819,11 +819,11 @@ pub enum AppSettings {
/// assert!(m.is_err());
/// assert_eq!(m.unwrap_err().kind, ErrorKind::InvalidUtf8);
/// ```
/// [`SubCommand`]: ./struct.SubCommand.html
/// [``]: ./struct..html
/// [`ErrorKind::InvalidUtf8`]: ./enum.ErrorKind.html#variant.InvalidUtf8
StrictUtf8,
/// Allows specifying that if no [`SubCommand`] is present at runtime,
/// Allows specifying that if no [``] is present at runtime,
/// error and exit gracefully.
///
/// **NOTE:** This defaults to `false` (subcommands do *not* need to be present)
@ -831,18 +831,18 @@ pub enum AppSettings {
/// # Examples
///
/// ```rust
/// # use clap::{App, AppSettings, SubCommand, ErrorKind};
/// # use clap::{App, AppSettings, ErrorKind};
/// let err = App::new("myprog")
/// .setting(AppSettings::SubcommandRequired)
/// .subcommand(SubCommand::with_name("test"))
/// .get_matches_from_safe(vec![
/// .subcommand(App::new("test"))
/// .try_get_matches_from(vec![
/// "myprog",
/// ]);
/// assert!(err.is_err());
/// assert_eq!(err.unwrap_err().kind, ErrorKind::MissingSubcommand);
/// # ;
/// ```
/// [`SubCommand`]: ./struct.SubCommand.html
/// [``]: ./struct..html
SubcommandRequired,
/// Specifies that the final positional argument is a "VarArg" and that `clap` should not
@ -879,7 +879,7 @@ pub enum AppSettings {
/// # Examples
///
/// ```no_run
/// # use clap::{App, Arg, SubCommand, AppSettings};
/// # use clap::{App, Arg, AppSettings};
/// App::new("myprog")
/// .setting(AppSettings::UnifiedHelpMessage)
/// .get_matches();
@ -887,7 +887,7 @@ pub enum AppSettings {
/// ```
UnifiedHelpMessage,
/// Disables `-V` and `--version` for all [`SubCommand`]s
/// Disables `-V` and `--version` for all [``]s
/// (Defaults to `false`; subcommands *do* have version flags.)
///
/// **NOTE:** This setting must be set **prior** adding any subcommands
@ -895,18 +895,18 @@ pub enum AppSettings {
/// # Examples
///
/// ```rust
/// # use clap::{App, SubCommand, AppSettings, ErrorKind};
/// # use clap::{App, AppSettings, ErrorKind};
/// let res = App::new("myprog")
/// .version("v1.1")
/// .setting(AppSettings::VersionlessSubcommands)
/// .subcommand(SubCommand::with_name("test"))
/// .get_matches_from_safe(vec![
/// .subcommand(App::new("test"))
/// .try_get_matches_from(vec![
/// "myprog", "test", "-V"
/// ]);
/// assert!(res.is_err());
/// assert_eq!(res.unwrap_err().kind, ErrorKind::UnknownArgument);
/// ```
/// [`SubCommand`]: ./struct.SubCommand.html
/// [``]: ./struct..html
VersionlessSubcommands,
/// Will display a message "Press \[ENTER\]/\[RETURN\] to continue..." and wait for user before
@ -916,7 +916,7 @@ pub enum AppSettings {
/// Windows where a user tries to open the binary by double-clicking instead of using the
/// command line.
///
/// **NOTE:** This setting is **not** recursive with [`SubCommand`]s, meaning if you wish this
/// **NOTE:** This setting is **not** recursive with [``]s, meaning if you wish this
/// behavior for all subcommands, you must set this on each command (needing this is extremely
/// rare)
///
@ -928,7 +928,7 @@ pub enum AppSettings {
/// .setting(AppSettings::WaitOnError)
/// # ;
/// ```
/// [`SubCommand`]: ./struct.SubCommand.html
/// [``]: ./struct..html
WaitOnError,
#[doc(hidden)]

110
src/build/arg/mod.rs
View file

@ -569,7 +569,7 @@ impl<'a, 'b> Arg<'a, 'b> {
/// .long("config"))
/// .arg(Arg::with_name("dbg")
/// .long("debug"))
/// .get_matches_from_safe(vec![
/// .try_get_matches_from(vec![
/// "prog", "--debug"
/// ]);
///
@ -587,7 +587,7 @@ impl<'a, 'b> Arg<'a, 'b> {
/// .long("config"))
/// .arg(Arg::with_name("dbg")
/// .long("debug"))
/// .get_matches_from_safe(vec![
/// .try_get_matches_from(vec![
/// "prog"
/// ]);
///
@ -638,7 +638,7 @@ impl<'a, 'b> Arg<'a, 'b> {
/// .arg(Arg::with_name("infile")
/// .short('i')
/// .takes_value(true))
/// .get_matches_from_safe(vec![
/// .try_get_matches_from(vec![
/// "prog", "--debug", "-i", "file"
/// ]);
///
@ -660,7 +660,7 @@ impl<'a, 'b> Arg<'a, 'b> {
/// .arg(Arg::with_name("infile")
/// .short('i')
/// .takes_value(true))
/// .get_matches_from_safe(vec![
/// .try_get_matches_from(vec![
/// "prog"
/// ]);
///
@ -712,7 +712,7 @@ impl<'a, 'b> Arg<'a, 'b> {
/// .arg(Arg::with_name("infile")
/// .short('i')
/// .takes_value(true))
/// .get_matches_from_safe(vec![
/// .try_get_matches_from(vec![
/// "prog", "--debug"
/// ]);
///
@ -734,7 +734,7 @@ impl<'a, 'b> Arg<'a, 'b> {
/// .arg(Arg::with_name("infile")
/// .short('i')
/// .takes_value(true))
/// .get_matches_from_safe(vec![
/// .try_get_matches_from(vec![
/// "prog"
/// ]);
///
@ -785,7 +785,7 @@ impl<'a, 'b> Arg<'a, 'b> {
/// .long("config"))
/// .arg(Arg::with_name("debug")
/// .long("debug"))
/// .get_matches_from_safe(vec![
/// .try_get_matches_from(vec![
/// "prog", "--debug", "--config", "file.conf"
/// ]);
///
@ -834,7 +834,7 @@ impl<'a, 'b> Arg<'a, 'b> {
/// .long("debug"))
/// .arg(Arg::with_name("input")
/// .index(1))
/// .get_matches_from_safe(vec![
/// .try_get_matches_from(vec![
/// "prog", "--config", "file.conf", "file.txt"
/// ]);
///
@ -1028,7 +1028,7 @@ impl<'a, 'b> Arg<'a, 'b> {
/// .long("config"))
/// .arg(Arg::with_name("input")
/// .index(1))
/// .get_matches_from_safe(vec![
/// .try_get_matches_from(vec![
/// "prog"
/// ]);
///
@ -1046,7 +1046,7 @@ impl<'a, 'b> Arg<'a, 'b> {
/// .long("config"))
/// .arg(Arg::with_name("input")
/// .index(1))
/// .get_matches_from_safe(vec![
/// .try_get_matches_from(vec![
/// "prog", "--config", "file.conf"
/// ]);
///
@ -1098,7 +1098,7 @@ impl<'a, 'b> Arg<'a, 'b> {
/// .requires_if("my.cfg", "other")
/// .long("config"))
/// .arg(Arg::with_name("other"))
/// .get_matches_from_safe(vec![
/// .try_get_matches_from(vec![
/// "prog", "--config", "some.cfg"
/// ]);
///
@ -1116,7 +1116,7 @@ impl<'a, 'b> Arg<'a, 'b> {
/// .requires_if("my.cfg", "input")
/// .long("config"))
/// .arg(Arg::with_name("input"))
/// .get_matches_from_safe(vec![
/// .try_get_matches_from(vec![
/// "prog", "--config", "my.cfg"
/// ]);
///
@ -1176,7 +1176,7 @@ impl<'a, 'b> Arg<'a, 'b> {
/// .long("option")
/// .takes_value(true))
/// .arg(Arg::with_name("other"))
/// .get_matches_from_safe(vec![
/// .try_get_matches_from(vec![
/// "prog", "--config", "special.conf"
/// ]);
///
@ -1234,7 +1234,7 @@ impl<'a, 'b> Arg<'a, 'b> {
/// .arg(Arg::with_name("other")
/// .long("other")
/// .takes_value(true))
/// .get_matches_from_safe(vec![
/// .try_get_matches_from(vec![
/// "prog", "--other", "not-special"
/// ]);
///
@ -1254,7 +1254,7 @@ impl<'a, 'b> Arg<'a, 'b> {
/// .arg(Arg::with_name("other")
/// .long("other")
/// .takes_value(true))
/// .get_matches_from_safe(vec![
/// .try_get_matches_from(vec![
/// "prog", "--other", "special"
/// ]);
///
@ -1317,7 +1317,7 @@ impl<'a, 'b> Arg<'a, 'b> {
/// .arg(Arg::with_name("option")
/// .takes_value(true)
/// .long("option"))
/// .get_matches_from_safe(vec![
/// .try_get_matches_from(vec![
/// "prog", "--option", "other"
/// ]);
///
@ -1343,7 +1343,7 @@ impl<'a, 'b> Arg<'a, 'b> {
/// .arg(Arg::with_name("option")
/// .takes_value(true)
/// .long("option"))
/// .get_matches_from_safe(vec![
/// .try_get_matches_from(vec![
/// "prog", "--option", "spec"
/// ]);
///
@ -1398,7 +1398,7 @@ impl<'a, 'b> Arg<'a, 'b> {
/// .index(1))
/// .arg(Arg::with_name("output")
/// .index(2))
/// .get_matches_from_safe(vec![
/// .try_get_matches_from(vec![
/// "prog"
/// ]);
///
@ -1419,7 +1419,7 @@ impl<'a, 'b> Arg<'a, 'b> {
/// .index(1))
/// .arg(Arg::with_name("output")
/// .index(2))
/// .get_matches_from_safe(vec![
/// .try_get_matches_from(vec![
/// "prog", "--config", "file.conf", "in.txt"
/// ]);
///
@ -1587,7 +1587,7 @@ impl<'a, 'b> Arg<'a, 'b> {
/// .long("mode")
/// .takes_value(true)
/// .possible_values(&["fast", "slow", "medium"]))
/// .get_matches_from_safe(vec![
/// .try_get_matches_from(vec![
/// "prog", "--mode", "wrong"
/// ]);
/// assert!(res.is_err());
@ -1652,7 +1652,7 @@ impl<'a, 'b> Arg<'a, 'b> {
/// .possible_value("fast")
/// .possible_value("slow")
/// .possible_value("medium"))
/// .get_matches_from_safe(vec![
/// .try_get_matches_from(vec![
/// "prog", "--mode", "wrong"
/// ]);
/// assert!(res.is_err());
@ -1779,7 +1779,7 @@ impl<'a, 'b> Arg<'a, 'b> {
/// .takes_value(true)
/// .number_of_values(2)
/// .short('F'))
/// .get_matches_from_safe(vec![
/// .try_get_matches_from(vec![
/// "prog", "-F", "file1"
/// ]);
///
@ -1819,7 +1819,7 @@ impl<'a, 'b> Arg<'a, 'b> {
/// .arg(Arg::with_name("file")
/// .index(1)
/// .validator(has_at))
/// .get_matches_from_safe(vec![
/// .try_get_matches_from(vec![
/// "prog", "some@file"
/// ]);
/// assert!(res.is_ok());
@ -1858,7 +1858,7 @@ impl<'a, 'b> Arg<'a, 'b> {
/// .arg(Arg::with_name("file")
/// .index(1)
/// .validator_os(has_ampersand))
/// .get_matches_from_safe(vec![
/// .try_get_matches_from(vec![
/// "prog", "Fish & chips"
/// ]);
/// assert!(res.is_ok());
@ -1907,7 +1907,7 @@ impl<'a, 'b> Arg<'a, 'b> {
/// .takes_value(true)
/// .max_values(3)
/// .short('F'))
/// .get_matches_from_safe(vec![
/// .try_get_matches_from(vec![
/// "prog", "-F", "file1", "file2"
/// ]);
///
@ -1926,7 +1926,7 @@ impl<'a, 'b> Arg<'a, 'b> {
/// .takes_value(true)
/// .max_values(2)
/// .short('F'))
/// .get_matches_from_safe(vec![
/// .try_get_matches_from(vec![
/// "prog", "-F", "file1", "file2", "file3"
/// ]);
///
@ -1971,7 +1971,7 @@ impl<'a, 'b> Arg<'a, 'b> {
/// .takes_value(true)
/// .min_values(2)
/// .short('F'))
/// .get_matches_from_safe(vec![
/// .try_get_matches_from(vec![
/// "prog", "-F", "file1", "file2", "file3"
/// ]);
///
@ -1990,7 +1990,7 @@ impl<'a, 'b> Arg<'a, 'b> {
/// .takes_value(true)
/// .min_values(2)
/// .short('F'))
/// .get_matches_from_safe(vec![
/// .try_get_matches_from(vec![
/// "prog", "-F", "file1"
/// ]);
///
@ -2974,7 +2974,7 @@ impl<'a, 'b> Arg<'a, 'b> {
}
}
/// Specifies that an argument can be matched to all child [`SubCommand`]s.
/// Specifies that an argument can be matched to all child [``]s.
///
/// **NOTE:** Global arguments *only* propagate down, **not** up (to parent commands), however
/// their values once a user uses them will be propagated back up to parents. In effect, this
@ -2996,14 +2996,14 @@ impl<'a, 'b> Arg<'a, 'b> {
/// want to clutter the source with three duplicate [`Arg`] definitions.
///
/// ```rust
/// # use clap::{App, Arg, SubCommand, ArgSettings};
/// # use clap::{App, Arg, ArgSettings};
/// let m = App::new("prog")
/// .arg(Arg::with_name("verb")
/// .long("verbose")
/// .short('v')
/// .setting(ArgSettings::Global))
/// .subcommand(SubCommand::with_name("test"))
/// .subcommand(SubCommand::with_name("do-stuff"))
/// .subcommand(App::new("test"))
/// .subcommand(App::new("do-stuff"))
/// .get_matches_from(vec![
/// "prog", "do-stuff", "--verbose"
/// ]);
@ -3012,7 +3012,7 @@ impl<'a, 'b> Arg<'a, 'b> {
/// let sub_m = m.subcommand_matches("do-stuff").unwrap();
/// assert!(sub_m.is_present("verb"));
/// ```
/// [`SubCommand`]: ./struct.App.html#method.subcommand
/// [``]: ./struct.App.html#method.subcommand
/// [required]: ./enum.ArgSettings.html#variant.Required
/// [`ArgMatches`]: ./struct.ArgMatches.html
/// [`ArgMatches::is_present("flag")`]: ./struct.ArgMatches.html#method.is_present
@ -3846,9 +3846,9 @@ impl<'a, 'b> Arg<'a, 'b> {
/// ```
pub fn hidden_short_help(self, hide: bool) -> Self {
if hide {
self.set(ArgSettings::HiddenShortHelp)
self.setting(ArgSettings::HiddenShortHelp)
} else {
self.unset(ArgSettings::HiddenShortHelp)
self.unset_setting(ArgSettings::HiddenShortHelp)
}
}
@ -3923,9 +3923,9 @@ impl<'a, 'b> Arg<'a, 'b> {
/// ```
pub fn hidden_long_help(self, hide: bool) -> Self {
if hide {
self.set(ArgSettings::HiddenLongHelp)
self.setting(ArgSettings::HiddenLongHelp)
} else {
self.unset(ArgSettings::HiddenLongHelp)
self.unset_setting(ArgSettings::HiddenLongHelp)
}
}
@ -4050,46 +4050,12 @@ impl<'a, 'b> Arg<'a, 'b> {
}
}
// Deprecations
// @TODO @v3-beta: remove
impl<'a, 'b> Arg<'a, 'b> {
/// **Deprecated**
#[deprecated(
since = "2.30.0",
note = "Renamed to `Arg::setting`. Will be removed in v3.0-beta"
)]
pub fn set(mut self, s: ArgSettings) -> Self {
self.setb(s);
self
}
/// **Deprecated**
#[deprecated(
since = "2.30.0",
note = "Renamed to `Arg::unset_setting`. Will be removed in v3.0-beta"
)]
pub fn unset(mut self, s: ArgSettings) -> Self {
self.unsetb(s);
self
}
/// **Deprecated**
#[deprecated(
since = "2.30.0",
note = "Use `Arg::from` instead. Will be removed in v3.0-beta"
)]
pub fn from_usage(u: &'a str) -> Self {
let parser = UsageParser::from_usage(u);
parser.parse()
}
}
impl<'a, 'b, 'z> From<&'z Arg<'a, 'b>> for Arg<'a, 'b> {
fn from(a: &'z Arg<'a, 'b>) -> Self { a.clone() }
}
impl<'a, 'b> From<&'a str> for Arg<'a, 'b> {
fn from(s: &'a str) -> Self { Self::from_usage(s) }
fn from(s: &'a str) -> Self { UsageParser::from_usage(s).parse() }
}
impl<'n, 'e> PartialEq for Arg<'n, 'e> {

38
src/build/arg_group.rs
View file

@ -39,15 +39,14 @@ use yaml_rust;
/// ```rust
/// # use clap::{App, ArgGroup, ErrorKind};
/// let result = App::new("app")
/// .args_from_usage(
/// "--set-ver [ver] 'set the version manually'
/// --major 'auto increase major'
/// --minor 'auto increase minor'
/// --patch 'auto increase patch'")
/// .arg("--set-ver [ver] 'set the version manually'")
/// .arg("--major 'auto increase major'")
/// .arg("--minor 'auto increase minor'")
/// .arg("--patch 'auto increase patch'")
/// .group(ArgGroup::with_name("vers")
/// .args(&["set-ver", "major", "minor","patch"])
/// .required(true))
/// .get_matches_from_safe(vec!["app", "--major", "--patch"]);
/// .try_get_matches_from(vec!["app", "--major", "--patch"]);
/// // Because we used two args in the group it's an error
/// assert!(result.is_err());
/// let err = result.unwrap_err();
@ -58,15 +57,14 @@ use yaml_rust;
/// ```rust
/// # use clap::{App, ArgGroup};
/// let result = App::new("app")
/// .args_from_usage(
/// "--set-ver [ver] 'set the version manually'
/// --major 'auto increase major'
/// --minor 'auto increase minor'
/// --patch 'auto increase patch'")
/// .arg("--set-ver [ver] 'set the version manually'")
/// .arg("--major 'auto increase major'")
/// .arg("--minor 'auto increase minor'")
/// .arg("--patch 'auto increase patch'")
/// .group(ArgGroup::with_name("vers")
/// .args(&["set-ver", "major", "minor","patch"])
/// .required(true))
/// .get_matches_from_safe(vec!["app", "--major"]);
/// .try_get_matches_from(vec!["app", "--major"]);
/// assert!(result.is_ok());
/// let matches = result.unwrap();
/// // We may not know which of the args was used, so we can test for the group...
@ -225,7 +223,7 @@ impl<'a> ArgGroup<'a> {
/// .short('c'))
/// .group(ArgGroup::with_name("req_flags")
/// .args(&["flag", "color"]))
/// .get_matches_from_safe(vec!["myprog", "-f", "-c"]);
/// .try_get_matches_from(vec!["myprog", "-f", "-c"]);
/// // Because we used both args in the group it's an error
/// assert!(result.is_err());
/// let err = result.unwrap_err();
@ -242,7 +240,7 @@ impl<'a> ArgGroup<'a> {
/// that one argument from this group *must* be present at runtime (unless
/// conflicting with another argument).
///
/// **NOTE:** This setting only applies to the current [`App`] / [`SubCommand`], and not
/// **NOTE:** This setting only applies to the current [`App`] / [``], and not
/// globally.
///
/// **NOTE:** By default, [`ArgGroup::multiple`] is set to `false` which when combined with
@ -262,14 +260,14 @@ impl<'a> ArgGroup<'a> {
/// .group(ArgGroup::with_name("req_flags")
/// .args(&["flag", "color"])
/// .required(true))
/// .get_matches_from_safe(vec!["myprog"]);
/// .try_get_matches_from(vec!["myprog"]);
/// // Because we didn't use any of the args in the group, it's an error
/// assert!(result.is_err());
/// let err = result.unwrap_err();
/// assert_eq!(err.kind, ErrorKind::MissingRequiredArgument);
/// ```
/// [`App`]: ./struct.App.html
/// [`SubCommand`]: ./struct.SubCommand.html
/// [``]: ./struct..html
/// [`ArgGroup::multiple`]: ./struct.ArgGroup.html#method.multiple
pub fn required(mut self, r: bool) -> Self {
self.required = r;
@ -297,7 +295,7 @@ impl<'a> ArgGroup<'a> {
/// .group(ArgGroup::with_name("req_flags")
/// .args(&["flag", "color"])
/// .requires("debug"))
/// .get_matches_from_safe(vec!["myprog", "-c"]);
/// .try_get_matches_from(vec!["myprog", "-c"]);
/// // because we used an arg from the group, and the group requires "-d" to be used, it's an
/// // error
/// assert!(result.is_err());
@ -338,7 +336,7 @@ impl<'a> ArgGroup<'a> {
/// .group(ArgGroup::with_name("req_flags")
/// .args(&["flag", "color"])
/// .requires_all(&["debug", "verb"]))
/// .get_matches_from_safe(vec!["myprog", "-c", "-d"]);
/// .try_get_matches_from(vec!["myprog", "-c", "-d"]);
/// // because we used an arg from the group, and the group requires "-d" and "-v" to be used,
/// // yet we only used "-d" it's an error
/// assert!(result.is_err());
@ -374,7 +372,7 @@ impl<'a> ArgGroup<'a> {
/// .group(ArgGroup::with_name("req_flags")
/// .args(&["flag", "color"])
/// .conflicts_with("debug"))
/// .get_matches_from_safe(vec!["myprog", "-c", "-d"]);
/// .try_get_matches_from(vec!["myprog", "-c", "-d"]);
/// // because we used an arg from the group, and the group conflicts with "-d", it's an error
/// assert!(result.is_err());
/// let err = result.unwrap_err();
@ -412,7 +410,7 @@ impl<'a> ArgGroup<'a> {
/// .group(ArgGroup::with_name("req_flags")
/// .args(&["flag", "color"])
/// .conflicts_with_all(&["debug", "verb"]))
/// .get_matches_from_safe(vec!["myprog", "-c", "-v"]);
/// .try_get_matches_from(vec!["myprog", "-c", "-v"]);
/// // because we used an arg from the group, and the group conflicts with either "-v" or "-d"
/// // it's an error
/// assert!(result.is_err());

190
src/completions/bash.rs
View file

@ -1,190 +0,0 @@
// Std
use std::io::Write;
// Internal
use build::{App, Arg};
use completions;
pub struct BashGen<'a, 'b>(&'b App<'a, 'b>)
where
'a: 'b;
impl<'a, 'b> BashGen<'a, 'b> {
pub fn new(app: &'b App<'a, 'b>) -> Self { BashGen(app) }
pub fn generate_to<W: Write>(&self, buf: &mut W) {
w!(
buf,
format!(
"_{name}() {{
local i cur prev opts cmds
COMPREPLY=()
cur=\"${{COMP_WORDS[COMP_CWORD]}}\"
prev=\"${{COMP_WORDS[COMP_CWORD-1]}}\"
cmd=\"\"
opts=\"\"
for i in ${{COMP_WORDS[@]}}
do
case \"${{i}}\" in
{name})
cmd=\"{name}\"
;;
{subcmds}
*)
;;
esac
done
case \"${{cmd}}\" in
{name})
opts=\"{name_opts}\"
if [[ ${{cur}} == -* || ${{COMP_CWORD}} -eq 1 ]] ; then
COMPREPLY=( $(compgen -W \"${{opts}}\" -- ${{cur}}) )
return 0
fi
case \"${{prev}}\" in
{name_opts_details}
*)
COMPREPLY=()
;;
esac
COMPREPLY=( $(compgen -W \"${{opts}}\" -- ${{cur}}) )
return 0
;;
{subcmd_details}
esac
}}
complete -F _{name} -o bashdefault -o default {name}
",
name = self.0.bin_name.as_ref().unwrap(),
name_opts = self.all_options_for_path(self.0.bin_name.as_ref().unwrap()),
name_opts_details = self.option_details_for_path(self.0.bin_name.as_ref().unwrap()),
subcmds = self.all_subcommands(),
subcmd_details = self.subcommand_details()
).as_bytes()
);
}
fn all_subcommands(&self) -> String {
debugln!("BashGen::all_subcommands;");
let mut subcmds = String::new();
let scs = completions::all_subcommand_names(self.0);
for sc in &scs {
subcmds = format!(
"{}
{name})
cmd+=\"__{fn_name}\"
;;",
subcmds,
name = sc,
fn_name = sc.replace("-", "__")
);
}
subcmds
}
fn subcommand_details(&self) -> String {
debugln!("BashGen::subcommand_details;");
let mut subcmd_dets = String::new();
let mut scs = completions::get_all_subcommand_paths(self.0, true);
scs.sort();
scs.dedup();
for sc in &scs {
subcmd_dets = format!(
"{}
{subcmd})
opts=\"{sc_opts}\"
if [[ ${{cur}} == -* || ${{COMP_CWORD}} -eq {level} ]] ; then
COMPREPLY=( $(compgen -W \"${{opts}}\" -- ${{cur}}) )
return 0
fi
case \"${{prev}}\" in
{opts_details}
*)
COMPREPLY=()
;;
esac
COMPREPLY=( $(compgen -W \"${{opts}}\" -- ${{cur}}) )
return 0
;;",
subcmd_dets,
subcmd = sc.replace("-", "__"),
sc_opts = self.all_options_for_path(&*sc),
level = sc.split("__").map(|_| 1).fold(0, |acc, n| acc + n),
opts_details = self.option_details_for_path(&*sc)
);
}
subcmd_dets
}
fn option_details_for_path(&self, path: &str) -> String {
debugln!("BashGen::option_details_for_path: path={}", path);
let mut p = self.0;
for sc in path.split("__").skip(1) {
debugln!("BashGen::option_details_for_path:iter: sc={}", sc);
p = &find_subcmd!(p, sc).unwrap();
}
let mut opts = String::new();
for o in opts!(p) {
if let Some(l) = o.long {
opts = format!(
"{}
--{})
COMPREPLY=({})
return 0
;;",
opts,
l,
self.vals_for(o)
);
}
if let Some(s) = o.short {
opts = format!(
"{}
-{})
COMPREPLY=({})
return 0
;;",
opts,
s,
self.vals_for(o)
);
}
}
opts
}
fn vals_for(&self, o: &Arg) -> String {
debugln!("BashGen::vals_for: o={}", o.name);
if let Some(ref vals) = o.possible_vals {
format!("$(compgen -W \"{}\" -- ${{cur}})", vals.join(" "))
} else {
String::from("$(compgen -f ${cur})")
}
}
fn all_options_for_path(&self, path: &str) -> String {
debugln!("BashGen::all_options_for_path: path={}", path);
let mut p = self.0;
for sc in path.split("__").skip(1) {
debugln!("BashGen::all_options_for_path:iter: sc={}", sc);
p = &find_subcmd!(p, sc).unwrap();
}
let opts = format!(
"{shorts} {longs} {pos} {subcmds}",
shorts = shorts!(p).fold(String::new(), |acc, s| format!("{} -{}", acc, s)),
// Handles aliases too
longs = longs!(p).fold(String::new(), |acc, l| format!("{} --{}", acc, l)),
pos = positionals!(p).fold(String::new(), |acc, p| format!("{} {}", acc, p)),
// Handles aliases too
subcmds = sc_names!(p).fold(String::new(), |acc, s| format!("{} {}", acc, s))
);
opts
}
}

129
src/completions/elvish.rs
View file

@ -1,129 +0,0 @@
// Std
use std::io::Write;
// Internal
use build::App;
use INTERNAL_ERROR_MSG;
pub struct ElvishGen<'a, 'b, 'c>
where
'a: 'b,
'b: 'c,
{
app: &'c App<'a, 'b>,
}
impl<'a, 'b, 'c> ElvishGen<'a, 'b, 'c> {
pub fn new(p: &'c App<'a, 'b>) -> Self { ElvishGen { app: p } }
pub fn generate_to<W: Write>(&self, buf: &mut W) {
let bin_name = self.app.bin_name.as_ref().unwrap();
let mut names = vec![];
let subcommands_cases = generate_inner(self.app, "", &mut names);
let result = format!(
r#"
edit:completion:arg-completer[{bin_name}] = [@words]{{
fn spaces [n]{{
repeat $n ' ' | joins ''
}}
fn cand [text desc]{{
edit:complex-candidate $text &display-suffix=' '(spaces (- 14 (wcswidth $text)))$desc
}}
command = '{bin_name}'
for word $words[1:-1] {{
if (has-prefix $word '-') {{
break
}}
command = $command';'$word
}}
completions = [{subcommands_cases}
]
$completions[$command]
}}
"#,
bin_name = bin_name,
subcommands_cases = subcommands_cases
);
w!(buf, result.as_bytes());
}
}
// Escape string inside single quotes
fn escape_string(string: &str) -> String { string.replace("'", "''") }
fn get_tooltip<T: ToString>(help: Option<&str>, data: T) -> String {
match help {
Some(help) => escape_string(help),
_ => data.to_string(),
}
}
fn generate_inner<'a, 'b, 'c>(
p: &'c App<'a, 'b>,
previous_command_name: &str,
names: &mut Vec<&'a str>,
) -> String
where
'a: 'b,
'b: 'c,
{
debugln!("ElvishGen::generate_inner;");
let command_name = if previous_command_name.is_empty() {
p.bin_name.as_ref().expect(INTERNAL_ERROR_MSG).clone()
} else {
format!("{};{}", previous_command_name, &p.name)
};
let mut completions = String::new();
let preamble = String::from("\n cand ");
for option in opts!(p) {
if let Some(data) = option.short {
let tooltip = get_tooltip(option.help, data);
completions.push_str(&preamble);
completions.push_str(format!("-{} '{}'", data, tooltip).as_str());
}
if let Some(data) = option.long {
let tooltip = get_tooltip(option.help, data);
completions.push_str(&preamble);
completions.push_str(format!("--{} '{}'", data, tooltip).as_str());
}
}
for flag in flags!(p) {
if let Some(data) = flag.short {
let tooltip = get_tooltip(flag.help, data);
completions.push_str(&preamble);
completions.push_str(format!("-{} '{}'", data, tooltip).as_str());
}
if let Some(data) = flag.long {
let tooltip = get_tooltip(flag.help, data);
completions.push_str(&preamble);
completions.push_str(format!("--{} '{}'", data, tooltip).as_str());
}
}
for subcommand in &p.subcommands {
let data = &subcommand.name;
let tooltip = get_tooltip(subcommand.about, data);
completions.push_str(&preamble);
completions.push_str(format!("{} '{}'", data, tooltip).as_str());
}
let mut subcommands_cases = format!(
r"
&'{}'= {{{}
}}",
&command_name, completions
);
for subcommand in &p.subcommands {
let subcommand_subcommands_cases = generate_inner(&subcommand, &command_name, names);
subcommands_cases.push_str(&subcommand_subcommands_cases);
}
subcommands_cases
}

96
src/completions/fish.rs
View file

@ -1,96 +0,0 @@
// Std
use std::io::Write;
// Internal
use build::App;
pub struct FishGen<'a, 'b>(&'b App<'a, 'b>)
where
'a: 'b;
impl<'a, 'b> FishGen<'a, 'b> {
pub fn new(app: &'b App<'a, 'b>) -> Self { FishGen(app) }
pub fn generate_to<W: Write>(&self, buf: &mut W) {
let command = self.0.bin_name.as_ref().unwrap();
let mut buffer = String::new();
gen_fish_inner(command, self, command, &mut buffer);
w!(buf, buffer.as_bytes());
}
}
// Escape string inside single quotes
fn escape_string(string: &str) -> String { string.replace("\\", "\\\\").replace("'", "\\'") }
fn gen_fish_inner(root_command: &str, comp_gen: &FishGen, subcommand: &str, buffer: &mut String) {
debugln!("FishGen::gen_fish_inner;");
// example :
//
// complete
// -c {command}
// -d "{description}"
// -s {short}
// -l {long}
// -a "{possible_arguments}"
// -r # if require parameter
// -f # don't use file completion
// -n "__fish_use_subcommand" # complete for command "myprog"
// -n "__fish_seen_subcommand_from subcmd1" # complete for command "myprog subcmd1"
let mut basic_template = format!("complete -c {} -n ", root_command);
if root_command == subcommand {
basic_template.push_str("\"__fish_use_subcommand\"");
} else {
basic_template.push_str(format!("\"__fish_seen_subcommand_from {}\"", subcommand).as_str());
}
for option in opts!(comp_gen.0) {
let mut template = basic_template.clone();
if let Some(data) = option.short {
template.push_str(format!(" -s {}", data).as_str());
}
if let Some(data) = option.long {
template.push_str(format!(" -l {}", data).as_str());
}
if let Some(data) = option.help {
template.push_str(format!(" -d '{}'", escape_string(data)).as_str());
}
if let Some(ref data) = option.possible_vals {
template.push_str(format!(" -r -f -a \"{}\"", data.join(" ")).as_str());
}
buffer.push_str(template.as_str());
buffer.push_str("\n");
}
for flag in flags!(comp_gen.0) {
let mut template = basic_template.clone();
if let Some(data) = flag.short {
template.push_str(format!(" -s {}", data).as_str());
}
if let Some(data) = flag.long {
template.push_str(format!(" -l {}", data).as_str());
}
if let Some(data) = flag.help {
template.push_str(format!(" -d '{}'", escape_string(data)).as_str());
}
buffer.push_str(template.as_str());
buffer.push_str("\n");
}
for subcommand in subcommands!(comp_gen.0) {
let mut template = basic_template.clone();
template.push_str(" -f");
template.push_str(format!(" -a \"{}\"", &subcommand.name).as_str());
if let Some(data) = subcommand.about {
template.push_str(format!(" -d '{}'", escape_string(data)).as_str())
}
buffer.push_str(template.as_str());
buffer.push_str("\n");
}
// generate options of subcommands
for subcommand in &comp_gen.0.subcommands {
let sub_comp_gen = FishGen::new(&subcommand);
gen_fish_inner(root_command, &sub_comp_gen, &subcommand.to_string(), buffer);
}
}

28
src/completions/macros.rs
View file

@ -1,28 +0,0 @@
macro_rules! w {
($buf:expr, $to_w:expr) => {
match $buf.write_all($to_w) {
Ok(..) => (),
Err(..) => panic!("Failed to write to completions file"),
}
};
}
macro_rules! get_zsh_arg_conflicts {
($app:expr, $arg:ident, $msg:ident) => {
if let Some(ref conf_vec) = $arg.blacklist {
let mut v = vec![];
for arg_name in conf_vec {
let arg = find!($app, arg_name).expect($msg);
if let Some(s) = arg.short {
v.push(format!("-{}", s));
}
if let Some(l) = arg.long {
v.push(format!("--{}", l));
}
}
v.join(" ")
} else {
String::new()
}
};
}

163
src/completions/mod.rs
View file

@ -1,163 +0,0 @@
#[macro_use]
mod macros;
mod bash;
mod elvish;
mod fish;
mod powershell;
mod shell;
mod zsh;
// Std
use std::io::Write;
// Internal
use self::bash::BashGen;
use self::elvish::ElvishGen;
use self::fish::FishGen;
use self::powershell::PowerShellGen;
pub use self::shell::Shell;
use self::zsh::ZshGen;
use build::App;
pub struct ComplGen<'a, 'b>(&'b App<'a, 'b>)
where
'a: 'b;
impl<'a, 'b> ComplGen<'a, 'b> {
pub fn new(app: &'b App<'a, 'b>) -> Self { ComplGen(app) }
pub fn generate<W: Write>(&self, for_shell: Shell, buf: &mut W) {
match for_shell {
Shell::Bash => BashGen::new(self.0).generate_to(buf),
Shell::Fish => FishGen::new(self.0).generate_to(buf),
Shell::Zsh => ZshGen::new(self.0).generate_to(buf),
Shell::PowerShell => PowerShellGen::new(self.0).generate_to(buf),
Shell::Elvish => ElvishGen::new(self.0).generate_to(buf),
_ => panic!("Unsupported shell type for generating completions"),
}
}
}
// Gets all subcommands including child subcommands in the form of 'name' where the name
// is a single word (i.e. "install") of the path to said subcommand (i.e.
// "rustup toolchain install")
//
// Also note, aliases are treated as their own subcommands but duplicates of whatever they're
// aliasing.
pub fn all_subcommand_names(p: &App) -> Vec<String> {
debugln!("all_subcommand_names;");
let mut subcmds: Vec<_> = subcommands_of(p)
.iter()
.map(|&(ref n, _)| n.clone())
.collect();
for sc_v in subcommands!(p).map(|s| all_subcommand_names(&s)) {
subcmds.extend(sc_v);
}
subcmds.sort();
subcmds.dedup();
subcmds
}
// Gets all subcommands including child subcommands in the form of ('name', 'bin_name') where the name
// is a single word (i.e. "install") of the path and full bin_name of said subcommand (i.e.
// "rustup toolchain install")
//
// Also note, aliases are treated as their own subcommands but duplicates of whatever they're
// aliasing.
pub fn all_subcommands(p: &App) -> Vec<(String, String)> {
debugln!("all_subcommands;");
let mut subcmds: Vec<_> = subcommands_of(p);
for sc_v in subcommands!(p).map(|s| all_subcommands(&s)) {
subcmds.extend(sc_v);
}
subcmds
}
// Gets all subcommands exlcuding child subcommands in the form of (name, bin_name) where the name
// is a single word (i.e. "install") and the bin_name is a space deliniated list of the path to said
// subcommand (i.e. "rustup toolchain install")
//
// Also note, aliases are treated as their own subcommands but duplicates of whatever they're
// aliasing.
pub fn subcommands_of(p: &App) -> Vec<(String, String)> {
debugln!(
"subcommands_of: name={}, bin_name={}",
p.name,
p.bin_name.as_ref().unwrap()
);
let mut subcmds = vec![];
debugln!(
"subcommands_of: Has subcommands...{:?}",
p.has_subcommands()
);
if !p.has_subcommands() {
let mut ret = vec![];
debugln!("subcommands_of: Looking for aliases...");
if let Some(ref aliases) = p.aliases {
for &(n, _) in aliases {
debugln!("subcommands_of:iter:iter: Found alias...{}", n);
let mut als_bin_name: Vec<_> = p.bin_name.as_ref().unwrap().split(' ').collect();
als_bin_name.push(n);
let old = als_bin_name.len() - 2;
als_bin_name.swap_remove(old);
ret.push((n.to_owned(), als_bin_name.join(" ")));
}
}
return ret;
}
for sc in subcommands!(p) {
debugln!(
"subcommands_of:iter: name={}, bin_name={}",
sc.name,
sc.bin_name.as_ref().unwrap()
);
debugln!("subcommands_of:iter: Looking for aliases...");
if let Some(ref aliases) = sc.aliases {
for &(n, _) in aliases {
debugln!("subcommands_of:iter:iter: Found alias...{}", n);
let mut als_bin_name: Vec<_> = p.bin_name.as_ref().unwrap().split(' ').collect();
als_bin_name.push(n);
let old = als_bin_name.len() - 2;
als_bin_name.swap_remove(old);
subcmds.push((n.to_owned(), als_bin_name.join(" ")));
}
}
subcmds.push((sc.name.clone(), sc.bin_name.as_ref().unwrap().clone()));
}
subcmds
}
pub fn get_all_subcommand_paths(p: &App, first: bool) -> Vec<String> {
debugln!("get_all_subcommand_paths;");
let mut subcmds = vec![];
if !p.has_subcommands() {
if !first {
let name = &*p.name;
let path = p.bin_name.as_ref().unwrap().clone().replace(" ", "__");
let mut ret = vec![path.clone()];
if let Some(ref aliases) = p.aliases {
for &(n, _) in aliases {
ret.push(path.replace(name, n));
}
}
return ret;
}
return vec![];
}
for sc in subcommands!(p) {
let name = &*sc.name;
let path = sc.bin_name.as_ref().unwrap().clone().replace(" ", "__");
subcmds.push(path.clone());
if let Some(ref aliases) = sc.aliases {
for &(n, _) in aliases {
subcmds.push(path.replace(name, n));
}
}
}
for sc_v in subcommands!(p).map(|s| get_all_subcommand_paths(&s, false)) {
subcmds.extend(sc_v);
}
subcmds
}

154
src/completions/powershell.rs
View file

@ -1,154 +0,0 @@
// Std
use std::io::Write;
// Internal
use build::App;
use INTERNAL_ERROR_MSG;
pub struct PowerShellGen<'a, 'b>(&'b App<'a, 'b>)
where
'a: 'b;
impl<'a, 'b> PowerShellGen<'a, 'b> {
pub fn new(app: &'b App<'a, 'b>) -> Self { PowerShellGen(app) }
pub fn generate_to<W: Write>(&self, buf: &mut W) {
let bin_name = self.0.bin_name.as_ref().unwrap();
let mut names = vec![];
let subcommands_cases = generate_inner(self.0, "", &mut names);
let result = format!(
r#"
using namespace System.Management.Automation
using namespace System.Management.Automation.Language
Register-ArgumentCompleter -Native -CommandName '{bin_name}' -ScriptBlock {{
param($wordToComplete, $commandAst, $cursorPosition)
$commandElements = $commandAst.CommandElements
$command = @(
'{bin_name}'
for ($i = 1; $i -lt $commandElements.Count; $i++) {{
$element = $commandElements[$i]
if ($element -isnot [StringConstantExpressionAst] -or
$element.StringConstantType -ne [StringConstantType]::BareWord -or
$element.Value.StartsWith('-')) {{
break
}}
$element.Value
}}) -join ';'
$completions = @(switch ($command) {{{subcommands_cases}
}})
$completions.Where{{ $_.CompletionText -like "$wordToComplete*" }} |
Sort-Object -Property ListItemText
}}
"#,
bin_name = bin_name,
subcommands_cases = subcommands_cases
);
w!(buf, result.as_bytes());
}
}
// Escape string inside single quotes
fn escape_string(string: &str) -> String { string.replace("'", "''") }
fn get_tooltip<T: ToString>(help: Option<&str>, data: T) -> String {
match help {
Some(help) => escape_string(&help),
_ => data.to_string(),
}
}
fn generate_inner<'a, 'b, 'p>(
p: &'p App<'a, 'b>,
previous_command_name: &str,
names: &mut Vec<&'p str>,
) -> String {
debugln!("PowerShellGen::generate_inner;");
let command_name = if previous_command_name.is_empty() {
p.bin_name.as_ref().expect(INTERNAL_ERROR_MSG).clone()
} else {
format!("{};{}", previous_command_name, &p.name)
};
let mut completions = String::new();
let preamble = String::from("\n [CompletionResult]::new(");
for option in opts!(p) {
if let Some(data) = option.short {
let tooltip = get_tooltip(option.help, data);
completions.push_str(&preamble);
completions.push_str(
format!(
"'-{}', '{}', {}, '{}')",
data, data, "[CompletionResultType]::ParameterName", tooltip
).as_str(),
);
}
if let Some(data) = option.long {
let tooltip = get_tooltip(option.help, data);
completions.push_str(&preamble);
completions.push_str(
format!(
"'--{}', '{}', {}, '{}')",
data, data, "[CompletionResultType]::ParameterName", tooltip
).as_str(),
);
}
}
for flag in flags!(p) {
if let Some(data) = flag.short {
let tooltip = get_tooltip(flag.help, data);
completions.push_str(&preamble);
completions.push_str(
format!(
"'-{}', '{}', {}, '{}')",
data, data, "[CompletionResultType]::ParameterName", tooltip
).as_str(),
);
}
if let Some(data) = flag.long {
let tooltip = get_tooltip(flag.help, data);
completions.push_str(&preamble);
completions.push_str(
format!(
"'--{}', '{}', {}, '{}')",
data, data, "[CompletionResultType]::ParameterName", tooltip
).as_str(),
);
}
}
for subcommand in subcommands!(p) {
let data = &subcommand.name;
let tooltip = get_tooltip(subcommand.about, data);
completions.push_str(&preamble);
completions.push_str(
format!(
"'{}', '{}', {}, '{}')",
data, data, "[CompletionResultType]::ParameterValue", tooltip
).as_str(),
);
}
let mut subcommands_cases = format!(
r"
'{}' {{{}
break
}}",
&command_name, completions
);
for subcommand in &p.subcommands {
let subcommand_subcommands_cases = generate_inner(&subcommand, &command_name, names);
subcommands_cases.push_str(&subcommand_subcommands_cases);
}
subcommands_cases
}

57
src/completions/shell.rs
View file

@ -1,57 +0,0 @@
#[allow(unused_imports)]
use std::ascii::AsciiExt;
use std::fmt;
use std::str::FromStr;
/// Describes which shell to produce a completions file for
#[cfg_attr(feature = "lints", allow(enum_variant_names))]
#[derive(Debug, Copy, Clone)]
pub enum Shell {
/// Generates a .bash completion file for the Bourne Again SHell (BASH)
Bash,
/// Generates a .fish completion file for the Friendly Interactive SHell (fish)
Fish,
/// Generates a completion file for the Z SHell (ZSH)
Zsh,
/// Generates a completion file for PowerShell
PowerShell,
/// Generates a completion file for Elvish
Elvish,
#[doc(hidden)]
__Nonexhaustive,
}
impl Shell {
/// A list of possible variants in `&'static str` form
pub fn variants() -> [&'static str; 5] { ["zsh", "bash", "fish", "powershell", "elvish"] }
}
impl FromStr for Shell {
type Err = String;
fn from_str(s: &str) -> Result<Self, Self::Err> {
match s {
"ZSH" | _ if s.eq_ignore_ascii_case("zsh") => Ok(Shell::Zsh),
"FISH" | _ if s.eq_ignore_ascii_case("fish") => Ok(Shell::Fish),
"BASH" | _ if s.eq_ignore_ascii_case("bash") => Ok(Shell::Bash),
"POWERSHELL" | _ if s.eq_ignore_ascii_case("powershell") => Ok(Shell::PowerShell),
"ELVISH" | _ if s.eq_ignore_ascii_case("elvish") => Ok(Shell::Elvish),
_ => Err(String::from(
"[valid values: bash, fish, zsh, powershell, elvish]",
)),
}
}
}
impl fmt::Display for Shell {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
Shell::Bash => write!(f, "BASH"),
Shell::Fish => write!(f, "FISH"),
Shell::Zsh => write!(f, "ZSH"),
Shell::PowerShell => write!(f, "POWERSHELL"),
Shell::Elvish => write!(f, "ELVISH"),
_ => panic!("Unsupported shell type for completion generation"),
}
}
}

485
src/completions/zsh.rs
View file

@ -1,485 +0,0 @@
// Std
#[allow(unused_imports)]
use std::ascii::AsciiExt;
use std::io::Write;
// Internal
use build::{App, ArgSettings};
use completions;
use INTERNAL_ERROR_MSG;
pub struct ZshGen<'a, 'b>(&'b App<'a, 'b>)
where
'a: 'b;
impl<'a, 'b> ZshGen<'a, 'b> {
pub fn new(app: &'b App<'a, 'b>) -> Self {
debugln!("ZshGen::new;");
ZshGen(app)
}
pub fn generate_to<W: Write>(&self, buf: &mut W) {
debugln!("ZshGen::generate_to;");
w!(
buf,
format!(
"\
#compdef {name}
autoload -U is-at-least
_{name}() {{
typeset -A opt_args
typeset -a _arguments_options
local ret=1
if is-at-least 5.2; then
_arguments_options=(-s -S -C)
else
_arguments_options=(-s -C)
fi
local context curcontext=\"$curcontext\" state line
{initial_args}
{subcommands}
}}
{subcommand_details}
_{name} \"$@\"",
name = self.0.bin_name.as_ref().unwrap(),
initial_args = get_args_of(self.0),
subcommands = get_subcommands_of(self.0),
subcommand_details = subcommand_details(self.0)
).as_bytes()
);
}
}
// Displays the commands of a subcommand
// (( $+functions[_[bin_name_underscore]_commands] )) ||
// _[bin_name_underscore]_commands() {
// local commands; commands=(
// '[arg_name]:[arg_help]'
// )
// _describe -t commands '[bin_name] commands' commands "$@"
//
// Where the following variables are present:
// [bin_name_underscore]: The full space deliniated bin_name, where spaces have been replaced by
// underscore characters
// [arg_name]: The name of the subcommand
// [arg_help]: The help message of the subcommand
// [bin_name]: The full space deliniated bin_name
//
// Here's a snippet from rustup:
//
// (( $+functions[_rustup_commands] )) ||
// _rustup_commands() {
// local commands; commands=(
// 'show:Show the active and installed toolchains'
// 'update:Update Rust toolchains'
// # ... snip for brevity
// 'help:Prints this message or the help of the given subcommand(s)'
// )
// _describe -t commands 'rustup commands' commands "$@"
//
fn subcommand_details(p: &App) -> String {
debugln!("ZshGen::subcommand_details;");
// First we do ourself
let mut ret = vec![format!(
"\
(( $+functions[_{bin_name_underscore}_commands] )) ||
_{bin_name_underscore}_commands() {{
local commands; commands=(
{subcommands_and_args}
)
_describe -t commands '{bin_name} commands' commands \"$@\"
}}",
bin_name_underscore = p.bin_name.as_ref().unwrap().replace(" ", "__"),
bin_name = p.bin_name.as_ref().unwrap(),
subcommands_and_args = subcommands_of(p)
)];
// Next we start looping through all the children, grandchildren, etc.
let mut all_subcommands = completions::all_subcommands(p);
all_subcommands.sort();
all_subcommands.dedup();
for &(_, ref bin_name) in &all_subcommands {
debugln!("ZshGen::subcommand_details:iter: bin_name={}", bin_name);
ret.push(format!(
"\
(( $+functions[_{bin_name_underscore}_commands] )) ||
_{bin_name_underscore}_commands() {{
local commands; commands=(
{subcommands_and_args}
)
_describe -t commands '{bin_name} commands' commands \"$@\"
}}",
bin_name_underscore = bin_name.replace(" ", "__"),
bin_name = bin_name,
subcommands_and_args = subcommands_of(parser_of(p, bin_name))
));
}
ret.join("\n")
}
// Generates subcommand completions in form of
//
// '[arg_name]:[arg_help]'
//
// Where:
// [arg_name]: the subcommand's name
// [arg_help]: the help message of the subcommand
//
// A snippet from rustup:
// 'show:Show the active and installed toolchains'
// 'update:Update Rust toolchains'
fn subcommands_of(p: &App) -> String {
debugln!("ZshGen::subcommands_of;");
let mut ret = vec![];
fn add_sc(sc: &App, n: &str, ret: &mut Vec<String>) {
debugln!("ZshGen::add_sc;");
let s = format!(
"\"{name}:{help}\" \\",
name = n,
help = sc
.about
.unwrap_or("")
.replace("[", "\\[")
.replace("]", "\\]")
);
if !s.is_empty() {
ret.push(s);
}
}
// The subcommands
for sc in subcommands!(p) {
debugln!("ZshGen::subcommands_of:iter: subcommand={}", sc.name);
add_sc(sc, &sc.name, &mut ret);
if let Some(ref v) = sc.aliases {
for alias in v.iter().filter(|&&(_, vis)| vis).map(|&(n, _)| n) {
add_sc(sc, alias, &mut ret);
}
}
}
ret.join("\n")
}
// Get's the subcommand section of a completion file
// This looks roughly like:
//
// case $state in
// ([bin_name]_args)
// curcontext=\"${curcontext%:*:*}:[name_hyphen]-command-$words[1]:\"
// case $line[1] in
//
// ([name])
// _arguments -C -s -S \
// [subcommand_args]
// && ret=0
//
// [RECURSIVE_CALLS]
//
// ;;",
//
// [repeat]
//
// esac
// ;;
// esac",
//
// Where the following variables are present:
// [name] = The subcommand name in the form of "install" for "rustup toolchain install"
// [bin_name] = The full space deliniated bin_name such as "rustup toolchain install"
// [name_hyphen] = The full space deliniated bin_name, but replace spaces with hyphens
// [repeat] = From the same recursive calls, but for all subcommands
// [subcommand_args] = The same as zsh::get_args_of
fn get_subcommands_of(p: &App) -> String {
debugln!("get_subcommands_of;");
debugln!(
"get_subcommands_of: Has subcommands...{:?}",
p.has_subcommands()
);
if !p.has_subcommands() {
return String::new();
}
let sc_names = completions::subcommands_of(p);
let mut subcmds = vec![];
for &(ref name, ref bin_name) in &sc_names {
let mut v = vec![format!("({})", name)];
let subcommand_args = get_args_of(parser_of(p, &*bin_name));
if !subcommand_args.is_empty() {
v.push(subcommand_args);
}
let subcommands = get_subcommands_of(parser_of(p, &*bin_name));
if !subcommands.is_empty() {
v.push(subcommands);
}
v.push(String::from(";;"));
subcmds.push(v.join("\n"));
}
format!(
"case $state in
({name})
words=($line[{pos}] \"${{words[@]}}\")
(( CURRENT += 1 ))
curcontext=\"${{curcontext%:*:*}}:{name_hyphen}-command-$line[{pos}]:\"
case $line[{pos}] in
{subcommands}
esac
;;
esac",
name = p.name,
name_hyphen = p.bin_name.as_ref().unwrap().replace(" ", "-"),
subcommands = subcmds.join("\n"),
pos = positionals!(p).count() + 1
)
}
fn parser_of<'a, 'b>(p: &'b App<'a, 'b>, mut sc: &str) -> &'b App<'a, 'b> {
debugln!("parser_of: sc={}", sc);
if sc == p.bin_name.as_ref().unwrap_or(&String::new()) {
return p;
}
sc = sc.split(" ").last().unwrap();
find_subcmd!(p, sc).expect(INTERNAL_ERROR_MSG)
}
// Writes out the args section, which ends up being the flags, opts and postionals, and a jump to
// another ZSH function if there are subcommands.
// The structer works like this:
// ([conflicting_args]) [multiple] arg [takes_value] [[help]] [: :(possible_values)]
// ^-- list '-v -h' ^--'*' ^--'+' ^-- list 'one two three'
//
// An example from the rustup command:
//
// _arguments -C -s -S \
// '(-h --help --verbose)-v[Enable verbose output]' \
// '(-V -v --version --verbose --help)-h[Prints help information]' \
// # ... snip for brevity
// ':: :_rustup_commands' \ # <-- displays subcommands
// '*::: :->rustup' \ # <-- displays subcommand args and child subcommands
// && ret=0
//
// The args used for _arguments are as follows:
// -C: modify the $context internal variable
// -s: Allow stacking of short args (i.e. -a -b -c => -abc)
// -S: Do not complete anything after '--' and treat those as argument values
fn get_args_of(p: &App) -> String {
debugln!("get_args_of;");
let mut ret = vec![String::from("_arguments \"${_arguments_options[@]}\" \\")];
let opts = write_opts_of(p);
let flags = write_flags_of(p);
let positionals = write_positionals_of(p);
let sc_or_a = if p.has_subcommands() {
format!(
"\":: :_{name}_commands\" \\",
name = p.bin_name.as_ref().unwrap().replace(" ", "__")
)
} else {
String::new()
};
let sc = if p.has_subcommands() {
format!("\"*::: :->{name}\" \\", name = p.name)
} else {
String::new()
};
if !opts.is_empty() {
ret.push(opts);
}
if !flags.is_empty() {
ret.push(flags);
}
if !positionals.is_empty() {
ret.push(positionals);
}
if !sc_or_a.is_empty() {
ret.push(sc_or_a);
}
if !sc.is_empty() {
ret.push(sc);
}
ret.push(String::from("&& ret=0"));
ret.join("\n")
}
// Escape help string inside single quotes and brackets
fn escape_help(string: &str) -> String {
string
.replace("\\", "\\\\")
.replace("'", "'\\''")
.replace("[", "\\[")
.replace("]", "\\]")
}
// Escape value string inside single quotes and parentheses
fn escape_value(string: &str) -> String {
string
.replace("\\", "\\\\")
.replace("'", "'\\''")
.replace("(", "\\(")
.replace(")", "\\)")
.replace(" ", "\\ ")
}
fn write_opts_of(p: &App) -> String {
debugln!("write_opts_of;");
let mut ret = vec![];
for o in opts!(p) {
debugln!("write_opts_of:iter: o={}", o.name);
let help = o.help.map_or(String::new(), escape_help);
let mut conflicts = get_zsh_arg_conflicts!(p, o, INTERNAL_ERROR_MSG);
conflicts = if conflicts.is_empty() {
String::new()
} else {
format!("({})", conflicts)
};
// @TODO @soundness should probably be either multiple occurrences or multiple values and
// not both
let multiple = if o.is_set(ArgSettings::MultipleOccurrences)
|| o.is_set(ArgSettings::MultipleValues)
{
"*"
} else {
""
};
let pv = if let Some(ref pv_vec) = o.possible_vals {
format!(
": :({})",
pv_vec
.iter()
.map(|v| escape_value(*v))
.collect::<Vec<String>>()
.join(" ")
)
} else {
String::new()
};
if let Some(short) = o.short {
let s = format!(
"'{conflicts}{multiple}-{arg}+[{help}]{possible_values}' \\",
conflicts = conflicts,
multiple = multiple,
arg = short,
possible_values = pv,
help = help
);
debugln!("write_opts_of:iter: Wrote...{}", &*s);
ret.push(s);
}
if let Some(long) = o.long {
let l = format!(
"'{conflicts}{multiple}--{arg}=[{help}]{possible_values}' \\",
conflicts = conflicts,
multiple = multiple,
arg = long,
possible_values = pv,
help = help
);
debugln!("write_opts_of:iter: Wrote...{}", &*l);
ret.push(l);
}
}
ret.join("\n")
}
fn write_flags_of(p: &App) -> String {
debugln!("write_flags_of;");
let mut ret = vec![];
for f in flags!(p) {
debugln!("write_flags_of:iter: f={}", f.name);
let help = f.help.map_or(String::new(), escape_help);
let mut conflicts = get_zsh_arg_conflicts!(p, f, INTERNAL_ERROR_MSG);
conflicts = if conflicts.is_empty() {
String::new()
} else {
format!("({})", conflicts)
};
let multiple = if f.is_set(ArgSettings::MultipleOccurrences) {
"*"
} else {
""
};
if let Some(short) = f.short {
let s = format!(
"'{conflicts}{multiple}-{arg}[{help}]' \\",
multiple = multiple,
conflicts = conflicts,
arg = short,
help = help
);
debugln!("write_flags_of:iter: Wrote...{}", &*s);
ret.push(s);
}
if let Some(long) = f.long {
let l = format!(
"'{conflicts}{multiple}--{arg}[{help}]' \\",
conflicts = conflicts,
multiple = multiple,
arg = long,
help = help
);
debugln!("write_flags_of:iter: Wrote...{}", &*l);
ret.push(l);
}
}
ret.join("\n")
}
fn write_positionals_of(p: &App) -> String {
debugln!("write_positionals_of;");
let mut ret = vec![];
for arg in positionals!(p) {
debugln!("write_positionals_of:iter: arg={}", arg.name);
let a = format!(
"'{optional}:{name}{help}:{action}' \\",
optional = if !arg.is_set(ArgSettings::Required) {
":"
} else {
""
},
name = arg.name,
help = arg
.help
.map_or("".to_owned(), |v| " -- ".to_owned() + v)
.replace("[", "\\[")
.replace("]", "\\]"),
action = arg
.possible_vals
.as_ref()
.map_or("_files".to_owned(), |values| {
format!(
"({})",
values
.iter()
.map(|v| escape_value(*v))
.collect::<Vec<String>>()
.join(" ")
)
})
);
debugln!("write_positionals_of:iter: Wrote...{}", a);
ret.push(a);
}
ret.join("\n")
}

21
src/lib.rs
View file

@ -46,7 +46,7 @@
//! // more verbose, but allows easier editing, and at times more advanced options, or the possibility
//! // to generate arguments dynamically.
//! extern crate clap;
//! use clap::{Arg, App, SubCommand};
//! use clap::{Arg, App, };
//!
//! fn main() {
//! let matches = App::new("My Super Program")
@ -67,7 +67,7 @@
//! .short('v')
//! .multiple(true)
//! .help("Sets the level of verbosity"))
//! .subcommand(SubCommand::with_name("test")
//! .subcommand(App::new("test")
//! .about("controls testing features")
//! .version("1.3")
//! .author("Someone E. <someone_else@other.com>")
@ -117,22 +117,21 @@
//! // This example demonstrates clap's "usage strings" method of creating arguments
//! // which is less verbose
//! extern crate clap;
//! use clap::{Arg, App, SubCommand};
//! use clap::{Arg, App, };
//!
//! fn main() {
//! let matches = App::new("myapp")
//! .version("1.0")
//! .author("Kevin K. <kbknapp@gmail.com>")
//! .about("Does awesome things")
//! .args_from_usage(
//! "-c, --config=[FILE] 'Sets a custom config file'
//! <INPUT> 'Sets the input file to use'
//! -v... 'Sets the level of verbosity'")
//! .subcommand(SubCommand::with_name("test")
//! .arg("-c, --config=[FILE] 'Sets a custom config file'")
//! .arg("<INPUT> 'Sets the input file to use'")
//! .arg("-v... 'Sets the level of verbosity'")
//! .subcommand(App::new("test")
//! .about("controls testing features")
//! .version("1.3")
//! .author("Someone E. <someone_else@other.com>")
//! .arg_from_usage("-d, --debug 'Print debug information'"))
//! .arg("-d, --debug 'Print debug information'"))
//! .get_matches();
//!
//! // Same as previous example...
@ -566,10 +565,9 @@ extern crate vec_map;
extern crate yaml_rust;
pub use build::{App, AppSettings, Arg, ArgGroup, ArgSettings, Propagation};
pub use completions::Shell;
pub use output::fmt::Format;
pub use parse::errors::{Error, ErrorKind, Result};
pub use parse::{ArgMatches, OsValues, SubCommand, Values};
pub use parse::{ArgMatches, OsValues, Values};
#[cfg(feature = "yaml")]
pub use yaml_rust::YamlLoader;
@ -582,7 +580,6 @@ use std::result::Result as StdResult;
#[macro_use]
mod macros;
mod build;
mod completions;
mod output;
mod parse;
mod util;

14
src/macros.rs
View file

@ -46,7 +46,7 @@ macro_rules! load_yaml {
/// # use clap::App;
/// # fn main() {
/// let matches = App::new("myapp")
/// .arg_from_usage("[length] 'Set the length to use as a pos whole num, i.e. 20'")
/// .arg("[length] 'Set the length to use as a pos whole num, i.e. 20'")
/// .get_matches();
///
/// let len = value_t!(matches.value_of("length"), u32).unwrap_or_else(|e| e.exit());
@ -92,7 +92,7 @@ macro_rules! value_t {
/// # use clap::App;
/// # fn main() {
/// let matches = App::new("myapp")
/// .arg_from_usage("[length] 'Set the length to use as a pos whole num, i.e. 20'")
/// .arg("[length] 'Set the length to use as a pos whole num, i.e. 20'")
/// .get_matches();
///
/// let len = value_t_or_exit!(matches.value_of("length"), u32);
@ -136,7 +136,7 @@ macro_rules! value_t_or_exit {
/// # use clap::App;
/// # fn main() {
/// let matches = App::new("myapp")
/// .arg_from_usage("[seq]... 'A sequence of pos whole nums, i.e. 20 45'")
/// .arg("[seq]... 'A sequence of pos whole nums, i.e. 20 45'")
/// .get_matches();
///
/// let vals = values_t!(matches.values_of("seq"), u32).unwrap_or_else(|e| e.exit());
@ -198,7 +198,7 @@ macro_rules! values_t {
/// # use clap::App;
/// # fn main() {
/// let matches = App::new("myapp")
/// .arg_from_usage("[seq]... 'A sequence of pos whole nums, i.e. 20 45'")
/// .arg("[seq]... 'A sequence of pos whole nums, i.e. 20 45'")
/// .get_matches();
///
/// let vals = values_t_or_exit!(matches.values_of("seq"), u32);
@ -578,7 +578,7 @@ macro_rules! app_from_crate {
};
}
/// Build `App`, `Arg`s, `SubCommand`s and `Group`s with Usage-string like input
/// Build `App`, `Arg`s, ``s and `Group`s with Usage-string like input
/// but without the associated parsing runtime cost.
///
/// `clap_app!` also supports several shorthand syntaxes.
@ -701,7 +701,7 @@ macro_rules! clap_app {
(@app ($builder:expr) (@subcommand $name:ident => $($tail:tt)*) $($tt:tt)*) => {
clap_app!{ @app
($builder.subcommand(
clap_app!{ @app ($crate::SubCommand::with_name(stringify!($name))) $($tail)* }
clap_app!{ @app ($crate::App::new(stringify!($name))) $($tail)* }
))
$($tt)*
}
@ -789,7 +789,7 @@ macro_rules! clap_app {
// Build a subcommand outside of an app.
(@subcommand $name:ident => $($tail:tt)*) => {
clap_app!{ @app ($crate::SubCommand::with_name(stringify!($name))) $($tail)* }
clap_app!{ @app ($crate::App::new(stringify!($name))) $($tail)* }
};
// Start the magic
(($name:expr) => $($tail:tt)*) => {{

50
src/parse/errors.rs
View file

@ -31,7 +31,7 @@ pub enum ErrorKind {
/// .arg(Arg::with_name("speed")
/// .possible_value("fast")
/// .possible_value("slow"))
/// .get_matches_from_safe(vec!["prog", "other"]);
/// .try_get_matches_from(vec!["prog", "other"]);
/// assert!(result.is_err());
/// assert_eq!(result.unwrap_err().kind, ErrorKind::InvalidValue);
/// ```
@ -46,13 +46,13 @@ pub enum ErrorKind {
/// # use clap::{App, Arg, ErrorKind};
/// let result = App::new("prog")
/// .arg(Arg::from("--flag 'some flag'"))
/// .get_matches_from_safe(vec!["prog", "--other"]);
/// .try_get_matches_from(vec!["prog", "--other"]);
/// assert!(result.is_err());
/// assert_eq!(result.unwrap_err().kind, ErrorKind::UnknownArgument);
/// ```
UnknownArgument,
/// Occurs when the user provides an unrecognized [`SubCommand`] which meets the threshold for
/// Occurs when the user provides an unrecognized [``] which meets the threshold for
/// being similar enough to an existing subcommand.
/// If it doesn't meet the threshold, or the 'suggestions' feature is disabled,
/// the more general [`UnknownArgument`] error is returned.
@ -61,22 +61,22 @@ pub enum ErrorKind {
///
#[cfg_attr(not(feature = "suggestions"), doc = " ```no_run")]
#[cfg_attr(feature = "suggestions", doc = " ```")]
/// # use clap::{App, Arg, ErrorKind, SubCommand};
/// # use clap::{App, Arg, ErrorKind, };
/// let result = App::new("prog")
/// .subcommand(SubCommand::with_name("config")
/// .subcommand(App::new("config")
/// .about("Used for configuration")
/// .arg(Arg::with_name("config_file")
/// .help("The configuration file to use")
/// .index(1)))
/// .get_matches_from_safe(vec!["prog", "confi"]);
/// .try_get_matches_from(vec!["prog", "confi"]);
/// assert!(result.is_err());
/// assert_eq!(result.unwrap_err().kind, ErrorKind::InvalidSubcommand);
/// ```
/// [`SubCommand`]: ./struct.SubCommand.html
/// [``]: ./struct..html
/// [`UnknownArgument`]: ./enum.ErrorKind.html#variant.UnknownArgument
InvalidSubcommand,
/// Occurs when the user provides an unrecognized [`SubCommand`] which either
/// Occurs when the user provides an unrecognized [``] which either
/// doesn't meet the threshold for being similar enough to an existing subcommand,
/// or the 'suggestions' feature is disabled.
/// Otherwise the more detailed [`InvalidSubcommand`] error is returned.
@ -87,18 +87,18 @@ pub enum ErrorKind {
/// # Examples
///
/// ```rust
/// # use clap::{App, Arg, ErrorKind, SubCommand};
/// # use clap::{App, Arg, ErrorKind, };
/// let result = App::new("prog")
/// .subcommand(SubCommand::with_name("config")
/// .subcommand(App::new("config")
/// .about("Used for configuration")
/// .arg(Arg::with_name("config_file")
/// .help("The configuration file to use")
/// .index(1)))
/// .get_matches_from_safe(vec!["prog", "help", "nothing"]);
/// .try_get_matches_from(vec!["prog", "help", "nothing"]);
/// assert!(result.is_err());
/// assert_eq!(result.unwrap_err().kind, ErrorKind::UnrecognizedSubcommand);
/// ```
/// [`SubCommand`]: ./struct.SubCommand.html
/// [``]: ./struct..html
/// [`InvalidSubcommand`]: ./enum.ErrorKind.html#variant.InvalidSubcommand
/// [`UnknownArgument`]: ./enum.ErrorKind.html#variant.UnknownArgument
UnrecognizedSubcommand,
@ -229,7 +229,7 @@ pub enum ErrorKind {
/// let result = App::new("prog")
/// .arg(Arg::with_name("debug")
/// .required(true))
/// .get_matches_from_safe(vec!["prog"]);
/// .try_get_matches_from(vec!["prog"]);
/// assert!(result.is_err());
/// assert_eq!(result.unwrap_err().kind, ErrorKind::MissingRequiredArgument);
/// ```
@ -241,11 +241,11 @@ pub enum ErrorKind {
/// # Examples
///
/// ```rust
/// # use clap::{App, AppSettings, SubCommand, ErrorKind};
/// # use clap::{App, AppSettings, ErrorKind};
/// let err = App::new("prog")
/// .setting(AppSettings::SubcommandRequired)
/// .subcommand(SubCommand::with_name("test"))
/// .get_matches_from_safe(vec![
/// .subcommand(App::new("test"))
/// .try_get_matches_from(vec![
/// "myprog",
/// ]);
/// assert!(err.is_err());
@ -255,24 +255,24 @@ pub enum ErrorKind {
/// [`AppSettings::SubcommandRequired`]: ./enum.AppSettings.html#variant.SubcommandRequired
MissingSubcommand,
/// Occurs when either an argument or [`SubCommand`] is required, as defined by
/// Occurs when either an argument or [``] is required, as defined by
/// [`AppSettings::ArgRequiredElseHelp`], but the user did not provide one.
///
/// # Examples
///
/// ```rust
/// # use clap::{App, Arg, AppSettings, ErrorKind, SubCommand};
/// # use clap::{App, Arg, AppSettings, ErrorKind, };
/// let result = App::new("prog")
/// .setting(AppSettings::ArgRequiredElseHelp)
/// .subcommand(SubCommand::with_name("config")
/// .subcommand(App::new("config")
/// .about("Used for configuration")
/// .arg(Arg::with_name("config_file")
/// .help("The configuration file to use")))
/// .get_matches_from_safe(vec!["prog"]);
/// .try_get_matches_from(vec!["prog"]);
/// assert!(result.is_err());
/// assert_eq!(result.unwrap_err().kind, ErrorKind::MissingArgumentOrSubcommand);
/// ```
/// [`SubCommand`]: ./struct.SubCommand.html
/// [``]: ./struct..html
/// [`AppSettings::ArgRequiredElseHelp`]: ./enum.AppSettings.html#variant.ArgRequiredElseHelp
MissingArgumentOrSubcommand,
@ -286,7 +286,7 @@ pub enum ErrorKind {
/// .arg(Arg::with_name("debug")
/// .long("debug")
/// .multiple(false))
/// .get_matches_from_safe(vec!["prog", "--debug", "--debug"]);
/// .try_get_matches_from(vec!["prog", "--debug", "--debug"]);
/// assert!(result.is_err());
/// assert_eq!(result.unwrap_err().kind, ErrorKind::UnexpectedMultipleUsage);
/// ```
@ -311,7 +311,7 @@ pub enum ErrorKind {
/// .arg(Arg::with_name("utf8")
/// .short('u')
/// .takes_value(true))
/// .get_matches_from_safe(vec![OsString::from("myprog"),
/// .try_get_matches_from(vec![OsString::from("myprog"),
/// OsString::from("-u"),
/// OsString::from_vec(vec![0xE9])]);
/// assert!(result.is_err());
@ -331,7 +331,7 @@ pub enum ErrorKind {
/// ```rust
/// # use clap::{App, Arg, ErrorKind};
/// let result = App::new("prog")
/// .get_matches_from_safe(vec!["prog", "--help"]);
/// .try_get_matches_from(vec!["prog", "--help"]);
/// assert!(result.is_err());
/// assert_eq!(result.unwrap_err().kind, ErrorKind::HelpDisplayed);
/// ```
@ -345,7 +345,7 @@ pub enum ErrorKind {
/// ```rust
/// # use clap::{App, Arg, ErrorKind};
/// let result = App::new("prog")
/// .get_matches_from_safe(vec!["prog", "--version"]);
/// .try_get_matches_from(vec!["prog", "--version"]);
/// assert!(result.is_err());
/// assert_eq!(result.unwrap_err().kind, ErrorKind::VersionDisplayed);
/// ```

24
src/parse/matches/arg_matches.rs
View file

@ -595,11 +595,11 @@ impl<'a> ArgMatches<'a> {
/// # Examples
///
/// ```rust
/// # use clap::{App, Arg, SubCommand};
/// # use clap::{App, Arg, };
/// let app_m = App::new("myprog")
/// .arg(Arg::with_name("debug")
/// .short('d'))
/// .subcommand(SubCommand::with_name("test")
/// .subcommand(App::new("test")
/// .arg(Arg::with_name("opt")
/// .long("option")
/// .takes_value(true)))
@ -616,7 +616,7 @@ impl<'a> ArgMatches<'a> {
/// assert_eq!(sub_m.value_of("opt"), Some("val"));
/// }
/// ```
/// [`Subcommand`]: ./struct.SubCommand.html
/// [`Subcommand`]: ./struct..html
/// [`App`]: ./struct.App.html
/// [`ArgMatches`]: ./struct.ArgMatches.html
pub fn subcommand_matches<S: AsRef<str>>(&self, name: S) -> Option<&ArgMatches<'a>> {
@ -669,11 +669,11 @@ impl<'a> ArgMatches<'a> {
/// # Examples
///
/// ```no_run
/// # use clap::{App, Arg, SubCommand};
/// # use clap::{App, Arg, };
/// let app_m = App::new("git")
/// .subcommand(SubCommand::with_name("clone"))
/// .subcommand(SubCommand::with_name("push"))
/// .subcommand(SubCommand::with_name("commit"))
/// .subcommand(App::new("clone"))
/// .subcommand(App::new("push"))
/// .subcommand(App::new("commit"))
/// .get_matches();
///
/// match app_m.subcommand_name() {
@ -683,7 +683,7 @@ impl<'a> ArgMatches<'a> {
/// _ => {}, // Either no subcommand or one not tested for...
/// }
/// ```
/// [`Subcommand`]: ./struct.SubCommand.html
/// [`Subcommand`]: ./struct..html
/// [`App`]: ./struct.App.html
/// [`ArgMatches`]: ./struct.ArgMatches.html
pub fn subcommand_name(&self) -> Option<&str> {
@ -696,11 +696,11 @@ impl<'a> ArgMatches<'a> {
/// # Examples
///
/// ```no_run
/// # use clap::{App, Arg, SubCommand};
/// # use clap::{App, Arg, };
/// let app_m = App::new("git")
/// .subcommand(SubCommand::with_name("clone"))
/// .subcommand(SubCommand::with_name("push"))
/// .subcommand(SubCommand::with_name("commit"))
/// .subcommand(App::new("clone"))
/// .subcommand(App::new("push"))
/// .subcommand(App::new("commit"))
/// .get_matches();
///
/// match app_m.subcommand() {

25
src/parse/matches/subcommand.rs
View file

@ -15,10 +15,10 @@ use ArgMatches;
/// # Examples
///
/// ```rust
/// # use clap::{App, Arg, SubCommand};
/// # use clap::{App, Arg, };
/// App::new("myprog")
/// .subcommand(
/// SubCommand::with_name("config")
/// App::new("config")
/// .about("Used for configuration")
/// .arg(Arg::with_name("config_file")
/// .help("The configuration file to use")
@ -35,24 +35,3 @@ pub struct SubCommand<'a> {
pub matches: ArgMatches<'a>,
}
impl<'a> SubCommand<'a> {
// @TODO-v3-beta: remove
/// **Deprecated**
#[deprecated(
since = "2.32.0",
note = "Use App::new instead. Will be removed in v3-beta"
)]
pub fn with_name<'b>(name: &str) -> App<'a, 'b> { App::new(name) }
// @TODO-v3-beta: remove
/// **Deprecated**
#[cfg_attr(
feature = "yaml",
deprecated(
since = "2.32.0",
note = "Use App::from instead. Will be removed in v3-beta"
)
)]
#[cfg(feature = "yaml")]
pub fn from_yaml(yaml: &Yaml) -> App { App::from_yaml(yaml) }
}

2
src/parse/mod.rs
View file

@ -8,6 +8,6 @@ mod validator;
pub use self::arg_matcher::ArgMatcher;
pub use self::matches::ArgMatches;
pub use self::matches::{MatchedArg, OsValues, SubCommand, Values};
pub use self::matches::{MatchedArg, OsValues, Values, SubCommand};
pub use self::parser::{ParseResult, Parser};
pub use self::validator::Validator;

4
src/parse/parser.rs
View file

@ -611,7 +611,7 @@ where
sc_m.add_val_to("", &a);
}
matcher.subcommand(SubCommand {
matcher.subcommand( SubCommand{
name: sc_name,
matches: sc_m.into(),
});
@ -886,7 +886,7 @@ where
let name = sc.name.clone();
let mut p = Parser::new(sc);
p.get_matches_with(&mut sc_matcher, it)?;
matcher.subcommand(SubCommand {
matcher.subcommand( SubCommand{
name: name,
matches: sc_matcher.into(),
});

176
tests/app_settings.rs
View file

@ -1,7 +1,7 @@
extern crate clap;
extern crate regex;
use clap::{App, AppSettings, Arg, ErrorKind, Propagation, SubCommand};
use clap::{App, AppSettings, Arg, ErrorKind, Propagation, };
include!("../clap-test.rs");
@ -78,7 +78,7 @@ fn sub_command_negate_required() {
App::new("sub_command_negate")
.setting(AppSettings::SubcommandsNegateReqs)
.arg(Arg::with_name("test").required(true).index(1))
.subcommand(SubCommand::with_name("sub1"))
.subcommand(App::new("sub1"))
.get_matches_from(vec!["myprog", "sub1"]);
}
@ -87,7 +87,7 @@ fn global_version() {
let mut app = App::new("global_version")
.setting(AppSettings::GlobalVersion)
.version("1.1")
.subcommand(SubCommand::with_name("sub1"));
.subcommand(App::new("sub1"));
app._propagate(Propagation::NextLevel);
assert_eq!(app.subcommands[0].version, Some("1.1"));
}
@ -97,8 +97,8 @@ fn sub_command_negate_required_2() {
let result = App::new("sub_command_negate")
.setting(AppSettings::SubcommandsNegateReqs)
.arg(Arg::with_name("test").required(true).index(1))
.subcommand(SubCommand::with_name("sub1"))
.get_matches_from_safe(vec![""]);
.subcommand(App::new("sub1"))
.try_get_matches_from(vec![""]);
assert!(result.is_err());
let err = result.err().unwrap();
assert_eq!(err.kind, ErrorKind::MissingRequiredArgument);
@ -108,8 +108,8 @@ fn sub_command_negate_required_2() {
fn sub_command_required() {
let result = App::new("sc_required")
.setting(AppSettings::SubcommandRequired)
.subcommand(SubCommand::with_name("sub1"))
.get_matches_from_safe(vec![""]);
.subcommand(App::new("sub1"))
.try_get_matches_from(vec![""]);
assert!(result.is_err());
let err = result.err().unwrap();
assert_eq!(err.kind, ErrorKind::MissingSubcommand);
@ -120,7 +120,7 @@ fn arg_required_else_help() {
let result = App::new("arg_required")
.setting(AppSettings::ArgRequiredElseHelp)
.arg(Arg::with_name("test").index(1))
.get_matches_from_safe(vec![""]);
.try_get_matches_from(vec![""]);
assert!(result.is_err());
let err = result.err().unwrap();
assert_eq!(err.kind, ErrorKind::MissingArgumentOrSubcommand);
@ -131,7 +131,7 @@ fn arg_required_else_help_over_reqs() {
let result = App::new("arg_required")
.setting(AppSettings::ArgRequiredElseHelp)
.arg(Arg::with_name("test").index(1).required(true))
.get_matches_from_safe(vec![""]);
.try_get_matches_from(vec![""]);
assert!(result.is_err());
let err = result.err().unwrap();
assert_eq!(err.kind, ErrorKind::MissingArgumentOrSubcommand);
@ -142,9 +142,9 @@ fn arg_required_else_help_over_reqs() {
fn infer_subcommands_fail_no_args() {
let m = App::new("prog")
.setting(AppSettings::InferSubcommands)
.subcommand(SubCommand::with_name("test"))
.subcommand(SubCommand::with_name("temp"))
.get_matches_from_safe(vec!["prog", "te"]);
.subcommand(App::new("test"))
.subcommand(App::new("temp"))
.try_get_matches_from(vec!["prog", "te"]);
assert!(m.is_err(), "{:#?}", m.unwrap());
assert_eq!(m.unwrap_err().kind, ErrorKind::UnrecognizedSubcommand);
}
@ -154,9 +154,9 @@ fn infer_subcommands_fail_no_args() {
fn infer_subcommands_fail_no_args() {
let m = App::new("prog")
.setting(AppSettings::InferSubcommands)
.subcommand(SubCommand::with_name("test"))
.subcommand(SubCommand::with_name("temp"))
.get_matches_from_safe(vec!["prog", "te"]);
.subcommand(App::new("test"))
.subcommand(App::new("temp"))
.try_get_matches_from(vec!["prog", "te"]);
assert!(m.is_err(), "{:#?}", m.unwrap());
assert_eq!(m.unwrap_err().kind, ErrorKind::InvalidSubcommand);
}
@ -166,9 +166,9 @@ fn infer_subcommands_fail_with_args() {
let m = App::new("prog")
.setting(AppSettings::InferSubcommands)
.arg(Arg::with_name("some"))
.subcommand(SubCommand::with_name("test"))
.subcommand(SubCommand::with_name("temp"))
.get_matches_from_safe(vec!["prog", "t"]);
.subcommand(App::new("test"))
.subcommand(App::new("temp"))
.try_get_matches_from(vec!["prog", "t"]);
assert!(m.is_ok(), "{:?}", m.unwrap_err().kind);
assert_eq!(m.unwrap().value_of("some"), Some("t"));
}
@ -178,9 +178,9 @@ fn infer_subcommands_fail_with_args2() {
let m = App::new("prog")
.setting(AppSettings::InferSubcommands)
.arg(Arg::with_name("some"))
.subcommand(SubCommand::with_name("test"))
.subcommand(SubCommand::with_name("temp"))
.get_matches_from_safe(vec!["prog", "te"]);
.subcommand(App::new("test"))
.subcommand(App::new("temp"))
.try_get_matches_from(vec!["prog", "te"]);
assert!(m.is_ok(), "{:?}", m.unwrap_err().kind);
assert_eq!(m.unwrap().value_of("some"), Some("te"));
}
@ -189,7 +189,7 @@ fn infer_subcommands_fail_with_args2() {
fn infer_subcommands_pass() {
let m = App::new("prog")
.setting(AppSettings::InferSubcommands)
.subcommand(SubCommand::with_name("test"))
.subcommand(App::new("test"))
.get_matches_from(vec!["prog", "te"]);
assert_eq!(m.subcommand_name(), Some("test"));
}
@ -198,8 +198,8 @@ fn infer_subcommands_pass() {
fn infer_subcommands_pass_close() {
let m = App::new("prog")
.setting(AppSettings::InferSubcommands)
.subcommand(SubCommand::with_name("test"))
.subcommand(SubCommand::with_name("temp"))
.subcommand(App::new("test"))
.subcommand(App::new("temp"))
.get_matches_from(vec!["prog", "tes"]);
assert_eq!(m.subcommand_name(), Some("test"));
}
@ -209,9 +209,9 @@ fn infer_subcommands_pass_close() {
fn infer_subcommands_fail_suggestions() {
let m = App::new("prog")
.setting(AppSettings::InferSubcommands)
.subcommand(SubCommand::with_name("test"))
.subcommand(SubCommand::with_name("temp"))
.get_matches_from_safe(vec!["prog", "temps"]);
.subcommand(App::new("test"))
.subcommand(App::new("temp"))
.try_get_matches_from(vec!["prog", "temps"]);
assert!(m.is_err(), "{:#?}", m.unwrap());
assert_eq!(m.unwrap_err().kind, ErrorKind::InvalidSubcommand);
}
@ -221,9 +221,9 @@ fn infer_subcommands_fail_suggestions() {
fn infer_subcommands_fail_suggestions() {
let m = App::new("prog")
.setting(AppSettings::InferSubcommands)
.subcommand(SubCommand::with_name("test"))
.subcommand(SubCommand::with_name("temp"))
.get_matches_from_safe(vec!["prog", "temps"]);
.subcommand(App::new("test"))
.subcommand(App::new("temp"))
.try_get_matches_from(vec!["prog", "temps"]);
assert!(m.is_err(), "{:#?}", m.unwrap());
assert_eq!(m.unwrap_err().kind, ErrorKind::UnrecognizedSubcommand);
}
@ -233,7 +233,7 @@ fn no_bin_name() {
let result = App::new("arg_required")
.setting(AppSettings::NoBinaryName)
.arg(Arg::with_name("test").required(true).index(1))
.get_matches_from_safe(vec!["testing"]);
.try_get_matches_from(vec!["testing"]);
assert!(result.is_ok());
let matches = result.unwrap();
assert_eq!(matches.value_of("test").unwrap(), "testing");
@ -247,11 +247,9 @@ fn unified_help() {
.about("tests stuff")
.version("1.3")
.setting(AppSettings::UnifiedHelpMessage)
.args_from_usage(
"-f, --flag 'some flag'
[arg1] 'some pos arg'
--option [opt] 'some option'",
);
.arg("-f, --flag 'some flag'")
.arg("[arg1] 'some pos arg'")
.arg("--option [opt] 'some option'");
assert!(test::compare_output(
app,
@ -285,7 +283,7 @@ fn skip_possible_values() {
fn global_setting() {
let mut app = App::new("test")
.global_setting(AppSettings::ColoredHelp)
.subcommand(SubCommand::with_name("subcmd"));
.subcommand(App::new("subcmd"));
app._propagate(Propagation::NextLevel);
assert!(
app.subcommands
@ -300,8 +298,9 @@ fn global_setting() {
#[test]
fn global_settings() {
let mut app = App::new("test")
.global_settings(&[AppSettings::ColoredHelp, AppSettings::TrailingVarArg])
.subcommand(SubCommand::with_name("subcmd"));
.global_setting(AppSettings::ColoredHelp)
.global_setting(AppSettings::TrailingVarArg)
.subcommand(App::new("subcmd"));
app._propagate(Propagation::NextLevel);
assert!(
app.subcommands
@ -329,7 +328,7 @@ fn stop_delim_values_only_pos_follows() {
Arg::from("-f [flag] 'some opt'"),
Arg::from("[arg]... 'some arg'"),
])
.get_matches_from_safe(vec!["", "--", "-f", "-g,x"]);
.try_get_matches_from(vec!["", "--", "-f", "-g,x"]);
assert!(r.is_ok());
let m = r.unwrap();
assert!(m.is_present("arg"));
@ -361,7 +360,7 @@ fn delim_values_only_pos_follows() {
Arg::from("-f [flag] 'some opt'"),
Arg::from("[arg]... 'some arg'"),
])
.get_matches_from_safe(vec!["", "--", "-f", "-g,x"]);
.try_get_matches_from(vec!["", "--", "-f", "-g,x"]);
assert!(r.is_ok());
let m = r.unwrap();
assert!(m.is_present("arg"));
@ -392,7 +391,7 @@ fn delim_values_only_pos_follows_with_delim() {
Arg::from("-f [flag] 'some opt'"),
Arg::from("[arg]... 'some arg'").use_delimiter(true),
])
.get_matches_from_safe(vec!["", "--", "-f", "-g,x"]);
.try_get_matches_from(vec!["", "--", "-f", "-g,x"]);
assert!(r.is_ok());
let m = r.unwrap();
assert!(m.is_present("arg"));
@ -422,7 +421,7 @@ fn leading_hyphen_short() {
.setting(AppSettings::AllowLeadingHyphen)
.arg(Arg::with_name("some"))
.arg(Arg::with_name("other").short('o'))
.get_matches_from_safe(vec!["", "-bar", "-o"]);
.try_get_matches_from(vec!["", "-bar", "-o"]);
assert!(res.is_ok(), "Error: {:?}", res.unwrap_err().kind);
let m = res.unwrap();
assert!(m.is_present("some"));
@ -436,7 +435,7 @@ fn leading_hyphen_long() {
.setting(AppSettings::AllowLeadingHyphen)
.arg(Arg::with_name("some"))
.arg(Arg::with_name("other").short('o'))
.get_matches_from_safe(vec!["", "--bar", "-o"]);
.try_get_matches_from(vec!["", "--bar", "-o"]);
assert!(res.is_ok(), "Error: {:?}", res.unwrap_err().kind);
let m = res.unwrap();
assert!(m.is_present("some"));
@ -450,7 +449,7 @@ fn leading_hyphen_opt() {
.setting(AppSettings::AllowLeadingHyphen)
.arg(Arg::with_name("some").takes_value(true).long("opt"))
.arg(Arg::with_name("other").short('o'))
.get_matches_from_safe(vec!["", "--opt", "--bar", "-o"]);
.try_get_matches_from(vec!["", "--opt", "--bar", "-o"]);
assert!(res.is_ok(), "Error: {:?}", res.unwrap_err().kind);
let m = res.unwrap();
assert!(m.is_present("some"));
@ -464,7 +463,7 @@ fn allow_negative_numbers() {
.setting(AppSettings::AllowNegativeNumbers)
.arg(Arg::with_name("panum"))
.arg(Arg::with_name("onum").short('o').takes_value(true))
.get_matches_from_safe(vec!["negnum", "-20", "-o", "-1.2"]);
.try_get_matches_from(vec!["negnum", "-20", "-o", "-1.2"]);
assert!(res.is_ok(), "Error: {:?}", res.unwrap_err().kind);
let m = res.unwrap();
assert_eq!(m.value_of("panum").unwrap(), "-20");
@ -477,7 +476,7 @@ fn allow_negative_numbers_fail() {
.setting(AppSettings::AllowNegativeNumbers)
.arg(Arg::with_name("panum"))
.arg(Arg::with_name("onum").short('o').takes_value(true))
.get_matches_from_safe(vec!["negnum", "--foo", "-o", "-1.2"]);
.try_get_matches_from(vec!["negnum", "--foo", "-o", "-1.2"]);
assert!(res.is_err());
assert_eq!(res.unwrap_err().kind, ErrorKind::UnknownArgument)
}
@ -511,8 +510,9 @@ fn unset_settings() {
assert!(&m.is_set(AppSettings::AllowInvalidUtf8));
assert!(&m.is_set(AppSettings::ColorAuto));
let m = m.unset_settings(&[AppSettings::AllowInvalidUtf8, AppSettings::ColorAuto]);
assert!(!m.is_set(AppSettings::AllowInvalidUtf8), "{:?}", m.settings);
let m = m.unset_setting(AppSettings::AllowInvalidUtf8)
.unset_setting(AppSettings::ColorAuto);
assert!(!m.is_set(AppSettings::AllowInvalidUtf8), "l: {:?}\ng:{:?}", m.settings, m.g_settings);
assert!(!m.is_set(AppSettings::ColorAuto));
}
@ -520,8 +520,8 @@ fn unset_settings() {
fn disable_help_subcommand() {
let result = App::new("disablehelp")
.setting(AppSettings::DisableHelpSubcommand)
.subcommand(SubCommand::with_name("sub1"))
.get_matches_from_safe(vec!["", "help"]);
.subcommand(App::new("sub1"))
.try_get_matches_from(vec!["", "help"]);
assert!(result.is_err());
let err = result.err().unwrap();
assert_eq!(err.kind, ErrorKind::UnknownArgument);
@ -570,12 +570,12 @@ fn args_negate_subcommands_one_level() {
App::new("disablehelp")
.setting(AppSettings::ArgsNegateSubcommands)
.setting(AppSettings::SubcommandsNegateReqs)
.arg_from_usage("<arg1> 'some arg'")
.arg_from_usage("<arg2> 'some arg'")
.subcommand(SubCommand::with_name("sub1").subcommand(
SubCommand::with_name("sub2").subcommand(SubCommand::with_name("sub3")),
.arg("<arg1> 'some arg'")
.arg("<arg2> 'some arg'")
.subcommand(App::new("sub1").subcommand(
App::new("sub2").subcommand(App::new("sub3")),
))
.get_matches_from_safe(vec!["", "pickles", "sub1"]);
.try_get_matches_from(vec!["", "pickles", "sub1"]);
assert!(res.is_ok(), "error: {:?}", res.unwrap_err().kind);
let m = res.unwrap();
assert_eq!(m.value_of("arg2"), Some("sub1"));
@ -586,17 +586,17 @@ fn args_negate_subcommands_two_levels() {
let res = App::new("disablehelp")
.global_setting(AppSettings::ArgsNegateSubcommands)
.global_setting(AppSettings::SubcommandsNegateReqs)
.arg_from_usage("<arg1> 'some arg'")
.arg_from_usage("<arg2> 'some arg'")
.arg("<arg1> 'some arg'")
.arg("<arg2> 'some arg'")
.subcommand(
SubCommand::with_name("sub1")
.arg_from_usage("<arg> 'some'")
.arg_from_usage("<arg2> 'some'")
App::new("sub1")
.arg("<arg> 'some'")
.arg("<arg2> 'some'")
.subcommand(
SubCommand::with_name("sub2").subcommand(SubCommand::with_name("sub3")),
App::new("sub2").subcommand(App::new("sub3")),
),
)
.get_matches_from_safe(vec!["", "sub1", "arg", "sub2"]);
.try_get_matches_from(vec!["", "sub1", "arg", "sub2"]);
assert!(res.is_ok(), "error: {:?}", res.unwrap_err().kind);
let m = res.unwrap();
assert_eq!(
@ -609,8 +609,8 @@ fn args_negate_subcommands_two_levels() {
fn propagate_vals_down() {
let m = App::new("myprog")
.arg(Arg::from("[cmd] 'command to run'").global(true))
.subcommand(SubCommand::with_name("foo"))
.get_matches_from_safe(vec!["myprog", "set", "foo"]);
.subcommand(App::new("foo"))
.try_get_matches_from(vec!["myprog", "set", "foo"]);
assert!(m.is_ok(), "{:?}", m.unwrap_err().kind);
let m = m.unwrap();
assert_eq!(m.value_of("cmd"), Some("set"));
@ -623,8 +623,8 @@ fn allow_missing_positional() {
let m = App::new("test")
.setting(AppSettings::AllowMissingPositional)
.arg(Arg::from("[src] 'some file'").default_value("src"))
.arg_from_usage("<dest> 'some file'")
.get_matches_from_safe(vec!["test", "file"]);
.arg("<dest> 'some file'")
.try_get_matches_from(vec!["test", "file"]);
assert!(m.is_ok(), "{:?}", m.unwrap_err().kind);
let m = m.unwrap();
assert_eq!(m.value_of("src"), Some("src"));
@ -636,8 +636,8 @@ fn allow_missing_positional_no_default() {
let m = App::new("test")
.setting(AppSettings::AllowMissingPositional)
.arg(Arg::from("[src] 'some file'"))
.arg_from_usage("<dest> 'some file'")
.get_matches_from_safe(vec!["test", "file"]);
.arg("<dest> 'some file'")
.try_get_matches_from(vec!["test", "file"]);
assert!(m.is_ok(), "{:?}", m.unwrap_err().kind);
let m = m.unwrap();
assert_eq!(m.value_of("src"), None);
@ -650,7 +650,7 @@ fn missing_positional_no_hyphen() {
.setting(AppSettings::AllowMissingPositional)
.arg(Arg::from("[BENCH] 'some bench'"))
.arg(Arg::from("[ARGS]... 'some args'"))
.get_matches_from_safe(vec!["bench", "foo", "arg1", "arg2", "arg3"]);
.try_get_matches_from(vec!["bench", "foo", "arg1", "arg2", "arg3"]);
assert!(r.is_ok(), "{:?}", r.unwrap_err().kind);
let m = r.unwrap();
@ -671,7 +671,7 @@ fn missing_positional_hyphen() {
.setting(AppSettings::AllowMissingPositional)
.arg(Arg::from("[BENCH] 'some bench'"))
.arg(Arg::from("[ARGS]... 'some args'"))
.get_matches_from_safe(vec!["bench", "--", "arg1", "arg2", "arg3"]);
.try_get_matches_from(vec!["bench", "--", "arg1", "arg2", "arg3"]);
assert!(r.is_ok(), "{:?}", r.unwrap_err().kind);
let m = r.unwrap();
@ -694,7 +694,7 @@ fn missing_positional_hyphen_far_back() {
.arg(Arg::from("[BENCH2] 'some bench'"))
.arg(Arg::from("[BENCH3] 'some bench'"))
.arg(Arg::from("[ARGS]... 'some args'"))
.get_matches_from_safe(vec!["bench", "foo", "--", "arg1", "arg2", "arg3"]);
.try_get_matches_from(vec!["bench", "foo", "--", "arg1", "arg2", "arg3"]);
assert!(r.is_ok(), "{:?}", r.unwrap_err().kind);
let m = r.unwrap();
@ -720,7 +720,7 @@ fn missing_positional_hyphen_req_error() {
.arg(Arg::from("[BENCH1] 'some bench'"))
.arg(Arg::from("<BENCH2> 'some bench'"))
.arg(Arg::from("[ARGS]... 'some args'"))
.get_matches_from_safe(vec!["bench", "foo", "--", "arg1", "arg2", "arg3"]);
.try_get_matches_from(vec!["bench", "foo", "--", "arg1", "arg2", "arg3"]);
assert!(r.is_err());
assert_eq!(r.unwrap_err().kind, ErrorKind::MissingRequiredArgument);
}
@ -730,7 +730,7 @@ fn issue_1066_allow_leading_hyphen_and_unknown_args() {
let res = App::new("prog")
.global_setting(AppSettings::AllowLeadingHyphen)
.arg(Arg::from("--some-argument"))
.get_matches_from_safe(vec!["prog", "hello"]);
.try_get_matches_from(vec!["prog", "hello"]);
assert!(res.is_err());
assert_eq!(res.unwrap_err().kind, ErrorKind::UnknownArgument);
@ -741,7 +741,7 @@ fn issue_1066_allow_leading_hyphen_and_unknown_args_no_vals() {
let res = App::new("prog")
.global_setting(AppSettings::AllowLeadingHyphen)
.arg(Arg::from("--some-argument"))
.get_matches_from_safe(vec!["prog", "--hello"]);
.try_get_matches_from(vec!["prog", "--hello"]);
assert!(res.is_err());
assert_eq!(res.unwrap_err().kind, ErrorKind::UnknownArgument);
@ -752,7 +752,7 @@ fn issue_1066_allow_leading_hyphen_and_unknown_args_option() {
let res = App::new("prog")
.global_setting(AppSettings::AllowLeadingHyphen)
.arg(Arg::from("--some-argument=[val]"))
.get_matches_from_safe(vec!["prog", "-hello"]);
.try_get_matches_from(vec!["prog", "-hello"]);
assert!(res.is_err());
assert_eq!(res.unwrap_err().kind, ErrorKind::UnknownArgument);
@ -776,8 +776,8 @@ fn external_subcommand_looks_like_built_in() {
let res = App::new("cargo")
.version("1.26.0")
.setting(AppSettings::AllowExternalSubcommands)
.subcommand(SubCommand::with_name("install"))
.get_matches_from_safe(vec!["cargo", "install-update", "foo"]);
.subcommand(App::new("install"))
.try_get_matches_from(vec!["cargo", "install-update", "foo"]);
assert!(res.is_ok());
let m = res.unwrap();
match m.subcommand() {
@ -795,7 +795,7 @@ fn aaos_flags() {
let res = App::new("posix")
.setting(AppSettings::AllArgsOverrideSelf)
.arg(Arg::from("--flag 'some flag'"))
.get_matches_from_safe(vec!["", "--flag", "--flag"]);
.try_get_matches_from(vec!["", "--flag", "--flag"]);
assert!(res.is_ok());
let m = res.unwrap();
assert!(m.is_present("flag"));
@ -808,7 +808,7 @@ fn aaos_flags_mult() {
let res = App::new("posix")
.setting(AppSettings::AllArgsOverrideSelf)
.arg(Arg::from("--flag... 'some flag'"))
.get_matches_from_safe(vec!["", "--flag", "--flag", "--flag", "--flag"]);
.try_get_matches_from(vec!["", "--flag", "--flag", "--flag", "--flag"]);
assert!(res.is_ok());
let m = res.unwrap();
assert!(m.is_present("flag"));
@ -821,7 +821,7 @@ fn aaos_opts() {
let res = App::new("posix")
.setting(AppSettings::AllArgsOverrideSelf)
.arg(Arg::from("--opt [val] 'some option'"))
.get_matches_from_safe(vec!["", "--opt=some", "--opt=other"]);
.try_get_matches_from(vec!["", "--opt=some", "--opt=other"]);
assert!(res.is_ok());
let m = res.unwrap();
assert!(m.is_present("opt"));
@ -836,7 +836,7 @@ fn aaos_opts_w_other_overrides() {
.setting(AppSettings::AllArgsOverrideSelf)
.arg(Arg::from("--opt [val] 'some option'"))
.arg(Arg::from("--other [val] 'some other option'").overrides_with("opt"))
.get_matches_from_safe(vec!["", "--opt=some", "--other=test", "--opt=other"]);
.try_get_matches_from(vec!["", "--opt=some", "--other=test", "--opt=other"]);
assert!(res.is_ok());
let m = res.unwrap();
assert!(m.is_present("opt"));
@ -852,7 +852,7 @@ fn aaos_opts_w_other_overrides_rev() {
.setting(AppSettings::AllArgsOverrideSelf)
.arg(Arg::from("--opt [val] 'some option'"))
.arg(Arg::from("--other [val] 'some other option'").overrides_with("opt"))
.get_matches_from_safe(vec!["", "--opt=some", "--opt=other", "--other=val"]);
.try_get_matches_from(vec!["", "--opt=some", "--opt=other", "--other=val"]);
assert!(res.is_ok());
let m = res.unwrap();
assert!(!m.is_present("opt"));
@ -867,7 +867,7 @@ fn aaos_opts_w_other_overrides_2() {
.setting(AppSettings::AllArgsOverrideSelf)
.arg(Arg::from("--opt [val] 'some option'").overrides_with("other"))
.arg(Arg::from("--other [val] 'some other option'"))
.get_matches_from_safe(vec!["", "--opt=some", "--other=test", "--opt=other"]);
.try_get_matches_from(vec!["", "--opt=some", "--other=test", "--opt=other"]);
assert!(res.is_ok());
let m = res.unwrap();
assert!(m.is_present("opt"));
@ -883,7 +883,7 @@ fn aaos_opts_w_other_overrides_rev_2() {
.setting(AppSettings::AllArgsOverrideSelf)
.arg(Arg::from("--opt [val] 'some option'").overrides_with("other"))
.arg(Arg::from("--other [val] 'some other option'"))
.get_matches_from_safe(vec!["", "--opt=some", "--opt=other", "--other=val"]);
.try_get_matches_from(vec!["", "--opt=some", "--opt=other", "--other=val"]);
assert!(res.is_ok());
let m = res.unwrap();
assert!(!m.is_present("opt"));
@ -901,7 +901,7 @@ fn aaos_opts_mult() {
.number_of_values(1)
.require_delimiter(true),
)
.get_matches_from_safe(vec!["", "--opt=some", "--opt=other", "--opt=one,two"]);
.try_get_matches_from(vec!["", "--opt=some", "--opt=other", "--opt=one,two"]);
assert!(res.is_ok());
let m = res.unwrap();
assert!(m.is_present("opt"));
@ -918,7 +918,7 @@ fn aaos_opts_mult_req_delims() {
let res = App::new("posix")
.setting(AppSettings::AllArgsOverrideSelf)
.arg(Arg::from("--opt [val]... 'some option'"))
.get_matches_from_safe(vec![
.try_get_matches_from(vec![
"", "--opt", "first", "overides", "--opt", "some", "other", "val",
]);
assert!(res.is_ok());
@ -937,7 +937,7 @@ fn aaos_pos_mult() {
let res = App::new("posix")
.setting(AppSettings::AllArgsOverrideSelf)
.arg(Arg::from("[val]... 'some pos'"))
.get_matches_from_safe(vec!["", "some", "other", "value"]);
.try_get_matches_from(vec!["", "some", "other", "value"]);
assert!(res.is_ok());
let m = res.unwrap();
assert!(m.is_present("val"));

28
tests/arg_aliases.rs
View file

@ -3,7 +3,7 @@ extern crate regex;
include!("../clap-test.rs");
use clap::{App, Arg, SubCommand};
use clap::{App, Arg, };
static SC_VISIBLE_ALIAS_HELP: &'static str = "ct-test 1.2
Some help
@ -43,7 +43,7 @@ fn single_alias_of_option() {
.help("single alias")
.alias("new-opt"),
)
.get_matches_from_safe(vec!["", "--new-opt", "cool"]);
.try_get_matches_from(vec!["", "--new-opt", "cool"]);
assert!(a.is_ok());
let a = a.unwrap();
assert!(a.is_present("alias"));
@ -61,25 +61,25 @@ fn multiple_aliases_of_option() {
);
let long = a
.clone()
.get_matches_from_safe(vec!["", "--aliases", "value"]);
.try_get_matches_from(vec!["", "--aliases", "value"]);
assert!(long.is_ok());
let long = long.unwrap();
let als1 = a
.clone()
.get_matches_from_safe(vec!["", "--alias1", "value"]);
.try_get_matches_from(vec!["", "--alias1", "value"]);
assert!(als1.is_ok());
let als1 = als1.unwrap();
let als2 = a
.clone()
.get_matches_from_safe(vec!["", "--alias2", "value"]);
.try_get_matches_from(vec!["", "--alias2", "value"]);
assert!(als2.is_ok());
let als2 = als2.unwrap();
let als3 = a
.clone()
.get_matches_from_safe(vec!["", "--alias3", "value"]);
.try_get_matches_from(vec!["", "--alias3", "value"]);
assert!(als3.is_ok());
let als3 = als3.unwrap();
@ -97,7 +97,7 @@ fn multiple_aliases_of_option() {
fn single_alias_of_flag() {
let a = App::new("test")
.arg(Arg::with_name("flag").long("flag").alias("alias"))
.get_matches_from_safe(vec!["", "--alias"]);
.try_get_matches_from(vec!["", "--alias"]);
assert!(a.is_ok());
let a = a.unwrap();
assert!(a.is_present("flag"));
@ -113,19 +113,19 @@ fn multiple_aliases_of_flag() {
"aliases",
]));
let flag = a.clone().get_matches_from_safe(vec!["", "--flag"]);
let flag = a.clone().try_get_matches_from(vec!["", "--flag"]);
assert!(flag.is_ok());
let flag = flag.unwrap();
let inv = a.clone().get_matches_from_safe(vec!["", "--invisible"]);
let inv = a.clone().try_get_matches_from(vec!["", "--invisible"]);
assert!(inv.is_ok());
let inv = inv.unwrap();
let cool = a.clone().get_matches_from_safe(vec!["", "--cool"]);
let cool = a.clone().try_get_matches_from(vec!["", "--cool"]);
assert!(cool.is_ok());
let cool = cool.unwrap();
let als = a.clone().get_matches_from_safe(vec!["", "--aliases"]);
let als = a.clone().try_get_matches_from(vec!["", "--aliases"]);
assert!(als.is_ok());
let als = als.unwrap();
@ -139,7 +139,7 @@ fn multiple_aliases_of_flag() {
fn alias_on_a_subcommand_option() {
let m = App::new("test")
.subcommand(
SubCommand::with_name("some").arg(
App::new("some").arg(
Arg::with_name("test")
.short('t')
.long("test")
@ -164,7 +164,7 @@ fn alias_on_a_subcommand_option() {
#[test]
fn invisible_arg_aliases_help_output() {
let app = App::new("ct").author("Salim Afiune").subcommand(
SubCommand::with_name("test")
App::new("test")
.about("Some help")
.version("1.2")
.arg(
@ -187,7 +187,7 @@ fn invisible_arg_aliases_help_output() {
#[test]
fn visible_arg_aliases_help_output() {
let app = App::new("ct").author("Salim Afiune").subcommand(
SubCommand::with_name("test")
App::new("test")
.about("Some help")
.version("1.2")
.arg(

6
tests/borrowed.rs
View file

@ -1,7 +1,7 @@
extern crate clap;
extern crate regex;
use clap::{App, Arg, SubCommand};
use clap::{App, Arg, };
include!("../clap-test.rs");
@ -19,7 +19,7 @@ fn borrowed_args() {
.arg(Arg::with_name("test").index(1))
.arg(&arg)
.arg(&arg2)
.subcommand(SubCommand::with_name("sub1").arg(&arg))
.get_matches_from_safe(vec!["prog"]);
.subcommand(App::new("sub1").arg(&arg))
.try_get_matches_from(vec!["prog"]);
assert!(result.is_ok());
}

899
tests/completions.rs
View file

@ -1,899 +0,0 @@
extern crate clap;
extern crate regex;
use clap::{App, Arg, Shell, SubCommand};
use regex::Regex;
static BASH: &'static str = r#"_myapp() {
local i cur prev opts cmds
COMPREPLY=()
cur="${COMP_WORDS[COMP_CWORD]}"
prev="${COMP_WORDS[COMP_CWORD-1]}"
cmd=""
opts=""
for i in ${COMP_WORDS[@]}
do
case "${i}" in
myapp)
cmd="myapp"
;;
help)
cmd+="__help"
;;
test)
cmd+="__test"
;;
*)
;;
esac
done
case "${cmd}" in
myapp)
opts=" -h -V --help --version <file> test help"
if [[ ${cur} == -* || ${COMP_CWORD} -eq 1 ]] ; then
COMPREPLY=( $(compgen -W "${opts}" -- ${cur}) )
return 0
fi
case "${prev}" in
*)
COMPREPLY=()
;;
esac
COMPREPLY=( $(compgen -W "${opts}" -- ${cur}) )
return 0
;;
myapp__help)
opts=" -h -V --help --version "
if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
COMPREPLY=( $(compgen -W "${opts}" -- ${cur}) )
return 0
fi
case "${prev}" in
*)
COMPREPLY=()
;;
esac
COMPREPLY=( $(compgen -W "${opts}" -- ${cur}) )
return 0
;;
myapp__test)
opts=" -h -V --case --help --version "
if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
COMPREPLY=( $(compgen -W "${opts}" -- ${cur}) )
return 0
fi
case "${prev}" in
--case)
COMPREPLY=($(compgen -f ${cur}))
return 0
;;
*)
COMPREPLY=()
;;
esac
COMPREPLY=( $(compgen -W "${opts}" -- ${cur}) )
return 0
;;
esac
}
complete -F _myapp -o bashdefault -o default myapp
"#;
static ZSH: &'static str = r#"#compdef myapp
autoload -U is-at-least
_myapp() {
typeset -A opt_args
typeset -a _arguments_options
local ret=1
if is-at-least 5.2; then
_arguments_options=(-s -S -C)
else
_arguments_options=(-s -C)
fi
local context curcontext="$curcontext" state line
_arguments "${_arguments_options[@]}" \
'-h[Prints help information]' \
'--help[Prints help information]' \
'-V[Prints version information]' \
'--version[Prints version information]' \
'::file -- some input file:_files' \
":: :_myapp_commands" \
"*::: :->myapp" \
&& ret=0
case $state in
(myapp)
words=($line[2] "${words[@]}")
(( CURRENT += 1 ))
curcontext="${curcontext%:*:*}:myapp-command-$line[2]:"
case $line[2] in
(test)
_arguments "${_arguments_options[@]}" \
'--case=[the case to test]' \
'-h[Prints help information]' \
'--help[Prints help information]' \
'-V[Prints version information]' \
'--version[Prints version information]' \
&& ret=0
;;
(help)
_arguments "${_arguments_options[@]}" \
'-h[Prints help information]' \
'--help[Prints help information]' \
'-V[Prints version information]' \
'--version[Prints version information]' \
&& ret=0
;;
esac
;;
esac
}
(( $+functions[_myapp_commands] )) ||
_myapp_commands() {
local commands; commands=(
"test:tests things" \
"help:Prints this message or the help of the given subcommand(s)" \
)
_describe -t commands 'myapp commands' commands "$@"
}
(( $+functions[_myapp__help_commands] )) ||
_myapp__help_commands() {
local commands; commands=(
)
_describe -t commands 'myapp help commands' commands "$@"
}
(( $+functions[_myapp__test_commands] )) ||
_myapp__test_commands() {
local commands; commands=(
)
_describe -t commands 'myapp test commands' commands "$@"
}
_myapp "$@""#;
static FISH: &'static str = r#"complete -c myapp -n "__fish_use_subcommand" -s h -l help -d 'Prints help information'
complete -c myapp -n "__fish_use_subcommand" -s V -l version -d 'Prints version information'
complete -c myapp -n "__fish_use_subcommand" -f -a "test" -d 'tests things'
complete -c myapp -n "__fish_use_subcommand" -f -a "help" -d 'Prints this message or the help of the given subcommand(s)'
complete -c myapp -n "__fish_seen_subcommand_from test" -l case -d 'the case to test'
complete -c myapp -n "__fish_seen_subcommand_from test" -s h -l help -d 'Prints help information'
complete -c myapp -n "__fish_seen_subcommand_from test" -s V -l version -d 'Prints version information'
complete -c myapp -n "__fish_seen_subcommand_from help" -s h -l help -d 'Prints help information'
complete -c myapp -n "__fish_seen_subcommand_from help" -s V -l version -d 'Prints version information'
"#;
static POWERSHELL: &'static str = r#"
using namespace System.Management.Automation
using namespace System.Management.Automation.Language
Register-ArgumentCompleter -Native -CommandName 'my_app' -ScriptBlock {
param($wordToComplete, $commandAst, $cursorPosition)
$commandElements = $commandAst.CommandElements
$command = @(
'my_app'
for ($i = 1; $i -lt $commandElements.Count; $i++) {
$element = $commandElements[$i]
if ($element -isnot [StringConstantExpressionAst] -or
$element.StringConstantType -ne [StringConstantType]::BareWord -or
$element.Value.StartsWith('-')) {
break
}
$element.Value
}) -join ';'
$completions = @(switch ($command) {
'my_app' {
[CompletionResult]::new('-h', 'h', [CompletionResultType]::ParameterName, 'Prints help information')
[CompletionResult]::new('--help', 'help', [CompletionResultType]::ParameterName, 'Prints help information')
[CompletionResult]::new('-V', 'V', [CompletionResultType]::ParameterName, 'Prints version information')
[CompletionResult]::new('--version', 'version', [CompletionResultType]::ParameterName, 'Prints version information')
[CompletionResult]::new('test', 'test', [CompletionResultType]::ParameterValue, 'tests things')
[CompletionResult]::new('help', 'help', [CompletionResultType]::ParameterValue, 'Prints this message or the help of the given subcommand(s)')
break
}
'my_app;test' {
[CompletionResult]::new('--case', 'case', [CompletionResultType]::ParameterName, 'the case to test')
[CompletionResult]::new('-h', 'h', [CompletionResultType]::ParameterName, 'Prints help information')
[CompletionResult]::new('--help', 'help', [CompletionResultType]::ParameterName, 'Prints help information')
[CompletionResult]::new('-V', 'V', [CompletionResultType]::ParameterName, 'Prints version information')
[CompletionResult]::new('--version', 'version', [CompletionResultType]::ParameterName, 'Prints version information')
break
}
'my_app;help' {
[CompletionResult]::new('-h', 'h', [CompletionResultType]::ParameterName, 'Prints help information')
[CompletionResult]::new('--help', 'help', [CompletionResultType]::ParameterName, 'Prints help information')
[CompletionResult]::new('-V', 'V', [CompletionResultType]::ParameterName, 'Prints version information')
[CompletionResult]::new('--version', 'version', [CompletionResultType]::ParameterName, 'Prints version information')
break
}
})
$completions.Where{ $_.CompletionText -like "$wordToComplete*" } |
Sort-Object -Property ListItemText
}
"#;
static ELVISH: &'static str = r#"
edit:completion:arg-completer[my_app] = [@words]{
fn spaces [n]{
repeat $n ' ' | joins ''
}
fn cand [text desc]{
edit:complex-candidate $text &display-suffix=' '(spaces (- 14 (wcswidth $text)))$desc
}
command = 'my_app'
for word $words[1:-1] {
if (has-prefix $word '-') {
break
}
command = $command';'$word
}
completions = [
&'my_app'= {
cand -h 'Prints help information'
cand --help 'Prints help information'
cand -V 'Prints version information'
cand --version 'Prints version information'
cand test 'tests things'
cand help 'Prints this message or the help of the given subcommand(s)'
}
&'my_app;test'= {
cand --case 'the case to test'
cand -h 'Prints help information'
cand --help 'Prints help information'
cand -V 'Prints version information'
cand --version 'Prints version information'
}
&'my_app;help'= {
cand -h 'Prints help information'
cand --help 'Prints help information'
cand -V 'Prints version information'
cand --version 'Prints version information'
}
]
$completions[$command]
}
"#;
static ELVISH_SPECIAL_CMDS: &'static str = r#"
edit:completion:arg-completer[my_app] = [@words]{
fn spaces [n]{
repeat $n ' ' | joins ''
}
fn cand [text desc]{
edit:complex-candidate $text &display-suffix=' '(spaces (- 14 (wcswidth $text)))$desc
}
command = 'my_app'
for word $words[1:-1] {
if (has-prefix $word '-') {
break
}
command = $command';'$word
}
completions = [
&'my_app'= {
cand -h 'Prints help information'
cand --help 'Prints help information'
cand -V 'Prints version information'
cand --version 'Prints version information'
cand test 'tests things'
cand some_cmd 'tests other things'
cand some-cmd-with-hypens 'some-cmd-with-hypens'
cand help 'Prints this message or the help of the given subcommand(s)'
}
&'my_app;test'= {
cand --case 'the case to test'
cand -h 'Prints help information'
cand --help 'Prints help information'
cand -V 'Prints version information'
cand --version 'Prints version information'
}
&'my_app;some_cmd'= {
cand --config 'the other case to test'
cand -h 'Prints help information'
cand --help 'Prints help information'
cand -V 'Prints version information'
cand --version 'Prints version information'
}
&'my_app;some-cmd-with-hypens'= {
cand -h 'Prints help information'
cand --help 'Prints help information'
cand -V 'Prints version information'
cand --version 'Prints version information'
}
&'my_app;help'= {
cand -h 'Prints help information'
cand --help 'Prints help information'
cand -V 'Prints version information'
cand --version 'Prints version information'
}
]
$completions[$command]
}
"#;
static POWERSHELL_SPECIAL_CMDS: &'static str = r#"
using namespace System.Management.Automation
using namespace System.Management.Automation.Language
Register-ArgumentCompleter -Native -CommandName 'my_app' -ScriptBlock {
param($wordToComplete, $commandAst, $cursorPosition)
$commandElements = $commandAst.CommandElements
$command = @(
'my_app'
for ($i = 1; $i -lt $commandElements.Count; $i++) {
$element = $commandElements[$i]
if ($element -isnot [StringConstantExpressionAst] -or
$element.StringConstantType -ne [StringConstantType]::BareWord -or
$element.Value.StartsWith('-')) {
break
}
$element.Value
}) -join ';'
$completions = @(switch ($command) {
'my_app' {
[CompletionResult]::new('-h', 'h', [CompletionResultType]::ParameterName, 'Prints help information')
[CompletionResult]::new('--help', 'help', [CompletionResultType]::ParameterName, 'Prints help information')
[CompletionResult]::new('-V', 'V', [CompletionResultType]::ParameterName, 'Prints version information')
[CompletionResult]::new('--version', 'version', [CompletionResultType]::ParameterName, 'Prints version information')
[CompletionResult]::new('test', 'test', [CompletionResultType]::ParameterValue, 'tests things')
[CompletionResult]::new('some_cmd', 'some_cmd', [CompletionResultType]::ParameterValue, 'tests other things')
[CompletionResult]::new('some-cmd-with-hypens', 'some-cmd-with-hypens', [CompletionResultType]::ParameterValue, 'some-cmd-with-hypens')
[CompletionResult]::new('help', 'help', [CompletionResultType]::ParameterValue, 'Prints this message or the help of the given subcommand(s)')
break
}
'my_app;test' {
[CompletionResult]::new('--case', 'case', [CompletionResultType]::ParameterName, 'the case to test')
[CompletionResult]::new('-h', 'h', [CompletionResultType]::ParameterName, 'Prints help information')
[CompletionResult]::new('--help', 'help', [CompletionResultType]::ParameterName, 'Prints help information')
[CompletionResult]::new('-V', 'V', [CompletionResultType]::ParameterName, 'Prints version information')
[CompletionResult]::new('--version', 'version', [CompletionResultType]::ParameterName, 'Prints version information')
break
}
'my_app;some_cmd' {
[CompletionResult]::new('--config', 'config', [CompletionResultType]::ParameterName, 'the other case to test')
[CompletionResult]::new('-h', 'h', [CompletionResultType]::ParameterName, 'Prints help information')
[CompletionResult]::new('--help', 'help', [CompletionResultType]::ParameterName, 'Prints help information')
[CompletionResult]::new('-V', 'V', [CompletionResultType]::ParameterName, 'Prints version information')
[CompletionResult]::new('--version', 'version', [CompletionResultType]::ParameterName, 'Prints version information')
break
}
'my_app;some-cmd-with-hypens' {
[CompletionResult]::new('-h', 'h', [CompletionResultType]::ParameterName, 'Prints help information')
[CompletionResult]::new('--help', 'help', [CompletionResultType]::ParameterName, 'Prints help information')
[CompletionResult]::new('-V', 'V', [CompletionResultType]::ParameterName, 'Prints version information')
[CompletionResult]::new('--version', 'version', [CompletionResultType]::ParameterName, 'Prints version information')
break
}
'my_app;help' {
[CompletionResult]::new('-h', 'h', [CompletionResultType]::ParameterName, 'Prints help information')
[CompletionResult]::new('--help', 'help', [CompletionResultType]::ParameterName, 'Prints help information')
[CompletionResult]::new('-V', 'V', [CompletionResultType]::ParameterName, 'Prints version information')
[CompletionResult]::new('--version', 'version', [CompletionResultType]::ParameterName, 'Prints version information')
break
}
})
$completions.Where{ $_.CompletionText -like "$wordToComplete*" } |
Sort-Object -Property ListItemText
}
"#;
static ZSH_SPECIAL_CMDS: &'static str = r#"#compdef my_app
autoload -U is-at-least
_my_app() {
typeset -A opt_args
typeset -a _arguments_options
local ret=1
if is-at-least 5.2; then
_arguments_options=(-s -S -C)
else
_arguments_options=(-s -C)
fi
local context curcontext="$curcontext" state line
_arguments "${_arguments_options[@]}" \
'-h[Prints help information]' \
'--help[Prints help information]' \
'-V[Prints version information]' \
'--version[Prints version information]' \
'::file -- some input file:_files' \
":: :_my_app_commands" \
"*::: :->my_app" \
&& ret=0
case $state in
(my_app)
words=($line[2] "${words[@]}")
(( CURRENT += 1 ))
curcontext="${curcontext%:*:*}:my_app-command-$line[2]:"
case $line[2] in
(test)
_arguments "${_arguments_options[@]}" \
'--case=[the case to test]' \
'-h[Prints help information]' \
'--help[Prints help information]' \
'-V[Prints version information]' \
'--version[Prints version information]' \
&& ret=0
;;
(some_cmd)
_arguments "${_arguments_options[@]}" \
'--config=[the other case to test]' \
'-h[Prints help information]' \
'--help[Prints help information]' \
'-V[Prints version information]' \
'--version[Prints version information]' \
&& ret=0
;;
(some-cmd-with-hypens)
_arguments "${_arguments_options[@]}" \
'-h[Prints help information]' \
'--help[Prints help information]' \
'-V[Prints version information]' \
'--version[Prints version information]' \
&& ret=0
;;
(help)
_arguments "${_arguments_options[@]}" \
'-h[Prints help information]' \
'--help[Prints help information]' \
'-V[Prints version information]' \
'--version[Prints version information]' \
&& ret=0
;;
esac
;;
esac
}
(( $+functions[_my_app_commands] )) ||
_my_app_commands() {
local commands; commands=(
"test:tests things" \
"some_cmd:tests other things" \
"some-cmd-with-hypens:" \
"help:Prints this message or the help of the given subcommand(s)" \
)
_describe -t commands 'my_app commands' commands "$@"
}
(( $+functions[_my_app__help_commands] )) ||
_my_app__help_commands() {
local commands; commands=(
)
_describe -t commands 'my_app help commands' commands "$@"
}
(( $+functions[_my_app__some-cmd-with-hypens_commands] )) ||
_my_app__some-cmd-with-hypens_commands() {
local commands; commands=(
)
_describe -t commands 'my_app some-cmd-with-hypens commands' commands "$@"
}
(( $+functions[_my_app__some_cmd_commands] )) ||
_my_app__some_cmd_commands() {
local commands; commands=(
)
_describe -t commands 'my_app some_cmd commands' commands "$@"
}
(( $+functions[_my_app__test_commands] )) ||
_my_app__test_commands() {
local commands; commands=(
)
_describe -t commands 'my_app test commands' commands "$@"
}
_my_app "$@""#;
static FISH_SPECIAL_CMDS: &'static str = r#"complete -c my_app -n "__fish_use_subcommand" -s h -l help -d 'Prints help information'
complete -c my_app -n "__fish_use_subcommand" -s V -l version -d 'Prints version information'
complete -c my_app -n "__fish_use_subcommand" -f -a "test" -d 'tests things'
complete -c my_app -n "__fish_use_subcommand" -f -a "some_cmd" -d 'tests other things'
complete -c my_app -n "__fish_use_subcommand" -f -a "some-cmd-with-hypens"
complete -c my_app -n "__fish_use_subcommand" -f -a "help" -d 'Prints this message or the help of the given subcommand(s)'
complete -c my_app -n "__fish_seen_subcommand_from test" -l case -d 'the case to test'
complete -c my_app -n "__fish_seen_subcommand_from test" -s h -l help -d 'Prints help information'
complete -c my_app -n "__fish_seen_subcommand_from test" -s V -l version -d 'Prints version information'
complete -c my_app -n "__fish_seen_subcommand_from some_cmd" -l config -d 'the other case to test'
complete -c my_app -n "__fish_seen_subcommand_from some_cmd" -s h -l help -d 'Prints help information'
complete -c my_app -n "__fish_seen_subcommand_from some_cmd" -s V -l version -d 'Prints version information'
complete -c my_app -n "__fish_seen_subcommand_from some-cmd-with-hypens" -s h -l help -d 'Prints help information'
complete -c my_app -n "__fish_seen_subcommand_from some-cmd-with-hypens" -s V -l version -d 'Prints version information'
complete -c my_app -n "__fish_seen_subcommand_from help" -s h -l help -d 'Prints help information'
complete -c my_app -n "__fish_seen_subcommand_from help" -s V -l version -d 'Prints version information'
"#;
static BASH_SPECIAL_CMDS: &'static str = r#"_my_app() {
local i cur prev opts cmds
COMPREPLY=()
cur="${COMP_WORDS[COMP_CWORD]}"
prev="${COMP_WORDS[COMP_CWORD-1]}"
cmd=""
opts=""
for i in ${COMP_WORDS[@]}
do
case "${i}" in
my_app)
cmd="my_app"
;;
help)
cmd+="__help"
;;
some-cmd-with-hypens)
cmd+="__some__cmd__with__hypens"
;;
some_cmd)
cmd+="__some_cmd"
;;
test)
cmd+="__test"
;;
*)
;;
esac
done
case "${cmd}" in
my_app)
opts=" -h -V --help --version <file> test some_cmd some-cmd-with-hypens help"
if [[ ${cur} == -* || ${COMP_CWORD} -eq 1 ]] ; then
COMPREPLY=( $(compgen -W "${opts}" -- ${cur}) )
return 0
fi
case "${prev}" in
*)
COMPREPLY=()
;;
esac
COMPREPLY=( $(compgen -W "${opts}" -- ${cur}) )
return 0
;;
my_app__help)
opts=" -h -V --help --version "
if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
COMPREPLY=( $(compgen -W "${opts}" -- ${cur}) )
return 0
fi
case "${prev}" in
*)
COMPREPLY=()
;;
esac
COMPREPLY=( $(compgen -W "${opts}" -- ${cur}) )
return 0
;;
my_app__some__cmd__with__hypens)
opts=" -h -V --help --version "
if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
COMPREPLY=( $(compgen -W "${opts}" -- ${cur}) )
return 0
fi
case "${prev}" in
*)
COMPREPLY=()
;;
esac
COMPREPLY=( $(compgen -W "${opts}" -- ${cur}) )
return 0
;;
my_app__some_cmd)
opts=" -h -V --config --help --version "
if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
COMPREPLY=( $(compgen -W "${opts}" -- ${cur}) )
return 0
fi
case "${prev}" in
--config)
COMPREPLY=($(compgen -f ${cur}))
return 0
;;
*)
COMPREPLY=()
;;
esac
COMPREPLY=( $(compgen -W "${opts}" -- ${cur}) )
return 0
;;
my_app__test)
opts=" -h -V --case --help --version "
if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
COMPREPLY=( $(compgen -W "${opts}" -- ${cur}) )
return 0
fi
case "${prev}" in
--case)
COMPREPLY=($(compgen -f ${cur}))
return 0
;;
*)
COMPREPLY=()
;;
esac
COMPREPLY=( $(compgen -W "${opts}" -- ${cur}) )
return 0
;;
esac
}
complete -F _my_app -o bashdefault -o default my_app
"#;
static FISH_SPECIAL_HELP: &'static str = r#"complete -c my_app -n "__fish_use_subcommand" -l single-quotes -d 'Can be \'always\', \'auto\', or \'never\''
complete -c my_app -n "__fish_use_subcommand" -l double-quotes -d 'Can be "always", "auto", or "never"'
complete -c my_app -n "__fish_use_subcommand" -l backticks -d 'For more information see `echo test`'
complete -c my_app -n "__fish_use_subcommand" -l backslash -d 'Avoid \'\\n\''
complete -c my_app -n "__fish_use_subcommand" -l brackets -d 'List packages [filter]'
complete -c my_app -n "__fish_use_subcommand" -l expansions -d 'Execute the shell command with $SHELL'
complete -c my_app -n "__fish_use_subcommand" -s h -l help -d 'Prints help information'
complete -c my_app -n "__fish_use_subcommand" -s V -l version -d 'Prints version information'
"#;
static ZSH_SPECIAL_HELP: &'static str = r#"#compdef my_app
autoload -U is-at-least
_my_app() {
typeset -A opt_args
typeset -a _arguments_options
local ret=1
if is-at-least 5.2; then
_arguments_options=(-s -S -C)
else
_arguments_options=(-s -C)
fi
local context curcontext="$curcontext" state line
_arguments "${_arguments_options[@]}" \
'--single-quotes[Can be '\''always'\'', '\''auto'\'', or '\''never'\'']' \
'--double-quotes[Can be "always", "auto", or "never"]' \
'--backticks[For more information see `echo test`]' \
'--backslash[Avoid '\''\\n'\'']' \
'--brackets[List packages \[filter\]]' \
'--expansions[Execute the shell command with $SHELL]' \
'-h[Prints help information]' \
'--help[Prints help information]' \
'-V[Prints version information]' \
'--version[Prints version information]' \
&& ret=0
}
(( $+functions[_my_app_commands] )) ||
_my_app_commands() {
local commands; commands=(
)
_describe -t commands 'my_app commands' commands "$@"
}
_my_app "$@""#;
fn compare(left: &str, right: &str) -> bool {
let b = left == right;
if !b {
let re = Regex::new(" ").unwrap();
println!("");
println!("--> left");
println!("{}", re.replace_all(left, "\u{2022}"));
println!("--> right");
println!("{}", re.replace_all(right, "\u{2022}"));
println!("--")
}
b
}
fn build_app() -> App<'static, 'static> { build_app_with_name("myapp") }
fn build_app_with_name(s: &'static str) -> App<'static, 'static> {
App::new(s)
.about("Tests completions")
.arg(Arg::with_name("file").help("some input file"))
.subcommand(
SubCommand::with_name("test").about("tests things").arg(
Arg::with_name("case")
.long("case")
.takes_value(true)
.help("the case to test"),
),
)
}
fn build_app_special_commands() -> App<'static, 'static> {
build_app_with_name("my_app")
.subcommand(
SubCommand::with_name("some_cmd")
.about("tests other things")
.arg(
Arg::with_name("config")
.long("--config")
.takes_value(true)
.help("the other case to test"),
),
)
.subcommand(SubCommand::with_name("some-cmd-with-hypens"))
}
fn build_app_special_help() -> App<'static, 'static> {
App::new("my_app")
.arg(
Arg::with_name("single-quotes")
.long("single-quotes")
.help("Can be 'always', 'auto', or 'never'"),
)
.arg(
Arg::with_name("double-quotes")
.long("double-quotes")
.help("Can be \"always\", \"auto\", or \"never\""),
)
.arg(
Arg::with_name("backticks")
.long("backticks")
.help("For more information see `echo test`"),
)
.arg(
Arg::with_name("backslash")
.long("backslash")
.help("Avoid '\\n'"),
)
.arg(
Arg::with_name("brackets")
.long("brackets")
.help("List packages [filter]"),
)
.arg(
Arg::with_name("expansions")
.long("expansions")
.help("Execute the shell command with $SHELL"),
)
}
#[test]
fn bash() {
let mut app = build_app();
let mut buf = vec![];
app.gen_completions_to("myapp", Shell::Bash, &mut buf);
let string = String::from_utf8(buf).unwrap();
assert!(compare(&*string, BASH));
}
#[test]
fn zsh() {
let mut app = build_app();
let mut buf = vec![];
app.gen_completions_to("myapp", Shell::Zsh, &mut buf);
let string = String::from_utf8(buf).unwrap();
assert!(compare(&*string, ZSH));
}
#[test]
fn fish() {
let mut app = build_app();
let mut buf = vec![];
app.gen_completions_to("myapp", Shell::Fish, &mut buf);
let string = String::from_utf8(buf).unwrap();
assert!(compare(&*string, FISH));
}
#[test]
fn powershell() {
let mut app = build_app();
let mut buf = vec![];
app.gen_completions_to("my_app", Shell::PowerShell, &mut buf);
let string = String::from_utf8(buf).unwrap();
assert!(compare(&*string, POWERSHELL));
}
#[test]
fn elvish() {
let mut app = build_app();
let mut buf = vec![];
app.gen_completions_to("my_app", Shell::Elvish, &mut buf);
let string = String::from_utf8(buf).unwrap();
assert!(compare(&*string, ELVISH));
}
#[test]
fn elvish_with_special_commands() {
let mut app = build_app_special_commands();
let mut buf = vec![];
app.gen_completions_to("my_app", Shell::Elvish, &mut buf);
let string = String::from_utf8(buf).unwrap();
assert!(compare(&*string, ELVISH_SPECIAL_CMDS));
}
#[test]
fn powershell_with_special_commands() {
let mut app = build_app_special_commands();
let mut buf = vec![];
app.gen_completions_to("my_app", Shell::PowerShell, &mut buf);
let string = String::from_utf8(buf).unwrap();
assert!(compare(&*string, POWERSHELL_SPECIAL_CMDS));
}
#[test]
fn bash_with_special_commands() {
let mut app = build_app_special_commands();
let mut buf = vec![];
app.gen_completions_to("my_app", Shell::Bash, &mut buf);
let string = String::from_utf8(buf).unwrap();
assert!(compare(&*string, BASH_SPECIAL_CMDS));
}
#[test]
fn fish_with_special_commands() {
let mut app = build_app_special_commands();
let mut buf = vec![];
app.gen_completions_to("my_app", Shell::Fish, &mut buf);
let string = String::from_utf8(buf).unwrap();
assert!(compare(&*string, FISH_SPECIAL_CMDS));
}
#[test]
fn zsh_with_special_commands() {
let mut app = build_app_special_commands();
let mut buf = vec![];
app.gen_completions_to("my_app", Shell::Zsh, &mut buf);
let string = String::from_utf8(buf).unwrap();
assert!(compare(&*string, ZSH_SPECIAL_CMDS));
}
#[test]
fn fish_with_special_help() {
let mut app = build_app_special_help();
let mut buf = vec![];
app.gen_completions_to("my_app", Shell::Fish, &mut buf);
let string = String::from_utf8(buf).unwrap();
assert!(compare(&*string, FISH_SPECIAL_HELP));
}
#[test]
fn zsh_with_special_help() {
let mut app = build_app_special_help();
let mut buf = vec![];
app.gen_completions_to("my_app", Shell::Zsh, &mut buf);
let string = String::from_utf8(buf).unwrap();
assert!(compare(&*string, ZSH_SPECIAL_HELP));
}

10
tests/conflicts.rs
View file

@ -24,7 +24,7 @@ fn flag_conflict() {
let result = App::new("flag_conflict")
.arg(Arg::from("-f, --flag 'some flag'").conflicts_with("other"))
.arg(Arg::from("-o, --other 'some flag'"))
.get_matches_from_safe(vec!["myprog", "-f", "-o"]);
.try_get_matches_from(vec!["myprog", "-f", "-o"]);
assert!(result.is_err());
let err = result.err().unwrap();
assert_eq!(err.kind, ErrorKind::ArgumentConflict);
@ -35,7 +35,7 @@ fn flag_conflict_2() {
let result = App::new("flag_conflict")
.arg(Arg::from("-f, --flag 'some flag'").conflicts_with("other"))
.arg(Arg::from("-o, --other 'some flag'"))
.get_matches_from_safe(vec!["myprog", "-o", "-f"]);
.try_get_matches_from(vec!["myprog", "-o", "-f"]);
assert!(result.is_err());
let err = result.err().unwrap();
assert_eq!(err.kind, ErrorKind::ArgumentConflict);
@ -53,7 +53,7 @@ fn group_conflict() {
)
.arg(Arg::from("--some 'some arg'"))
.arg(Arg::from("--other 'other arg'"))
.get_matches_from_safe(vec!["myprog", "--other", "-f"]);
.try_get_matches_from(vec!["myprog", "--other", "-f"]);
assert!(result.is_err());
let err = result.err().unwrap();
assert_eq!(err.kind, ErrorKind::ArgumentConflict);
@ -71,7 +71,7 @@ fn group_conflict_2() {
)
.arg(Arg::from("--some 'some arg'"))
.arg(Arg::from("--other 'other arg'"))
.get_matches_from_safe(vec!["myprog", "-f", "--some"]);
.try_get_matches_from(vec!["myprog", "-f", "--some"]);
assert!(result.is_err());
let err = result.err().unwrap();
assert_eq!(err.kind, ErrorKind::ArgumentConflict);
@ -102,7 +102,7 @@ fn conflict_with_unused_default_value() {
let result = App::new("conflict")
.arg(Arg::from("-o, --opt=[opt] 'some opt'").default_value("default"))
.arg(Arg::from("-f, --flag 'some flag'").conflicts_with("opt"))
.get_matches_from_safe(vec!["myprog", "-f"]);
.try_get_matches_from(vec!["myprog", "-f"]);
assert!(result.is_ok());
let m = result.unwrap();
assert_eq!(m.value_of("opt"), Some("default"));

58
tests/default_vals.rs
View file

@ -9,7 +9,7 @@ use clap::{App, Arg, ErrorKind};
fn opts() {
let r = App::new("df")
.arg(Arg::from("-o [opt] 'some opt'").default_value("default"))
.get_matches_from_safe(vec![""]);
.try_get_matches_from(vec![""]);
assert!(r.is_ok());
let m = r.unwrap();
assert!(m.is_present("o"));
@ -20,7 +20,7 @@ fn opts() {
fn opt_user_override() {
let r = App::new("df")
.arg(Arg::from("--opt [FILE] 'some arg'").default_value("default"))
.get_matches_from_safe(vec!["", "--opt", "value"]);
.try_get_matches_from(vec!["", "--opt", "value"]);
assert!(r.is_ok());
let m = r.unwrap();
assert!(m.is_present("opt"));
@ -31,7 +31,7 @@ fn opt_user_override() {
fn positionals() {
let r = App::new("df")
.arg(Arg::from("[arg] 'some opt'").default_value("default"))
.get_matches_from_safe(vec![""]);
.try_get_matches_from(vec![""]);
assert!(r.is_ok());
let m = r.unwrap();
assert!(m.is_present("arg"));
@ -42,7 +42,7 @@ fn positionals() {
fn positional_user_override() {
let r = App::new("df")
.arg(Arg::from("[arg] 'some arg'").default_value("default"))
.get_matches_from_safe(vec!["", "value"]);
.try_get_matches_from(vec!["", "value"]);
assert!(r.is_ok());
let m = r.unwrap();
assert!(m.is_present("arg"));
@ -58,7 +58,7 @@ fn osstr_opts() {
let r = App::new("df")
.arg(Arg::from("-o [opt] 'some opt'").default_value_os(expected))
.get_matches_from_safe(vec![""]);
.try_get_matches_from(vec![""]);
assert!(r.is_ok());
let m = r.unwrap();
assert!(m.is_present("o"));
@ -72,7 +72,7 @@ fn osstr_opt_user_override() {
let r = App::new("df")
.arg(Arg::from("--opt [FILE] 'some arg'").default_value_os(default))
.get_matches_from_safe(vec!["", "--opt", "value"]);
.try_get_matches_from(vec!["", "--opt", "value"]);
assert!(r.is_ok());
let m = r.unwrap();
assert!(m.is_present("opt"));
@ -86,7 +86,7 @@ fn osstr_positionals() {
let r = App::new("df")
.arg(Arg::from("[arg] 'some opt'").default_value_os(expected))
.get_matches_from_safe(vec![""]);
.try_get_matches_from(vec![""]);
assert!(r.is_ok());
let m = r.unwrap();
assert!(m.is_present("arg"));
@ -100,7 +100,7 @@ fn osstr_positional_user_override() {
let r = App::new("df")
.arg(Arg::from("[arg] 'some arg'").default_value_os(default))
.get_matches_from_safe(vec!["", "value"]);
.try_get_matches_from(vec!["", "value"]);
assert!(r.is_ok());
let m = r.unwrap();
assert!(m.is_present("arg"));
@ -114,7 +114,7 @@ fn default_if_arg_present_no_default() {
let r = App::new("df")
.arg(Arg::from("--opt [FILE] 'some arg'"))
.arg(Arg::from("[arg] 'some arg'").default_value_if("opt", None, "default"))
.get_matches_from_safe(vec!["", "--opt", "some"]);
.try_get_matches_from(vec!["", "--opt", "some"]);
assert!(r.is_ok());
let m = r.unwrap();
assert!(m.is_present("arg"));
@ -126,7 +126,7 @@ fn default_if_arg_present_no_default_user_override() {
let r = App::new("df")
.arg(Arg::from("--opt [FILE] 'some arg'"))
.arg(Arg::from("[arg] 'some arg'").default_value_if("opt", None, "default"))
.get_matches_from_safe(vec!["", "--opt", "some", "other"]);
.try_get_matches_from(vec!["", "--opt", "some", "other"]);
assert!(r.is_ok());
let m = r.unwrap();
assert!(m.is_present("arg"));
@ -142,7 +142,7 @@ fn default_if_arg_present_no_arg_with_default() {
.default_value("first")
.default_value_if("opt", None, "default"),
)
.get_matches_from_safe(vec![""]);
.try_get_matches_from(vec![""]);
assert!(r.is_ok());
let m = r.unwrap();
assert!(m.is_present("arg"));
@ -158,7 +158,7 @@ fn default_if_arg_present_with_default() {
.default_value("first")
.default_value_if("opt", None, "default"),
)
.get_matches_from_safe(vec!["", "--opt", "some"]);
.try_get_matches_from(vec!["", "--opt", "some"]);
assert!(r.is_ok());
let m = r.unwrap();
assert!(m.is_present("arg"));
@ -174,7 +174,7 @@ fn default_if_arg_present_with_default_user_override() {
.default_value("first")
.default_value_if("opt", None, "default"),
)
.get_matches_from_safe(vec!["", "--opt", "some", "other"]);
.try_get_matches_from(vec!["", "--opt", "some", "other"]);
assert!(r.is_ok());
let m = r.unwrap();
assert!(m.is_present("arg"));
@ -190,7 +190,7 @@ fn default_if_arg_present_no_arg_with_default_user_override() {
.default_value("first")
.default_value_if("opt", None, "default"),
)
.get_matches_from_safe(vec!["", "other"]);
.try_get_matches_from(vec!["", "other"]);
assert!(r.is_ok());
let m = r.unwrap();
assert!(m.is_present("arg"));
@ -204,7 +204,7 @@ fn default_if_arg_present_with_value_no_default() {
let r = App::new("df")
.arg(Arg::from("--opt [FILE] 'some arg'"))
.arg(Arg::from("[arg] 'some arg'").default_value_if("opt", Some("value"), "default"))
.get_matches_from_safe(vec!["", "--opt", "value"]);
.try_get_matches_from(vec!["", "--opt", "value"]);
assert!(r.is_ok());
let m = r.unwrap();
assert!(m.is_present("arg"));
@ -216,7 +216,7 @@ fn default_if_arg_present_with_value_no_default_fail() {
let r = App::new("df")
.arg(Arg::from("--opt [FILE] 'some arg'"))
.arg(Arg::from("[arg] 'some arg'").default_value_if("opt", Some("value"), "default"))
.get_matches_from_safe(vec!["", "--opt", "other"]);
.try_get_matches_from(vec!["", "--opt", "other"]);
assert!(r.is_ok());
let m = r.unwrap();
assert!(!m.is_present("arg"));
@ -227,7 +227,7 @@ fn default_if_arg_present_with_value_no_default_user_override() {
let r = App::new("df")
.arg(Arg::from("--opt [FILE] 'some arg'"))
.arg(Arg::from("[arg] 'some arg'").default_value_if("opt", Some("some"), "default"))
.get_matches_from_safe(vec!["", "--opt", "some", "other"]);
.try_get_matches_from(vec!["", "--opt", "some", "other"]);
assert!(r.is_ok());
let m = r.unwrap();
assert!(m.is_present("arg"));
@ -243,7 +243,7 @@ fn default_if_arg_present_with_value_no_arg_with_default() {
.default_value("first")
.default_value_if("opt", Some("some"), "default"),
)
.get_matches_from_safe(vec![""]);
.try_get_matches_from(vec![""]);
assert!(r.is_ok());
let m = r.unwrap();
assert!(m.is_present("arg"));
@ -259,7 +259,7 @@ fn default_if_arg_present_with_value_no_arg_with_default_fail() {
.default_value("first")
.default_value_if("opt", Some("some"), "default"),
)
.get_matches_from_safe(vec!["", "--opt", "other"]);
.try_get_matches_from(vec!["", "--opt", "other"]);
assert!(r.is_ok());
let m = r.unwrap();
assert!(m.is_present("arg"));
@ -275,7 +275,7 @@ fn default_if_arg_present_with_value_with_default() {
.default_value("first")
.default_value_if("opt", Some("some"), "default"),
)
.get_matches_from_safe(vec!["", "--opt", "some"]);
.try_get_matches_from(vec!["", "--opt", "some"]);
assert!(r.is_ok());
let m = r.unwrap();
assert!(m.is_present("arg"));
@ -291,7 +291,7 @@ fn default_if_arg_present_with_value_with_default_user_override() {
.default_value("first")
.default_value_if("opt", Some("some"), "default"),
)
.get_matches_from_safe(vec!["", "--opt", "some", "other"]);
.try_get_matches_from(vec!["", "--opt", "some", "other"]);
assert!(r.is_ok());
let m = r.unwrap();
assert!(m.is_present("arg"));
@ -307,7 +307,7 @@ fn default_if_arg_present_no_arg_with_value_with_default_user_override() {
.default_value("first")
.default_value_if("opt", Some("some"), "default"),
)
.get_matches_from_safe(vec!["", "other"]);
.try_get_matches_from(vec!["", "other"]);
assert!(r.is_ok());
let m = r.unwrap();
assert!(m.is_present("arg"));
@ -323,7 +323,7 @@ fn default_if_arg_present_no_arg_with_value_with_default_user_override_fail() {
.default_value("first")
.default_value_if("opt", Some("some"), "default"),
)
.get_matches_from_safe(vec!["", "--opt", "value", "other"]);
.try_get_matches_from(vec!["", "--opt", "value", "other"]);
assert!(r.is_ok());
let m = r.unwrap();
assert!(m.is_present("arg"));
@ -342,7 +342,7 @@ fn default_ifs_arg_present() {
.default_value("first")
.default_value_ifs(&[("opt", Some("some"), "default"), ("flag", None, "flg")]),
)
.get_matches_from_safe(vec!["", "--flag"]);
.try_get_matches_from(vec!["", "--flag"]);
assert!(r.is_ok());
let m = r.unwrap();
assert!(m.is_present("arg"));
@ -359,7 +359,7 @@ fn default_ifs_arg_present_user_override() {
.default_value("first")
.default_value_ifs(&[("opt", Some("some"), "default"), ("flag", None, "flg")]),
)
.get_matches_from_safe(vec!["", "--flag", "value"]);
.try_get_matches_from(vec!["", "--flag", "value"]);
assert!(r.is_ok());
let m = r.unwrap();
assert!(m.is_present("arg"));
@ -376,7 +376,7 @@ fn default_ifs_arg_present_order() {
.default_value("first")
.default_value_ifs(&[("opt", Some("some"), "default"), ("flag", None, "flg")]),
)
.get_matches_from_safe(vec!["", "--opt=some", "--flag"]);
.try_get_matches_from(vec!["", "--opt=some", "--flag"]);
assert!(r.is_ok());
let m = r.unwrap();
assert!(m.is_present("arg"));
@ -408,7 +408,7 @@ fn conditional_reqs_fail() {
.required_if("target", "file")
.long("output"),
)
.get_matches_from_safe(vec!["test", "--input", "some"]);
.try_get_matches_from(vec!["test", "--input", "some"]);
assert!(m.is_err());
assert_eq!(m.unwrap_err().kind, ErrorKind::MissingRequiredArgument);
@ -439,7 +439,7 @@ fn conditional_reqs_pass() {
.required_if("target", "file")
.long("output"),
)
.get_matches_from_safe(vec!["test", "--input", "some", "--output", "other"]);
.try_get_matches_from(vec!["test", "--input", "some", "--output", "other"]);
assert!(m.is_ok());
let m = m.unwrap();
@ -458,7 +458,7 @@ fn issue_1050_num_vals_and_defaults() {
.number_of_values(1)
.default_value("0"),
)
.get_matches_from_safe(vec!["hello", "--exit-code=1"]);
.try_get_matches_from(vec!["hello", "--exit-code=1"]);
assert!(res.is_ok());
let m = res.unwrap();
assert_eq!(m.value_of("exit-code"), Some("1"));

10
tests/derive_order.rs
View file

@ -3,7 +3,7 @@ extern crate regex;
use std::str;
use clap::{App, AppSettings, Arg, SubCommand};
use clap::{App, AppSettings, Arg, };
include!("../clap-test.rs");
@ -225,7 +225,7 @@ fn derive_order_subcommand_propagate() {
.global_setting(AppSettings::DeriveDisplayOrder)
.version("1.2")
.subcommand(
SubCommand::with_name("sub").version("1.2").args(&[
App::new("sub").version("1.2").args(&[
Arg::with_name("flag_b").long("flag_b").help("first flag"),
Arg::with_name("option_b")
.long("option_b")
@ -252,7 +252,7 @@ fn unified_help_subcommand_propagate() {
let app = App::new("test")
.global_setting(AppSettings::UnifiedHelpMessage)
.subcommand(
SubCommand::with_name("sub").version("1.2").args(&[
App::new("sub").version("1.2").args(&[
Arg::with_name("flag_b").long("flag_b").help("first flag"),
Arg::with_name("option_b")
.long("option_b")
@ -280,7 +280,7 @@ fn unified_help_and_derive_order_subcommand_propagate() {
.global_setting(AppSettings::DeriveDisplayOrder)
.global_setting(AppSettings::UnifiedHelpMessage)
.subcommand(
SubCommand::with_name("sub").version("1.2").args(&[
App::new("sub").version("1.2").args(&[
Arg::with_name("flag_b").long("flag_b").help("first flag"),
Arg::with_name("option_b")
.long("option_b")
@ -308,7 +308,7 @@ fn unified_help_and_derive_order_subcommand_propagate_with_explicit_display_orde
.global_setting(AppSettings::DeriveDisplayOrder)
.global_setting(AppSettings::UnifiedHelpMessage)
.subcommand(
SubCommand::with_name("sub").version("1.2").args(&[
App::new("sub").version("1.2").args(&[
Arg::with_name("flag_b").long("flag_b").help("first flag"),
Arg::with_name("option_b")
.long("option_b")

28
tests/env.rs
View file

@ -11,7 +11,7 @@ fn env() {
let r = App::new("df")
.arg(Arg::from("[arg] 'some opt'").env("CLP_TEST_ENV"))
.get_matches_from_safe(vec![""]);
.try_get_matches_from(vec![""]);
assert!(r.is_ok());
let m = r.unwrap();
@ -26,7 +26,7 @@ fn env_os() {
let r = App::new("df")
.arg(Arg::from("[arg] 'some opt'").env_os(OsStr::new("CLP_TEST_ENV")))
.get_matches_from_safe(vec![""]);
.try_get_matches_from(vec![""]);
assert!(r.is_ok());
let m = r.unwrap();
@ -43,7 +43,7 @@ fn no_env() {
let r = App::new("df")
.arg(Arg::from("[arg] 'some opt'").env("CLP_TEST_ENV_NONE"))
.get_matches_from_safe(vec![""]);
.try_get_matches_from(vec![""]);
assert!(r.is_ok());
let m = r.unwrap();
@ -62,7 +62,7 @@ fn with_default() {
.env("CLP_TEST_ENV")
.default_value("default"),
)
.get_matches_from_safe(vec![""]);
.try_get_matches_from(vec![""]);
assert!(r.is_ok());
let m = r.unwrap();
@ -77,7 +77,7 @@ fn opt_user_override() {
let r = App::new("df")
.arg(Arg::from("--arg [FILE] 'some arg'").env("CLP_TEST_ENV"))
.get_matches_from_safe(vec!["", "--arg", "opt"]);
.try_get_matches_from(vec!["", "--arg", "opt"]);
assert!(r.is_ok());
let m = r.unwrap();
@ -92,7 +92,7 @@ fn positionals() {
let r = App::new("df")
.arg(Arg::from("[arg] 'some opt'").env("CLP_TEST_ENV"))
.get_matches_from_safe(vec![""]);
.try_get_matches_from(vec![""]);
assert!(r.is_ok());
let m = r.unwrap();
@ -107,7 +107,7 @@ fn positionals_user_override() {
let r = App::new("df")
.arg(Arg::from("[arg] 'some opt'").env("CLP_TEST_ENV"))
.get_matches_from_safe(vec!["", "opt"]);
.try_get_matches_from(vec!["", "opt"]);
assert!(r.is_ok());
let m = r.unwrap();
@ -127,7 +127,7 @@ fn multiple_one() {
.use_delimiter(true)
.multiple(true),
)
.get_matches_from_safe(vec![""]);
.try_get_matches_from(vec![""]);
assert!(r.is_ok());
let m = r.unwrap();
@ -147,7 +147,7 @@ fn multiple_three() {
.use_delimiter(true)
.multiple(true),
)
.get_matches_from_safe(vec![""]);
.try_get_matches_from(vec![""]);
assert!(r.is_ok());
let m = r.unwrap();
@ -169,7 +169,7 @@ fn multiple_no_delimiter() {
.env("CLP_TEST_ENV_MULTI2")
.multiple(true),
)
.get_matches_from_safe(vec![""]);
.try_get_matches_from(vec![""]);
assert!(r.is_ok());
let m = r.unwrap();
@ -191,7 +191,7 @@ fn possible_value() {
.env("CLP_TEST_ENV")
.possible_value("env"),
)
.get_matches_from_safe(vec![""]);
.try_get_matches_from(vec![""]);
assert!(r.is_ok());
let m = r.unwrap();
@ -210,7 +210,7 @@ fn not_possible_value() {
.env("CLP_TEST_ENV")
.possible_value("never"),
)
.get_matches_from_safe(vec![""]);
.try_get_matches_from(vec![""]);
assert!(r.is_err());
}
@ -231,7 +231,7 @@ fn validator() {
}
}),
)
.get_matches_from_safe(vec![""]);
.try_get_matches_from(vec![""]);
assert!(r.is_ok());
let m = r.unwrap();
@ -271,7 +271,7 @@ fn validator_invalid() {
}
}),
)
.get_matches_from_safe(vec![""]);
.try_get_matches_from(vec![""]);
assert!(r.is_err());
}

4
tests/flags.rs
View file

@ -18,7 +18,7 @@ fn flag_using_short() {
fn lots_o_flags_sep() {
let r = App::new("opts")
.arg(Arg::from("-o... 'some flag'"))
.get_matches_from_safe(vec![
.try_get_matches_from(vec![
"", "-o", "-o", "-o", "-o", "-o", "-o", "-o", "-o", "-o", "-o", "-o", "-o", "-o", "-o",
"-o", "-o", "-o", "-o", "-o", "-o", "-o", "-o", "-o", "-o", "-o", "-o", "-o", "-o",
"-o", "-o", "-o", "-o", "-o", "-o", "-o", "-o", "-o", "-o", "-o", "-o", "-o", "-o",
@ -52,7 +52,7 @@ fn lots_o_flags_sep() {
fn lots_o_flags_combined() {
let r = App::new("opts")
.arg(Arg::from("-o... 'some flag'"))
.get_matches_from_safe(vec![
.try_get_matches_from(vec![
"",
"-oooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo",
"-oooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo",

10
tests/global_args.rs
View file

@ -4,7 +4,7 @@ extern crate regex;
#[cfg(test)]
mod tests {
include!("../clap-test.rs");
use clap::{App, Arg, SubCommand};
use clap::{App, Arg, };
fn get_app() -> App<'static, 'static> {
App::new("myprog")
@ -23,14 +23,14 @@ mod tests {
.multiple(true)
.global(true),
)
.subcommand(SubCommand::with_name("outer").subcommand(SubCommand::with_name("inner")))
.subcommand(App::new("outer").subcommand(App::new("inner")))
}
#[test]
fn issue_1076() {
let mut app = get_app();
let _ = app.get_matches_from_safe_borrow(vec!["myprog"]);
let _ = app.get_matches_from_safe_borrow(vec!["myprog"]);
let _ = app.get_matches_from_safe_borrow(vec!["myprog"]);
let _ = app.try_get_matches_from_mut(vec!["myprog"]);
let _ = app.try_get_matches_from_mut(vec!["myprog"]);
let _ = app.try_get_matches_from_mut(vec!["myprog"]);
}
}

80
tests/groups.rs
View file

@ -32,16 +32,14 @@ For more information try --help";
#[test]
fn required_group_missing_arg() {
let result = App::new("group")
.args_from_usage(
"-f, --flag 'some flag'
-c, --color 'some other flag'",
)
.arg("-f, --flag 'some flag'")
.arg(" -c, --color 'some other flag'")
.group(
ArgGroup::with_name("req")
.args(&["flag", "color"])
.required(true),
)
.get_matches_from_safe(vec![""]);
.try_get_matches_from(vec![""]);
assert!(result.is_err());
let err = result.err().unwrap();
assert_eq!(err.kind, ErrorKind::MissingRequiredArgument);
@ -51,27 +49,23 @@ fn required_group_missing_arg() {
#[should_panic]
fn non_existing_arg() {
let _ = App::new("group")
.args_from_usage(
"-f, --flag 'some flag'
-c, --color 'some other flag'",
)
.arg("-f, --flag 'some flag'")
.arg("-c, --color 'some other flag'")
.group(
ArgGroup::with_name("req")
.args(&["flg", "color"])
.required(true),
)
.get_matches_from_safe(vec![""]);
.try_get_matches_from(vec![""]);
}
#[test]
fn group_single_value() {
let res = App::new("group")
.args_from_usage(
"-f, --flag 'some flag'
-c, --color [color] 'some option'",
)
.arg("-f, --flag 'some flag'")
.arg("-c, --color [color] 'some option'")
.group(ArgGroup::with_name("grp").args(&["flag", "color"]))
.get_matches_from_safe(vec!["", "-c", "blue"]);
.try_get_matches_from(vec!["", "-c", "blue"]);
assert!(res.is_ok());
let m = res.unwrap();
@ -82,12 +76,10 @@ fn group_single_value() {
#[test]
fn group_single_flag() {
let res = App::new("group")
.args_from_usage(
"-f, --flag 'some flag'
-c, --color [color] 'some option'",
)
.arg("-f, --flag 'some flag'")
.arg("-c, --color [color] 'some option'")
.group(ArgGroup::with_name("grp").args(&["flag", "color"]))
.get_matches_from_safe(vec!["", "-f"]);
.try_get_matches_from(vec!["", "-f"]);
assert!(res.is_ok());
let m = res.unwrap();
@ -98,12 +90,10 @@ fn group_single_flag() {
#[test]
fn group_empty() {
let res = App::new("group")
.args_from_usage(
"-f, --flag 'some flag'
-c, --color [color] 'some option'",
)
.arg("-f, --flag 'some flag'")
.arg("-c, --color [color] 'some option'")
.group(ArgGroup::with_name("grp").args(&["flag", "color"]))
.get_matches_from_safe(vec![""]);
.try_get_matches_from(vec![""]);
assert!(res.is_ok());
let m = res.unwrap();
@ -114,16 +104,14 @@ fn group_empty() {
#[test]
fn group_reqired_flags_empty() {
let result = App::new("group")
.args_from_usage(
"-f, --flag 'some flag'
-c, --color 'some option'",
)
.arg("-f, --flag 'some flag'")
.arg("-c, --color 'some option'")
.group(
ArgGroup::with_name("grp")
.required(true)
.args(&["flag", "color"]),
)
.get_matches_from_safe(vec![""]);
.try_get_matches_from(vec![""]);
assert!(result.is_err());
let err = result.err().unwrap();
assert_eq!(err.kind, ErrorKind::MissingRequiredArgument);
@ -132,12 +120,10 @@ fn group_reqired_flags_empty() {
#[test]
fn group_multi_value_single_arg() {
let res = App::new("group")
.args_from_usage(
"-f, --flag 'some flag'
-c, --color [color]... 'some option'",
)
.arg("-f, --flag 'some flag'")
.arg("-c, --color [color]... 'some option'")
.group(ArgGroup::with_name("grp").args(&["flag", "color"]))
.get_matches_from_safe(vec!["", "-c", "blue", "red", "green"]);
.try_get_matches_from(vec!["", "-c", "blue", "red", "green"]);
assert!(res.is_ok(), "{:?}", res.unwrap_err().kind);
let m = res.unwrap();
@ -153,7 +139,7 @@ fn empty_group() {
let r = App::new("empty_group")
.arg(Arg::from("-f, --flag 'some flag'"))
.group(ArgGroup::with_name("vers").required(true))
.get_matches_from_safe(vec!["empty_prog"]);
.try_get_matches_from(vec!["empty_prog"]);
assert!(r.is_err());
let err = r.err().unwrap();
assert_eq!(err.kind, ErrorKind::MissingRequiredArgument);
@ -162,10 +148,8 @@ fn empty_group() {
#[test]
fn req_group_usage_string() {
let app = App::new("req_group")
.args_from_usage(
"[base] 'Base commit'
-d, --delete 'Remove the base commit information'",
)
.arg("[base] 'Base commit'")
.arg("-d, --delete 'Remove the base commit information'")
.group(
ArgGroup::with_name("base_or_delete")
.args(&["base", "delete"])
@ -205,17 +189,15 @@ fn req_group_with_conflict_usage_string() {
#[test]
fn required_group_multiple_args() {
let result = App::new("group")
.args_from_usage(
"-f, --flag 'some flag'
-c, --color 'some other flag'",
)
.arg("-f, --flag 'some flag'")
.arg("-c, --color 'some other flag'")
.group(
ArgGroup::with_name("req")
.args(&["flag", "color"])
.required(true)
.multiple(true),
)
.get_matches_from_safe(vec!["group", "-f", "-c"]);
.try_get_matches_from(vec!["group", "-f", "-c"]);
assert!(result.is_ok());
let m = result.unwrap();
assert!(m.is_present("flag"));
@ -225,12 +207,10 @@ fn required_group_multiple_args() {
#[test]
fn group_multiple_args_error() {
let result = App::new("group")
.args_from_usage(
"-f, --flag 'some flag'
-c, --color 'some other flag'",
)
.arg("-f, --flag 'some flag'")
.arg("-c, --color 'some other flag'")
.group(ArgGroup::with_name("req").args(&["flag", "color"]))
.get_matches_from_safe(vec!["group", "-f", "-c"]);
.try_get_matches_from(vec!["group", "-f", "-c"]);
assert!(result.is_err());
let err = result.unwrap_err();
assert_eq!(err.kind, ErrorKind::ArgumentConflict);

100
tests/help.rs
View file

@ -4,7 +4,7 @@ extern crate regex;
include!("../clap-test.rs");
use clap::{App, AppSettings, Arg, ArgSettings, ErrorKind, SubCommand};
use clap::{App, AppSettings, Arg, ArgSettings, ErrorKind, };
static REQUIRE_DELIM_HELP: &'static str = "test 1.3
Kevin K.
@ -479,14 +479,14 @@ USAGE:
myapp [arg1]
ARGS:
<arg1>
<arg1>
some option
FLAGS:
-h, --help
-h, --help
Prints help information
-V, --version
-V, --version
Prints version information";
static HIDE_ENV_VALS: &'static str = "ctest 0.1
@ -541,7 +541,7 @@ fn setup() -> App<'static, 'static> {
#[test]
fn help_short() {
let m = setup().get_matches_from_safe(vec!["myprog", "-h"]);
let m = setup().try_get_matches_from(vec!["myprog", "-h"]);
assert!(m.is_err());
assert_eq!(m.unwrap_err().kind, ErrorKind::HelpDisplayed);
@ -549,7 +549,7 @@ fn help_short() {
#[test]
fn help_long() {
let m = setup().get_matches_from_safe(vec!["myprog", "--help"]);
let m = setup().try_get_matches_from(vec!["myprog", "--help"]);
assert!(m.is_err());
assert_eq!(m.unwrap_err().kind, ErrorKind::HelpDisplayed);
@ -557,7 +557,7 @@ fn help_long() {
#[test]
fn help_no_subcommand() {
let m = setup().get_matches_from_safe(vec!["myprog", "help"]);
let m = setup().try_get_matches_from(vec!["myprog", "help"]);
assert!(m.is_err());
assert_eq!(m.unwrap_err().kind, ErrorKind::UnknownArgument);
@ -567,11 +567,11 @@ fn help_no_subcommand() {
fn help_subcommand() {
let m = setup()
.subcommand(
SubCommand::with_name("test")
App::new("test")
.about("tests things")
.arg_from_usage("-v --verbose 'with verbosity'"),
.arg("-v --verbose 'with verbosity'"),
)
.get_matches_from_safe(vec!["myprog", "help"]);
.try_get_matches_from(vec!["myprog", "help"]);
assert!(m.is_err());
assert_eq!(m.unwrap_err().kind, ErrorKind::HelpDisplayed);
@ -643,7 +643,7 @@ fn args_with_last_usage() {
#[test]
fn subcommand_short_help() {
let m = test::complex_app().get_matches_from_safe(vec!["clap-test", "subcmd", "-h"]);
let m = test::complex_app().try_get_matches_from(vec!["clap-test", "subcmd", "-h"]);
assert!(m.is_err());
assert_eq!(m.unwrap_err().kind, ErrorKind::HelpDisplayed);
@ -651,7 +651,7 @@ fn subcommand_short_help() {
#[test]
fn subcommand_long_help() {
let m = test::complex_app().get_matches_from_safe(vec!["clap-test", "subcmd", "--help"]);
let m = test::complex_app().try_get_matches_from(vec!["clap-test", "subcmd", "--help"]);
assert!(m.is_err());
assert_eq!(m.unwrap_err().kind, ErrorKind::HelpDisplayed);
@ -659,7 +659,7 @@ fn subcommand_long_help() {
#[test]
fn subcommand_help_rev() {
let m = test::complex_app().get_matches_from_safe(vec!["clap-test", "help", "subcmd"]);
let m = test::complex_app().try_get_matches_from(vec!["clap-test", "help", "subcmd"]);
assert!(m.is_err());
assert_eq!(m.unwrap_err().kind, ErrorKind::HelpDisplayed);
@ -693,15 +693,13 @@ fn after_and_before_help_output() {
#[test]
fn multi_level_sc_help() {
let app = App::new("ctest").subcommand(
SubCommand::with_name("subcmd").subcommand(
SubCommand::with_name("multi")
App::new("subcmd").subcommand(
App::new("multi")
.about("tests subcommands")
.author("Kevin K. <kbknapp@gmail.com>")
.version("0.1")
.args_from_usage(
"-f, --flag 'tests flags'
-o, --option [scoption]... 'tests options'",
),
.arg("-f, --flag 'tests flags'")
.arg("-o, --option [scoption]... 'tests options'")
),
);
assert!(test::compare_output(
@ -714,7 +712,7 @@ fn multi_level_sc_help() {
#[test]
fn no_wrap_help() {
let app = App::new("ctest").set_term_width(0).help(MULTI_SC_HELP);
let app = App::new("ctest").set_term_width(0).about(MULTI_SC_HELP);
assert!(test::compare_output(
app,
"ctest --help",
@ -836,7 +834,7 @@ fn issue_626_variable_panic() {
d'Afrique et d'Asie, dans des plantations qui sont cultivées pour les marchés d'exportation. \
Le café est souvent une contribution majeure aux exportations des régions productrices.")
.takes_value(true))
.get_matches_from_safe(vec!["ctest", "--help"]);
.try_get_matches_from(vec!["ctest", "--help"]);
}
}
@ -993,7 +991,7 @@ fn issue_760() {
#[test]
fn ripgrep_usage() {
let app = App::new("ripgrep").version("0.5").usage(
let app = App::new("ripgrep").version("0.5").override_usage(
"rg [OPTIONS] <pattern> [<path> ...]
rg [OPTIONS] [-e PATTERN | -f FILE ]... [<path> ...]
rg [OPTIONS] --files [<path> ...]
@ -1007,14 +1005,14 @@ fn ripgrep_usage() {
fn ripgrep_usage_using_templates() {
let app = App::new("ripgrep")
.version("0.5")
.usage(
.override_usage(
"
rg [OPTIONS] <pattern> [<path> ...]
rg [OPTIONS] [-e PATTERN | -f FILE ]... [<path> ...]
rg [OPTIONS] --files [<path> ...]
rg [OPTIONS] --type-list",
)
.template(
.help_template(
"\
{bin} {version}
@ -1032,9 +1030,9 @@ fn sc_negates_reqs() {
let app = App::new("prog")
.version("1.0")
.setting(AppSettings::SubcommandsNegateReqs)
.arg_from_usage("-o, --opt <FILE> 'tests options'")
.arg("-o, --opt <FILE> 'tests options'")
.arg(Arg::with_name("PATH").help("help"))
.subcommand(SubCommand::with_name("test"));
.subcommand(App::new("test"));
assert!(test::compare_output(
app,
"prog --help",
@ -1047,10 +1045,8 @@ fn sc_negates_reqs() {
fn hidden_args() {
let app = App::new("prog")
.version("1.0")
.args_from_usage(
"-f, --flag 'testing flags'
-o, --opt [FILE] 'tests options'",
)
.arg("-f, --flag 'testing flags'")
.arg("-o, --opt [FILE] 'tests options'")
.arg(Arg::with_name("pos").hidden(true));
assert!(test::compare_output(app, "prog --help", HIDDEN_ARGS, false));
}
@ -1060,12 +1056,10 @@ fn args_negate_sc() {
let app = App::new("prog")
.version("1.0")
.setting(AppSettings::ArgsNegateSubcommands)
.args_from_usage(
"-f, --flag 'testing flags'
-o, --opt [FILE] 'tests options'",
)
.arg("-f, --flag 'testing flags'")
.arg("-o, --opt [FILE] 'tests options'")
.arg(Arg::with_name("PATH").help("help"))
.subcommand(SubCommand::with_name("test"));
.subcommand(App::new("test"));
assert!(test::compare_output(
app,
"prog --help",
@ -1078,12 +1072,10 @@ fn args_negate_sc() {
fn issue_1046_hidden_scs() {
let app = App::new("prog")
.version("1.0")
.args_from_usage(
"-f, --flag 'testing flags'
-o, --opt [FILE] 'tests options'",
)
.arg("-f, --flag 'testing flags'")
.arg("-o, --opt [FILE] 'tests options'")
.arg(Arg::with_name("PATH").help("some"))
.subcommand(SubCommand::with_name("test").setting(AppSettings::Hidden));
.subcommand(App::new("test").setting(AppSettings::Hidden));
assert!(test::compare_output(
app,
"prog --help",
@ -1108,10 +1100,8 @@ fn customize_version_and_help() {
.version("0.1")
.author("Nobody <odysseus@example.com>")
.about("You can customize the version and help text")
.help_short("H")
.help_message("Print help information")
.version_short("v")
.version_message("Print version information");
.mut_arg("help", |h| h.short('H').long("help").help("Print help information"))
.mut_arg("version", |v| v.short('v').long("version").help("Print version information"));
assert!(test::compare_output(
app,
"customize --help",
@ -1170,7 +1160,7 @@ fn last_arg_mult_usage_req_with_sc() {
.required(true)
.help("some"),
)
.subcommand(SubCommand::with_name("test").about("some"));
.subcommand(App::new("test").about("some"));
assert!(test::compare_output(
app,
"last --help",
@ -1192,7 +1182,7 @@ fn last_arg_mult_usage_with_sc() {
.last(true)
.help("some"),
)
.subcommand(SubCommand::with_name("test").about("some"));
.subcommand(App::new("test").about("some"));
assert!(test::compare_output(app, "last --help", LAST_ARG_SC, false));
}
@ -1232,12 +1222,12 @@ fn issue_1112_setup() -> App<'static, 'static> {
.about("tests stuff")
.version("1.3")
.arg(Arg::from("-h, --help 'some help'"))
.subcommand(SubCommand::with_name("foo").arg(Arg::from("-h, --help 'some help'")))
.subcommand(App::new("foo").arg(Arg::from("-h, --help 'some help'")))
}
#[test]
fn issue_1112_override_help_long() {
let m = issue_1112_setup().get_matches_from_safe(vec!["test", "--help"]);
let m = issue_1112_setup().try_get_matches_from(vec!["test", "--help"]);
assert!(m.is_ok());
assert!(m.unwrap().is_present("help"));
@ -1245,7 +1235,7 @@ fn issue_1112_override_help_long() {
#[test]
fn issue_1112_override_help_short() {
let m = issue_1112_setup().get_matches_from_safe(vec!["test", "-h"]);
let m = issue_1112_setup().try_get_matches_from(vec!["test", "-h"]);
assert!(m.is_ok());
assert!(m.unwrap().is_present("help"));
@ -1253,7 +1243,7 @@ fn issue_1112_override_help_short() {
#[test]
fn issue_1112_override_help_subcmd_long() {
let m = issue_1112_setup().get_matches_from_safe(vec!["test", "foo", "--help"]);
let m = issue_1112_setup().try_get_matches_from(vec!["test", "foo", "--help"]);
assert!(m.is_ok());
assert!(
@ -1266,7 +1256,7 @@ fn issue_1112_override_help_subcmd_long() {
#[test]
fn issue_1112_override_help_subcmd_short() {
let m = issue_1112_setup().get_matches_from_safe(vec!["test", "foo", "-h"]);
let m = issue_1112_setup().try_get_matches_from(vec!["test", "foo", "-h"]);
assert!(m.is_ok());
assert!(
@ -1461,16 +1451,16 @@ USAGE:
ctest foo
FLAGS:
-h, --help
-h, --help
Prints help information
-V, --version
-V, --version
Prints version information";
#[test]
fn show_long_about_issue_897() {
let app = App::new("ctest").version("0.1").subcommand(
SubCommand::with_name("foo")
App::new("foo")
.version("0.1")
.about("About foo")
.long_about("Long about foo"),
@ -1496,7 +1486,7 @@ FLAGS:
#[test]
fn show_short_about_issue_897() {
let app = App::new("ctest").version("0.1").subcommand(
SubCommand::with_name("foo")
App::new("foo")
.version("0.1")
.about("About foo")
.long_about("Long about foo"),

14
tests/macros.rs
View file

@ -110,7 +110,7 @@ fn quoted_arg_long_name() {
);
let matches = app
.get_matches_from_safe(vec!["bin_name", "value1", "value2", "--long-option-2"])
.try_get_matches_from(vec!["bin_name", "value1", "value2", "--long-option-2"])
.expect("Expected to successfully match the given args.");
assert!(matches.is_present("option2"));
}
@ -148,7 +148,7 @@ fn quoted_arg_name() {
);
let matches = app
.get_matches_from_safe(vec!["bin_name", "value1", "value2", "--long-option-2"])
.try_get_matches_from(vec!["bin_name", "value1", "value2", "--long-option-2"])
.expect("Expected to successfully match the given args.");
assert!(matches.is_present("option2"));
}
@ -166,7 +166,7 @@ fn group_macro() {
)
);
let result = app.get_matches_from_safe(vec!["bin_name", "--hard"]);
let result = app.try_get_matches_from(vec!["bin_name", "--hard"]);
assert!(result.is_ok());
let matches = result.expect("Expected to successfully match the given args.");
assert!(matches.is_present("difficulty"));
@ -186,7 +186,7 @@ fn group_macro_set_multiple() {
)
);
let result = app.get_matches_from_safe(vec!["bin_name", "--hard", "--easy"]);
let result = app.try_get_matches_from(vec!["bin_name", "--hard", "--easy"]);
assert!(result.is_ok());
let matches = result.expect("Expected to successfully match the given args.");
assert!(matches.is_present("difficulty"));
@ -208,7 +208,7 @@ fn group_macro_set_not_multiple() {
)
);
let result = app.get_matches_from_safe(vec!["bin_name", "--hard", "--easy"]);
let result = app.try_get_matches_from(vec!["bin_name", "--hard", "--easy"]);
assert!(result.is_err());
let err = result.unwrap_err();
assert_eq!(err.kind, ErrorKind::ArgumentConflict);
@ -227,7 +227,7 @@ fn group_macro_set_required() {
)
);
let result = app.get_matches_from_safe(vec!["bin_name"]);
let result = app.try_get_matches_from(vec!["bin_name"]);
assert!(result.is_err());
let err = result.unwrap_err();
assert_eq!(err.kind, ErrorKind::MissingRequiredArgument);
@ -246,7 +246,7 @@ fn group_macro_set_not_required() {
)
);
let result = app.get_matches_from_safe(vec!["bin_name"]);
let result = app.try_get_matches_from(vec!["bin_name"]);
assert!(result.is_ok());
let matches = result.expect("Expected to successfully match the given args.");
assert!(!matches.is_present("difficulty"));

106
tests/multiple_values.rs
View file

@ -1,6 +1,6 @@
extern crate clap;
use clap::{App, Arg, ErrorKind, SubCommand};
use clap::{App, Arg, ErrorKind, };
#[test]
fn option_long() {
@ -12,7 +12,7 @@ fn option_long() {
.takes_value(true)
.multiple(true),
)
.get_matches_from_safe(vec![
.try_get_matches_from(vec![
"", "--option", "val1", "--option", "val2", "--option", "val3",
]);
@ -37,7 +37,7 @@ fn option_short() {
.takes_value(true)
.multiple(true),
)
.get_matches_from_safe(vec!["", "-o", "val1", "-o", "val2", "-o", "val3"]);
.try_get_matches_from(vec!["", "-o", "val1", "-o", "val2", "-o", "val3"]);
assert!(m.is_ok());
let m = m.unwrap();
@ -61,7 +61,7 @@ fn option_mixed() {
.takes_value(true)
.multiple(true),
)
.get_matches_from_safe(vec![
.try_get_matches_from(vec![
"", "-o", "val1", "--option", "val2", "--option", "val3", "-o", "val4",
]);
@ -87,7 +87,7 @@ fn option_exact_exact() {
.multiple(true)
.number_of_values(3),
)
.get_matches_from_safe(vec!["", "-o", "val1", "-o", "val2", "-o", "val3"]);
.try_get_matches_from(vec!["", "-o", "val1", "-o", "val2", "-o", "val3"]);
assert!(m.is_ok());
let m = m.unwrap();
@ -110,7 +110,7 @@ fn option_exact_exact_not_mult() {
.takes_value(true)
.number_of_values(3),
)
.get_matches_from_safe(vec!["", "-o", "val1", "val2", "val3"]);
.try_get_matches_from(vec!["", "-o", "val1", "val2", "val3"]);
assert!(m.is_ok());
let m = m.unwrap();
@ -134,7 +134,7 @@ fn option_exact_exact_mult() {
.multiple(true)
.number_of_values(3),
)
.get_matches_from_safe(vec![
.try_get_matches_from(vec![
"", "-o", "val1", "val2", "val3", "-o", "val4", "val5", "val6",
]);
@ -160,7 +160,7 @@ fn option_exact_less() {
.multiple(true)
.number_of_values(3),
)
.get_matches_from_safe(vec!["", "-o", "val1", "-o", "val2"]);
.try_get_matches_from(vec!["", "-o", "val1", "-o", "val2"]);
assert!(m.is_err());
assert_eq!(m.unwrap_err().kind, ErrorKind::WrongNumberOfValues);
@ -177,7 +177,7 @@ fn option_exact_more() {
.multiple(true)
.number_of_values(3),
)
.get_matches_from_safe(vec![
.try_get_matches_from(vec![
"", "-o", "val1", "-o", "val2", "-o", "val3", "-o", "val4",
]);
@ -196,7 +196,7 @@ fn option_min_exact() {
.multiple(true)
.min_values(3),
)
.get_matches_from_safe(vec!["", "-o", "val1", "-o", "val2", "-o", "val3"]);
.try_get_matches_from(vec!["", "-o", "val1", "-o", "val2", "-o", "val3"]);
assert!(m.is_ok());
let m = m.unwrap();
@ -220,7 +220,7 @@ fn option_min_less() {
.multiple(true)
.min_values(3),
)
.get_matches_from_safe(vec!["", "-o", "val1", "-o", "val2"]);
.try_get_matches_from(vec!["", "-o", "val1", "-o", "val2"]);
assert!(m.is_err());
assert_eq!(m.unwrap_err().kind, ErrorKind::TooFewValues);
@ -238,7 +238,7 @@ fn option_short_min_more_mult_occurs() {
.multiple(true)
.min_values(3),
)
.get_matches_from_safe(vec![
.try_get_matches_from(vec![
"", "pos", "-o", "val1", "-o", "val2", "-o", "val3", "-o", "val4",
]);
@ -267,7 +267,7 @@ fn option_short_min_more_single_occur() {
.multiple(true)
.min_values(3),
)
.get_matches_from_safe(vec!["", "pos", "-o", "val1", "val2", "val3", "val4"]);
.try_get_matches_from(vec!["", "pos", "-o", "val1", "val2", "val3", "val4"]);
assert!(res.is_ok(), "{:?}", res.unwrap_err().kind);
let m = res.unwrap();
@ -293,7 +293,7 @@ fn option_max_exact() {
.multiple(true)
.max_values(3),
)
.get_matches_from_safe(vec!["", "-o", "val1", "-o", "val2", "-o", "val3"]);
.try_get_matches_from(vec!["", "-o", "val1", "-o", "val2", "-o", "val3"]);
assert!(m.is_ok());
let m = m.unwrap();
@ -317,7 +317,7 @@ fn option_max_less() {
.multiple(true)
.max_values(3),
)
.get_matches_from_safe(vec!["", "-o", "val1", "-o", "val2"]);
.try_get_matches_from(vec!["", "-o", "val1", "-o", "val2"]);
assert!(m.is_ok());
let m = m.unwrap();
@ -341,7 +341,7 @@ fn option_max_more() {
.multiple(true)
.max_values(3),
)
.get_matches_from_safe(vec![
.try_get_matches_from(vec![
"", "-o", "val1", "-o", "val2", "-o", "val3", "-o", "val4",
]);
@ -357,7 +357,7 @@ fn positional() {
.help("multiple positionals")
.multiple(true),
)
.get_matches_from_safe(vec!["myprog", "val1", "val2", "val3"]);
.try_get_matches_from(vec!["myprog", "val1", "val2", "val3"]);
assert!(m.is_ok());
let m = m.unwrap();
@ -378,7 +378,7 @@ fn positional_exact_exact() {
.help("multiple positionals")
.number_of_values(3),
)
.get_matches_from_safe(vec!["myprog", "val1", "val2", "val3"]);
.try_get_matches_from(vec!["myprog", "val1", "val2", "val3"]);
assert!(m.is_ok());
let m = m.unwrap();
@ -399,7 +399,7 @@ fn positional_exact_less() {
.help("multiple positionals")
.number_of_values(3),
)
.get_matches_from_safe(vec!["myprog", "val1", "val2"]);
.try_get_matches_from(vec!["myprog", "val1", "val2"]);
assert!(m.is_err());
assert_eq!(m.unwrap_err().kind, ErrorKind::WrongNumberOfValues);
@ -413,7 +413,7 @@ fn positional_exact_more() {
.help("multiple positionals")
.number_of_values(3),
)
.get_matches_from_safe(vec!["myprog", "val1", "val2", "val3", "val4"]);
.try_get_matches_from(vec!["myprog", "val1", "val2", "val3", "val4"]);
assert!(m.is_err());
assert_eq!(m.unwrap_err().kind, ErrorKind::WrongNumberOfValues);
@ -427,7 +427,7 @@ fn positional_min_exact() {
.help("multiple positionals")
.min_values(3),
)
.get_matches_from_safe(vec!["myprog", "val1", "val2", "val3"]);
.try_get_matches_from(vec!["myprog", "val1", "val2", "val3"]);
assert!(m.is_ok());
let m = m.unwrap();
@ -448,7 +448,7 @@ fn positional_min_less() {
.help("multiple positionals")
.min_values(3),
)
.get_matches_from_safe(vec!["myprog", "val1", "val2"]);
.try_get_matches_from(vec!["myprog", "val1", "val2"]);
assert!(m.is_err());
assert_eq!(m.unwrap_err().kind, ErrorKind::TooFewValues);
@ -462,7 +462,7 @@ fn positional_min_more() {
.help("multiple positionals")
.min_values(3),
)
.get_matches_from_safe(vec!["myprog", "val1", "val2", "val3", "val4"]);
.try_get_matches_from(vec!["myprog", "val1", "val2", "val3", "val4"]);
assert!(m.is_ok());
let m = m.unwrap();
@ -483,7 +483,7 @@ fn positional_max_exact() {
.help("multiple positionals")
.max_values(3),
)
.get_matches_from_safe(vec!["myprog", "val1", "val2", "val3"]);
.try_get_matches_from(vec!["myprog", "val1", "val2", "val3"]);
assert!(m.is_ok());
let m = m.unwrap();
@ -504,7 +504,7 @@ fn positional_max_less() {
.help("multiple positionals")
.max_values(3),
)
.get_matches_from_safe(vec!["myprog", "val1", "val2"]);
.try_get_matches_from(vec!["myprog", "val1", "val2"]);
assert!(m.is_ok());
let m = m.unwrap();
@ -525,7 +525,7 @@ fn positional_max_more() {
.help("multiple positionals")
.max_values(3),
)
.get_matches_from_safe(vec!["myprog", "val1", "val2", "val3", "val4"]);
.try_get_matches_from(vec!["myprog", "val1", "val2", "val3", "val4"]);
assert!(m.is_err());
assert_eq!(m.unwrap_err().kind, ErrorKind::TooManyValues);
@ -542,7 +542,7 @@ fn sep_long_equals() {
.takes_value(true)
.multiple(true),
)
.get_matches_from_safe(vec!["", "--option=val1,val2,val3"]);
.try_get_matches_from(vec!["", "--option=val1,val2,val3"]);
assert!(m.is_ok());
let m = m.unwrap();
@ -566,7 +566,7 @@ fn sep_long_space() {
.takes_value(true)
.multiple(true),
)
.get_matches_from_safe(vec!["", "--option", "val1,val2,val3"]);
.try_get_matches_from(vec!["", "--option", "val1,val2,val3"]);
assert!(m.is_ok());
let m = m.unwrap();
@ -590,7 +590,7 @@ fn sep_short_equals() {
.takes_value(true)
.multiple(true),
)
.get_matches_from_safe(vec!["", "-o=val1,val2,val3"]);
.try_get_matches_from(vec!["", "-o=val1,val2,val3"]);
assert!(m.is_ok());
let m = m.unwrap();
@ -614,7 +614,7 @@ fn sep_short_space() {
.takes_value(true)
.multiple(true),
)
.get_matches_from_safe(vec!["", "-o", "val1,val2,val3"]);
.try_get_matches_from(vec!["", "-o", "val1,val2,val3"]);
assert!(m.is_ok());
let m = m.unwrap();
@ -638,7 +638,7 @@ fn sep_short_no_space() {
.takes_value(true)
.multiple(true),
)
.get_matches_from_safe(vec!["", "-oval1,val2,val3"]);
.try_get_matches_from(vec!["", "-oval1,val2,val3"]);
assert!(m.is_ok());
let m = m.unwrap();
@ -660,7 +660,7 @@ fn sep_positional() {
.use_delimiter(true)
.multiple(true),
)
.get_matches_from_safe(vec!["", "val1,val2,val3"]);
.try_get_matches_from(vec!["", "val1,val2,val3"]);
assert!(m.is_ok());
let m = m.unwrap();
@ -683,7 +683,7 @@ fn different_sep() {
.takes_value(true)
.value_delimiter(";"),
)
.get_matches_from_safe(vec!["", "--option=val1;val2;val3"]);
.try_get_matches_from(vec!["", "--option=val1;val2;val3"]);
assert!(m.is_ok());
let m = m.unwrap();
@ -704,7 +704,7 @@ fn different_sep_positional() {
.help("multiple options")
.value_delimiter(";"),
)
.get_matches_from_safe(vec!["", "val1;val2;val3"]);
.try_get_matches_from(vec!["", "val1;val2;val3"]);
assert!(m.is_ok());
let m = m.unwrap();
@ -727,7 +727,7 @@ fn no_sep() {
.takes_value(true)
.use_delimiter(false),
)
.get_matches_from_safe(vec!["", "--option=val1,val2,val3"]);
.try_get_matches_from(vec!["", "--option=val1,val2,val3"]);
assert!(m.is_ok());
let m = m.unwrap();
@ -745,7 +745,7 @@ fn no_sep_positional() {
.help("multiple options")
.use_delimiter(false),
)
.get_matches_from_safe(vec!["", "val1,val2,val3"]);
.try_get_matches_from(vec!["", "val1,val2,val3"]);
assert!(m.is_ok());
let m = m.unwrap();
@ -767,7 +767,7 @@ fn req_delimiter_long() {
.takes_value(true),
)
.arg(Arg::with_name("args").multiple(true).index(1))
.get_matches_from_safe(vec!["", "--option", "val1", "val2", "val3"]);
.try_get_matches_from(vec!["", "--option", "val1", "val2", "val3"]);
assert!(m.is_ok());
let m = m.unwrap();
@ -796,7 +796,7 @@ fn req_delimiter_long_with_equal() {
.takes_value(true),
)
.arg(Arg::with_name("args").multiple(true).index(1))
.get_matches_from_safe(vec!["", "--option=val1", "val2", "val3"]);
.try_get_matches_from(vec!["", "--option=val1", "val2", "val3"]);
assert!(m.is_ok());
let m = m.unwrap();
@ -825,7 +825,7 @@ fn req_delimiter_short_with_space() {
.takes_value(true),
)
.arg(Arg::with_name("args").multiple(true).index(1))
.get_matches_from_safe(vec!["", "-o", "val1", "val2", "val3"]);
.try_get_matches_from(vec!["", "-o", "val1", "val2", "val3"]);
assert!(m.is_ok());
let m = m.unwrap();
@ -854,7 +854,7 @@ fn req_delimiter_short_with_no_space() {
.takes_value(true),
)
.arg(Arg::with_name("args").multiple(true).index(1))
.get_matches_from_safe(vec!["", "-oval1", "val2", "val3"]);
.try_get_matches_from(vec!["", "-oval1", "val2", "val3"]);
assert!(m.is_ok());
let m = m.unwrap();
@ -883,7 +883,7 @@ fn req_delimiter_short_with_equal() {
.takes_value(true),
)
.arg(Arg::with_name("args").multiple(true).index(1))
.get_matches_from_safe(vec!["", "-o=val1", "val2", "val3"]);
.try_get_matches_from(vec!["", "-o=val1", "val2", "val3"]);
assert!(m.is_ok());
let m = m.unwrap();
@ -913,7 +913,7 @@ fn req_delimiter_complex() {
.takes_value(true),
)
.arg(Arg::with_name("args").multiple(true).index(1))
.get_matches_from_safe(vec![
.try_get_matches_from(vec![
"",
"val1",
"-oval2",
@ -974,7 +974,7 @@ fn low_index_positional_not_required() {
.multiple(true),
)
.arg(Arg::with_name("target").index(2))
.get_matches_from_safe(vec!["lip", "file1", "file2", "file3", "target"]);
.try_get_matches_from(vec!["lip", "file1", "file2", "file3", "target"]);
}
#[test]
@ -993,7 +993,7 @@ fn low_index_positional_last_multiple_too() {
.required(true)
.multiple(true),
)
.get_matches_from_safe(vec!["lip", "file1", "file2", "file3", "target"]);
.try_get_matches_from(vec!["lip", "file1", "file2", "file3", "target"]);
}
#[test]
@ -1008,7 +1008,7 @@ fn low_index_positional_too_far_back() {
)
.arg(Arg::with_name("target").required(true).index(2))
.arg(Arg::with_name("target2").required(true).index(3))
.get_matches_from_safe(vec!["lip", "file1", "file2", "file3", "target"]);
.try_get_matches_from(vec!["lip", "file1", "file2", "file3", "target"]);
}
#[test]
@ -1021,7 +1021,7 @@ fn low_index_positional() {
.multiple(true),
)
.arg(Arg::with_name("target").index(2).required(true))
.get_matches_from_safe(vec!["lip", "file1", "file2", "file3", "target"]);
.try_get_matches_from(vec!["lip", "file1", "file2", "file3", "target"]);
assert!(m.is_ok(), "{:?}", m.unwrap_err().kind);
let m = m.unwrap();
@ -1041,7 +1041,7 @@ fn low_index_positional() {
fn low_index_positional_in_subcmd() {
let m = App::new("lip")
.subcommand(
SubCommand::with_name("test")
App::new("test")
.arg(
Arg::with_name("files")
.index(1)
@ -1050,7 +1050,7 @@ fn low_index_positional_in_subcmd() {
)
.arg(Arg::with_name("target").index(2).required(true)),
)
.get_matches_from_safe(vec!["lip", "test", "file1", "file2", "file3", "target"]);
.try_get_matches_from(vec!["lip", "test", "file1", "file2", "file3", "target"]);
assert!(m.is_ok(), "{:?}", m.unwrap_err().kind);
let m = m.unwrap();
@ -1078,7 +1078,7 @@ fn low_index_positional_with_option() {
)
.arg(Arg::with_name("target").index(2).required(true))
.arg(Arg::with_name("opt").long("option").takes_value(true))
.get_matches_from_safe(vec![
.try_get_matches_from(vec![
"lip", "file1", "file2", "file3", "target", "--option", "test",
]);
@ -1108,7 +1108,7 @@ fn low_index_positional_with_flag() {
)
.arg(Arg::with_name("target").index(2).required(true))
.arg(Arg::with_name("flg").long("flag"))
.get_matches_from_safe(vec!["lip", "file1", "file2", "file3", "target", "--flag"]);
.try_get_matches_from(vec!["lip", "file1", "file2", "file3", "target", "--flag"]);
assert!(m.is_ok(), "{:?}", m.unwrap_err().kind);
let m = m.unwrap();
@ -1135,7 +1135,7 @@ fn multiple_value_terminator_option() {
.multiple(true),
)
.arg(Arg::with_name("other"))
.get_matches_from_safe(vec!["lip", "-f", "val1", "val2", ";", "otherval"]);
.try_get_matches_from(vec!["lip", "-f", "val1", "val2", ";", "otherval"]);
assert!(m.is_ok(), "{:?}", m.unwrap_err().kind);
let m = m.unwrap();
@ -1161,7 +1161,7 @@ fn multiple_value_terminator_option_other_arg() {
)
.arg(Arg::with_name("other"))
.arg(Arg::with_name("flag").short('F'))
.get_matches_from_safe(vec!["lip", "-f", "val1", "val2", "-F", "otherval"]);
.try_get_matches_from(vec!["lip", "-f", "val1", "val2", "-F", "otherval"]);
assert!(m.is_ok(), "{:?}", m.unwrap_err().kind);
let m = m.unwrap();
@ -1186,7 +1186,7 @@ fn multiple_vals_with_hyphen() {
.value_terminator(";"),
)
.arg(Arg::with_name("location"))
.get_matches_from_safe(vec![
.try_get_matches_from(vec![
"do",
"find",
"-type",

8
tests/opts.rs
View file

@ -318,7 +318,7 @@ fn leading_hyphen_fail() {
fn leading_hyphen_with_flag_after() {
let r = App::new("mvae")
.arg(Arg::from("-o [opt]... 'some opt'").setting(ArgSettings::AllowHyphenValues))
.arg_from_usage("-f 'some flag'")
.arg("-f 'some flag'")
.try_get_matches_from(vec!["", "-o", "-2", "-f"]);
assert!(r.is_ok());
let m = r.unwrap();
@ -331,7 +331,7 @@ fn leading_hyphen_with_flag_after() {
fn leading_hyphen_with_flag_before() {
let r = App::new("mvae")
.arg(Arg::from("-o [opt]... 'some opt'").setting(ArgSettings::AllowHyphenValues))
.arg_from_usage("-f 'some flag'")
.arg("-f 'some flag'")
.try_get_matches_from(vec!["", "-f", "-o", "-2"]);
assert!(r.is_ok());
let m = r.unwrap();
@ -348,7 +348,7 @@ fn leading_hyphen_with_only_pos_follows() {
.number_of_values(1)
.setting(ArgSettings::AllowHyphenValues),
)
.arg_from_usage("[arg] 'some arg'")
.arg("[arg] 'some arg'")
.try_get_matches_from(vec!["", "-o", "-2", "--", "val"]);
assert!(r.is_ok(), "{:?}", r);
let m = r.unwrap();
@ -371,7 +371,7 @@ fn did_you_mean() {
#[test]
fn issue_665() {
let res = App::new("tester")
.arg_from_usage("-v, --reroll-count=[N] 'Mark the patch series as PATCH vN'")
.arg("-v, --reroll-count=[N] 'Mark the patch series as PATCH vN'")
.arg(Arg::from(
"--subject-prefix [Subject-Prefix] 'Use [Subject-Prefix] instead of the standard [PATCH] prefix'") )
.try_get_matches_from(vec!["test", "--subject-prefix", "-v", "2"]);

62
tests/positionals.rs
View file

@ -9,7 +9,7 @@ fn only_pos_follow() {
Arg::from("-f [flag] 'some opt'"),
Arg::from("[arg] 'some arg'"),
])
.get_matches_from_safe(vec!["", "--", "-f"]);
.try_get_matches_from(vec!["", "--", "-f"]);
assert!(r.is_ok());
let m = r.unwrap();
assert!(m.is_present("arg"));
@ -21,14 +21,14 @@ fn only_pos_follow() {
fn issue_946() {
let r = App::new("compiletest")
.setting(clap::AppSettings::AllowLeadingHyphen)
.args_from_usage("--exact 'filters match exactly'")
.arg("--exact 'filters match exactly'")
.arg(
clap::Arg::with_name("filter")
.index(1)
.takes_value(true)
.help("filters to apply to output"),
)
.get_matches_from_safe(vec!["compiletest", "--exact"]);
.try_get_matches_from(vec!["compiletest", "--exact"]);
assert!(r.is_ok(), "{:#?}", r);
let matches = r.unwrap();
@ -43,7 +43,7 @@ fn positional() {
Arg::from("-f, --flag 'some flag'"),
Arg::with_name("positional").index(1),
])
.get_matches_from_safe(vec!["", "-f", "test"]);
.try_get_matches_from(vec!["", "-f", "test"]);
assert!(r.is_ok(), "{:#?}", r);
let m = r.unwrap();
assert!(m.is_present("positional"));
@ -65,7 +65,7 @@ fn positional() {
fn lots_o_vals() {
let r = App::new("opts")
.arg(Arg::from("[opt]... 'some pos'"))
.get_matches_from_safe(vec![
.try_get_matches_from(vec![
"", "some", "some", "some", "some", "some", "some", "some", "some", "some", "some",
"some", "some", "some", "some", "some", "some", "some", "some", "some", "some", "some",
"some", "some", "some", "some", "some", "some", "some", "some", "some", "some", "some",
@ -108,7 +108,7 @@ fn positional_multiple() {
Arg::from("-f, --flag 'some flag'"),
Arg::with_name("positional").index(1).multiple(true),
])
.get_matches_from_safe(vec!["", "-f", "test1", "test2", "test3"]);
.try_get_matches_from(vec!["", "-f", "test1", "test2", "test3"]);
assert!(r.is_ok(), "{:#?}", r);
let m = r.unwrap();
assert!(m.is_present("positional"));
@ -126,7 +126,7 @@ fn positional_multiple_3() {
Arg::from("-f, --flag 'some flag'"),
Arg::with_name("positional").index(1).multiple(true),
])
.get_matches_from_safe(vec!["", "test1", "test2", "test3", "--flag"]);
.try_get_matches_from(vec!["", "test1", "test2", "test3", "--flag"]);
assert!(r.is_ok(), "{:#?}", r);
let m = r.unwrap();
assert!(m.is_present("positional"));
@ -144,7 +144,7 @@ fn positional_multiple_2() {
Arg::from("-f, --flag 'some flag'"),
Arg::with_name("positional").index(1),
])
.get_matches_from_safe(vec!["", "-f", "test1", "test2", "test3"]);
.try_get_matches_from(vec!["", "-f", "test1", "test2", "test3"]);
assert!(result.is_err());
let err = result.err().unwrap();
assert_eq!(err.kind, ErrorKind::UnknownArgument);
@ -159,7 +159,7 @@ fn positional_possible_values() {
.index(1)
.possible_value("test123"),
])
.get_matches_from_safe(vec!["", "-f", "test123"]);
.try_get_matches_from(vec!["", "-f", "test123"]);
assert!(r.is_ok(), "{:#?}", r);
let m = r.unwrap();
assert!(m.is_present("positional"));
@ -186,35 +186,35 @@ fn positional_hyphen_does_not_panic() {
#[test]
fn single_positional_usage_string() {
let mut app = App::new("test").arg_from_usage("[FILE] 'some file'");
let mut app = App::new("test").arg("[FILE] 'some file'");
assert_eq!(app.generate_usage(), "USAGE:\n test [FILE]");
}
#[test]
fn single_positional_multiple_usage_string() {
let mut app = App::new("test").arg_from_usage("[FILE]... 'some file'");
let mut app = App::new("test").arg("[FILE]... 'some file'");
assert_eq!(app.generate_usage(), "USAGE:\n test [FILE]...");
}
#[test]
fn multiple_positional_usage_string() {
let mut app = App::new("test")
.arg_from_usage("[FILE] 'some file'")
.arg_from_usage("[FILES]... 'some file'");
.arg("[FILE] 'some file'")
.arg("[FILES]... 'some file'");
assert_eq!(app.generate_usage(), "USAGE:\n test [ARGS]");
}
#[test]
fn multiple_positional_one_required_usage_string() {
let mut app = App::new("test")
.arg_from_usage("<FILE> 'some file'")
.arg_from_usage("[FILES]... 'some file'");
.arg("<FILE> 'some file'")
.arg("[FILES]... 'some file'");
assert_eq!(app.generate_usage(), "USAGE:\n test <FILE> [FILES]...");
}
#[test]
fn single_positional_required_usage_string() {
let mut app = App::new("test").arg_from_usage("<FILE> 'some file'");
let mut app = App::new("test").arg("<FILE> 'some file'");
assert_eq!(app.generate_usage(), "USAGE:\n test <FILE>");
}
@ -222,9 +222,9 @@ fn single_positional_required_usage_string() {
#[should_panic]
fn missing_required() {
let r = App::new("test")
.arg_from_usage("[FILE1] 'some file'")
.arg_from_usage("<FILE2> 'some file'")
.get_matches_from_safe(vec!["test", "file"]);
.arg("[FILE1] 'some file'")
.arg("<FILE2> 'some file'")
.try_get_matches_from(vec!["test", "file"]);
assert!(r.is_err());
assert_eq!(r.unwrap_err().kind, ErrorKind::MissingRequiredArgument);
}
@ -232,9 +232,9 @@ fn missing_required() {
#[test]
fn missing_required_2() {
let r = App::new("test")
.arg_from_usage("<FILE1> 'some file'")
.arg_from_usage("<FILE2> 'some file'")
.get_matches_from_safe(vec!["test", "file"]);
.arg("<FILE1> 'some file'")
.arg("<FILE2> 'some file'")
.try_get_matches_from(vec!["test", "file"]);
assert!(r.is_err());
assert_eq!(r.unwrap_err().kind, ErrorKind::MissingRequiredArgument);
}
@ -242,10 +242,10 @@ fn missing_required_2() {
#[test]
fn last_positional() {
let r = App::new("test")
.arg_from_usage("<TARGET> 'some target'")
.arg_from_usage("[CORPUS] 'some corpus'")
.arg("<TARGET> 'some target'")
.arg("[CORPUS] 'some corpus'")
.arg(Arg::from("[ARGS]... 'some file'").last(true))
.get_matches_from_safe(vec!["test", "tgt", "--", "arg"]);
.try_get_matches_from(vec!["test", "tgt", "--", "arg"]);
assert!(r.is_ok());
let m = r.unwrap();
assert_eq!(m.values_of("ARGS").unwrap().collect::<Vec<_>>(), &["arg"]);
@ -254,10 +254,10 @@ fn last_positional() {
#[test]
fn last_positional_no_double_dash() {
let r = App::new("test")
.arg_from_usage("<TARGET> 'some target'")
.arg_from_usage("[CORPUS] 'some corpus'")
.arg("<TARGET> 'some target'")
.arg("[CORPUS] 'some corpus'")
.arg(Arg::from("[ARGS]... 'some file'").last(true))
.get_matches_from_safe(vec!["test", "tgt", "crp", "arg"]);
.try_get_matches_from(vec!["test", "tgt", "crp", "arg"]);
assert!(r.is_err());
assert_eq!(r.unwrap_err().kind, ErrorKind::UnknownArgument);
}
@ -265,9 +265,9 @@ fn last_positional_no_double_dash() {
#[test]
fn last_positional_second_to_last_mult() {
let r = App::new("test")
.arg_from_usage("<TARGET> 'some target'")
.arg_from_usage("[CORPUS]... 'some corpus'")
.arg("<TARGET> 'some target'")
.arg("[CORPUS]... 'some corpus'")
.arg(Arg::from("[ARGS]... 'some file'").last(true))
.get_matches_from_safe(vec!["test", "tgt", "crp1", "crp2", "--", "arg"]);
.try_get_matches_from(vec!["test", "tgt", "crp1", "crp2", "--", "arg"]);
assert!(r.is_ok(), "{:?}", r.unwrap_err().kind);
}

20
tests/posix_compatible.rs
View file

@ -5,7 +5,7 @@ use clap::{App, Arg, ErrorKind};
fn flag_overrides_itself() {
let res = App::new("posix")
.arg(Arg::from("--flag 'some flag'").overrides_with("flag"))
.get_matches_from_safe(vec!["", "--flag", "--flag"]);
.try_get_matches_from(vec!["", "--flag", "--flag"]);
assert!(res.is_ok());
let m = res.unwrap();
assert!(m.is_present("flag"));
@ -16,7 +16,7 @@ fn flag_overrides_itself() {
fn mult_flag_overrides_itself() {
let res = App::new("posix")
.arg(Arg::from("--flag... 'some flag'").overrides_with("flag"))
.get_matches_from_safe(vec!["", "--flag", "--flag", "--flag", "--flag"]);
.try_get_matches_from(vec!["", "--flag", "--flag", "--flag", "--flag"]);
assert!(res.is_ok());
let m = res.unwrap();
assert!(m.is_present("flag"));
@ -27,7 +27,7 @@ fn mult_flag_overrides_itself() {
fn option_overrides_itself() {
let res = App::new("posix")
.arg(Arg::from("--opt [val] 'some option'").overrides_with("opt"))
.get_matches_from_safe(vec!["", "--opt=some", "--opt=other"]);
.try_get_matches_from(vec!["", "--opt=some", "--opt=other"]);
assert!(res.is_ok());
let m = res.unwrap();
assert!(m.is_present("opt"));
@ -44,7 +44,7 @@ fn mult_option_require_delim_overrides_itself() {
.number_of_values(1)
.require_delimiter(true),
)
.get_matches_from_safe(vec!["", "--opt=some", "--opt=other", "--opt=one,two"]);
.try_get_matches_from(vec!["", "--opt=some", "--opt=other", "--opt=one,two"]);
assert!(res.is_ok());
let m = res.unwrap();
assert!(m.is_present("opt"));
@ -59,7 +59,7 @@ fn mult_option_require_delim_overrides_itself() {
fn mult_option_overrides_itself() {
let res = App::new("posix")
.arg(Arg::from("--opt [val]... 'some option'").overrides_with("opt"))
.get_matches_from_safe(vec![
.try_get_matches_from(vec![
"", "--opt", "first", "overides", "--opt", "some", "other", "val",
]);
assert!(res.is_ok());
@ -90,7 +90,7 @@ fn pos_mult_overrides_itself() {
// opts with multiple
let res = App::new("posix")
.arg(Arg::from("[val]... 'some pos'").overrides_with("val"))
.get_matches_from_safe(vec!["", "some", "other", "value"]);
.try_get_matches_from(vec!["", "some", "other", "value"]);
assert!(res.is_ok());
let m = res.unwrap();
assert!(m.is_present("val"));
@ -224,7 +224,7 @@ fn conflict_overriden_2() {
.arg(Arg::from("-f, --flag 'some flag'").conflicts_with("debug"))
.arg(Arg::from("-d, --debug 'other flag'"))
.arg(Arg::from("-c, --color 'third flag'").overrides_with("flag"))
.get_matches_from_safe(vec!["", "-f", "-d", "-c"]);
.try_get_matches_from(vec!["", "-f", "-d", "-c"]);
assert!(result.is_ok());
let m = result.unwrap();
assert!(m.is_present("color"));
@ -238,7 +238,7 @@ fn conflict_overriden_3() {
.arg(Arg::from("-f, --flag 'some flag'").conflicts_with("debug"))
.arg(Arg::from("-d, --debug 'other flag'"))
.arg(Arg::from("-c, --color 'third flag'").overrides_with("flag"))
.get_matches_from_safe(vec!["", "-d", "-c", "-f"]);
.try_get_matches_from(vec!["", "-d", "-c", "-f"]);
assert!(result.is_err());
let err = result.err().unwrap();
assert_eq!(err.kind, ErrorKind::ArgumentConflict);
@ -261,7 +261,7 @@ fn pos_required_overridden_by_flag() {
let result = App::new("require_overriden")
.arg(Arg::with_name("pos").index(1).required(true))
.arg(Arg::from("-c, --color 'some flag'").overrides_with("pos"))
.get_matches_from_safe(vec!["", "test", "-c"]);
.try_get_matches_from(vec!["", "test", "-c"]);
assert!(result.is_ok(), "{:?}", result.unwrap_err());
}
@ -293,7 +293,7 @@ fn require_overriden_4() {
.arg(Arg::from("-f, --flag 'some flag'").requires("debug"))
.arg(Arg::from("-d, --debug 'other flag'"))
.arg(Arg::from("-c, --color 'third flag'").overrides_with("flag"))
.get_matches_from_safe(vec!["", "-c", "-f"]);
.try_get_matches_from(vec!["", "-c", "-f"]);
assert!(result.is_err());
let err = result.err().unwrap();
assert_eq!(err.kind, ErrorKind::MissingRequiredArgument);

24
tests/possible_values.rs
View file

@ -37,7 +37,7 @@ fn possible_values_of_positional() {
.index(1)
.possible_value("test123"),
)
.get_matches_from_safe(vec!["myprog", "test123"]);
.try_get_matches_from(vec!["myprog", "test123"]);
assert!(m.is_ok());
let m = m.unwrap();
@ -54,7 +54,7 @@ fn possible_values_of_positional_fail() {
.index(1)
.possible_value("test123"),
)
.get_matches_from_safe(vec!["myprog", "notest"]);
.try_get_matches_from(vec!["myprog", "notest"]);
assert!(m.is_err());
assert_eq!(m.unwrap_err().kind, ErrorKind::InvalidValue);
@ -70,7 +70,7 @@ fn possible_values_of_positional_multiple() {
.possible_value("test321")
.multiple(true),
)
.get_matches_from_safe(vec!["myprog", "test123", "test321"]);
.try_get_matches_from(vec!["myprog", "test123", "test321"]);
assert!(m.is_ok());
let m = m.unwrap();
@ -92,7 +92,7 @@ fn possible_values_of_positional_multiple_fail() {
.possible_value("test321")
.multiple(true),
)
.get_matches_from_safe(vec!["myprog", "test123", "notest"]);
.try_get_matches_from(vec!["myprog", "test123", "notest"]);
assert!(m.is_err());
assert_eq!(m.unwrap_err().kind, ErrorKind::InvalidValue);
@ -108,7 +108,7 @@ fn possible_values_of_option() {
.takes_value(true)
.possible_value("test123"),
)
.get_matches_from_safe(vec!["myprog", "--option", "test123"]);
.try_get_matches_from(vec!["myprog", "--option", "test123"]);
assert!(m.is_ok());
let m = m.unwrap();
@ -127,7 +127,7 @@ fn possible_values_of_option_fail() {
.takes_value(true)
.possible_value("test123"),
)
.get_matches_from_safe(vec!["myprog", "--option", "notest"]);
.try_get_matches_from(vec!["myprog", "--option", "notest"]);
assert!(m.is_err());
assert_eq!(m.unwrap_err().kind, ErrorKind::InvalidValue);
@ -145,7 +145,7 @@ fn possible_values_of_option_multiple() {
.possible_value("test321")
.multiple(true),
)
.get_matches_from_safe(vec!["", "--option", "test123", "--option", "test321"]);
.try_get_matches_from(vec!["", "--option", "test123", "--option", "test321"]);
assert!(m.is_ok());
let m = m.unwrap();
@ -169,7 +169,7 @@ fn possible_values_of_option_multiple_fail() {
.possible_value("test321")
.multiple(true),
)
.get_matches_from_safe(vec!["", "--option", "test123", "--option", "notest"]);
.try_get_matches_from(vec!["", "--option", "test123", "--option", "notest"]);
assert!(m.is_err());
assert_eq!(m.unwrap_err().kind, ErrorKind::InvalidValue);
@ -197,7 +197,7 @@ fn case_insensitive() {
.possible_value("test321")
.case_insensitive(true),
)
.get_matches_from_safe(vec!["pv", "--option", "TeSt123"]);
.try_get_matches_from(vec!["pv", "--option", "TeSt123"]);
assert!(m.is_ok());
assert!(
@ -219,7 +219,7 @@ fn case_insensitive_faili() {
.possible_value("test123")
.possible_value("test321"),
)
.get_matches_from_safe(vec!["pv", "--option", "TeSt123"]);
.try_get_matches_from(vec!["pv", "--option", "TeSt123"]);
assert!(m.is_err());
assert_eq!(m.unwrap_err().kind, ErrorKind::InvalidValue);
@ -238,7 +238,7 @@ fn case_insensitive_multiple() {
.multiple(true)
.case_insensitive(true),
)
.get_matches_from_safe(vec!["pv", "--option", "TeSt123", "teST123", "tESt321"]);
.try_get_matches_from(vec!["pv", "--option", "TeSt123", "teST123", "tESt321"]);
assert!(m.is_ok());
assert_eq!(
@ -259,7 +259,7 @@ fn case_insensitive_multiple_fail() {
.possible_value("test321")
.multiple(true),
)
.get_matches_from_safe(vec!["pv", "--option", "test123", "teST123", "test321"]);
.try_get_matches_from(vec!["pv", "--option", "test123", "teST123", "test321"]);
assert!(m.is_err());
assert_eq!(m.unwrap_err().kind, ErrorKind::InvalidValue);

4
tests/propagate_globals.rs
View file

@ -4,7 +4,7 @@ extern crate regex;
#[cfg(test)]
mod tests {
include!("../clap-test.rs");
use clap::{App, Arg, ArgMatches, ArgSettings, SubCommand};
use clap::{App, Arg, ArgMatches, ArgSettings, };
fn get_app() -> App<'static, 'static> {
App::new("myprog")
@ -23,7 +23,7 @@ mod tests {
.setting(ArgSettings::MultipleOccurrences)
.setting(ArgSettings::Global),
)
.subcommand(SubCommand::with_name("outer").subcommand(SubCommand::with_name("inner")))
.subcommand(App::new("outer").subcommand(App::new("inner")))
}
fn get_matches(app: App<'static, 'static>, argv: &'static str) -> ArgMatches<'static> {

66
tests/require.rs
View file

@ -36,7 +36,7 @@ fn flag_required() {
let result = App::new("flag_required")
.arg(Arg::from("-f, --flag 'some flag'").requires("color"))
.arg(Arg::from("-c, --color 'third flag'"))
.get_matches_from_safe(vec!["", "-f"]);
.try_get_matches_from(vec!["", "-f"]);
assert!(result.is_err());
let err = result.err().unwrap();
assert_eq!(err.kind, ErrorKind::MissingRequiredArgument);
@ -57,7 +57,7 @@ fn option_required() {
let result = App::new("option_required")
.arg(Arg::from("-f [flag] 'some flag'").requires("c"))
.arg(Arg::from("-c [color] 'third flag'"))
.get_matches_from_safe(vec!["", "-f", "val"]);
.try_get_matches_from(vec!["", "-f", "val"]);
assert!(result.is_err());
let err = result.err().unwrap();
assert_eq!(err.kind, ErrorKind::MissingRequiredArgument);
@ -79,7 +79,7 @@ fn option_required_2() {
fn positional_required() {
let result = App::new("positional_required")
.arg(Arg::with_name("flag").index(1).required(true))
.get_matches_from_safe(vec![""]);
.try_get_matches_from(vec![""]);
assert!(result.is_err());
let err = result.err().unwrap();
assert_eq!(err.kind, ErrorKind::MissingRequiredArgument);
@ -106,7 +106,7 @@ fn group_required() {
)
.arg(Arg::from("--some 'some arg'"))
.arg(Arg::from("--other 'other arg'"))
.get_matches_from_safe(vec!["", "-f"]);
.try_get_matches_from(vec!["", "-f"]);
assert!(result.is_err());
let err = result.err().unwrap();
assert_eq!(err.kind, ErrorKind::MissingRequiredArgument);
@ -210,7 +210,7 @@ fn issue_753() {
)
.arg(Arg::from("-s, --server=[SERVER_IP] 'NTP server IP address'").required_unless("list"))
.arg(Arg::from("-p, --port=[SERVER_PORT] 'NTP server port'").default_value("123"))
.get_matches_from_safe(vec!["test", "--list"]);
.try_get_matches_from(vec!["test", "--list"]);
assert!(m.is_ok());
}
@ -224,7 +224,7 @@ fn required_unless() {
.long("config"),
)
.arg(Arg::with_name("dbg").long("debug"))
.get_matches_from_safe(vec!["unlesstest", "--debug"]);
.try_get_matches_from(vec!["unlesstest", "--debug"]);
assert!(res.is_ok());
let m = res.unwrap();
@ -242,7 +242,7 @@ fn required_unless_err() {
.long("config"),
)
.arg(Arg::with_name("dbg").long("debug"))
.get_matches_from_safe(vec!["unlesstest"]);
.try_get_matches_from(vec!["unlesstest"]);
assert!(res.is_err());
assert_eq!(res.unwrap_err().kind, ErrorKind::MissingRequiredArgument);
@ -261,7 +261,7 @@ fn required_unless_all() {
)
.arg(Arg::with_name("dbg").long("debug"))
.arg(Arg::with_name("infile").short('i').takes_value(true))
.get_matches_from_safe(vec!["unlessall", "--debug", "-i", "file"]);
.try_get_matches_from(vec!["unlessall", "--debug", "-i", "file"]);
assert!(res.is_ok());
let m = res.unwrap();
@ -281,7 +281,7 @@ fn required_unless_all_err() {
)
.arg(Arg::with_name("dbg").long("debug"))
.arg(Arg::with_name("infile").short('i').takes_value(true))
.get_matches_from_safe(vec!["unlessall", "--debug"]);
.try_get_matches_from(vec!["unlessall", "--debug"]);
assert!(res.is_err());
assert_eq!(res.unwrap_err().kind, ErrorKind::MissingRequiredArgument);
@ -300,7 +300,7 @@ fn required_unless_one() {
)
.arg(Arg::with_name("dbg").long("debug"))
.arg(Arg::with_name("infile").short('i').takes_value(true))
.get_matches_from_safe(vec!["unlessone", "--debug"]);
.try_get_matches_from(vec!["unlessone", "--debug"]);
assert!(res.is_ok());
let m = res.unwrap();
@ -321,7 +321,7 @@ fn required_unless_one_2() {
)
.arg(Arg::with_name("dbg").long("debug"))
.arg(Arg::with_name("infile").short('i').takes_value(true))
.get_matches_from_safe(vec!["unlessone", "-i", "file"]);
.try_get_matches_from(vec!["unlessone", "-i", "file"]);
assert!(res.is_ok());
let m = res.unwrap();
@ -340,7 +340,7 @@ fn required_unless_one_works_with_short() {
.short('x')
.required_unless_one(&["a", "b"]),
)
.get_matches_from_safe(vec!["unlessone", "-a"]);
.try_get_matches_from(vec!["unlessone", "-a"]);
assert!(res.is_ok());
}
@ -355,7 +355,7 @@ fn required_unless_one_works_with_short_err() {
.short('x')
.required_unless_one(&["a", "b"]),
)
.get_matches_from_safe(vec!["unlessone"]);
.try_get_matches_from(vec!["unlessone"]);
assert!(!res.is_ok());
}
@ -366,7 +366,7 @@ fn required_unless_one_works_without() {
.arg(Arg::with_name("a").conflicts_with("b").short('a'))
.arg(Arg::with_name("b").short('b'))
.arg(Arg::with_name("x").required_unless_one(&["a", "b"]))
.get_matches_from_safe(vec!["unlessone", "-a"]);
.try_get_matches_from(vec!["unlessone", "-a"]);
assert!(res.is_ok());
}
@ -381,7 +381,7 @@ fn required_unless_one_works_with_long() {
.long("x_is_the_option")
.required_unless_one(&["a", "b"]),
)
.get_matches_from_safe(vec!["unlessone", "-a"]);
.try_get_matches_from(vec!["unlessone", "-a"]);
assert!(res.is_ok());
}
@ -397,7 +397,7 @@ fn required_unless_one_1() {
)
.arg(Arg::with_name("dbg").long("debug"))
.arg(Arg::with_name("infile").short('i').takes_value(true))
.get_matches_from_safe(vec!["unlessone", "--debug"]);
.try_get_matches_from(vec!["unlessone", "--debug"]);
assert!(res.is_ok());
let m = res.unwrap();
@ -417,7 +417,7 @@ fn required_unless_one_err() {
)
.arg(Arg::with_name("dbg").long("debug"))
.arg(Arg::with_name("infile").short('i').takes_value(true))
.get_matches_from_safe(vec!["unlessone"]);
.try_get_matches_from(vec!["unlessone"]);
assert!(res.is_err());
assert_eq!(res.unwrap_err().kind, ErrorKind::MissingRequiredArgument);
@ -445,7 +445,7 @@ fn requires_if_present_val() {
.long("config"),
)
.arg(Arg::with_name("extra").long("extra"))
.get_matches_from_safe(vec!["unlessone", "--config=my.cfg"]);
.try_get_matches_from(vec!["unlessone", "--config=my.cfg"]);
assert!(res.is_err());
assert_eq!(res.unwrap_err().kind, ErrorKind::MissingRequiredArgument);
@ -462,7 +462,7 @@ fn requires_if_present_mult() {
)
.arg(Arg::with_name("extra").long("extra"))
.arg(Arg::with_name("other").long("other"))
.get_matches_from_safe(vec!["unlessone", "--config=other.cfg"]);
.try_get_matches_from(vec!["unlessone", "--config=other.cfg"]);
assert!(res.is_err());
assert_eq!(res.unwrap_err().kind, ErrorKind::MissingRequiredArgument);
@ -479,7 +479,7 @@ fn requires_if_present_mult_pass() {
)
.arg(Arg::with_name("extra").long("extra"))
.arg(Arg::with_name("other").long("other"))
.get_matches_from_safe(vec!["unlessone", "--config=some.cfg"]);
.try_get_matches_from(vec!["unlessone", "--config=some.cfg"]);
assert!(res.is_ok());
}
@ -494,7 +494,7 @@ fn requires_if_present_val_no_present_pass() {
.long("config"),
)
.arg(Arg::with_name("extra").long("extra"))
.get_matches_from_safe(vec!["unlessone"]);
.try_get_matches_from(vec!["unlessone"]);
assert!(res.is_ok());
}
@ -511,7 +511,7 @@ fn required_if_val_present_pass() {
.long("config"),
)
.arg(Arg::with_name("extra").takes_value(true).long("extra"))
.get_matches_from_safe(vec!["ri", "--extra", "val", "--config", "my.cfg"]);
.try_get_matches_from(vec!["ri", "--extra", "val", "--config", "my.cfg"]);
assert!(res.is_ok());
}
@ -526,7 +526,7 @@ fn required_if_val_present_fail() {
.long("config"),
)
.arg(Arg::with_name("extra").takes_value(true).long("extra"))
.get_matches_from_safe(vec!["ri", "--extra", "val"]);
.try_get_matches_from(vec!["ri", "--extra", "val"]);
assert!(res.is_err());
assert_eq!(res.unwrap_err().kind, ErrorKind::MissingRequiredArgument);
@ -576,7 +576,7 @@ fn required_if_wrong_val() {
.long("config"),
)
.arg(Arg::with_name("extra").takes_value(true).long("extra"))
.get_matches_from_safe(vec!["ri", "--extra", "other"]);
.try_get_matches_from(vec!["ri", "--extra", "other"]);
assert!(res.is_ok());
}
@ -592,7 +592,7 @@ fn required_ifs_val_present_pass() {
)
.arg(Arg::with_name("option").takes_value(true).long("option"))
.arg(Arg::with_name("extra").takes_value(true).long("extra"))
.get_matches_from_safe(vec!["ri", "--option", "spec", "--config", "my.cfg"]);
.try_get_matches_from(vec!["ri", "--option", "spec", "--config", "my.cfg"]);
assert!(res.is_ok());
}
@ -608,7 +608,7 @@ fn required_ifs_val_present_fail() {
)
.arg(Arg::with_name("extra").takes_value(true).long("extra"))
.arg(Arg::with_name("option").takes_value(true).long("option"))
.get_matches_from_safe(vec!["ri", "--option", "spec"]);
.try_get_matches_from(vec!["ri", "--option", "spec"]);
assert!(res.is_err());
assert_eq!(res.unwrap_err().kind, ErrorKind::MissingRequiredArgument);
@ -625,7 +625,7 @@ fn required_ifs_wrong_val() {
)
.arg(Arg::with_name("extra").takes_value(true).long("extra"))
.arg(Arg::with_name("option").takes_value(true).long("option"))
.get_matches_from_safe(vec!["ri", "--option", "other"]);
.try_get_matches_from(vec!["ri", "--option", "other"]);
assert!(res.is_ok());
}
@ -641,7 +641,7 @@ fn required_ifs_wrong_val_mult_fail() {
)
.arg(Arg::with_name("extra").takes_value(true).long("extra"))
.arg(Arg::with_name("option").takes_value(true).long("option"))
.get_matches_from_safe(vec!["ri", "--extra", "other", "--option", "spec"]);
.try_get_matches_from(vec!["ri", "--extra", "other", "--option", "spec"]);
assert!(res.is_err());
assert_eq!(res.unwrap_err().kind, ErrorKind::MissingRequiredArgument);
@ -674,19 +674,19 @@ For more information try --help";
fn issue_1158_app() -> App<'static, 'static> {
App::new("example")
.arg(
Arg::from_usage("-c, --config [FILE] 'Custom config file.'")
Arg::from("-c, --config [FILE] 'Custom config file.'")
.required_unless("ID")
.conflicts_with("ID"),
)
.arg(
Arg::from_usage("[ID] 'ID'")
Arg::from("[ID] 'ID'")
.required_unless("config")
.conflicts_with("config")
.requires_all(&["x", "y", "z"]),
)
.arg(Arg::from_usage("-x [X] 'X'"))
.arg(Arg::from_usage("-y [Y] 'Y'"))
.arg(Arg::from_usage("-z [Z] 'Z'"))
.arg(Arg::from("-x [X] 'X'"))
.arg(Arg::from("-y [Y] 'Y'"))
.arg(Arg::from("-z [Z] 'Z'"))
}
#[test]

36
tests/subcommands.rs
View file

@ -3,7 +3,7 @@ extern crate regex;
include!("../clap-test.rs");
use clap::{App, Arg, ErrorKind, SubCommand};
use clap::{App, Arg, ErrorKind, };
static VISIBLE_ALIAS_HELP: &'static str = "clap-test 2.6
@ -56,7 +56,7 @@ For more information try --help";
fn subcommand() {
let m = App::new("test")
.subcommand(
SubCommand::with_name("some").arg(
App::new("some").arg(
Arg::with_name("test")
.short('t')
.long("test")
@ -77,7 +77,7 @@ fn subcommand() {
fn subcommand_none_given() {
let m = App::new("test")
.subcommand(
SubCommand::with_name("some").arg(
App::new("some").arg(
Arg::with_name("test")
.short('t')
.long("test")
@ -95,14 +95,14 @@ fn subcommand_none_given() {
fn subcommand_multiple() {
let m = App::new("test")
.subcommands(vec![
SubCommand::with_name("some").arg(
App::new("some").arg(
Arg::with_name("test")
.short('t')
.long("test")
.takes_value(true)
.help("testing testing"),
),
SubCommand::with_name("add").arg(Arg::with_name("roster").short('r')),
App::new("add").arg(Arg::with_name("roster").short('r')),
])
.arg(Arg::with_name("other").long("other"))
.get_matches_from(vec!["myprog", "some", "--test", "testing"]);
@ -118,7 +118,7 @@ fn subcommand_multiple() {
#[test]
fn single_alias() {
let m = App::new("myprog")
.subcommand(SubCommand::with_name("test").alias("do-stuff"))
.subcommand(App::new("test").alias("do-stuff"))
.get_matches_from(vec!["myprog", "do-stuff"]);
assert_eq!(m.subcommand_name(), Some("test"));
}
@ -126,7 +126,7 @@ fn single_alias() {
#[test]
fn multiple_aliases() {
let m = App::new("myprog")
.subcommand(SubCommand::with_name("test").aliases(&["do-stuff", "test-stuff"]))
.subcommand(App::new("test").aliases(&["do-stuff", "test-stuff"]))
.get_matches_from(vec!["myprog", "test-stuff"]);
assert_eq!(m.subcommand_name(), Some("test"));
}
@ -134,7 +134,7 @@ fn multiple_aliases() {
#[test]
#[cfg(feature = "suggestions")]
fn subcmd_did_you_mean_output() {
let app = App::new("dym").subcommand(SubCommand::with_name("subcmd"));
let app = App::new("dym").subcommand(App::new("subcmd"));
assert!(test::compare_output(app, "dym subcm", DYM_SUBCMD, true));
}
@ -142,7 +142,7 @@ fn subcmd_did_you_mean_output() {
#[cfg(feature = "suggestions")]
fn subcmd_did_you_mean_output_arg() {
let app = App::new("dym").subcommand(
SubCommand::with_name("subcmd").arg_from_usage("-s --subcmdarg [subcmdarg] 'tests'"),
App::new("subcmd").arg("-s --subcmdarg [subcmdarg] 'tests'"),
);
assert!(test::compare_output(app, "dym --subcm foo", DYM_ARG, true));
}
@ -150,8 +150,8 @@ fn subcmd_did_you_mean_output_arg() {
#[test]
fn alias_help() {
let m = App::new("myprog")
.subcommand(SubCommand::with_name("test").alias("do-stuff"))
.get_matches_from_safe(vec!["myprog", "help", "do-stuff"]);
.subcommand(App::new("test").alias("do-stuff"))
.try_get_matches_from(vec!["myprog", "help", "do-stuff"]);
assert!(m.is_err());
assert_eq!(m.unwrap_err().kind, ErrorKind::HelpDisplayed);
}
@ -159,7 +159,7 @@ fn alias_help() {
#[test]
fn visible_aliases_help_output() {
let app = App::new("clap-test").version("2.6").subcommand(
SubCommand::with_name("test")
App::new("test")
.about("Some help")
.alias("invisible")
.visible_alias("dongle")
@ -176,7 +176,7 @@ fn visible_aliases_help_output() {
#[test]
fn invisible_aliases_help_output() {
let app = App::new("clap-test").version("2.6").subcommand(
SubCommand::with_name("test")
App::new("test")
.about("Some help")
.alias("invisible"),
);
@ -192,8 +192,8 @@ fn invisible_aliases_help_output() {
fn issue_1031_args_with_same_name() {
let res = App::new("prog")
.arg(Arg::from("--ui-path=<PATH>"))
.subcommand(SubCommand::with_name("signer"))
.get_matches_from_safe(vec!["prog", "--ui-path", "signer"]);
.subcommand(App::new("signer"))
.try_get_matches_from(vec!["prog", "--ui-path", "signer"]);
assert!(res.is_ok(), "{:?}", res.unwrap_err().kind);
let m = res.unwrap();
@ -204,8 +204,8 @@ fn issue_1031_args_with_same_name() {
fn issue_1031_args_with_same_name_no_more_vals() {
let res = App::new("prog")
.arg(Arg::from("--ui-path=<PATH>"))
.subcommand(SubCommand::with_name("signer"))
.get_matches_from_safe(vec!["prog", "--ui-path", "value", "signer"]);
.subcommand(App::new("signer"))
.try_get_matches_from(vec!["prog", "--ui-path", "value", "signer"]);
assert!(res.is_ok(), "{:?}", res.unwrap_err().kind);
let m = res.unwrap();
@ -220,7 +220,7 @@ fn issue_1161_multiple_hyphen_hyphen() {
.arg(Arg::with_name("eff").short('f'))
.arg(Arg::with_name("pea").short('p').takes_value(true))
.arg(Arg::with_name("slop").multiple(true).last(true))
.get_matches_from_safe(vec![
.try_get_matches_from(vec![
"-f",
"-p=bob",
"--",

26
tests/template_help.rs
View file

@ -1,7 +1,7 @@
extern crate clap;
extern crate regex;
use clap::{App, SubCommand};
use clap::{App, };
include!("../clap-test.rs");
@ -51,7 +51,7 @@ SUBCOMMANDS:
#[test]
fn with_template() {
let app = app_example1().template(EXAMPLE1_TMPL_S);
let app = app_example1().help_template(EXAMPLE1_TMPL_S);
assert!(test::compare_output(
app,
"MyApp --help",
@ -62,7 +62,7 @@ fn with_template() {
#[test]
fn custom_template() {
let app = app_example1().template(EXAMPLE1_TMPS_F);
let app = app_example1().help_template(EXAMPLE1_TMPS_F);
assert!(test::compare_output(
app,
"MyApp --help",
@ -77,7 +77,7 @@ fn template_empty() {
.version("1.0")
.author("Kevin K. <kbknapp@gmail.com>")
.about("Does awesome things")
.template("");
.help_template("");
assert!(test::compare_output(app, "MyApp --help", "", false));
}
@ -87,7 +87,7 @@ fn template_notag() {
.version("1.0")
.author("Kevin K. <kbknapp@gmail.com>")
.about("Does awesome things")
.template("test no tag test");
.help_template("test no tag test");
assert!(test::compare_output(
app,
"MyApp --help",
@ -102,7 +102,7 @@ fn template_unknowntag() {
.version("1.0")
.author("Kevin K. <kbknapp@gmail.com>")
.about("Does awesome things")
.template("test {unknown_tag} test");
.help_template("test {unknown_tag} test");
assert!(test::compare_output(
app,
"MyApp --help",
@ -117,7 +117,7 @@ fn template_author_version() {
.version("1.0")
.author("Kevin K. <kbknapp@gmail.com>")
.about("Does awesome things")
.template("{author}\n{version}\n{about}\n{bin}");
.help_template("{author}\n{version}\n{about}\n{bin}");
assert!(test::compare_output(
app,
"MyApp --help",
@ -133,14 +133,12 @@ fn app_example1<'b, 'c>() -> App<'b, 'c> {
.version("1.0")
.author("Kevin K. <kbknapp@gmail.com>")
.about("Does awesome things")
.args_from_usage(
"-c, --config=[FILE] 'Sets a custom config file'
<output> 'Sets an optional output file'
-d... 'Turn debugging information on'",
)
.arg("-c, --config=[FILE] 'Sets a custom config file'")
.arg("<output> 'Sets an optional output file'")
.arg("-d... 'Turn debugging information on'")
.subcommand(
SubCommand::with_name("test")
App::new("test")
.about("does testing things")
.arg_from_usage("-l, --list 'lists test values'"),
.arg("-l, --list 'lists test values'"),
)
}

6
tests/unique_args.rs
View file

@ -10,7 +10,7 @@ fn unique_arg_names() {
Arg::with_name("arg").short('a'),
Arg::with_name("arg").short('b'),
])
.get_matches_safe();
.try_get_matches();
}
#[test]
@ -21,7 +21,7 @@ fn unique_arg_shorts() {
Arg::with_name("arg1").short('a'),
Arg::with_name("arg2").short('a'),
])
.get_matches_safe();
.try_get_matches();
}
#[test]
@ -32,5 +32,5 @@ fn unique_arg_longs() {
Arg::with_name("arg1").long("long"),
Arg::with_name("arg2").long("long"),
])
.get_matches_safe();
.try_get_matches();
}

36
tests/utf8.rs
View file

@ -11,7 +11,7 @@ fn invalid_utf8_strict_positional() {
let m = App::new("bad_utf8")
.arg(Arg::from("<arg> 'some arg'"))
.setting(AppSettings::StrictUtf8)
.get_matches_from_safe(vec![OsString::from(""), OsString::from_vec(vec![0xe9])]);
.try_get_matches_from(vec![OsString::from(""), OsString::from_vec(vec![0xe9])]);
assert!(m.is_err());
assert_eq!(m.unwrap_err().kind, ErrorKind::InvalidUtf8);
}
@ -21,7 +21,7 @@ fn invalid_utf8_strict_option_short_space() {
let m = App::new("bad_utf8")
.arg(Arg::from("-a, --arg <arg> 'some arg'"))
.setting(AppSettings::StrictUtf8)
.get_matches_from_safe(vec![
.try_get_matches_from(vec![
OsString::from(""),
OsString::from("-a"),
OsString::from_vec(vec![0xe9]),
@ -35,7 +35,7 @@ fn invalid_utf8_strict_option_short_equals() {
let m = App::new("bad_utf8")
.arg(Arg::from("-a, --arg <arg> 'some arg'"))
.setting(AppSettings::StrictUtf8)
.get_matches_from_safe(vec![
.try_get_matches_from(vec![
OsString::from(""),
OsString::from_vec(vec![0x2d, 0x61, 0x3d, 0xe9]),
]);
@ -48,7 +48,7 @@ fn invalid_utf8_strict_option_short_no_space() {
let m = App::new("bad_utf8")
.arg(Arg::from("-a, --arg <arg> 'some arg'"))
.setting(AppSettings::StrictUtf8)
.get_matches_from_safe(vec![
.try_get_matches_from(vec![
OsString::from(""),
OsString::from_vec(vec![0x2d, 0x61, 0xe9]),
]);
@ -61,7 +61,7 @@ fn invalid_utf8_strict_option_long_space() {
let m = App::new("bad_utf8")
.arg(Arg::from("-a, --arg <arg> 'some arg'"))
.setting(AppSettings::StrictUtf8)
.get_matches_from_safe(vec![
.try_get_matches_from(vec![
OsString::from(""),
OsString::from("--arg"),
OsString::from_vec(vec![0xe9]),
@ -75,7 +75,7 @@ fn invalid_utf8_strict_option_long_equals() {
let m = App::new("bad_utf8")
.arg(Arg::from("-a, --arg <arg> 'some arg'"))
.setting(AppSettings::StrictUtf8)
.get_matches_from_safe(vec![
.try_get_matches_from(vec![
OsString::from(""),
OsString::from_vec(vec![0x2d, 0x2d, 0x61, 0x72, 0x67, 0x3d, 0xe9]),
]);
@ -87,7 +87,7 @@ fn invalid_utf8_strict_option_long_equals() {
fn invalid_utf8_lossy_positional() {
let r = App::new("bad_utf8")
.arg(Arg::from("<arg> 'some arg'"))
.get_matches_from_safe(vec![OsString::from(""), OsString::from_vec(vec![0xe9])]);
.try_get_matches_from(vec![OsString::from(""), OsString::from_vec(vec![0xe9])]);
assert!(r.is_ok());
let m = r.unwrap();
assert!(m.is_present("arg"));
@ -98,7 +98,7 @@ fn invalid_utf8_lossy_positional() {
fn invalid_utf8_lossy_option_short_space() {
let r = App::new("bad_utf8")
.arg(Arg::from("-a, --arg <arg> 'some arg'"))
.get_matches_from_safe(vec![
.try_get_matches_from(vec![
OsString::from(""),
OsString::from("-a"),
OsString::from_vec(vec![0xe9]),
@ -113,7 +113,7 @@ fn invalid_utf8_lossy_option_short_space() {
fn invalid_utf8_lossy_option_short_equals() {
let r = App::new("bad_utf8")
.arg(Arg::from("-a, --arg <arg> 'some arg'"))
.get_matches_from_safe(vec![
.try_get_matches_from(vec![
OsString::from(""),
OsString::from_vec(vec![0x2d, 0x61, 0x3d, 0xe9]),
]);
@ -127,7 +127,7 @@ fn invalid_utf8_lossy_option_short_equals() {
fn invalid_utf8_lossy_option_short_no_space() {
let r = App::new("bad_utf8")
.arg(Arg::from("-a, --arg <arg> 'some arg'"))
.get_matches_from_safe(vec![
.try_get_matches_from(vec![
OsString::from(""),
OsString::from_vec(vec![0x2d, 0x61, 0xe9]),
]);
@ -141,7 +141,7 @@ fn invalid_utf8_lossy_option_short_no_space() {
fn invalid_utf8_lossy_option_long_space() {
let r = App::new("bad_utf8")
.arg(Arg::from("-a, --arg <arg> 'some arg'"))
.get_matches_from_safe(vec![
.try_get_matches_from(vec![
OsString::from(""),
OsString::from("--arg"),
OsString::from_vec(vec![0xe9]),
@ -156,7 +156,7 @@ fn invalid_utf8_lossy_option_long_space() {
fn invalid_utf8_lossy_option_long_equals() {
let r = App::new("bad_utf8")
.arg(Arg::from("-a, --arg <arg> 'some arg'"))
.get_matches_from_safe(vec![
.try_get_matches_from(vec![
OsString::from(""),
OsString::from_vec(vec![0x2d, 0x2d, 0x61, 0x72, 0x67, 0x3d, 0xe9]),
]);
@ -170,7 +170,7 @@ fn invalid_utf8_lossy_option_long_equals() {
fn invalid_utf8_positional() {
let r = App::new("bad_utf8")
.arg(Arg::from("<arg> 'some arg'"))
.get_matches_from_safe(vec![OsString::from(""), OsString::from_vec(vec![0xe9])]);
.try_get_matches_from(vec![OsString::from(""), OsString::from_vec(vec![0xe9])]);
assert!(r.is_ok());
let m = r.unwrap();
assert!(m.is_present("arg"));
@ -184,7 +184,7 @@ fn invalid_utf8_positional() {
fn invalid_utf8_option_short_space() {
let r = App::new("bad_utf8")
.arg(Arg::from("-a, --arg <arg> 'some arg'"))
.get_matches_from_safe(vec![
.try_get_matches_from(vec![
OsString::from(""),
OsString::from("-a"),
OsString::from_vec(vec![0xe9]),
@ -202,7 +202,7 @@ fn invalid_utf8_option_short_space() {
fn invalid_utf8_option_short_equals() {
let r = App::new("bad_utf8")
.arg(Arg::from("-a, --arg <arg> 'some arg'"))
.get_matches_from_safe(vec![
.try_get_matches_from(vec![
OsString::from(""),
OsString::from_vec(vec![0x2d, 0x61, 0x3d, 0xe9]),
]);
@ -219,7 +219,7 @@ fn invalid_utf8_option_short_equals() {
fn invalid_utf8_option_short_no_space() {
let r = App::new("bad_utf8")
.arg(Arg::from("-a, --arg <arg> 'some arg'"))
.get_matches_from_safe(vec![
.try_get_matches_from(vec![
OsString::from(""),
OsString::from_vec(vec![0x2d, 0x61, 0xe9]),
]);
@ -236,7 +236,7 @@ fn invalid_utf8_option_short_no_space() {
fn invalid_utf8_option_long_space() {
let r = App::new("bad_utf8")
.arg(Arg::from("-a, --arg <arg> 'some arg'"))
.get_matches_from_safe(vec![
.try_get_matches_from(vec![
OsString::from(""),
OsString::from("--arg"),
OsString::from_vec(vec![0xe9]),
@ -254,7 +254,7 @@ fn invalid_utf8_option_long_space() {
fn invalid_utf8_option_long_equals() {
let r = App::new("bad_utf8")
.arg(Arg::from("-a, --arg <arg> 'some arg'"))
.get_matches_from_safe(vec![
.try_get_matches_from(vec![
OsString::from(""),
OsString::from_vec(vec![0x2d, 0x2d, 0x61, 0x72, 0x67, 0x3d, 0xe9]),
]);

8
tests/version.rs
View file

@ -15,7 +15,7 @@ fn version_short() {
.author("Kevin K.")
.about("tests stuff")
.version("1.3")
.get_matches_from_safe(vec!["myprog", "-V"]);
.try_get_matches_from(vec!["myprog", "-V"]);
assert!(m.is_err());
assert_eq!(m.unwrap_err().kind, ErrorKind::VersionDisplayed);
@ -27,7 +27,7 @@ fn version_long() {
.author("Kevin K.")
.about("tests stuff")
.version("1.3")
.get_matches_from_safe(vec!["myprog", "--version"]);
.try_get_matches_from(vec!["myprog", "--version"]);
assert!(m.is_err());
assert_eq!(m.unwrap_err().kind, ErrorKind::VersionDisplayed);
@ -36,7 +36,7 @@ fn version_long() {
#[test]
fn complex_version_output() {
let mut a = App::new("clap-test").version("v1.4.8");
let _ = a.get_matches_from_safe_borrow(vec![""]);
let _ = a.try_get_matches_from_mut(vec![""]);
// Now we check the output of print_version()
let mut ver = vec![];
@ -51,7 +51,7 @@ fn override_ver() {
.about("tests stuff")
.version("1.3")
.arg(Arg::from("-v, --version 'some version'"))
.get_matches_from_safe(vec!["test", "--version"]);
.try_get_matches_from(vec!["test", "--version"]);
assert!(m.is_ok());
assert!(m.unwrap().is_present("version"));

4
tests/yaml.rs
View file

@ -23,7 +23,7 @@ fn help_message() {
let yml = load_yaml!("app.yml");
let mut app = App::from_yaml(yml);
// Generate the full help message!
let _ = app.get_matches_from_safe_borrow(Vec::<String>::new());
let _ = app.try_get_matches_from_mut(Vec::<String>::new());
let mut help_buffer = Vec::new();
app.write_help(&mut help_buffer).unwrap();
@ -38,7 +38,7 @@ fn author() {
let yml = load_yaml!("app.yml");
let mut app = App::from_yaml(yml);
// Generate the full help message!
let _ = app.get_matches_from_safe_borrow(Vec::<String>::new());
let _ = app.try_get_matches_from_mut(Vec::<String>::new());
let mut help_buffer = Vec::new();
app.write_help(&mut help_buffer).unwrap();