Add .wasParsed() to ArgResults.

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';
+import 'arg_parser.dart';
+import 'arg_results.dart';
+import 'option.dart';
 
 final _SOLO_OPT = new RegExp(r'^-([a-zA-Z0-9])$');
 final _ABBR_OPT = new RegExp(r'^-([a-zA-Z0-9]+)(.*)$');
 final _LONG_OPT = new RegExp(r'^--([a-zA-Z\-_0-9]+)(=(.*))?$');
 
 /// The actual argument parsing class.
 ///
 /// Unlike [ArgParser] which is really more an "arg grammar", this is the class
 /// that does the parsing and holds the mutable state required during a parse.
 class Parser {
@@ skipping 21 matching lines @@
     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.
@@ skipping 14 matching lines @@
       if (parseSoloOption()) continue;
       if (parseAbbreviation(this)) continue;
       if (parseLongOption()) continue;
 
       // This argument is neither option nor command, so stop parsing unless
       // the [allowTrailingOptions] option is set.
       if (!grammar.allowTrailingOptions) break;
       rest.add(args.removeAt(0));
     }
 
-    // Set unspecified multivalued arguments to their default value,
-    // if any, and invoke the callbacks.
+    // 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]);
+      if (option.callback == null) return;
+      option.callback(option.getOrDefault(results[name]));
     });
 
     // Add in the leftover arguments we didn't parse to the innermost command.
     rest.addAll(args);
     args.clear();
-    return new ArgResults(results, commandName, commandResults, rest);
+    return newArgResults(grammar, 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}".');
 
@@ skipping 147 matching lines @@
   }
 
   /// Validates and stores [value] as the value for [option].
   void setOption(Map results, Option option, value) {
     // See if it's one of the allowed values.
     if (option.allowed != null) {
       validate(option.allowed.any((allow) => allow == value),
           '"$value" is not an allowed value for option "${option.name}".');
     }
 
-    if (option.allowMultiple) {
-      results[option.name].add(value);
+    if (option.isMultiple) {
+      var list = results.putIfAbsent(option.name, () => []);
+      list.add(value);
     } else {
       results[option.name] = value;
     }
   }
 }