Update charted to 0.4.8 and roll

packages/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 'arg_parser.dart';
+import 'arg_parser_exception.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
@@ skipping 12 matching lines @@
 
   /// The arguments being parsed.
   final List<String> args;
 
   /// The remaining non-option, non-command arguments.
   final rest = <String>[];
 
   /// The accumulated parsed options.
   final Map<String, dynamic> results = <String, dynamic>{};
 
-  Parser(this.commandName, this.grammar, this.args, this.parent, rest) {
+  Parser(this.commandName, this.grammar, this.args,
+      [this.parent, List<String> rest]) {
     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 arguments = args.toList();
     var commandResults = null;
 
     // 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, rest);
-        commandResults = commandParser.parse();
+
+        try {
+          commandResults = commandParser.parse();
+        } on ArgParserException catch (error) {
+          if (commandName == null) rethrow;
+          throw new ArgParserException(
+              error.message,
+              [commandName]..addAll(error.commands));
+        }
 
         // 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;
@@ skipping 158 matching lines @@
       // Walk up to the parent command if possible.
       validate(parent != null, 'Could not find an option named "$name".');
       return parent.parseLongOption();
     }
 
     return true;
   }
 
   /// Called during parsing to validate the arguments.
   ///
-  /// Throws a [FormatException] if [condition] is `false`.
+  /// Throws an [ArgParserException] if [condition] is `false`.
   void validate(bool condition, String message) {
-    if (!condition) throw new FormatException(message);
+    if (!condition) throw new ArgParserException(message);
   }
 
   /// Validates and stores [value] as the value for [option], which must not be
   /// a flag.
   void setOption(Map results, Option option, String value) {
     assert(!option.isFlag);
 
     if (!option.isMultiple) {
       _validateAllowed(option, value);
       results[option.name] = value;
       return;
     }
 
-    var list = results.putIfAbsent(option.name, () => []);
+    var list = results.putIfAbsent(option.name, () => <String>[]);
 
     if (option.splitCommas) {
       for (var element in value.split(",")) {
         _validateAllowed(option, element);
         list.add(element);
       }
     } else {
       _validateAllowed(option, value);
       list.add(value);
     }
   }
 
   /// Validates and stores [value] as the value for [option], which must be a
   /// flag.
   void setFlag(Map results, Option option, bool value) {
     assert(option.isFlag);
     results[option.name] = value;
   }
 
   /// Validates that [value] is allowed as a value of [option].
   void _validateAllowed(Option option, String value) {
     if (option.allowed == null) return;
 
     validate(option.allowed.contains(value),
         '"$value" is not an allowed value for option "${option.name}".');
   }
 }