clap/app/
settings.rs

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