Added the ability to get the names of the options in a set of parsed arguments, and the default val…

lib/args/args.dart

 // Copyright (c) 2012, 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 ##
  *
@@ skipping 471 matching lines @@
    * Finds the option whose abbreviation is [abbr], or `null` if no option has
    * that abbreviation.
    */
   _Option _findByAbbr(String abbr) {
     for (var option in _options.getValues()) {
       if (option.abbreviation == abbr) return option;
     }
 
     return null;
   }
+
+  /**
+   * Get the default value for an option. Useful after parsing to test
+   * if the user specified something other than the default.

[Bob Nystrom, 2012/08/16 21:26:58]

This method is useful in its own right, but if it's just for testing that, why
not have isDefault(option) on ArgResults?

[gram, 2012/08/16 21:55:53]

ArgResults does not have that information. We could add a flag but then there
are two choices, neither of which are great - have a second map and duplicate
all the keys, or change the map to contain classes with option data rather than
just values. This seemed like a lightweight approach that has a trivial
implementation and, as you point out, adds more flexibility than just the use
case that drove me to add it. Isn't solving a more general problem considered a
good thing, especially when it comes virtually for free? If we added
isDefault(), and then later on discovered we had other reasons for getting at
the default value, we might end up adding yet another method, and thus is born
needless complexity.

+   */
+
+   getDefault(String option) => _options.containsKey(option) ?
+       _options[option].defaultValue : null;

[Bob Nystrom, 2012/08/16 21:26:58]

If the option name is invalid, this should throw an InvalidArgumentException,
not just silently return null.

[gram, 2012/08/16 21:55:53]

Done. I assume you mean IllegalArgument...

 }
 
 /**
  * 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 _options;
 
   /**
    * 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.rest);
 
   /** Gets the parsed command-line option named [name]. */
   operator [](String name) {
     if (!_options.containsKey(name)) {
       throw new IllegalArgumentException(
           'Could not find an option named "$name".');
     }
 
     return _options[name];
   }
+
+  /** Get the names of the options as a [Collection]. */
+  Collection<String> get options => _options.getKeys();

[Bob Nystrom, 2012/08/16 21:26:58]

Instead of this, how about making ArgResults implement Collection itself?

[gram, 2012/08/16 21:55:53]

That seems like a lot of extra effort. All I want is a way to get at the valid
keys for indexing. Would it be enough to  change the name to getKeys()? Or to
implement Iterable<String>? Or leave it as is?

 }
 
 class _Option {
   final String name;
   final String abbreviation;
   final List allowed;
   final defaultValue;
   final Function callback;
   final String help;
   final Map<String, String> allowedHelp;
@@ skipping 218 matching lines @@
       allowedBuffer.add(allowed);
       if (allowed == option.defaultValue) {
         allowedBuffer.add(' (default)');
       }
       first = false;
     }
     allowedBuffer.add(']');
     return allowedBuffer.toString();
   }
 }