Added the continueParsing option to ArgParser.

pkg/args/lib/src/parser.dart

 // 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.
 
 library args.src.parser;
 
 import '../args.dart';
 
 final _SOLO_OPT = new RegExp(r'^-([a-zA-Z0-9])$');
 final _ABBR_OPT = new RegExp(r'^-([a-zA-Z0-9]+)(.*)$');
@@ skipping 10 matching lines @@
    * command. For top-level results, this returns `null`.
    */
   final String commandName;
 
   /**
    * The parser for the supercommand of this command parser, or `null` if this
    * is the top-level parser.
    */
   final Parser parent;
 
+  /** If `true`, parsing will continue after a non-option argument. */
+  final bool allowTrailingOptions;
+
   /** The grammar being parsed. */
   final ArgParser grammar;
 
   /** The arguments being parsed. */
   final List<String> args;
 
+  /** The remaining non-option, non-command arguments. */
+  List<String> rest = <String>[];

[Bob Nystrom, 2013/06/24 20:49:29]

Make this final and lose the type annotation.

[Andrei Mouravski, 2013/06/24 20:54:29]

Done.

+
   /** The accumulated parsed options. */
   final Map results = {};
 
-  Parser(this.commandName, this.grammar, this.args, [this.parent]);
+  Parser(this.commandName, this.grammar, this.args, this.parent, rest,
+      {this.allowTrailingOptions: false}) {
+    if (rest != null) this.rest.addAll(rest);
+  }
+
 
   /** The current argument being parsed. */
   String get current => args[0];
 
   /** Parses the arguments. This can only be called once. */
   ArgResults parse() {
     var commandResults = null;
 
     // Initialize flags to their defaults.
     grammar.options.forEach((name, option) {
       if (option.allowMultiple) {
         results[name] = [];
       } else {
         results[name] = option.defaultValue;
       }
     });
 
     // Parse the args.
     while (args.length > 0) {
       if (current == '--') {
         // Reached the argument terminator, so stop here.
         args.removeAt(0);
         break;
       }
 
       // Try to parse the current argument as a command. This happens before
       // options so that commands can have option-like names.
       var command = grammar.commands[current];
       if (command != null) {
+        validate(rest.isEmpty, 'Cannot specify arguments before a command.');
         var commandName = args.removeAt(0);
-        var commandParser = new Parser(commandName, command, args, this);
+        var commandParser = new Parser(commandName, command, args, this, rest,
+            allowTrailingOptions: allowTrailingOptions);
         commandResults = commandParser.parse();
-        continue;
+
+        // All remaining arguments were passed to command so clear them here.
+        rest.clear();
+        break;
       }
 
       // Try to parse the current argument as an option. Note that the order
       // here matters.
-      if (parseSoloOption()) continue;
-      if (parseAbbreviation(this)) continue;
-      if (parseLongOption()) continue;
+      if (isCurrentArgAnOption) {

[Bob Nystrom, 2013/06/24 20:49:29]

This isn't needed any more.

[Andrei Mouravski, 2013/06/24 20:54:29]

Done.

+        if (parseSoloOption()) continue;
+        if (parseAbbreviation(this)) continue;
+        if (parseLongOption()) continue;
+      }
 
-      // If we got here, the argument doesn't look like an option, so stop.
-      break;
+      // This argument is neither option nor command, so stop parsing unless
+      // the [allowTrailingOptions] option is set.
+      if (!allowTrailingOptions) break;
+      rest.add(args.removeAt(0));
     }
 
     // Set unspecified multivalued arguments to their default value,
     // if any, and invoke the callbacks.
     grammar.options.forEach((name, option) {
       if (option.allowMultiple &&
           results[name].length == 0 &&
           option.defaultValue != null) {
         results[name].add(option.defaultValue);
       }
       if (option.callback != null) option.callback(results[name]);
     });
 
     // Add in the leftover arguments we didn't parse to the innermost command.
-    var rest = args.toList();
+    rest.addAll(args);
     args.clear();
     return new ArgResults(results, commandName, commandResults, rest);
   }
 
   /**
    * Pulls the value for [option] from the second argument in [args]. Validates
    * that there is a valid value there.
    */
   void readNextArgAsValue(Option option) {
     // Take the option argument from the next command line arg.
     validate(args.length > 0,
         'Missing argument for "${option.name}".');
 
     // Make sure it isn't an option itself.
     validate(!_ABBR_OPT.hasMatch(current) && !_LONG_OPT.hasMatch(current),
         'Missing argument for "${option.name}".');
 
     setOption(results, option, current);
     args.removeAt(0);
   }
 
+  /** Returns `true` if the current argument looks like an option. */
+  bool get isCurrentArgAnOption => [_SOLO_OPT, _ABBR_OPT, _LONG_OPT].any(
+      (re) => re.firstMatch(current) != null);

[Bob Nystrom, 2013/06/24 20:49:29]

You can ditch this.

[Andrei Mouravski, 2013/06/24 20:54:29]

Done.

+
   /**
    * 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() {
     var soloOpt = _SOLO_OPT.firstMatch(current);
     if (soloOpt == null) return false;
 
@@ skipping 142 matching lines @@
           '"$value" is not an allowed value for option "${option.name}".');
     }
 
     if (option.allowMultiple) {
       results[option.name].add(value);
     } else {
       results[option.name] = value;
     }
   }
 }