Use dartfmt on Observatory code

runtime/observatory/lib/src/cli/command.dart

 // Copyright (c) 2015, 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.
 
 part of cli;
 
 // Splits a line into a list of string args.  Each arg retains any
 // trailing whitespace so that we can reconstruct the original command
 // line from the pieces.
 List<String> _splitLine(String line) {
@@ skipping 66 matching lines @@
   // arguments.
   List<Command> _match(List<String> args, bool preferExact) {
     if (args.isEmpty) {
       return [];
     }
     bool lastArg = (args.length == 1);
     var matches = _matchLocal(args[0], !lastArg || preferExact);
     if (matches.isEmpty) {
       return [];
     } else if (matches.length == 1) {
-      var childMatches =  matches[0]._match(args.sublist(1), preferExact);
+      var childMatches = matches[0]._match(args.sublist(1), preferExact);
       if (childMatches.isEmpty) {
         return matches;
       } else {
         return childMatches;
       }
     } else {
       return matches;
     }
   }
 
   // Builds a list of completions for this command.
-  Future<List<String>> _buildCompletions(List<String> args,
-                                         bool addEmptyString) {
-    return complete(args.sublist(_depth, args.length))
-      .then((completions) {
-        if (addEmptyString && completions.isEmpty &&
-            args[args.length - 1] == '') {
-          // Special case allowance for an empty particle at the end of
-          // the command.
-          completions = [''];
-        }
-        var prefix = _concatArgs(args, _depth);
-        return completions.map((str) => '${prefix}${str}').toList();
-      });
+  Future<List<String>> _buildCompletions(
+      List<String> args, bool addEmptyString) {
+    return complete(args.sublist(_depth, args.length)).then((completions) {
+      if (addEmptyString &&
+          completions.isEmpty &&
+          args[args.length - 1] == '') {
+        // Special case allowance for an empty particle at the end of
+        // the command.
+        completions = [''];
+      }
+      var prefix = _concatArgs(args, _depth);
+      return completions.map((str) => '${prefix}${str}').toList();
+    });
   }
-
 }
 
 // The root of a tree of commands.
 class RootCommand extends _CommandBase {
   RootCommand(List<Command> children, [List<String> history])
-     : this._(children, history ?? ['']);
+      : this._(children, history ?? ['']);
 
-   RootCommand._(List<Command> children, List<String> history)
+  RootCommand._(List<Command> children, List<String> history)
       : history = history,
         historyPos = history.length - 1,
-      super(children);
+        super(children);
 
   // Provides a list of possible completions for a line of text.
   Future<List<String>> completeCommand(String line) {
     var args = _splitLine(line);
     bool showAll = line.endsWith(' ') || args.isEmpty;
     if (showAll) {
       // Adding an empty string to the end causes us to match all
       // subcommands of the last command.
       args.add('');
     }
-    var commands =  _match(args, false);
+    var commands = _match(args, false);
     if (commands.isEmpty) {
       // No matching commands.
       return new Future.value([]);
     }
     int matchLen = commands[0]._depth;
     if (matchLen < args.length) {
       // We were able to find a command which matches a prefix of the
       // args, but not the full list.
       if (commands.length == 1) {
         // The matching command is unique.  Attempt to provide local
         // argument completion from the command.
         return commands[0]._buildCompletions(args, true);
       } else {
         // An ambiguous prefix match leaves us nowhere.  The user is
         // typing a bunch of stuff that we don't know how to complete.
         return new Future.value([]);
       }
     }
 
     // We have found a set of commands which match all of the args.
     // Return the completion strings.
     var prefix = _concatArgs(args, args.length - 1);
     var completions =
         commands.map((command) => '${prefix}${command.name} ').toList();
     if (matchLen == args.length) {
       // If we are showing all possiblities, also include local
       // completions for the parent command.
-      return commands[0]._parent._buildCompletions(args, false)
-        .then((localCompletions) {
-          completions.addAll(localCompletions);
-          return completions;
-        });
+      return commands[0]
+          ._parent
+          ._buildCompletions(args, false)
+          .then((localCompletions) {
+        completions.addAll(localCompletions);
+        return completions;
+      });
     }
     return new Future.value(completions);
   }
 
   // Runs a command.
   Future runCommand(String line) {
     _historyAdvance(line);
     var args = _splitLine(line);
-    var commands =  _match(args, true);
+    var commands = _match(args, true);
     if (commands.isEmpty) {
       // TODO(turnidge): Add a proper exception class for this.
       return new Future.error('No such command');
     } else if (commands.length == 1) {
       return commands[0].run(args.sublist(commands[0]._depth));
     } else {
       // TODO(turnidge): Add a proper exception class for this.
       return new Future.error('Ambiguous command');
     }
   }
@@ skipping 59 matching lines @@
     if (_parent is RootCommand) {
       return name;
     } else {
       Command parent = _parent;
       return '${parent.fullName} $name';
     }
   }
 
   toString() => 'Command(${name})';
 }