format code, removed unused variables and deprecated usage

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_results.dart';
 import 'option.dart';
 
@@ skipping 74 matching lines @@
 
     // Invoke the callbacks.
     grammar.options.forEach((name, option) {
       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 newArgResults(grammar, results, commandName, commandResults, rest,
-        arguments);
+    return newArgResults(
+        grammar, results, commandName, commandResults, rest, arguments);
   }
 
   /// 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}".');
+    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);
   }
 
   /// 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;
 
     var option = grammar.findByAbbreviation(soloOpt[1]);
     if (option == null) {
       // Walk up to the parent command if possible.
-      validate(parent != null,
-          'Could not find an option or flag "-${soloOpt[1]}".');
+      validate(
+          parent != null, 'Could not find an option or flag "-${soloOpt[1]}".');
       return parent.parseSoloOption();
     }
 
     args.removeAt(0);
 
     if (option.isFlag) {
       setOption(results, option, true);
     } else {
       readNextArgAsValue(option);
     }
 
     return true;
   }
 
   /// Tries to parse the current argument as a series of collapsed abbreviations
   /// (like "-abc") or a single abbreviation with the value directly attached
   /// to it (like "-mrelease").
   bool parseAbbreviation(Parser innermostCommand) {
     var abbrOpt = _ABBR_OPT.firstMatch(current);
     if (abbrOpt == null) return false;
 
     // If the first character is the abbreviation for a non-flag option, then
     // the rest is the value.
     var c = abbrOpt[1].substring(0, 1);
     var first = grammar.findByAbbreviation(c);
     if (first == null) {
       // Walk up to the parent command if possible.
-      validate(parent != null,
-          'Could not find an option with short name "-$c".');
+      validate(
+          parent != null, 'Could not find an option with short name "-$c".');
       return parent.parseAbbreviation(innermostCommand);
     } else if (!first.isFlag) {
       // The first character is a non-flag option, so the rest must be the
       // value.
       var value = '${abbrOpt[1].substring(1)}${abbrOpt[2]}';
       setOption(results, first, value);
     } else {
       // If we got some non-flag characters, then it must be a value, but
       // if we got here, it's a flag, which is wrong.
       validate(abbrOpt[2] == '',
-        'Option "-$c" is a flag and cannot handle value '
-        '"${abbrOpt[1].substring(1)}${abbrOpt[2]}".');
+          'Option "-$c" is a flag and cannot handle value '
+          '"${abbrOpt[1].substring(1)}${abbrOpt[2]}".');
 
       // Not an option, so all characters should be flags.
       // We use "innermostCommand" here so that if a parent command parses the
       // *first* letter, subcommands can still be found to parse the other
       // letters.
       for (var i = 0; i < abbrOpt[1].length; i++) {
         var c = abbrOpt[1].substring(i, i + 1);
         innermostCommand.parseShortFlag(c);
       }
     }
 
     args.removeAt(0);
     return true;
   }
 
   void parseShortFlag(String c) {
     var option = grammar.findByAbbreviation(c);
     if (option == null) {
       // Walk up to the parent command if possible.
-      validate(parent != null,
-          'Could not find an option with short name "-$c".');
+      validate(
+          parent != null, 'Could not find an option with short name "-$c".');
       parent.parseShortFlag(c);
       return;
     }
 
     // In a list of short options, only the first can be a non-flag. If
     // we get here we've checked that already.
-    validate(option.isFlag,
-        'Option "-$c" must be a flag to be in a collapsed "-".');
+    validate(
+        option.isFlag, 'Option "-$c" must be a flag to be in a collapsed "-".');
 
     setOption(results, option, true);
   }
 
   /// Tries to parse the current argument as a long-form named option, which
   /// may include a value like "--mode=release" or "--mode release".
   bool parseLongOption() {
     var longOpt = _LONG_OPT.firstMatch(current);
     if (longOpt == null) return false;
 
@@ skipping 53 matching lines @@
     }
 
     if (option.isMultiple) {
       var list = results.putIfAbsent(option.name, () => []);
       list.add(value);
     } else {
       results[option.name] = value;
     }
   }
 }