Format all files under tools and utils directory.

tools/testing/dart/vendored_pkg/args/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';
 
 final _SOLO_OPT = new RegExp(r'^-([a-zA-Z0-9])$');
 final _ABBR_OPT = new RegExp(r'^-([a-zA-Z0-9]+)(.*)$');
@@ skipping 88 matching lines @@
     args.clear();
     return new ArgResults(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}".');
+    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]}".');
+      validate(
+          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);
@@ skipping 55 matching lines @@
           '"$value" is not an allowed value for option "${option.name}".');
     }
 
     if (option.allowMultiple) {
       results[option.name].add(value);
     } else {
       results[option.name] = value;
     }
   }
 }