| // Copyright (c) 2013, the Dart project authors. Please see the AUTHORS file |
| // for details. All rights reserved. Use of this source code is governed by a |
| // BSD-style license that can be found in the LICENSE file. |
| |
| /// This library lets you define parsers for parsing raw command-line arguments |
| /// into a set of options and values using [GNU][] and [POSIX][] style options. |
| /// |
| /// ## Defining options ## |
| /// |
| /// To use this library, you create an [ArgParser] object which will contain |
| /// the set of options you support: |
| /// |
| /// var parser = new ArgParser(); |
| /// |
| /// Then you define a set of options on that parser using [addOption()] and |
| /// [addFlag()]. The minimal way to create an option is: |
| /// |
| /// parser.addOption('name'); |
| /// |
| /// This creates an option named "name". Options must be given a value on the |
| /// command line. If you have a simple on/off flag, you can instead use: |
| /// |
| /// parser.addFlag('name'); |
| /// |
| /// Flag options will, by default, accept a 'no-' prefix to negate the option. |
| /// This can be disabled like so: |
| /// |
| /// parser.addFlag('name', negatable: false); |
| /// |
| /// (From here on out "option" will refer to both "regular" options and flags. |
| /// In cases where the distinction matters, we'll use "non-flag option".) |
| /// |
| /// Options may have an optional single-character abbreviation: |
| /// |
| /// parser.addOption('mode', abbr: 'm'); |
| /// parser.addFlag('verbose', abbr: 'v'); |
| /// |
| /// They may also specify a default value. The default value will be used if the |
| /// option isn't provided: |
| /// |
| /// parser.addOption('mode', defaultsTo: 'debug'); |
| /// parser.addFlag('verbose', defaultsTo: false); |
| /// |
| /// The default value for non-flag options can be any [String]. For flags, it |
| /// must be a [bool]. |
| /// |
| /// To validate non-flag options, you may provide an allowed set of values. When |
| /// you do, it will throw a [FormatException] when you parse the arguments if |
| /// the value for an option is not in the allowed set: |
| /// |
| /// parser.addOption('mode', allowed: ['debug', 'release']); |
| /// |
| /// You can provide a callback when you define an option. When you later parse |
| /// a set of arguments, the callback for that option will be invoked with the |
| /// value provided for it: |
| /// |
| /// parser.addOption('mode', callback: (mode) => print('Got mode $mode)); |
| /// parser.addFlag('verbose', callback: (verbose) { |
| /// if (verbose) print('Verbose'); |
| /// }); |
| /// |
| /// The callback for each option will *always* be called when you parse a set of |
| /// arguments. If the option isn't provided in the args, the callback will be |
| /// passed the default value, or `null` if there is none set. |
| /// |
| /// ## Parsing arguments ## |
| /// |
| /// Once you have an [ArgParser] set up with some options and flags, you use it |
| /// by calling [ArgParser.parse()] with a set of arguments: |
| /// |
| /// var results = parser.parse(['some', 'command', 'line', 'args']); |
| /// |
| /// These will usually come from `new Options().arguments`, but you can pass in |
| /// any list of strings. It returns an instance of [ArgResults]. This is a |
| /// map-like object that will return the value of any parsed option. |
| /// |
| /// var parser = new ArgParser(); |
| /// parser.addOption('mode'); |
| /// parser.addFlag('verbose', defaultsTo: true); |
| /// var results = parser.parse('['--mode', 'debug', 'something', 'else']); |
| /// |
| /// print(results['mode']); // debug |
| /// print(results['verbose']); // true |
| /// |
| /// The [parse()] method will stop as soon as it reaches `--` or anything that |
| /// it doesn't recognize as an option, flag, or option value. If there are still |
| /// arguments left, they will be provided to you in |
| /// [ArgResults.rest]. |
| /// |
| /// print(results.rest); // ['something', 'else'] |
| /// |
| /// ## Specifying options ## |
| /// |
| /// To actually pass in options and flags on the command line, use GNU or POSIX |
| /// style. If you define an option like: |
| /// |
| /// parser.addOption('name', abbr: 'n'); |
| /// |
| /// Then a value for it can be specified on the command line using any of: |
| /// |
| /// --name=somevalue |
| /// --name somevalue |
| /// -nsomevalue |
| /// -n somevalue |
| /// |
| /// Given this flag: |
| /// |
| /// parser.addFlag('name', abbr: 'n'); |
| /// |
| /// You can set it on using one of: |
| /// |
| /// --name |
| /// -n |
| /// |
| /// Or set it off using: |
| /// |
| /// --no-name |
| /// |
| /// Multiple flag abbreviation can also be collapsed into a single argument. If |
| /// you define: |
| /// |
| /// parser.addFlag('verbose', abbr: 'v'); |
| /// parser.addFlag('french', abbr: 'f'); |
| /// parser.addFlag('iambic-pentameter', abbr: 'i'); |
| /// |
| /// Then all three flags could be set using: |
| /// |
| /// -vfi |
| /// |
| /// By default, an option has only a single value, with later option values |
| /// overriding earlier ones; for example: |
| /// |
| /// var parser = new ArgParser(); |
| /// parser.addOption('mode'); |
| /// var results = parser.parse(['--mode', 'on', '--mode', 'off']); |
| /// print(results['mode']); // prints 'off' |
| /// |
| /// If you need multiple values, set the `allowMultiple` flag. In that |
| /// case the option can occur multiple times and when parsing arguments a |
| /// List of values will be returned: |
| /// |
| /// var parser = new ArgParser(); |
| /// parser.addOption('mode', allowMultiple: true); |
| /// var results = parser.parse(['--mode', 'on', '--mode', 'off']); |
| /// print(results['mode']); // prints '[on, off]' |
| /// |
| /// ## Defining commands ## |
| /// |
| /// In addition to *options*, you can also define *commands*. A command is a |
| /// named argument that has its own set of options. For example, when you run: |
| /// |
| /// $ git commit -a |
| /// |
| /// The executable is `git`, the command is `commit`, and the `-a` option is an |
| /// option passed to the command. You can add a command like so: |
| /// |
| /// var parser = new ArgParser(); |
| /// var command = parser.addCommand("commit"); |
| /// command.addFlag('all', abbr: 'a'); |
| /// |
| /// It returns another [ArgParser] which you can use to define options and |
| /// subcommands on that command. When an argument list is parsed, you can then |
| /// determine which command was entered and what options were provided for it. |
| /// |
| /// var results = parser.parse(['commit', '-a']); |
| /// print(results.command.name); // "commit" |
| /// print(results.command['a']); // true |
| /// |
| /// ## Displaying usage ## |
| /// |
| /// This library can also be used to automatically generate nice usage help |
| /// text like you get when you run a program with `--help`. To use this, you |
| /// will also want to provide some help text when you create your options. To |
| /// define help text for the entire option, do: |
| /// |
| /// parser.addOption('mode', help: 'The compiler configuration', |
| /// allowed: ['debug', 'release']); |
| /// parser.addFlag('verbose', help: 'Show additional diagnostic info'); |
| /// |
| /// For non-flag options, you can also provide detailed help for each expected |
| /// value using a map: |
| /// |
| /// parser.addOption('arch', help: 'The architecture to compile for', |
| /// allowedHelp: { |
| /// 'ia32': 'Intel x86', |
| /// 'arm': 'ARM Holding 32-bit chip' |
| /// }); |
| /// |
| /// If you define a set of options like the above, then calling this: |
| /// |
| /// print(parser.getUsage()); |
| /// |
| /// Will display something like: |
| /// |
| /// --mode The compiler configuration |
| /// [debug, release] |
| /// |
| /// --[no-]verbose Show additional diagnostic info |
| /// --arch The architecture to compile for |
| /// |
| /// [arm] ARM Holding 32-bit chip |
| /// [ia32] Intel x86 |
| /// |
| /// To assist the formatting of the usage help, single line help text will |
| /// be followed by a single new line. Options with multi-line help text |
| /// will be followed by two new lines. This provides spatial diversity between |
| /// options. |
| /// |
| /// [posix]: http://pubs.opengroup.org/onlinepubs/009695399/basedefs/xbd_chap12.html#tag_12_02 |
| /// [gnu]: http://www.gnu.org/prep/standards/standards.html#Command_002dLine-Interfaces |
| library args; |
| |
| import 'src/parser.dart'; |
| import 'src/usage.dart'; |
| |
| /// A class for taking a list of raw command line arguments and parsing out |
| /// options and flags from them. |
| class ArgParser { |
| /// The options that have been defined for this parser. |
| final Map<String, Option> options = <String, Option>{}; |
| |
| /// The commands that have been defined for this parser. |
| final Map<String, ArgParser> commands = <String, ArgParser>{}; |
| |
| /// Creates a new ArgParser. |
| ArgParser(); |
| |
| /// Defines a command. A command is a named argument which may in turn |
| /// define its own options and subcommands. Returns an [ArgParser] that can |
| /// be used to define the command's options. |
| ArgParser addCommand(String name) { |
| // Make sure the name isn't in use. |
| if (commands.containsKey(name)) { |
| throw ArgumentError('Duplicate command "$name".'); |
| } |
| |
| var command = ArgParser(); |
| commands[name] = command; |
| return command; |
| } |
| |
| /// Defines a flag. Throws an [ArgumentError] if: |
| /// |
| /// * There is already an option named [name]. |
| /// * There is already an option using abbreviation [abbr]. |
| void addFlag(String name, |
| {String abbr, |
| String help, |
| bool defaultsTo = false, |
| bool negatable = true, |
| void callback(bool value)}) { |
| _addOption(name, abbr, help, null, null, defaultsTo, |
| callback == null ? null : (value) => callback(value as bool), |
| isFlag: true, negatable: negatable); |
| } |
| |
| /// Defines a value-taking option. Throws an [ArgumentError] if: |
| /// |
| /// * There is already an option with name [name]. |
| /// * There is already an option using abbreviation [abbr]. |
| void addOption(String name, |
| {String abbr, |
| String help, |
| List<String> allowed, |
| Map<String, String> allowedHelp, |
| String defaultsTo, |
| void callback(dynamic value), |
| bool allowMultiple = false}) { |
| _addOption(name, abbr, help, allowed, allowedHelp, defaultsTo, callback, |
| isFlag: false, allowMultiple: allowMultiple); |
| } |
| |
| void _addOption( |
| String name, |
| String abbr, |
| String help, |
| List<String> allowed, |
| Map<String, String> allowedHelp, |
| dynamic defaultsTo, |
| void callback(dynamic value), |
| {bool isFlag, |
| bool negatable = false, |
| bool allowMultiple = false}) { |
| // Make sure the name isn't in use. |
| if (options.containsKey(name)) { |
| throw ArgumentError('Duplicate option "$name".'); |
| } |
| |
| // Make sure the abbreviation isn't too long or in use. |
| if (abbr != null) { |
| if (abbr.length > 1) { |
| throw ArgumentError( |
| 'Abbreviation "$abbr" is longer than one character.'); |
| } |
| |
| var existing = findByAbbreviation(abbr); |
| if (existing != null) { |
| throw ArgumentError( |
| 'Abbreviation "$abbr" is already used by "${existing.name}".'); |
| } |
| } |
| |
| options[name] = Option( |
| name, abbr, help, allowed, allowedHelp, defaultsTo, callback, |
| isFlag: isFlag, negatable: negatable, allowMultiple: allowMultiple); |
| } |
| |
| /// Parses [args], a list of command-line arguments, matches them against the |
| /// flags and options defined by this parser, and returns the result. |
| ArgResults parse(List<String> args) => |
| Parser(null, this, args.toList()).parse(); |
| |
| /// Generates a string displaying usage information for the defined options. |
| /// This is basically the help text shown on the command line. |
| String getUsage() => Usage(this).generate(); |
| |
| /// Get the default value for an option. Useful after parsing to test |
| /// if the user specified something other than the default. |
| dynamic getDefault(String option) { |
| if (!options.containsKey(option)) { |
| throw ArgumentError('No option named $option'); |
| } |
| return options[option].defaultValue; |
| } |
| |
| /// Finds the option whose abbreviation is [abbr], or `null` if no option has |
| /// that abbreviation. |
| Option findByAbbreviation(String abbr) { |
| return options.values.firstWhere((option) => option.abbreviation == abbr, |
| orElse: () => null); |
| } |
| } |
| |
| /// A command-line option. Includes both flags and options which take a value. |
| class Option { |
| final String name; |
| final String abbreviation; |
| final List allowed; |
| final dynamic defaultValue; |
| final Function callback; |
| final String help; |
| final Map<String, String> allowedHelp; |
| final bool isFlag; |
| final bool negatable; |
| final bool allowMultiple; |
| |
| Option(this.name, this.abbreviation, this.help, this.allowed, |
| this.allowedHelp, this.defaultValue, this.callback, |
| {this.isFlag, this.negatable, this.allowMultiple = false}); |
| } |
| |
| /// The results of parsing a series of command line arguments using |
| /// [ArgParser.parse()]. Includes the parsed options and any remaining unparsed |
| /// command line arguments. |
| class ArgResults { |
| final Map<String, dynamic> _options; |
| |
| /// If these are the results for parsing a command's options, this will be |
| /// the name of the command. For top-level results, this returns `null`. |
| final String name; |
| |
| /// The command that was selected, or `null` if none was. This will contain |
| /// the options that were selected for that command. |
| final ArgResults command; |
| |
| /// The remaining command-line arguments that were not parsed as options or |
| /// flags. If `--` was used to separate the options from the remaining |
| /// arguments, it will not be included in this list. |
| final List<String> rest; |
| |
| /// Creates a new [ArgResults]. |
| ArgResults(this._options, this.name, this.command, this.rest); |
| |
| /// Gets the parsed command-line option named [name]. |
| dynamic operator [](String name) { |
| if (!_options.containsKey(name)) { |
| throw ArgumentError('Could not find an option named "$name".'); |
| } |
| |
| return _options[name]; |
| } |
| |
| List<String> get options => _options.keys.toList(); |
| } |