1 // Std 2 #[allow(deprecated, unused_imports)] 3 use std::ascii::AsciiExt; 4 use std::ops::BitOr; 5 use std::str::FromStr; 6 7 bitflags! { 8 struct Flags: u64 { 9 const SC_NEGATE_REQS = 1; 10 const SC_REQUIRED = 1 << 1; 11 const A_REQUIRED_ELSE_HELP = 1 << 2; 12 const GLOBAL_VERSION = 1 << 3; 13 const VERSIONLESS_SC = 1 << 4; 14 const UNIFIED_HELP = 1 << 5; 15 const WAIT_ON_ERROR = 1 << 6; 16 const SC_REQUIRED_ELSE_HELP= 1 << 7; 17 const NEEDS_LONG_HELP = 1 << 8; 18 const NEEDS_LONG_VERSION = 1 << 9; 19 const NEEDS_SC_HELP = 1 << 10; 20 const DISABLE_VERSION = 1 << 11; 21 const HIDDEN = 1 << 12; 22 const TRAILING_VARARG = 1 << 13; 23 const NO_BIN_NAME = 1 << 14; 24 const ALLOW_UNK_SC = 1 << 15; 25 const UTF8_STRICT = 1 << 16; 26 const UTF8_NONE = 1 << 17; 27 const LEADING_HYPHEN = 1 << 18; 28 const NO_POS_VALUES = 1 << 19; 29 const NEXT_LINE_HELP = 1 << 20; 30 const DERIVE_DISP_ORDER = 1 << 21; 31 const COLORED_HELP = 1 << 22; 32 const COLOR_ALWAYS = 1 << 23; 33 const COLOR_AUTO = 1 << 24; 34 const COLOR_NEVER = 1 << 25; 35 const DONT_DELIM_TRAIL = 1 << 26; 36 const ALLOW_NEG_NUMS = 1 << 27; 37 const LOW_INDEX_MUL_POS = 1 << 28; 38 const DISABLE_HELP_SC = 1 << 29; 39 const DONT_COLLAPSE_ARGS = 1 << 30; 40 const ARGS_NEGATE_SCS = 1 << 31; 41 const PROPAGATE_VALS_DOWN = 1 << 32; 42 const ALLOW_MISSING_POS = 1 << 33; 43 const TRAILING_VALUES = 1 << 34; 44 const VALID_NEG_NUM_FOUND = 1 << 35; 45 const PROPAGATED = 1 << 36; 46 const VALID_ARG_FOUND = 1 << 37; 47 const INFER_SUBCOMMANDS = 1 << 38; 48 const CONTAINS_LAST = 1 << 39; 49 const ARGS_OVERRIDE_SELF = 1 << 40; 50 const DISABLE_HELP_FLAGS = 1 << 41; 51 } 52 } 53 54 #[doc(hidden)] 55 #[derive(Debug, Copy, Clone, PartialEq)] 56 pub struct AppFlags(Flags); 57 58 impl BitOr for AppFlags { 59 type Output = Self; bitor(self, rhs: Self) -> Self60 fn bitor(self, rhs: Self) -> Self { 61 AppFlags(self.0 | rhs.0) 62 } 63 } 64 65 impl Default for AppFlags { default() -> Self66 fn default() -> Self { 67 AppFlags( 68 Flags::NEEDS_LONG_VERSION 69 | Flags::NEEDS_LONG_HELP 70 | Flags::NEEDS_SC_HELP 71 | Flags::UTF8_NONE 72 | Flags::COLOR_AUTO, 73 ) 74 } 75 } 76 77 #[allow(deprecated)] 78 impl AppFlags { new() -> Self79 pub fn new() -> Self { 80 AppFlags::default() 81 } zeroed() -> Self82 pub fn zeroed() -> Self { 83 AppFlags(Flags::empty()) 84 } 85 86 impl_settings! { AppSettings, 87 ArgRequiredElseHelp => Flags::A_REQUIRED_ELSE_HELP, 88 ArgsNegateSubcommands => Flags::ARGS_NEGATE_SCS, 89 AllArgsOverrideSelf => Flags::ARGS_OVERRIDE_SELF, 90 AllowExternalSubcommands => Flags::ALLOW_UNK_SC, 91 AllowInvalidUtf8 => Flags::UTF8_NONE, 92 AllowLeadingHyphen => Flags::LEADING_HYPHEN, 93 AllowNegativeNumbers => Flags::ALLOW_NEG_NUMS, 94 AllowMissingPositional => Flags::ALLOW_MISSING_POS, 95 ColoredHelp => Flags::COLORED_HELP, 96 ColorAlways => Flags::COLOR_ALWAYS, 97 ColorAuto => Flags::COLOR_AUTO, 98 ColorNever => Flags::COLOR_NEVER, 99 DontDelimitTrailingValues => Flags::DONT_DELIM_TRAIL, 100 DontCollapseArgsInUsage => Flags::DONT_COLLAPSE_ARGS, 101 DeriveDisplayOrder => Flags::DERIVE_DISP_ORDER, 102 DisableHelpFlags => Flags::DISABLE_HELP_FLAGS, 103 DisableHelpSubcommand => Flags::DISABLE_HELP_SC, 104 DisableVersion => Flags::DISABLE_VERSION, 105 GlobalVersion => Flags::GLOBAL_VERSION, 106 HidePossibleValuesInHelp => Flags::NO_POS_VALUES, 107 Hidden => Flags::HIDDEN, 108 LowIndexMultiplePositional => Flags::LOW_INDEX_MUL_POS, 109 NeedsLongHelp => Flags::NEEDS_LONG_HELP, 110 NeedsLongVersion => Flags::NEEDS_LONG_VERSION, 111 NeedsSubcommandHelp => Flags::NEEDS_SC_HELP, 112 NoBinaryName => Flags::NO_BIN_NAME, 113 PropagateGlobalValuesDown=> Flags::PROPAGATE_VALS_DOWN, 114 StrictUtf8 => Flags::UTF8_STRICT, 115 SubcommandsNegateReqs => Flags::SC_NEGATE_REQS, 116 SubcommandRequired => Flags::SC_REQUIRED, 117 SubcommandRequiredElseHelp => Flags::SC_REQUIRED_ELSE_HELP, 118 TrailingVarArg => Flags::TRAILING_VARARG, 119 UnifiedHelpMessage => Flags::UNIFIED_HELP, 120 NextLineHelp => Flags::NEXT_LINE_HELP, 121 VersionlessSubcommands => Flags::VERSIONLESS_SC, 122 WaitOnError => Flags::WAIT_ON_ERROR, 123 TrailingValues => Flags::TRAILING_VALUES, 124 ValidNegNumFound => Flags::VALID_NEG_NUM_FOUND, 125 Propagated => Flags::PROPAGATED, 126 ValidArgFound => Flags::VALID_ARG_FOUND, 127 InferSubcommands => Flags::INFER_SUBCOMMANDS, 128 ContainsLast => Flags::CONTAINS_LAST 129 } 130 } 131 132 /// Application level settings, which affect how [`App`] operates 133 /// 134 /// **NOTE:** When these settings are used, they apply only to current command, and are *not* 135 /// propagated down or up through child or parent subcommands 136 /// 137 /// [`App`]: ./struct.App.html 138 #[derive(Debug, PartialEq, Copy, Clone)] 139 pub enum AppSettings { 140 /// Specifies that any invalid UTF-8 code points should *not* be treated as an error. 141 /// This is the default behavior of `clap`. 142 /// 143 /// **NOTE:** Using argument values with invalid UTF-8 code points requires using 144 /// [`ArgMatches::os_value_of`], [`ArgMatches::os_values_of`], [`ArgMatches::lossy_value_of`], 145 /// or [`ArgMatches::lossy_values_of`] for those particular arguments which may contain invalid 146 /// UTF-8 values 147 /// 148 /// **NOTE:** This rule only applies to argument values, as flags, options, and 149 /// [`SubCommand`]s themselves only allow valid UTF-8 code points. 150 /// 151 /// # Platform Specific 152 /// 153 /// Non Windows systems only 154 /// 155 /// # Examples 156 /// 157 #[cfg_attr(not(unix), doc = " ```ignore")] 158 #[cfg_attr(unix, doc = " ```")] 159 /// # use clap::{App, AppSettings}; 160 /// use std::ffi::OsString; 161 /// use std::os::unix::ffi::{OsStrExt,OsStringExt}; 162 /// 163 /// let r = App::new("myprog") 164 /// //.setting(AppSettings::AllowInvalidUtf8) 165 /// .arg_from_usage("<arg> 'some positional arg'") 166 /// .get_matches_from_safe( 167 /// vec![ 168 /// OsString::from("myprog"), 169 /// OsString::from_vec(vec![0xe9])]); 170 /// 171 /// assert!(r.is_ok()); 172 /// let m = r.unwrap(); 173 /// assert_eq!(m.value_of_os("arg").unwrap().as_bytes(), &[0xe9]); 174 /// ``` 175 /// [`ArgMatches::os_value_of`]: ./struct.ArgMatches.html#method.os_value_of 176 /// [`ArgMatches::os_values_of`]: ./struct.ArgMatches.html#method.os_values_of 177 /// [`ArgMatches::lossy_value_of`]: ./struct.ArgMatches.html#method.lossy_value_of 178 /// [`ArgMatches::lossy_values_of`]: ./struct.ArgMatches.html#method.lossy_values_of 179 /// [`SubCommand`]: ./struct.SubCommand.html 180 AllowInvalidUtf8, 181 182 /// Essentially sets [`Arg::overrides_with("itself")`] for all arguments. 183 /// 184 /// **WARNING:** Positional arguments cannot override themselves (or we would never be able 185 /// to advance to the next positional). This setting ignores positional arguments. 186 /// [`Arg::overrides_with("itself")`]: ./struct.Arg.html#method.overrides_with 187 AllArgsOverrideSelf, 188 189 /// Specifies that leading hyphens are allowed in argument *values*, such as negative numbers 190 /// like `-10`. (which would otherwise be parsed as another flag or option) 191 /// 192 /// **NOTE:** Use this setting with caution as it silences certain circumstances which would 193 /// otherwise be an error (such as accidentally forgetting to specify a value for leading 194 /// option). It is preferred to set this on a per argument basis, via [`Arg::allow_hyphen_values`] 195 /// 196 /// # Examples 197 /// 198 /// ```rust 199 /// # use clap::{Arg, App, AppSettings}; 200 /// // Imagine you needed to represent negative numbers as well, such as -10 201 /// let m = App::new("nums") 202 /// .setting(AppSettings::AllowLeadingHyphen) 203 /// .arg(Arg::with_name("neg").index(1)) 204 /// .get_matches_from(vec![ 205 /// "nums", "-20" 206 /// ]); 207 /// 208 /// assert_eq!(m.value_of("neg"), Some("-20")); 209 /// # ; 210 /// ``` 211 /// [`Arg::allow_hyphen_values`]: ./struct.Arg.html#method.allow_hyphen_values 212 AllowLeadingHyphen, 213 214 /// Allows negative numbers to pass as values. This is similar to 215 /// `AllowLeadingHyphen` except that it only allows numbers, all 216 /// other undefined leading hyphens will fail to parse. 217 /// 218 /// # Examples 219 /// 220 /// ```rust 221 /// # use clap::{App, Arg, AppSettings}; 222 /// let res = App::new("myprog") 223 /// .version("v1.1") 224 /// .setting(AppSettings::AllowNegativeNumbers) 225 /// .arg(Arg::with_name("num")) 226 /// .get_matches_from_safe(vec![ 227 /// "myprog", "-20" 228 /// ]); 229 /// assert!(res.is_ok()); 230 /// let m = res.unwrap(); 231 /// assert_eq!(m.value_of("num").unwrap(), "-20"); 232 /// ``` 233 /// [`AllowLeadingHyphen`]: ./enum.AppSettings.html#variant.AllowLeadingHyphen 234 AllowNegativeNumbers, 235 236 /// Allows one to implement two styles of CLIs where positionals can be used out of order. 237 /// 238 /// The first example is a CLI where the second to last positional argument is optional, but 239 /// the final positional argument is required. Such as `$ prog [optional] <required>` where one 240 /// of the two following usages is allowed: 241 /// 242 /// * `$ prog [optional] <required>` 243 /// * `$ prog <required>` 244 /// 245 /// This would otherwise not be allowed. This is useful when `[optional]` has a default value. 246 /// 247 /// **Note:** when using this style of "missing positionals" the final positional *must* be 248 /// [required] if `--` will not be used to skip to the final positional argument. 249 /// 250 /// **Note:** This style also only allows a single positional argument to be "skipped" without 251 /// the use of `--`. To skip more than one, see the second example. 252 /// 253 /// The second example is when one wants to skip multiple optional positional arguments, and use 254 /// of the `--` operator is OK (but not required if all arguments will be specified anyways). 255 /// 256 /// For example, imagine a CLI which has three positional arguments `[foo] [bar] [baz]...` where 257 /// `baz` accepts multiple values (similar to man `ARGS...` style training arguments). 258 /// 259 /// With this setting the following invocations are possible: 260 /// 261 /// * `$ prog foo bar baz1 baz2 baz3` 262 /// * `$ prog foo -- baz1 baz2 baz3` 263 /// * `$ prog -- baz1 baz2 baz3` 264 /// 265 /// # Examples 266 /// 267 /// Style number one from above: 268 /// 269 /// ```rust 270 /// # use clap::{App, Arg, AppSettings}; 271 /// // Assume there is an external subcommand named "subcmd" 272 /// let m = App::new("myprog") 273 /// .setting(AppSettings::AllowMissingPositional) 274 /// .arg(Arg::with_name("arg1")) 275 /// .arg(Arg::with_name("arg2") 276 /// .required(true)) 277 /// .get_matches_from(vec![ 278 /// "prog", "other" 279 /// ]); 280 /// 281 /// assert_eq!(m.value_of("arg1"), None); 282 /// assert_eq!(m.value_of("arg2"), Some("other")); 283 /// ``` 284 /// 285 /// Now the same example, but using a default value for the first optional positional argument 286 /// 287 /// ```rust 288 /// # use clap::{App, Arg, AppSettings}; 289 /// // Assume there is an external subcommand named "subcmd" 290 /// let m = App::new("myprog") 291 /// .setting(AppSettings::AllowMissingPositional) 292 /// .arg(Arg::with_name("arg1") 293 /// .default_value("something")) 294 /// .arg(Arg::with_name("arg2") 295 /// .required(true)) 296 /// .get_matches_from(vec![ 297 /// "prog", "other" 298 /// ]); 299 /// 300 /// assert_eq!(m.value_of("arg1"), Some("something")); 301 /// assert_eq!(m.value_of("arg2"), Some("other")); 302 /// ``` 303 /// Style number two from above: 304 /// 305 /// ```rust 306 /// # use clap::{App, Arg, AppSettings}; 307 /// // Assume there is an external subcommand named "subcmd" 308 /// let m = App::new("myprog") 309 /// .setting(AppSettings::AllowMissingPositional) 310 /// .arg(Arg::with_name("foo")) 311 /// .arg(Arg::with_name("bar")) 312 /// .arg(Arg::with_name("baz").multiple(true)) 313 /// .get_matches_from(vec![ 314 /// "prog", "foo", "bar", "baz1", "baz2", "baz3" 315 /// ]); 316 /// 317 /// assert_eq!(m.value_of("foo"), Some("foo")); 318 /// assert_eq!(m.value_of("bar"), Some("bar")); 319 /// assert_eq!(m.values_of("baz").unwrap().collect::<Vec<_>>(), &["baz1", "baz2", "baz3"]); 320 /// ``` 321 /// 322 /// Now notice if we don't specify `foo` or `baz` but use the `--` operator. 323 /// 324 /// ```rust 325 /// # use clap::{App, Arg, AppSettings}; 326 /// // Assume there is an external subcommand named "subcmd" 327 /// let m = App::new("myprog") 328 /// .setting(AppSettings::AllowMissingPositional) 329 /// .arg(Arg::with_name("foo")) 330 /// .arg(Arg::with_name("bar")) 331 /// .arg(Arg::with_name("baz").multiple(true)) 332 /// .get_matches_from(vec![ 333 /// "prog", "--", "baz1", "baz2", "baz3" 334 /// ]); 335 /// 336 /// assert_eq!(m.value_of("foo"), None); 337 /// assert_eq!(m.value_of("bar"), None); 338 /// assert_eq!(m.values_of("baz").unwrap().collect::<Vec<_>>(), &["baz1", "baz2", "baz3"]); 339 /// ``` 340 /// [required]: ./struct.Arg.html#method.required 341 AllowMissingPositional, 342 343 /// Specifies that an unexpected positional argument, 344 /// which would otherwise cause a [`ErrorKind::UnknownArgument`] error, 345 /// should instead be treated as a [`SubCommand`] within the [`ArgMatches`] struct. 346 /// 347 /// **NOTE:** Use this setting with caution, 348 /// as a truly unexpected argument (i.e. one that is *NOT* an external subcommand) 349 /// will **not** cause an error and instead be treated as a potential subcommand. 350 /// One should check for such cases manually and inform the user appropriately. 351 /// 352 /// # Examples 353 /// 354 /// ```rust 355 /// # use clap::{App, AppSettings}; 356 /// // Assume there is an external subcommand named "subcmd" 357 /// let m = App::new("myprog") 358 /// .setting(AppSettings::AllowExternalSubcommands) 359 /// .get_matches_from(vec![ 360 /// "myprog", "subcmd", "--option", "value", "-fff", "--flag" 361 /// ]); 362 /// 363 /// // All trailing arguments will be stored under the subcommand's sub-matches using an empty 364 /// // string argument name 365 /// match m.subcommand() { 366 /// (external, Some(ext_m)) => { 367 /// let ext_args: Vec<&str> = ext_m.values_of("").unwrap().collect(); 368 /// assert_eq!(external, "subcmd"); 369 /// assert_eq!(ext_args, ["--option", "value", "-fff", "--flag"]); 370 /// }, 371 /// _ => {}, 372 /// } 373 /// ``` 374 /// [`ErrorKind::UnknownArgument`]: ./enum.ErrorKind.html#variant.UnknownArgument 375 /// [`SubCommand`]: ./struct.SubCommand.html 376 /// [`ArgMatches`]: ./struct.ArgMatches.html 377 AllowExternalSubcommands, 378 379 /// Specifies that use of a valid [argument] negates [subcommands] being used after. By default 380 /// `clap` allows arguments between subcommands such as 381 /// `<cmd> [cmd_args] <cmd2> [cmd2_args] <cmd3> [cmd3_args]`. This setting disables that 382 /// functionality and says that arguments can only follow the *final* subcommand. For instance 383 /// using this setting makes only the following invocations possible: 384 /// 385 /// * `<cmd> <cmd2> <cmd3> [cmd3_args]` 386 /// * `<cmd> <cmd2> [cmd2_args]` 387 /// * `<cmd> [cmd_args]` 388 /// 389 /// # Examples 390 /// 391 /// ```rust 392 /// # use clap::{App, AppSettings}; 393 /// App::new("myprog") 394 /// .setting(AppSettings::ArgsNegateSubcommands) 395 /// # ; 396 /// ``` 397 /// [subcommands]: ./struct.SubCommand.html 398 /// [argument]: ./struct.Arg.html 399 ArgsNegateSubcommands, 400 401 /// Specifies that the help text should be displayed (and then exit gracefully), 402 /// if no arguments are present at runtime (i.e. an empty run such as, `$ myprog`. 403 /// 404 /// **NOTE:** [`SubCommand`]s count as arguments 405 /// 406 /// **NOTE:** Setting [`Arg::default_value`] effectively disables this option as it will 407 /// ensure that some argument is always present. 408 /// 409 /// # Examples 410 /// 411 /// ```rust 412 /// # use clap::{App, AppSettings}; 413 /// App::new("myprog") 414 /// .setting(AppSettings::ArgRequiredElseHelp) 415 /// # ; 416 /// ``` 417 /// [`SubCommand`]: ./struct.SubCommand.html 418 /// [`Arg::default_value`]: ./struct.Arg.html#method.default_value 419 ArgRequiredElseHelp, 420 421 /// Uses colorized help messages. 422 /// 423 /// **NOTE:** Must be compiled with the `color` cargo feature 424 /// 425 /// # Platform Specific 426 /// 427 /// This setting only applies to Unix, Linux, and macOS (i.e. non-Windows platforms) 428 /// 429 /// # Examples 430 /// 431 /// ```no_run 432 /// # use clap::{App, Arg, SubCommand, AppSettings}; 433 /// App::new("myprog") 434 /// .setting(AppSettings::ColoredHelp) 435 /// .get_matches(); 436 /// ``` 437 ColoredHelp, 438 439 /// Enables colored output only when the output is going to a terminal or TTY. 440 /// 441 /// **NOTE:** This is the default behavior of `clap`. 442 /// 443 /// **NOTE:** Must be compiled with the `color` cargo feature. 444 /// 445 /// # Platform Specific 446 /// 447 /// This setting only applies to Unix, Linux, and macOS (i.e. non-Windows platforms). 448 /// 449 /// # Examples 450 /// 451 /// ```no_run 452 /// # use clap::{App, Arg, SubCommand, AppSettings}; 453 /// App::new("myprog") 454 /// .setting(AppSettings::ColorAuto) 455 /// .get_matches(); 456 /// ``` 457 ColorAuto, 458 459 /// Enables colored output regardless of whether or not the output is going to a terminal/TTY. 460 /// 461 /// **NOTE:** Must be compiled with the `color` cargo feature. 462 /// 463 /// # Platform Specific 464 /// 465 /// This setting only applies to Unix, Linux, and macOS (i.e. non-Windows platforms). 466 /// 467 /// # Examples 468 /// 469 /// ```no_run 470 /// # use clap::{App, Arg, SubCommand, AppSettings}; 471 /// App::new("myprog") 472 /// .setting(AppSettings::ColorAlways) 473 /// .get_matches(); 474 /// ``` 475 ColorAlways, 476 477 /// Disables colored output no matter if the output is going to a terminal/TTY, or not. 478 /// 479 /// **NOTE:** Must be compiled with the `color` cargo feature 480 /// 481 /// # Platform Specific 482 /// 483 /// This setting only applies to Unix, Linux, and macOS (i.e. non-Windows platforms) 484 /// 485 /// # Examples 486 /// 487 /// ```no_run 488 /// # use clap::{App, Arg, SubCommand, AppSettings}; 489 /// App::new("myprog") 490 /// .setting(AppSettings::ColorNever) 491 /// .get_matches(); 492 /// ``` 493 ColorNever, 494 495 /// Disables the automatic collapsing of positional args into `[ARGS]` inside the usage string 496 /// 497 /// # Examples 498 /// 499 /// ```no_run 500 /// # use clap::{App, Arg, SubCommand, AppSettings}; 501 /// App::new("myprog") 502 /// .setting(AppSettings::DontCollapseArgsInUsage) 503 /// .get_matches(); 504 /// ``` 505 DontCollapseArgsInUsage, 506 507 /// Disables the automatic delimiting of values when `--` or [`AppSettings::TrailingVarArg`] 508 /// was used. 509 /// 510 /// **NOTE:** The same thing can be done manually by setting the final positional argument to 511 /// [`Arg::use_delimiter(false)`]. Using this setting is safer, because it's easier to locate 512 /// when making changes. 513 /// 514 /// # Examples 515 /// 516 /// ```no_run 517 /// # use clap::{App, Arg, SubCommand, AppSettings}; 518 /// App::new("myprog") 519 /// .setting(AppSettings::DontDelimitTrailingValues) 520 /// .get_matches(); 521 /// ``` 522 /// [`AppSettings::TrailingVarArg`]: ./enum.AppSettings.html#variant.TrailingVarArg 523 /// [`Arg::use_delimiter(false)`]: ./struct.Arg.html#method.use_delimiter 524 DontDelimitTrailingValues, 525 526 /// Disables `-h` and `--help` [`App`] without affecting any of the [`SubCommand`]s 527 /// (Defaults to `false`; application *does* have help flags) 528 /// 529 /// # Examples 530 /// 531 /// ```rust 532 /// # use clap::{App, AppSettings, ErrorKind}; 533 /// let res = App::new("myprog") 534 /// .setting(AppSettings::DisableHelpFlags) 535 /// .get_matches_from_safe(vec![ 536 /// "myprog", "-h" 537 /// ]); 538 /// assert!(res.is_err()); 539 /// assert_eq!(res.unwrap_err().kind, ErrorKind::UnknownArgument); 540 /// ``` 541 /// 542 /// ```rust 543 /// # use clap::{App, SubCommand, AppSettings, ErrorKind}; 544 /// let res = App::new("myprog") 545 /// .setting(AppSettings::DisableHelpFlags) 546 /// .subcommand(SubCommand::with_name("test")) 547 /// .get_matches_from_safe(vec![ 548 /// "myprog", "test", "-h" 549 /// ]); 550 /// assert!(res.is_err()); 551 /// assert_eq!(res.unwrap_err().kind, ErrorKind::HelpDisplayed); 552 /// ``` 553 /// [`SubCommand`]: ./struct.SubCommand.html 554 /// [`App`]: ./struct.App.html 555 DisableHelpFlags, 556 557 /// Disables the `help` subcommand 558 /// 559 /// # Examples 560 /// 561 /// ```rust 562 /// # use clap::{App, AppSettings, ErrorKind, SubCommand}; 563 /// let res = App::new("myprog") 564 /// .version("v1.1") 565 /// .setting(AppSettings::DisableHelpSubcommand) 566 /// // Normally, creating a subcommand causes a `help` subcommand to automatically 567 /// // be generated as well 568 /// .subcommand(SubCommand::with_name("test")) 569 /// .get_matches_from_safe(vec![ 570 /// "myprog", "help" 571 /// ]); 572 /// assert!(res.is_err()); 573 /// assert_eq!(res.unwrap_err().kind, ErrorKind::UnknownArgument); 574 /// ``` 575 /// [`SubCommand`]: ./struct.SubCommand.html 576 DisableHelpSubcommand, 577 578 /// Disables `-V` and `--version` [`App`] without affecting any of the [`SubCommand`]s 579 /// (Defaults to `false`; application *does* have a version flag) 580 /// 581 /// # Examples 582 /// 583 /// ```rust 584 /// # use clap::{App, AppSettings, ErrorKind}; 585 /// let res = App::new("myprog") 586 /// .version("v1.1") 587 /// .setting(AppSettings::DisableVersion) 588 /// .get_matches_from_safe(vec![ 589 /// "myprog", "-V" 590 /// ]); 591 /// assert!(res.is_err()); 592 /// assert_eq!(res.unwrap_err().kind, ErrorKind::UnknownArgument); 593 /// ``` 594 /// 595 /// ```rust 596 /// # use clap::{App, SubCommand, AppSettings, ErrorKind}; 597 /// let res = App::new("myprog") 598 /// .version("v1.1") 599 /// .setting(AppSettings::DisableVersion) 600 /// .subcommand(SubCommand::with_name("test")) 601 /// .get_matches_from_safe(vec![ 602 /// "myprog", "test", "-V" 603 /// ]); 604 /// assert!(res.is_err()); 605 /// assert_eq!(res.unwrap_err().kind, ErrorKind::VersionDisplayed); 606 /// ``` 607 /// [`SubCommand`]: ./struct.SubCommand.html 608 /// [`App`]: ./struct.App.html 609 DisableVersion, 610 611 /// Displays the arguments and [`SubCommand`]s in the help message in the order that they were 612 /// declared in, and not alphabetically which is the default. 613 /// 614 /// # Examples 615 /// 616 /// ```no_run 617 /// # use clap::{App, Arg, SubCommand, AppSettings}; 618 /// App::new("myprog") 619 /// .setting(AppSettings::DeriveDisplayOrder) 620 /// .get_matches(); 621 /// ``` 622 /// [`SubCommand`]: ./struct.SubCommand.html 623 DeriveDisplayOrder, 624 625 /// Specifies to use the version of the current command for all child [`SubCommand`]s. 626 /// (Defaults to `false`; subcommands have independent version strings from their parents.) 627 /// 628 /// **NOTE:** The version for the current command **and** this setting must be set **prior** to 629 /// adding any child subcommands 630 /// 631 /// # Examples 632 /// 633 /// ```no_run 634 /// # use clap::{App, Arg, SubCommand, AppSettings}; 635 /// App::new("myprog") 636 /// .version("v1.1") 637 /// .setting(AppSettings::GlobalVersion) 638 /// .subcommand(SubCommand::with_name("test")) 639 /// .get_matches(); 640 /// // running `$ myprog test --version` will display 641 /// // "myprog-test v1.1" 642 /// ``` 643 /// [`SubCommand`]: ./struct.SubCommand.html 644 GlobalVersion, 645 646 /// Specifies that this [`SubCommand`] should be hidden from help messages 647 /// 648 /// # Examples 649 /// 650 /// ```rust 651 /// # use clap::{App, Arg, AppSettings, SubCommand}; 652 /// App::new("myprog") 653 /// .subcommand(SubCommand::with_name("test") 654 /// .setting(AppSettings::Hidden)) 655 /// # ; 656 /// ``` 657 /// [`SubCommand`]: ./struct.SubCommand.html 658 Hidden, 659 660 /// Tells `clap` *not* to print possible values when displaying help information. 661 /// This can be useful if there are many values, or they are explained elsewhere. 662 HidePossibleValuesInHelp, 663 664 /// Tries to match unknown args to partial [`subcommands`] or their [aliases]. For example to 665 /// match a subcommand named `test`, one could use `t`, `te`, `tes`, and `test`. 666 /// 667 /// **NOTE:** The match *must not* be ambiguous at all in order to succeed. i.e. to match `te` 668 /// to `test` there could not also be a subcommand or alias `temp` because both start with `te` 669 /// 670 /// **CAUTION:** This setting can interfere with [positional/free arguments], take care when 671 /// designing CLIs which allow inferred subcommands and have potential positional/free 672 /// arguments whose values could start with the same characters as subcommands. If this is the 673 /// case, it's recommended to use settings such as [`AppSeettings::ArgsNegateSubcommands`] in 674 /// conjunction with this setting. 675 /// 676 /// # Examples 677 /// 678 /// ```no_run 679 /// # use clap::{App, Arg, SubCommand, AppSettings}; 680 /// let m = App::new("prog") 681 /// .setting(AppSettings::InferSubcommands) 682 /// .subcommand(SubCommand::with_name("test")) 683 /// .get_matches_from(vec![ 684 /// "prog", "te" 685 /// ]); 686 /// assert_eq!(m.subcommand_name(), Some("test")); 687 /// ``` 688 /// [`subcommands`]: ./struct.SubCommand.html 689 /// [positional/free arguments]: ./struct.Arg.html#method.index 690 /// [aliases]: ./struct.App.html#method.alias 691 /// [`AppSeettings::ArgsNegateSubcommands`]: ./enum.AppSettings.html#variant.ArgsNegateSubcommands 692 InferSubcommands, 693 694 /// Specifies that the parser should not assume the first argument passed is the binary name. 695 /// This is normally the case when using a "daemon" style mode, or an interactive CLI where one 696 /// one would not normally type the binary or program name for each command. 697 /// 698 /// # Examples 699 /// 700 /// ```rust 701 /// # use clap::{App, Arg, AppSettings}; 702 /// let m = App::new("myprog") 703 /// .setting(AppSettings::NoBinaryName) 704 /// .arg(Arg::from_usage("<cmd>... 'commands to run'")) 705 /// .get_matches_from(vec!["command", "set"]); 706 /// 707 /// let cmds: Vec<&str> = m.values_of("cmd").unwrap().collect(); 708 /// assert_eq!(cmds, ["command", "set"]); 709 /// ``` 710 NoBinaryName, 711 712 /// Places the help string for all arguments on the line after the argument. 713 /// 714 /// # Examples 715 /// 716 /// ```no_run 717 /// # use clap::{App, Arg, SubCommand, AppSettings}; 718 /// App::new("myprog") 719 /// .setting(AppSettings::NextLineHelp) 720 /// .get_matches(); 721 /// ``` 722 NextLineHelp, 723 724 /// **DEPRECATED**: This setting is no longer required in order to propagate values up or down 725 /// 726 /// Specifies that the parser should propagate global arg's values down or up through any *used* 727 /// child subcommands. Meaning, if a subcommand wasn't used, the values won't be propagated to 728 /// said subcommand. 729 /// 730 /// # Examples 731 /// 732 /// ```rust 733 /// # use clap::{App, Arg, AppSettings, SubCommand}; 734 /// let m = App::new("myprog") 735 /// .arg(Arg::from_usage("[cmd] 'command to run'") 736 /// .global(true)) 737 /// .subcommand(SubCommand::with_name("foo")) 738 /// .get_matches_from(vec!["myprog", "set", "foo"]); 739 /// 740 /// assert_eq!(m.value_of("cmd"), Some("set")); 741 /// 742 /// let sub_m = m.subcommand_matches("foo").unwrap(); 743 /// assert_eq!(sub_m.value_of("cmd"), Some("set")); 744 /// ``` 745 /// Now doing the same thing, but *not* using any subcommands will result in the value not being 746 /// propagated down. 747 /// 748 /// ```rust 749 /// # use clap::{App, Arg, AppSettings, SubCommand}; 750 /// let m = App::new("myprog") 751 /// .arg(Arg::from_usage("[cmd] 'command to run'") 752 /// .global(true)) 753 /// .subcommand(SubCommand::with_name("foo")) 754 /// .get_matches_from(vec!["myprog", "set"]); 755 /// 756 /// assert_eq!(m.value_of("cmd"), Some("set")); 757 /// 758 /// assert!(m.subcommand_matches("foo").is_none()); 759 /// ``` 760 #[deprecated(since = "2.27.0", note = "No longer required to propagate values")] 761 PropagateGlobalValuesDown, 762 763 /// Allows [`SubCommand`]s to override all requirements of the parent command. 764 /// For example if you had a subcommand or top level application with a required argument 765 /// that is only required as long as there is no subcommand present, 766 /// using this setting would allow you to set those arguments to [`Arg::required(true)`] 767 /// and yet receive no error so long as the user uses a valid subcommand instead. 768 /// 769 /// **NOTE:** This defaults to false (using subcommand does *not* negate requirements) 770 /// 771 /// # Examples 772 /// 773 /// This first example shows that it is an error to not use a required argument 774 /// 775 /// ```rust 776 /// # use clap::{App, Arg, AppSettings, SubCommand, ErrorKind}; 777 /// let err = App::new("myprog") 778 /// .setting(AppSettings::SubcommandsNegateReqs) 779 /// .arg(Arg::with_name("opt").required(true)) 780 /// .subcommand(SubCommand::with_name("test")) 781 /// .get_matches_from_safe(vec![ 782 /// "myprog" 783 /// ]); 784 /// assert!(err.is_err()); 785 /// assert_eq!(err.unwrap_err().kind, ErrorKind::MissingRequiredArgument); 786 /// # ; 787 /// ``` 788 /// 789 /// This next example shows that it is no longer error to not use a required argument if a 790 /// valid subcommand is used. 791 /// 792 /// ```rust 793 /// # use clap::{App, Arg, AppSettings, SubCommand, ErrorKind}; 794 /// let noerr = App::new("myprog") 795 /// .setting(AppSettings::SubcommandsNegateReqs) 796 /// .arg(Arg::with_name("opt").required(true)) 797 /// .subcommand(SubCommand::with_name("test")) 798 /// .get_matches_from_safe(vec![ 799 /// "myprog", "test" 800 /// ]); 801 /// assert!(noerr.is_ok()); 802 /// # ; 803 /// ``` 804 /// [`Arg::required(true)`]: ./struct.Arg.html#method.required 805 /// [`SubCommand`]: ./struct.SubCommand.html 806 SubcommandsNegateReqs, 807 808 /// Specifies that the help text should be displayed (before exiting gracefully) if no 809 /// [`SubCommand`]s are present at runtime (i.e. an empty run such as `$ myprog`). 810 /// 811 /// **NOTE:** This should *not* be used with [`AppSettings::SubcommandRequired`] as they do 812 /// nearly same thing; this prints the help text, and the other prints an error. 813 /// 814 /// **NOTE:** If the user specifies arguments at runtime, but no subcommand the help text will 815 /// still be displayed and exit. If this is *not* the desired result, consider using 816 /// [`AppSettings::ArgRequiredElseHelp`] instead. 817 /// 818 /// # Examples 819 /// 820 /// ```rust 821 /// # use clap::{App, Arg, AppSettings}; 822 /// App::new("myprog") 823 /// .setting(AppSettings::SubcommandRequiredElseHelp) 824 /// # ; 825 /// ``` 826 /// [`SubCommand`]: ./struct.SubCommand.html 827 /// [`AppSettings::SubcommandRequired`]: ./enum.AppSettings.html#variant.SubcommandRequired 828 /// [`AppSettings::ArgRequiredElseHelp`]: ./enum.AppSettings.html#variant.ArgRequiredElseHelp 829 SubcommandRequiredElseHelp, 830 831 /// Specifies that any invalid UTF-8 code points should be treated as an error and fail 832 /// with a [`ErrorKind::InvalidUtf8`] error. 833 /// 834 /// **NOTE:** This rule only applies to argument values; Things such as flags, options, and 835 /// [`SubCommand`]s themselves only allow valid UTF-8 code points. 836 /// 837 /// # Platform Specific 838 /// 839 /// Non Windows systems only 840 /// 841 /// # Examples 842 /// 843 #[cfg_attr(not(unix), doc = " ```ignore")] 844 #[cfg_attr(unix, doc = " ```")] 845 /// # use clap::{App, AppSettings, ErrorKind}; 846 /// use std::ffi::OsString; 847 /// use std::os::unix::ffi::OsStringExt; 848 /// 849 /// let m = App::new("myprog") 850 /// .setting(AppSettings::StrictUtf8) 851 /// .arg_from_usage("<arg> 'some positional arg'") 852 /// .get_matches_from_safe( 853 /// vec![ 854 /// OsString::from("myprog"), 855 /// OsString::from_vec(vec![0xe9])]); 856 /// 857 /// assert!(m.is_err()); 858 /// assert_eq!(m.unwrap_err().kind, ErrorKind::InvalidUtf8); 859 /// ``` 860 /// [`SubCommand`]: ./struct.SubCommand.html 861 /// [`ErrorKind::InvalidUtf8`]: ./enum.ErrorKind.html#variant.InvalidUtf8 862 StrictUtf8, 863 864 /// Allows specifying that if no [`SubCommand`] is present at runtime, 865 /// error and exit gracefully. 866 /// 867 /// **NOTE:** This defaults to `false` (subcommands do *not* need to be present) 868 /// 869 /// # Examples 870 /// 871 /// ```rust 872 /// # use clap::{App, AppSettings, SubCommand, ErrorKind}; 873 /// let err = App::new("myprog") 874 /// .setting(AppSettings::SubcommandRequired) 875 /// .subcommand(SubCommand::with_name("test")) 876 /// .get_matches_from_safe(vec![ 877 /// "myprog", 878 /// ]); 879 /// assert!(err.is_err()); 880 /// assert_eq!(err.unwrap_err().kind, ErrorKind::MissingSubcommand); 881 /// # ; 882 /// ``` 883 /// [`SubCommand`]: ./struct.SubCommand.html 884 SubcommandRequired, 885 886 /// Specifies that the final positional argument is a "VarArg" and that `clap` should not 887 /// attempt to parse any further args. 888 /// 889 /// The values of the trailing positional argument will contain all args from itself on. 890 /// 891 /// **NOTE:** The final positional argument **must** have [`Arg::multiple(true)`] or the usage 892 /// string equivalent. 893 /// 894 /// # Examples 895 /// 896 /// ```rust 897 /// # use clap::{App, Arg, AppSettings}; 898 /// let m = App::new("myprog") 899 /// .setting(AppSettings::TrailingVarArg) 900 /// .arg(Arg::from_usage("<cmd>... 'commands to run'")) 901 /// .get_matches_from(vec!["myprog", "arg1", "-r", "val1"]); 902 /// 903 /// let trail: Vec<&str> = m.values_of("cmd").unwrap().collect(); 904 /// assert_eq!(trail, ["arg1", "-r", "val1"]); 905 /// ``` 906 /// [`Arg::multiple(true)`]: ./struct.Arg.html#method.multiple 907 TrailingVarArg, 908 909 /// Groups flags and options together, presenting a more unified help message 910 /// (a la `getopts` or `docopt` style). 911 /// 912 /// The default is that the auto-generated help message will group flags, and options 913 /// separately. 914 /// 915 /// **NOTE:** This setting is cosmetic only and does not affect any functionality. 916 /// 917 /// # Examples 918 /// 919 /// ```no_run 920 /// # use clap::{App, Arg, SubCommand, AppSettings}; 921 /// App::new("myprog") 922 /// .setting(AppSettings::UnifiedHelpMessage) 923 /// .get_matches(); 924 /// // running `myprog --help` will display a unified "docopt" or "getopts" style help message 925 /// ``` 926 UnifiedHelpMessage, 927 928 /// Disables `-V` and `--version` for all [`SubCommand`]s 929 /// (Defaults to `false`; subcommands *do* have version flags.) 930 /// 931 /// **NOTE:** This setting must be set **prior** to adding any subcommands. 932 /// 933 /// # Examples 934 /// 935 /// ```rust 936 /// # use clap::{App, SubCommand, AppSettings, ErrorKind}; 937 /// let res = App::new("myprog") 938 /// .version("v1.1") 939 /// .setting(AppSettings::VersionlessSubcommands) 940 /// .subcommand(SubCommand::with_name("test")) 941 /// .get_matches_from_safe(vec![ 942 /// "myprog", "test", "-V" 943 /// ]); 944 /// assert!(res.is_err()); 945 /// assert_eq!(res.unwrap_err().kind, ErrorKind::UnknownArgument); 946 /// ``` 947 /// [`SubCommand`]: ./struct.SubCommand.html 948 VersionlessSubcommands, 949 950 /// Will display a message "Press \[ENTER\]/\[RETURN\] to continue..." and wait for user before 951 /// exiting 952 /// 953 /// This is most useful when writing an application which is run from a GUI shortcut, or on 954 /// Windows where a user tries to open the binary by double-clicking instead of using the 955 /// command line. 956 /// 957 /// **NOTE:** This setting is **not** recursive with [`SubCommand`]s, meaning if you wish this 958 /// behavior for all subcommands, you must set this on each command (needing this is extremely 959 /// rare) 960 /// 961 /// # Examples 962 /// 963 /// ```rust 964 /// # use clap::{App, Arg, AppSettings}; 965 /// App::new("myprog") 966 /// .setting(AppSettings::WaitOnError) 967 /// # ; 968 /// ``` 969 /// [`SubCommand`]: ./struct.SubCommand.html 970 WaitOnError, 971 972 #[doc(hidden)] 973 NeedsLongVersion, 974 975 #[doc(hidden)] 976 NeedsLongHelp, 977 978 #[doc(hidden)] 979 NeedsSubcommandHelp, 980 981 #[doc(hidden)] 982 LowIndexMultiplePositional, 983 984 #[doc(hidden)] 985 TrailingValues, 986 987 #[doc(hidden)] 988 ValidNegNumFound, 989 990 #[doc(hidden)] 991 Propagated, 992 993 #[doc(hidden)] 994 ValidArgFound, 995 996 #[doc(hidden)] 997 ContainsLast, 998 } 999 1000 impl FromStr for AppSettings { 1001 type Err = String; from_str(s: &str) -> Result<Self, <Self as FromStr>::Err>1002 fn from_str(s: &str) -> Result<Self, <Self as FromStr>::Err> { 1003 match &*s.to_ascii_lowercase() { 1004 "disablehelpflags" => Ok(AppSettings::DisableHelpFlags), 1005 "argrequiredelsehelp" => Ok(AppSettings::ArgRequiredElseHelp), 1006 "argsnegatesubcommands" => Ok(AppSettings::ArgsNegateSubcommands), 1007 "allowinvalidutf8" => Ok(AppSettings::AllowInvalidUtf8), 1008 "allowleadinghyphen" => Ok(AppSettings::AllowLeadingHyphen), 1009 "allowexternalsubcommands" => Ok(AppSettings::AllowExternalSubcommands), 1010 "allownegativenumbers" => Ok(AppSettings::AllowNegativeNumbers), 1011 "colorauto" => Ok(AppSettings::ColorAuto), 1012 "coloralways" => Ok(AppSettings::ColorAlways), 1013 "colornever" => Ok(AppSettings::ColorNever), 1014 "coloredhelp" => Ok(AppSettings::ColoredHelp), 1015 "derivedisplayorder" => Ok(AppSettings::DeriveDisplayOrder), 1016 "dontcollapseargsinusage" => Ok(AppSettings::DontCollapseArgsInUsage), 1017 "dontdelimittrailingvalues" => Ok(AppSettings::DontDelimitTrailingValues), 1018 "disablehelpsubcommand" => Ok(AppSettings::DisableHelpSubcommand), 1019 "disableversion" => Ok(AppSettings::DisableVersion), 1020 "globalversion" => Ok(AppSettings::GlobalVersion), 1021 "hidden" => Ok(AppSettings::Hidden), 1022 "hidepossiblevaluesinhelp" => Ok(AppSettings::HidePossibleValuesInHelp), 1023 "infersubcommands" => Ok(AppSettings::InferSubcommands), 1024 "lowindexmultiplepositional" => Ok(AppSettings::LowIndexMultiplePositional), 1025 "nobinaryname" => Ok(AppSettings::NoBinaryName), 1026 "nextlinehelp" => Ok(AppSettings::NextLineHelp), 1027 "strictutf8" => Ok(AppSettings::StrictUtf8), 1028 "subcommandsnegatereqs" => Ok(AppSettings::SubcommandsNegateReqs), 1029 "subcommandrequired" => Ok(AppSettings::SubcommandRequired), 1030 "subcommandrequiredelsehelp" => Ok(AppSettings::SubcommandRequiredElseHelp), 1031 "trailingvararg" => Ok(AppSettings::TrailingVarArg), 1032 "unifiedhelpmessage" => Ok(AppSettings::UnifiedHelpMessage), 1033 "versionlesssubcommands" => Ok(AppSettings::VersionlessSubcommands), 1034 "waitonerror" => Ok(AppSettings::WaitOnError), 1035 "validnegnumfound" => Ok(AppSettings::ValidNegNumFound), 1036 "validargfound" => Ok(AppSettings::ValidArgFound), 1037 "propagated" => Ok(AppSettings::Propagated), 1038 "trailingvalues" => Ok(AppSettings::TrailingValues), 1039 _ => Err("unknown AppSetting, cannot convert from str".to_owned()), 1040 } 1041 } 1042 } 1043 1044 #[cfg(test)] 1045 mod test { 1046 use super::AppSettings; 1047 1048 #[test] app_settings_fromstr()1049 fn app_settings_fromstr() { 1050 assert_eq!( 1051 "disablehelpflags".parse::<AppSettings>().unwrap(), 1052 AppSettings::DisableHelpFlags 1053 ); 1054 assert_eq!( 1055 "argsnegatesubcommands".parse::<AppSettings>().unwrap(), 1056 AppSettings::ArgsNegateSubcommands 1057 ); 1058 assert_eq!( 1059 "argrequiredelsehelp".parse::<AppSettings>().unwrap(), 1060 AppSettings::ArgRequiredElseHelp 1061 ); 1062 assert_eq!( 1063 "allowexternalsubcommands".parse::<AppSettings>().unwrap(), 1064 AppSettings::AllowExternalSubcommands 1065 ); 1066 assert_eq!( 1067 "allowinvalidutf8".parse::<AppSettings>().unwrap(), 1068 AppSettings::AllowInvalidUtf8 1069 ); 1070 assert_eq!( 1071 "allowleadinghyphen".parse::<AppSettings>().unwrap(), 1072 AppSettings::AllowLeadingHyphen 1073 ); 1074 assert_eq!( 1075 "allownegativenumbers".parse::<AppSettings>().unwrap(), 1076 AppSettings::AllowNegativeNumbers 1077 ); 1078 assert_eq!( 1079 "coloredhelp".parse::<AppSettings>().unwrap(), 1080 AppSettings::ColoredHelp 1081 ); 1082 assert_eq!( 1083 "colorauto".parse::<AppSettings>().unwrap(), 1084 AppSettings::ColorAuto 1085 ); 1086 assert_eq!( 1087 "coloralways".parse::<AppSettings>().unwrap(), 1088 AppSettings::ColorAlways 1089 ); 1090 assert_eq!( 1091 "colornever".parse::<AppSettings>().unwrap(), 1092 AppSettings::ColorNever 1093 ); 1094 assert_eq!( 1095 "disablehelpsubcommand".parse::<AppSettings>().unwrap(), 1096 AppSettings::DisableHelpSubcommand 1097 ); 1098 assert_eq!( 1099 "disableversion".parse::<AppSettings>().unwrap(), 1100 AppSettings::DisableVersion 1101 ); 1102 assert_eq!( 1103 "dontcollapseargsinusage".parse::<AppSettings>().unwrap(), 1104 AppSettings::DontCollapseArgsInUsage 1105 ); 1106 assert_eq!( 1107 "dontdelimittrailingvalues".parse::<AppSettings>().unwrap(), 1108 AppSettings::DontDelimitTrailingValues 1109 ); 1110 assert_eq!( 1111 "derivedisplayorder".parse::<AppSettings>().unwrap(), 1112 AppSettings::DeriveDisplayOrder 1113 ); 1114 assert_eq!( 1115 "globalversion".parse::<AppSettings>().unwrap(), 1116 AppSettings::GlobalVersion 1117 ); 1118 assert_eq!( 1119 "hidden".parse::<AppSettings>().unwrap(), 1120 AppSettings::Hidden 1121 ); 1122 assert_eq!( 1123 "hidepossiblevaluesinhelp".parse::<AppSettings>().unwrap(), 1124 AppSettings::HidePossibleValuesInHelp 1125 ); 1126 assert_eq!( 1127 "lowindexmultiplePositional".parse::<AppSettings>().unwrap(), 1128 AppSettings::LowIndexMultiplePositional 1129 ); 1130 assert_eq!( 1131 "nobinaryname".parse::<AppSettings>().unwrap(), 1132 AppSettings::NoBinaryName 1133 ); 1134 assert_eq!( 1135 "nextlinehelp".parse::<AppSettings>().unwrap(), 1136 AppSettings::NextLineHelp 1137 ); 1138 assert_eq!( 1139 "subcommandsnegatereqs".parse::<AppSettings>().unwrap(), 1140 AppSettings::SubcommandsNegateReqs 1141 ); 1142 assert_eq!( 1143 "subcommandrequired".parse::<AppSettings>().unwrap(), 1144 AppSettings::SubcommandRequired 1145 ); 1146 assert_eq!( 1147 "subcommandrequiredelsehelp".parse::<AppSettings>().unwrap(), 1148 AppSettings::SubcommandRequiredElseHelp 1149 ); 1150 assert_eq!( 1151 "strictutf8".parse::<AppSettings>().unwrap(), 1152 AppSettings::StrictUtf8 1153 ); 1154 assert_eq!( 1155 "trailingvararg".parse::<AppSettings>().unwrap(), 1156 AppSettings::TrailingVarArg 1157 ); 1158 assert_eq!( 1159 "unifiedhelpmessage".parse::<AppSettings>().unwrap(), 1160 AppSettings::UnifiedHelpMessage 1161 ); 1162 assert_eq!( 1163 "versionlesssubcommands".parse::<AppSettings>().unwrap(), 1164 AppSettings::VersionlessSubcommands 1165 ); 1166 assert_eq!( 1167 "waitonerror".parse::<AppSettings>().unwrap(), 1168 AppSettings::WaitOnError 1169 ); 1170 assert_eq!( 1171 "validnegnumfound".parse::<AppSettings>().unwrap(), 1172 AppSettings::ValidNegNumFound 1173 ); 1174 assert_eq!( 1175 "validargfound".parse::<AppSettings>().unwrap(), 1176 AppSettings::ValidArgFound 1177 ); 1178 assert_eq!( 1179 "propagated".parse::<AppSettings>().unwrap(), 1180 AppSettings::Propagated 1181 ); 1182 assert_eq!( 1183 "trailingvalues".parse::<AppSettings>().unwrap(), 1184 AppSettings::TrailingValues 1185 ); 1186 assert_eq!( 1187 "infersubcommands".parse::<AppSettings>().unwrap(), 1188 AppSettings::InferSubcommands 1189 ); 1190 assert!("hahahaha".parse::<AppSettings>().is_err()); 1191 } 1192 } 1193