Using arg parsing lib for dart2js.

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 156 matching lines @@
 
 /**
  * A class for taking a list of raw command line arguments and parsing out
  * options and flags from them.
  */
 class ArgParser {
   static final _SOLO_OPT = const RegExp(@'^-([a-z0-9])$');
   static final _ABBR_OPT = const RegExp(@'^-([a-z0-9]+)(.*)$');
   static final _LONG_OPT = const RegExp(@'^--([a-z\-_0-9]+)(=(.*))?$');
 
+  final String _usage;
   final Map<String, _Option> _options;
 
   /**
    * The names of the options, in the order that they were added. This way we
    * can generate usage information in the same order.
    */
   // TODO(rnystrom): Use an ordered map type, if one appears.
   final List<String> _optionNames;
 
   /** The current argument list being parsed. Set by [parse()]. */
   List<String> _args;
 
   /** Index of the current argument being parsed in [_args]. */
   int _current;
 
-  /** Creates a new ArgParser. */
-  ArgParser()
-    : _options = <_Option>{},
-      _optionNames = <String>[];
+  /**
+   * Creates a new ArgParser. If provided [usage] will be included when usage
+   * information is displayed. It is typically the example command-line shown
+   * at the top of help documentation like:
+   *
+   *     myapp [options] <arg> <another>
+   *
+   * If [includeHelp] is `true` (or omitted), it will automatically add a
+   * `--help` flag.
+   */
+  ArgParser([String usage, bool includeHelp = true])
+    : _usage = usage,
+      _options = <_Option>{},
+      _optionNames = <String>[] {
+    if (includeHelp) {
+      addFlag('help', abbr: 'h', help: 'Display usage information');
+    }
+  }
 
   /**
    * Defines a flag. Throws an [IllegalArgumentException] 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,
       void callback(bool value)]) {
     _addOption(name, abbr, help, null, null, defaultsTo, callback,
@@ skipping 79 matching lines @@
       var option = _options[name];
       if (option.callback != null) option.callback(results[name]);
     }
 
     // Add in the leftover arguments we didn't parse.
     return new ArgResults(results,
         _args.getRange(_current, _args.length - _current));
   }
 
   /**
+   * Parses [args], a list of command-line arguments, matches them against the
+   * flags and options defined by this parser, and returns the result. If
+   * `--help` is specified, then it prints usage information to stdout and
+   * exits the process.
+   *
+   * If an error occurs (i.e. an [ArgFormatException] is thrown while parsing),
+   * it prints the error and the usage information and then exits the process
+   * with exit code 1.
+   *
+   * Otherwise, it will return the results of parsing.
+   */
+  ArgResults process(List<String> args) {
+    try {
+      var results = parse(args);
+
+      if (results['help']) {
+        print(getUsage());
+        exit(0);
+      }
+
+      return results;
+    } catch (ArgFormatException ex) {
+      print('${ex.message} Usage:\n\n${getUsage()}');
+      exit(1);
+    }
+  }
+
+  /**
    * Generates a string displaying usage information for the defined options.
    * This is basically the help text shown on the command line.
    */
   String getUsage() {
     return new _Usage(this).generate();
   }
 
   /**
    * Called during parsing to validate the arguments. Throws an
    * [ArgFormatException] if [condition] is `false`.
@@ skipping 36 matching lines @@
    * Tries to parse the current argument as a "solo" option, which is a single
    * hyphen followed by a single letter. We treat this differently than
    * collapsed abbreviations (like "-abc") to handle the possible value that
    * may follow it.
    */
   bool _parseSoloOption(Map results) {
     var soloOpt = _SOLO_OPT.firstMatch(_args[_current]);
     if (soloOpt == null) return false;
 
     var option = _findByAbbr(soloOpt[1]);
-    _validate(option != null,
-        'Could not find an option or flag "-${soloOpt[1]}".');
+    _validate(option != null, 'Unknown option "-${soloOpt[1]}".');
 
     if (option.isFlag) {
       _setOption(results, option, true);
     } else {
       _readNextArgAsValue(results, option);
     }
 
     return true;
   }
 
   /**
    * Tries to parse the current argument as a series of collapsed abbreviations
    * (like "-abc") or a single abbreviation with the value directly attached
    * to it (like "-mrelease").
    */
   bool _parseAbbreviation(Map results) {
     var abbrOpt = _ABBR_OPT.firstMatch(_args[_current]);
     if (abbrOpt == null) return false;
 
     // If the first character is the abbreviation for a non-flag option, then
     // the rest is the value.
     var c = abbrOpt[1].substring(0, 1);
     var first = _findByAbbr(c);
     if (first == null) {
-      _validate(false, 'Could not find an option with short name "-$c".');
+      _validate(false, 'Unknown option "-$c".');
     } else if (!first.isFlag) {
       // The first character is a non-flag option, so the rest must be the
       // value.
       var value = '${abbrOpt[1].substring(1)}${abbrOpt[2]}';
       _setOption(results, first, value);
     } else {
       // If we got some non-flag characters, then it must be a value, but
       // if we got here, it's a flag, which is wrong.
       _validate(abbrOpt[2] == '',
         'Option "-$c" is a flag and cannot handle value '
         '"${abbrOpt[1].substring(1)}${abbrOpt[2]}".');
 
       // Not an option, so all characters should be flags.
       for (var i = 0; i < abbrOpt[1].length; i++) {
         var c = abbrOpt[1].substring(i, i + 1);
         var option = _findByAbbr(c);
         _validate(option != null,
-            'Could not find an option with short name "-$c".');
+            'Unknown option "-$c".');
 
         // In a list of short options, only the first can be a non-flag. If
         // we get here we've checked that already.
         _validate(option.isFlag,
             'Option "-$c" must be a flag to be in a collapsed "-".');
 
         _setOption(results, option, true);
       }
     }
 
@@ skipping 20 matching lines @@
         // We have a value like --foo=bar.
         _setOption(results, option, longOpt[3]);
       } else {
         // Option like --foo, so look for the value as the next arg.
         _readNextArgAsValue(results, option);
       }
     } else if (name.startsWith('no-')) {
       // See if it's a negated flag.
       name = name.substring('no-'.length);
       option = _options[name];
-      _validate(option != null, 'Could not find an option named "$name".');
+      _validate(option != null, 'Unknown option "$name".');
       _validate(option.isFlag, 'Cannot negate non-flag option "$name.');
 
       _setOption(results, option, false);
     } else {
-      _validate(option != null, 'Could not find an option named "$name".');
+      _validate(option != null, 'Unknown option "$name".');
     }
 
     return true;
   }
 
   /**
    * Finds the option whose abbreviation is [abbr], or `null` if no option has
    * that abbreviation.
    */
   _Option _findByAbbr(String abbr) {
@@ skipping 105 matching lines @@
 
   _Usage(this.args);
 
   /**
    * Generates a string displaying usage information for the defined options.
    * This is basically the help text shown on the command line.
    */
   String generate() {
     buffer = new StringBuffer();
 
+    if (args._usage != null) buffer.add('${args._usage}\n\n');
+
     calculateColumnWidths();
 
     for (var name in args._optionNames) {
       var option = args._options[name];
       write(0, getAbbreviation(option));
       write(1, getLongOption(option));
 
       if (option.help != null) write(2, option.help);
 
       if (option.allowedHelp != null) {
@@ skipping 143 matching lines @@
       allowedBuffer.add(allowed);
       if (allowed == option.defaultValue) {
         allowedBuffer.add(' (default)');
       }
       first = false;
     }
     allowedBuffer.add(']');
     return allowedBuffer.toString();
   }
 }