• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 // Copyright ⓒ 2015-2016 Kevin B. Knapp and [`clap-rs` contributors](https://github.com/clap-rs/clap/blob/v2.33.1/CONTRIBUTORS.md).
2 // Licensed under the MIT license
3 // (see LICENSE or <http://opensource.org/licenses/MIT>) All files in the project carrying such
4 // notice may not be copied, modified, or distributed except according to those terms.
5 
6 //! `clap` is a simple-to-use, efficient, and full-featured library for parsing command line
7 //! arguments and subcommands when writing console/terminal applications.
8 //!
9 //! ## About
10 //!
11 //! `clap` is used to parse *and validate* the string of command line arguments provided by the user
12 //! at runtime. You provide the list of valid possibilities, and `clap` handles the rest. This means
13 //! you focus on your *applications* functionality, and less on the parsing and validating of
14 //! arguments.
15 //!
16 //! `clap` also provides the traditional version and help switches (or flags) 'for free' meaning
17 //! automatically with no configuration. It does this by checking the list of valid possibilities you
18 //! supplied and adding only the ones you haven't already defined. If you are using subcommands,
19 //! `clap` will also auto-generate a `help` subcommand for you in addition to the traditional flags.
20 //!
21 //! Once `clap` parses the user provided string of arguments, it returns the matches along with any
22 //! applicable values. If the user made an error or typo, `clap` informs them of the mistake and
23 //! exits gracefully (or returns a `Result` type and allows you to perform any clean up prior to
24 //! exit). Because of this, you can make reasonable assumptions in your code about the validity of
25 //! the arguments.
26 //!
27 //!
28 //! ## Quick Example
29 //!
30 //! The following examples show a quick example of some of the very basic functionality of `clap`.
31 //! For more advanced usage, such as requirements, conflicts, groups, multiple values and
32 //! occurrences see the [documentation](https://docs.rs/clap/), [examples/] directory of
33 //! this repository or the [video tutorials].
34 //!
35 //! **NOTE:** All of these examples are functionally the same, but show different styles in which to
36 //! use `clap`
37 //!
38 //! The first example shows a method that allows more advanced configuration options (not shown in
39 //! this small example), or even dynamically generating arguments when desired. The downside is it's
40 //! more verbose.
41 //!
42 //! ```no_run
43 //! // (Full example with detailed comments in examples/01b_quick_example.rs)
44 //! //
45 //! // This example demonstrates clap's full 'builder pattern' style of creating arguments which is
46 //! // more verbose, but allows easier editing, and at times more advanced options, or the possibility
47 //! // to generate arguments dynamically.
48 //! extern crate clap;
49 //! use clap::{Arg, App, SubCommand};
50 //!
51 //! fn main() {
52 //!     let matches = App::new("My Super Program")
53 //!                           .version("1.0")
54 //!                           .author("Kevin K. <kbknapp@gmail.com>")
55 //!                           .about("Does awesome things")
56 //!                           .arg(Arg::with_name("config")
57 //!                                .short("c")
58 //!                                .long("config")
59 //!                                .value_name("FILE")
60 //!                                .help("Sets a custom config file")
61 //!                                .takes_value(true))
62 //!                           .arg(Arg::with_name("INPUT")
63 //!                                .help("Sets the input file to use")
64 //!                                .required(true)
65 //!                                .index(1))
66 //!                           .arg(Arg::with_name("v")
67 //!                                .short("v")
68 //!                                .multiple(true)
69 //!                                .help("Sets the level of verbosity"))
70 //!                           .subcommand(SubCommand::with_name("test")
71 //!                                       .about("controls testing features")
72 //!                                       .version("1.3")
73 //!                                       .author("Someone E. <someone_else@other.com>")
74 //!                                       .arg(Arg::with_name("debug")
75 //!                                           .short("d")
76 //!                                           .help("print debug information verbosely")))
77 //!                           .get_matches();
78 //!
79 //!     // Gets a value for config if supplied by user, or defaults to "default.conf"
80 //!     let config = matches.value_of("config").unwrap_or("default.conf");
81 //!     println!("Value for config: {}", config);
82 //!
83 //!     // Calling .unwrap() is safe here because "INPUT" is required (if "INPUT" wasn't
84 //!     // required we could have used an 'if let' to conditionally get the value)
85 //!     println!("Using input file: {}", matches.value_of("INPUT").unwrap());
86 //!
87 //!     // Vary the output based on how many times the user used the "verbose" flag
88 //!     // (i.e. 'myprog -v -v -v' or 'myprog -vvv' vs 'myprog -v'
89 //!     match matches.occurrences_of("v") {
90 //!         0 => println!("No verbose info"),
91 //!         1 => println!("Some verbose info"),
92 //!         2 => println!("Tons of verbose info"),
93 //!         3 | _ => println!("Don't be crazy"),
94 //!     }
95 //!
96 //!     // You can handle information about subcommands by requesting their matches by name
97 //!     // (as below), requesting just the name used, or both at the same time
98 //!     if let Some(matches) = matches.subcommand_matches("test") {
99 //!         if matches.is_present("debug") {
100 //!             println!("Printing debug info...");
101 //!         } else {
102 //!             println!("Printing normally...");
103 //!         }
104 //!     }
105 //!
106 //!     // more program logic goes here...
107 //! }
108 //! ```
109 //!
110 //! The next example shows a far less verbose method, but sacrifices some of the advanced
111 //! configuration options (not shown in this small example). This method also takes a *very* minor
112 //! runtime penalty.
113 //!
114 //! ```no_run
115 //! // (Full example with detailed comments in examples/01a_quick_example.rs)
116 //! //
117 //! // This example demonstrates clap's "usage strings" method of creating arguments
118 //! // which is less verbose
119 //! extern crate clap;
120 //! use clap::{Arg, App, SubCommand};
121 //!
122 //! fn main() {
123 //!     let matches = App::new("myapp")
124 //!                           .version("1.0")
125 //!                           .author("Kevin K. <kbknapp@gmail.com>")
126 //!                           .about("Does awesome things")
127 //!                           .args_from_usage(
128 //!                               "-c, --config=[FILE] 'Sets a custom config file'
129 //!                               <INPUT>              'Sets the input file to use'
130 //!                               -v...                'Sets the level of verbosity'")
131 //!                           .subcommand(SubCommand::with_name("test")
132 //!                                       .about("controls testing features")
133 //!                                       .version("1.3")
134 //!                                       .author("Someone E. <someone_else@other.com>")
135 //!                                       .arg_from_usage("-d, --debug 'Print debug information'"))
136 //!                           .get_matches();
137 //!
138 //!     // Same as previous example...
139 //! }
140 //! ```
141 //!
142 //! This third method shows how you can use a YAML file to build your CLI and keep your Rust source
143 //! tidy or support multiple localized translations by having different YAML files for each
144 //! localization.
145 //!
146 //! First, create the `cli.yml` file to hold your CLI options, but it could be called anything we
147 //! like:
148 //!
149 //! ```yaml
150 //! name: myapp
151 //! version: "1.0"
152 //! author: Kevin K. <kbknapp@gmail.com>
153 //! about: Does awesome things
154 //! args:
155 //!     - config:
156 //!         short: c
157 //!         long: config
158 //!         value_name: FILE
159 //!         help: Sets a custom config file
160 //!         takes_value: true
161 //!     - INPUT:
162 //!         help: Sets the input file to use
163 //!         required: true
164 //!         index: 1
165 //!     - verbose:
166 //!         short: v
167 //!         multiple: true
168 //!         help: Sets the level of verbosity
169 //! subcommands:
170 //!     - test:
171 //!         about: controls testing features
172 //!         version: "1.3"
173 //!         author: Someone E. <someone_else@other.com>
174 //!         args:
175 //!             - debug:
176 //!                 short: d
177 //!                 help: print debug information
178 //! ```
179 //!
180 //! Since this feature requires additional dependencies that not everyone may want, it is *not*
181 //! compiled in by default and we need to enable a feature flag in Cargo.toml:
182 //!
183 //! Simply change your `clap = "~2.27.0"` to `clap = {version = "~2.27.0", features = ["yaml"]}`.
184 //!
185 //! At last we create our `main.rs` file just like we would have with the previous two examples:
186 //!
187 //! ```ignore
188 //! // (Full example with detailed comments in examples/17_yaml.rs)
189 //! //
190 //! // This example demonstrates clap's building from YAML style of creating arguments which is far
191 //! // more clean, but takes a very small performance hit compared to the other two methods.
192 //! #[macro_use]
193 //! extern crate clap;
194 //! use clap::App;
195 //!
196 //! fn main() {
197 //!     // The YAML file is found relative to the current file, similar to how modules are found
198 //!     let yaml = load_yaml!("cli.yml");
199 //!     let matches = App::from_yaml(yaml).get_matches();
200 //!
201 //!     // Same as previous examples...
202 //! }
203 //! ```
204 //!
205 //! Finally there is a macro version, which is like a hybrid approach offering the speed of the
206 //! builder pattern (the first example), but without all the verbosity.
207 //!
208 //! ```no_run
209 //! #[macro_use]
210 //! extern crate clap;
211 //!
212 //! fn main() {
213 //!     let matches = clap_app!(myapp =>
214 //!         (version: "1.0")
215 //!         (author: "Kevin K. <kbknapp@gmail.com>")
216 //!         (about: "Does awesome things")
217 //!         (@arg CONFIG: -c --config +takes_value "Sets a custom config file")
218 //!         (@arg INPUT: +required "Sets the input file to use")
219 //!         (@arg debug: -d ... "Sets the level of debugging information")
220 //!         (@subcommand test =>
221 //!             (about: "controls testing features")
222 //!             (version: "1.3")
223 //!             (author: "Someone E. <someone_else@other.com>")
224 //!             (@arg verbose: -v --verbose "Print test information verbosely")
225 //!         )
226 //!     ).get_matches();
227 //!
228 //!     // Same as before...
229 //! }
230 //! ```
231 //!
232 //! If you were to compile any of the above programs and run them with the flag `--help` or `-h` (or
233 //! `help` subcommand, since we defined `test` as a subcommand) the following would be output
234 //!
235 //! ```text
236 //! $ myprog --help
237 //! My Super Program 1.0
238 //! Kevin K. <kbknapp@gmail.com>
239 //! Does awesome things
240 //!
241 //! USAGE:
242 //!     MyApp [FLAGS] [OPTIONS] <INPUT> [SUBCOMMAND]
243 //!
244 //! FLAGS:
245 //!     -h, --help       Prints this message
246 //!     -v               Sets the level of verbosity
247 //!     -V, --version    Prints version information
248 //!
249 //! OPTIONS:
250 //!     -c, --config <FILE>    Sets a custom config file
251 //!
252 //! ARGS:
253 //!     INPUT    The input file to use
254 //!
255 //! SUBCOMMANDS:
256 //!     help    Prints this message
257 //!     test    Controls testing features
258 //! ```
259 //!
260 //! **NOTE:** You could also run `myapp test --help` to see similar output and options for the
261 //! `test` subcommand.
262 //!
263 //! ## Try it!
264 //!
265 //! ### Pre-Built Test
266 //!
267 //! To try out the pre-built example, use the following steps:
268 //!
269 //! * Clone the repository `$ git clone https://github.com/clap-rs/clap && cd clap-rs/tests`
270 //! * Compile the example `$ cargo build --release`
271 //! * Run the help info `$ ./target/release/claptests --help`
272 //! * Play with the arguments!
273 //!
274 //! ### BYOB (Build Your Own Binary)
275 //!
276 //! To test out `clap`'s default auto-generated help/version follow these steps:
277 //!
278 //! * Create a new cargo project `$ cargo new fake --bin && cd fake`
279 //! * Add `clap` to your `Cargo.toml`
280 //!
281 //! ```toml
282 //! [dependencies]
283 //! clap = "2"
284 //! ```
285 //!
286 //! * Add the following to your `src/main.rs`
287 //!
288 //! ```no_run
289 //! extern crate clap;
290 //! use clap::App;
291 //!
292 //! fn main() {
293 //!   App::new("fake").version("v1.0-beta").get_matches();
294 //! }
295 //! ```
296 //!
297 //! * Build your program `$ cargo build --release`
298 //! * Run with help or version `$ ./target/release/fake --help` or `$ ./target/release/fake
299 //! --version`
300 //!
301 //! ## Usage
302 //!
303 //! For full usage, add `clap` as a dependency in your `Cargo.toml` (it is **highly** recommended to
304 //! use the `~major.minor.patch` style versions in your `Cargo.toml`, for more information see
305 //! [Compatibility Policy](#compatibility-policy)) to use from crates.io:
306 //!
307 //! ```toml
308 //! [dependencies]
309 //! clap = "~2.27.0"
310 //! ```
311 //!
312 //! Or get the latest changes from the master branch at github:
313 //!
314 //! ```toml
315 //! [dependencies.clap]
316 //! git = "https://github.com/clap-rs/clap.git"
317 //! ```
318 //!
319 //! Add `extern crate clap;` to your crate root.
320 //!
321 //! Define a list of valid arguments for your program (see the
322 //! [documentation](https://docs.rs/clap/) or [examples/] directory of this repo)
323 //!
324 //! Then run `cargo build` or `cargo update && cargo build` for your project.
325 //!
326 //! ### Optional Dependencies / Features
327 //!
328 //! #### Features enabled by default
329 //!
330 //! * `suggestions`: Turns on the `Did you mean '--myoption'?` feature for when users make typos. (builds dependency `strsim`)
331 //! * `color`: Turns on colored error messages. This feature only works on non-Windows OSs. (builds dependency `ansi-term` and `atty`)
332 //! * `wrap_help`: Wraps the help at the actual terminal width when
333 //!  available, instead of 120 characters. (builds dependency `textwrap`
334 //! with feature `term_size`)
335 //!
336 //! To disable these, add this to your `Cargo.toml`:
337 //!
338 //! ```toml
339 //! [dependencies.clap]
340 //! version = "~2.27.0"
341 //! default-features = false
342 //! ```
343 //!
344 //! You can also selectively enable only the features you'd like to include, by adding:
345 //!
346 //! ```toml
347 //! [dependencies.clap]
348 //! version = "~2.27.0"
349 //! default-features = false
350 //!
351 //! # Cherry-pick the features you'd like to use
352 //! features = [ "suggestions", "color" ]
353 //! ```
354 //!
355 //! #### Opt-in features
356 //!
357 //! * **"yaml"**: Enables building CLIs from YAML documents. (builds dependency `yaml-rust`)
358 //! * **"unstable"**: Enables unstable `clap` features that may change from release to release
359 //!
360 //! ### Dependencies Tree
361 //!
362 //! The following graphic depicts `clap`s dependency graph (generated using
363 //! [cargo-graph](https://github.com/kbknapp/cargo-graph)).
364 //!
365 //!  * **Dashed** Line: Optional dependency
366 //!  * **Red** Color: **NOT** included by default (must use cargo `features` to enable)
367 //!  * **Blue** Color: Dev dependency, only used while developing.
368 //!
369 //! ![clap dependencies](https://github.com/clap-rs/clap/blob/v2.33.1/clap_dep_graph.png)
370 //!
371 //! ### More Information
372 //!
373 //! You can find complete documentation on the [docs.rs](https://docs.rs/clap/) for this project.
374 //!
375 //! You can also find usage examples in the [examples/] directory of this repo.
376 //!
377 //! #### Video Tutorials
378 //!
379 //! There's also the video tutorial series [Argument Parsing with Rust v2][video tutorials].
380 //!
381 //! These videos slowly trickle out as I finish them and currently a work in progress.
382 //!
383 //! ## How to Contribute
384 //!
385 //! Contributions are always welcome! And there is a multitude of ways in which you can help
386 //! depending on what you like to do, or are good at. Anything from documentation, code cleanup,
387 //! issue completion, new features, you name it, even filing issues is contributing and greatly
388 //! appreciated!
389 //!
390 //! Another really great way to help is if you find an interesting, or helpful way in which to use
391 //! `clap`. You can either add it to the [examples/] directory, or file an issue and tell
392 //! me. I'm all about giving credit where credit is due :)
393 //!
394 //! Please read [CONTRIBUTING.md](https://github.com/clap-rs/clap/blob/v2.33.1/.github/CONTRIBUTING.md) before you start contributing.
395 //!
396 //!
397 //! ### Testing Code
398 //!
399 //! To test with all features both enabled and disabled, you can run theese commands:
400 //!
401 //! ```text
402 //! $ cargo test --no-default-features
403 //! $ cargo test --features "yaml unstable"
404 //! ```
405 //!
406 //! Alternatively, if you have [`just`](https://github.com/casey/just) installed you can run the
407 //! prebuilt recipes. *Not* using `just` is perfectly fine as well, it simply bundles commands
408 //! automatically.
409 //!
410 //! For example, to test the code, as above simply run:
411 //!
412 //! ```text
413 //! $ just run-tests
414 //! ```
415 //!
416 //! From here on, I will list the appropriate `cargo` command as well as the `just` command.
417 //!
418 //! Sometimes it's helpful to only run a subset of the tests, which can be done via:
419 //!
420 //! ```text
421 //! $ cargo test --test <test_name>
422 //!
423 //! # Or
424 //!
425 //! $ just run-test <test_name>
426 //! ```
427 //!
428 //! ### Linting Code
429 //!
430 //! During the CI process `clap` runs against many different lints using
431 //! [`clippy`](https://github.com/Manishearth/rust-clippy). In order to check if these lints pass on
432 //! your own computer prior to submitting a PR you'll need a nightly compiler.
433 //!
434 //! In order to check the code for lints run either:
435 //!
436 //! ```text
437 //! $ rustup override add nightly
438 //! $ cargo build --features lints
439 //! $ rustup override remove
440 //!
441 //! # Or
442 //!
443 //! $ just lint
444 //! ```
445 //!
446 //! ### Debugging Code
447 //!
448 //! Another helpful technique is to see the `clap` debug output while developing features. In order
449 //! to see the debug output while running the full test suite or individual tests, run:
450 //!
451 //! ```text
452 //! $ cargo test --features debug
453 //!
454 //! # Or for individual tests
455 //! $ cargo test --test <test_name> --features debug
456 //!
457 //! # The corresponding just command for individual debugging tests is:
458 //! $ just debug <test_name>
459 //! ```
460 //!
461 //! ### Goals
462 //!
463 //! There are a few goals of `clap` that I'd like to maintain throughout contributions. If your
464 //! proposed changes break, or go against any of these goals we'll discuss the changes further
465 //! before merging (but will *not* be ignored, all contributes are welcome!). These are by no means
466 //! hard-and-fast rules, as I'm no expert and break them myself from time to time (even if by
467 //! mistake or ignorance).
468 //!
469 //! * Remain backwards compatible when possible
470 //!   - If backwards compatibility *must* be broken, use deprecation warnings if at all possible before
471 //!   removing legacy code - This does not apply for security concerns
472 //! * Parse arguments quickly
473 //!   - Parsing of arguments shouldn't slow down usage of the main program - This is also true of
474 //!   generating help and usage information (although *slightly* less stringent, as the program is about
475 //!   to exit)
476 //! * Try to be cognizant of memory usage
477 //!   - Once parsing is complete, the memory footprint of `clap` should be low since the  main program
478 //!   is the star of the show
479 //! * `panic!` on *developer* error, exit gracefully on *end-user* error
480 //!
481 //! ### Compatibility Policy
482 //!
483 //! Because `clap` takes `SemVer` and compatibility seriously, this is the official policy regarding
484 //! breaking changes and previous versions of Rust.
485 //!
486 //! `clap` will pin the minimum required version of Rust to the CI builds. Bumping the minimum
487 //! version of Rust is considered a minor breaking change, meaning *at a minimum* the minor version
488 //! of `clap` will be bumped.
489 //!
490 //! In order to keep from being surprised by breaking changes, it is **highly** recommended to use
491 //! the `~major.minor.patch` style in your `Cargo.toml`:
492 //!
493 //! ```toml
494 //! [dependencies] clap = "~2.27.0"
495 //! ```
496 //!
497 //! This will cause *only* the patch version to be updated upon a `cargo update` call, and therefore
498 //! cannot break due to new features, or bumped minimum versions of Rust.
499 //!
500 //! #### Minimum Version of Rust
501 //!
502 //! `clap` will officially support current stable Rust, minus two releases, but may work with prior
503 //! releases as well. For example, current stable Rust at the time of this writing is 1.21.0,
504 //! meaning `clap` is guaranteed to compile with 1.19.0 and beyond. At the 1.22.0 release, `clap`
505 //! will be guaranteed to compile with 1.20.0 and beyond, etc.
506 //!
507 //! Upon bumping the minimum version of Rust (assuming it's within the stable-2 range), it *must* be
508 //! clearly annotated in the `CHANGELOG.md`
509 //!
510 //! ## License
511 //!
512 //! `clap` is licensed under the MIT license. Please read the [LICENSE-MIT][license] file in
513 //! this repository for more information.
514 //!
515 //! [examples/]: https://github.com/clap-rs/clap/tree/v2.33.1/examples
516 //! [video tutorials]: https://www.youtube.com/playlist?list=PLza5oFLQGTl2Z5T8g1pRkIynR3E0_pc7U
517 //! [license]: https://github.com/clap-rs/clap/blob/v2.33.1/LICENSE-MIT
518 
519 #![crate_type = "lib"]
520 #![doc(html_root_url = "https://docs.rs/clap/2.33.3")]
521 #![deny(
522     missing_docs,
523     missing_debug_implementations,
524     missing_copy_implementations,
525     trivial_casts,
526     unused_import_braces,
527     unused_allocation
528 )]
529 // Lints we'd like to deny but are currently failing for upstream crates
530 //      unused_qualifications       (bitflags, clippy)
531 //      trivial_numeric_casts       (bitflags)
532 #![cfg_attr(
533     not(any(feature = "lints", feature = "nightly")),
534     forbid(unstable_features)
535 )]
536 #![cfg_attr(feature = "lints", feature(plugin))]
537 #![cfg_attr(feature = "lints", plugin(clippy))]
538 // Need to disable deny(warnings) while deprecations are active
539 // #![cfg_attr(feature = "lints", deny(warnings))]
540 #![cfg_attr(feature = "lints", allow(cyclomatic_complexity))]
541 #![cfg_attr(feature = "lints", allow(doc_markdown))]
542 #![cfg_attr(feature = "lints", allow(explicit_iter_loop))]
543 
544 #[cfg(all(feature = "color", not(target_os = "windows")))]
545 extern crate ansi_term;
546 #[cfg(feature = "color")]
547 extern crate atty;
548 #[macro_use]
549 extern crate bitflags;
550 #[cfg(feature = "suggestions")]
551 extern crate strsim;
552 #[cfg(feature = "wrap_help")]
553 extern crate term_size;
554 extern crate textwrap;
555 #[cfg(feature = "vec_map")]
556 extern crate vec_map;
557 #[cfg(feature = "yaml")]
558 extern crate yaml_rust;
559 
560 pub use app::{App, AppSettings};
561 pub use args::{Arg, ArgGroup, ArgMatches, ArgSettings, OsValues, SubCommand, Values};
562 pub use completions::Shell;
563 pub use errors::{Error, ErrorKind, Result};
564 pub use fmt::Format;
565 #[cfg(feature = "yaml")]
566 pub use yaml_rust::YamlLoader;
567 
568 #[macro_use]
569 mod macros;
570 mod app;
571 mod args;
572 mod completions;
573 mod errors;
574 mod fmt;
575 mod map;
576 mod osstringext;
577 mod strext;
578 mod suggestions;
579 mod usage_parser;
580 
581 const INTERNAL_ERROR_MSG: &'static str = "Fatal internal error. Please consider filing a bug \
582                                           report at https://github.com/clap-rs/clap/issues";
583 const INVALID_UTF8: &'static str = "unexpected invalid UTF-8 code point";
584 
585 #[cfg(unstable)]
586 pub use derive::{ArgEnum, ClapApp, FromArgMatches, IntoApp};
587 
588 #[cfg(unstable)]
589 mod derive {
590     /// @TODO @release @docs
591     pub trait ClapApp: IntoApp + FromArgMatches + Sized {
592         /// @TODO @release @docs
parse() -> Self593         fn parse() -> Self {
594             Self::from_argmatches(Self::into_app().get_matches())
595         }
596 
597         /// @TODO @release @docs
parse_from<I, T>(argv: I) -> Self where I: IntoIterator<Item = T>, T: Into<OsString> + Clone,598         fn parse_from<I, T>(argv: I) -> Self
599         where
600             I: IntoIterator<Item = T>,
601             T: Into<OsString> + Clone,
602         {
603             Self::from_argmatches(Self::into_app().get_matches_from(argv))
604         }
605 
606         /// @TODO @release @docs
try_parse() -> Result<Self, clap::Error>607         fn try_parse() -> Result<Self, clap::Error> {
608             Self::try_from_argmatches(Self::into_app().get_matches_safe()?)
609         }
610 
611         /// @TODO @release @docs
try_parse_from<I, T>(argv: I) -> Result<Self, clap::Error> where I: IntoIterator<Item = T>, T: Into<OsString> + Clone,612         fn try_parse_from<I, T>(argv: I) -> Result<Self, clap::Error>
613         where
614             I: IntoIterator<Item = T>,
615             T: Into<OsString> + Clone,
616         {
617             Self::try_from_argmatches(Self::into_app().get_matches_from_safe(argv)?)
618         }
619     }
620 
621     /// @TODO @release @docs
622     pub trait IntoApp {
623         /// @TODO @release @docs
into_app<'a, 'b>() -> clap::App<'a, 'b>624         fn into_app<'a, 'b>() -> clap::App<'a, 'b>;
625     }
626 
627     /// @TODO @release @docs
628     pub trait FromArgMatches: Sized {
629         /// @TODO @release @docs
from_argmatches<'a>(matches: clap::ArgMatches<'a>) -> Self630         fn from_argmatches<'a>(matches: clap::ArgMatches<'a>) -> Self;
631 
632         /// @TODO @release @docs
try_from_argmatches<'a>(matches: clap::ArgMatches<'a>) -> Result<Self, clap::Error>633         fn try_from_argmatches<'a>(matches: clap::ArgMatches<'a>) -> Result<Self, clap::Error>;
634     }
635 
636     /// @TODO @release @docs
637     pub trait ArgEnum {}
638 }
639