format code, removed unused variables and deprecated usage

lib/src/arg_parser.dart

 // Copyright (c) 2014, 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.arg_parser;
 
 import 'package:collection/wrappers.dart';
 
 import 'arg_results.dart';
 import 'option.dart';
@@ skipping 15 matching lines @@
   /// Whether or not this parser parses options that appear after non-option
   /// arguments.
   final bool allowTrailingOptions;
 
   /// Creates a new ArgParser.
   ///
   /// If [allowTrailingOptions] is set, the parser will continue parsing even
   /// after it finds an argument that is neither an option nor a command.
   /// This allows options to be specified after regular arguments. Defaults to
   /// `false`.
-  factory ArgParser({bool allowTrailingOptions}) =>
-      new ArgParser._(<String, Option>{}, <String, ArgParser>{},
-          allowTrailingOptions: allowTrailingOptions);
+  factory ArgParser({bool allowTrailingOptions}) => new ArgParser._(
+      <String, Option>{}, <String, ArgParser>{},
+      allowTrailingOptions: allowTrailingOptions);
 
   ArgParser._(Map<String, Option> options, Map<String, ArgParser> commands,
-      {bool allowTrailingOptions}) :
-    this._options = options,
-    this.options = new UnmodifiableMapView(options),
-    this._commands = commands,
-    this.commands = new UnmodifiableMapView(commands),
-    this.allowTrailingOptions = allowTrailingOptions != null ?
-        allowTrailingOptions : false;
+      {bool allowTrailingOptions})
+      : this._options = options,
+        this.options = new UnmodifiableMapView(options),
+        this._commands = commands,
+        this.commands = new UnmodifiableMapView(commands),
+        this.allowTrailingOptions = allowTrailingOptions != null
+            ? allowTrailingOptions
+            : false;
 
   /// Defines a command.
   ///
   /// A command is a named argument which may in turn define its own options and
   /// subcommands using the given parser. If [parser] is omitted, implicitly
   /// creates a new one. Returns the parser for the command.
   ArgParser addCommand(String name, [ArgParser parser]) {
     // Make sure the name isn't in use.
     if (_commands.containsKey(name)) {
       throw new ArgumentError('Duplicate command "$name".');
@@ skipping 21 matching lines @@
   void addOption(String name, {String abbr, String help, String valueHelp,
       List<String> allowed, Map<String, String> allowedHelp, String defaultsTo,
       void callback(value), bool allowMultiple: false, bool hide: false}) {
     _addOption(name, abbr, help, valueHelp, allowed, allowedHelp, defaultsTo,
         callback, allowMultiple ? OptionType.MULTIPLE : OptionType.SINGLE,
         hide: hide);
   }
 
   void _addOption(String name, String abbr, String help, String valueHelp,
       List<String> allowed, Map<String, String> allowedHelp, defaultsTo,
-      void callback(value), OptionType type, {bool negatable: false,
-      bool hide: false}) {
+      void callback(value), OptionType type,
+      {bool negatable: false, bool hide: false}) {
     // Make sure the name isn't in use.
     if (_options.containsKey(name)) {
       throw new ArgumentError('Duplicate option "$name".');
     }
 
     // Make sure the abbreviation isn't too long or in use.
     if (abbr != null) {
       var existing = findByAbbreviation(abbr);
       if (existing != null) {
         throw new ArgumentError(
             'Abbreviation "$abbr" is already used by "${existing.name}".');
       }
     }
 
     _options[name] = newOption(name, abbr, help, valueHelp, allowed,
-        allowedHelp, defaultsTo, callback, type, negatable: negatable,
-        hide: hide);
+        allowedHelp, defaultsTo, callback, type,
+        negatable: negatable, hide: hide);
   }
 
   /// Parses [args], a list of command-line arguments, matches them against the
   /// flags and options defined by this parser, and returns the result.
   ArgResults parse(List<String> args) =>
       new Parser(null, this, args.toList(), null, null).parse();
 
   /// Generates a string displaying usage information for the defined options.
   ///
   /// This is basically the help text shown on the command line.
@@ skipping 14 matching lines @@
     return options[option].defaultValue;
   }
 
   /// Finds the option whose abbreviation is [abbr], or `null` if no option has
   /// that abbreviation.
   Option findByAbbreviation(String abbr) {
     return options.values.firstWhere((option) => option.abbreviation == abbr,
         orElse: () => null);
   }
 }