Rename BadNumberFormatException -> FormatException.

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 23 matching lines @@
  * They may also specify a default value. The default value will be used if the
  * option isn't provided:
  *
  *     parser.addOption('mode', defaultsTo: 'debug');
  *     parser.addFlag('verbose', defaultsTo: false);
  *
  * The default value for non-flag options can be any [String]. For flags, it
  * must be a [bool].
  *
  * To validate non-flag options, you may provide an allowed set of values. When
- * you do, it will throw an [ArgFormatException] when you parse the arguments
- * if the value for an option is not in the allowed set:
+ * you do, it will throw a [FormatException] when you parse the arguments if
+ * the value for an option is not in the allowed set:
  *
  *     parser.addOption('mode', allowed: ['debug', 'release']);
  *
  * You can provide a callback when you define an option. When you later parse
  * a set of arguments, the callback for that option will be invoked with the
  * value provided for it:
  *
  *     parser.addOption('mode', callback: (mode) => print('Got mode $mode));
  *     parser.addFlag('verbose', callback: (verbose) {
  *       if (verbose) print('Verbose');
@@ skipping 237 matching lines @@
 
   /**
    * 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`.
+   * Called during parsing to validate the arguments. Throws a
+   * [FormatException] if [condition] is `false`.
    */
   _validate(bool condition, String message) {
-    if (!condition) throw new ArgFormatException(message);
+    if (!condition) throw new FormatException(message);
   }
 
   /** Validates and stores [value] as the value for [option]. */
   _setOption(Map results, _Option option, value) {
     // See if it's one of the allowed values.
     if (option.allowed != null) {
       _validate(option.allowed.some((allow) => allow == value),
           '"$value" is not an allowed value for option "${option.name}".');
     }
 
@@ skipping 162 matching lines @@
   operator [](String name) {
     if (!_options.containsKey(name)) {
       throw new IllegalArgumentException(
           'Could not find an option named "$name".');
     }
 
     return _options[name];
   }
 }
 
-/**
- * Exception thrown by [ArgParser.parse()] when the argument list isn't valid.
- */
-class ArgFormatException implements Exception {
-  final String message;
-  const ArgFormatException(this.message);
-}
-
 class _Option {
   final String name;
   final String abbreviation;
   final List allowed;
   final defaultValue;
   final Function callback;
   final String help;
   final Map<String, String> allowedHelp;
   final bool isFlag;
   final bool negatable;
@@ skipping 215 matching lines @@
       allowedBuffer.add(allowed);
       if (allowed == option.defaultValue) {
         allowedBuffer.add(' (default)');
       }
       first = false;
     }
     allowedBuffer.add(']');
     return allowedBuffer.toString();
   }
 }