ddbg_service changes.

tools/ddbg_service/lib/debugger.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 debugger;
 
 import "dart:async";
 import "dart:io";
 
 import "package:ddbg/commando.dart";
 import "package:observatory/service_io.dart";
 
 class Debugger {
   Commando cmdo;
   var _cmdoSubscription;
 
+  CommandList _commands;
+
   VM _vm;
   VM get vm => _vm;
   set vm(VM vm) {
     if (_vm == vm) {
       // Do nothing.
       return;
     }
     if (_vm != null) {
       _vm.disconnect();
     }
@@ skipping 57 matching lines @@
         error is ServiceError) {
       // These are handled elsewhere.  Ignore.
       return;
     }
     cmdo.print('\n--------\nExiting due to unexpected error:\n'
                 '  $error\n$trace\n');
     quit();
   }
 
   Debugger() {
-    cmdo = new Commando(completer: completeCommand);
+    cmdo = new Commando(completer: _completeCommand);
     _cmdoSubscription = cmdo.commands.listen(_processCommand,
                                              onError: _cmdoError,
                                              onDone: _cmdoDone);
+    _commands = new CommandList();
+    _commands.register(new AttachCommand());
+    _commands.register(new DetachCommand());
+    _commands.register(new HelpCommand(_commands));
+    _commands.register(new IsolateCommand());
+    _commands.register(new QuitCommand());

[turnidge, 2014/09/17 16:06:24]

CommandList is now an object and owned by the Debugger.

   }
 
   Future _closeCmdo() {
     var sub = _cmdoSubscription;
     _cmdoSubscription = null;
     cmdo = null;
 
     var future = sub.cancel();
     if (future != null) {
       return future;
     } else {
       return new Future.value();
     }
   }
 
   Future quit() {
     return Future.wait([_closeCmdo()]).then((_) {
         exit(0);
       });
   }
 
-  void _cmdoError(self, parent, zone, error, StackTrace trace) {
+  void _cmdoError(error, StackTrace trace) {
     cmdo.print('\n--------\nExiting due to unexpected error:\n'
                '  $error\n$trace\n');
     quit();
   }
 
   void _cmdoDone() {
     quit();
   }
 
+  List<String> _completeCommand(List<String> commandParts) {
+    return _commands.complete(commandParts);
+  }
+
   void _processCommand(String cmdLine) {
     void huh() {
       cmdo.print("'$cmdLine' not understood, try 'help' for help.");
     }
 
     cmdo.hide();
     cmdLine = cmdLine.trim();
     var args = cmdLine.split(' ');
     if (args.length == 0) {
       return;
     }
     var command = args[0];
-    var matches = matchCommand(command, true);
+    var matches  = _commands.match(command, true);
     if (matches.length == 0) {
       huh();
       cmdo.show();
     } else if (matches.length == 1) {
       matches[0].run(this, args).then((_) {
           cmdo.show();
         });
     } else {
       var matchNames = matches.map((handler) => handler.name);
       cmdo.print("Ambigous command '$command' : ${matchNames.toList()}");
       cmdo.show();
     }
   }
 
 }
 
 // Every debugger command extends this base class.
 abstract class Command {
   String get name;
   String get helpShort;
   void printHelp(Debugger debugger, List<String> args);
   Future run(Debugger debugger, List<String> args);
+  List<String> complete(List<String> commandParts) {
+    return ["$name ${commandParts.join(' ')}"];

[turnidge, 2014/09/17 16:06:24]

Commands can now implement command-specific completers.

[Cutch, 2014/09/17 20:07:26]

Nice!

+
+  }
 }
 
 class AttachCommand extends Command {
   final name = 'attach';
   final helpShort = 'Attach to a running Dart VM';
   void printHelp(Debugger debugger, List<String> args) {
     debugger.cmdo.print('''
 ----- attach -----
 
 Attach to the Dart VM running at the indicated host:port. If no
@@ skipping 22 matching lines @@
           for (var isolate in vm.isolates) {
             if (isolate.name == 'root') {
               debugger.isolate = isolate;
             }
           }
         }
       });
   }
 }
 
-class DetachCommand extends Command {
-  final name = 'detach';
-  final helpShort = 'Detach from a running Dart VM';
-  void printHelp(Debugger debugger, List<String> args) {
-    cmdo.print('''
------ detach -----
+class CommandList {
+  List _commands = new List<Command>();
 
-Detach from the Dart VM.
-
-Usage:
-  detach
-''');
+  void register(Command cmd) {
+    _commands.add(cmd);
   }
 
-  Future run(Debugger debugger, List<String> args) {
-    var cmdo = debugger.cmdo;
-    if (args.length > 1) {
-      cmdo.print('$name expects no arguments');
-      return new Future.value();
+  List<Command> match(String commandName, bool exactMatchWins) {
+    var matches = [];
+    for (var command in _commands) {
+      if (command.name.startsWith(commandName)) {
+        if (exactMatchWins && command.name == commandName) {
+          // Exact match
+          return [command];
+        } else {
+          matches.add(command);
+        }
+      }
     }
-    if (debugger.vm == null) {
-      cmdo.print('No VM is attached');
-    } else {
-      debugger.vm = null;
-    }
-    return new Future.value();
-  }
-}
-
-class HelpCommand extends Command {
-  final name = 'help';
-  final helpShort = 'Show a list of debugger commands';
-  void printHelp(Debugger debugger, List<String> args) {
-    debugger.cmdo.print('''
------ help -----
-
-Show a list of debugger commands or get more information about a
-particular command.
-
-Usage:
-  help
-  help <command>
-''');
+    return matches;
   }
 
-  Future run(Debugger debugger, List<String> args) {
+  List<String> complete(List<String> commandParts) {
+    var completions = new List<String>();
+    String prefix = commandParts[0];
+    for (var command in _commands) {
+      if (command.name.startsWith(prefix)) {
+        completions.addAll(command.complete(commandParts.sublist(1)));
+      }
+    }
+    return completions;
+  }
+
+  void printHelp(Debugger debugger, List<String> args) {
     var cmdo = debugger.cmdo;
     if (args.length <= 1) {
       cmdo.print("\nDebugger commands:\n");
-      for (var command in commandList) {
+      for (var command in _commands) {
         cmdo.print('  ${command.name.padRight(11)} ${command.helpShort}');
       }
       cmdo.print("For more information about a particular command, type:\n\n"
                   "  help <command>\n");
 
       cmdo.print("Commands may be abbreviated: e.g. type 'h' for 'help.\n");
     } else {
       var commandName = args[1];
-      var matches = matchCommand(commandName, true);
+      var matches =match(commandName, true);
       if (matches.length == 0) {
         cmdo.print("Command '$commandName' not recognized.  "
                     "Try 'help' for a list of commands.");
       } else {
         for (var command in matches) {
           command.printHelp(debugger, args);
         }
       }
     }
+  }
+}
 
+class DetachCommand extends Command {
+  final name = 'detach';
+  final helpShort = 'Detach from a running Dart VM';
+  void printHelp(Debugger debugger, List<String> args) {
+    cmdo.print('''
+----- detach -----
+
+Detach from the Dart VM.
+
+Usage:
+  detach
+''');
+  }
+
+  Future run(Debugger debugger, List<String> args) {
+    var cmdo = debugger.cmdo;
+    if (args.length > 1) {
+      cmdo.print('$name expects no arguments');
+      return new Future.value();
+    }
+    if (debugger.vm == null) {
+      cmdo.print('No VM is attached');
+    } else {
+      debugger.vm = null;
+    }
     return new Future.value();
   }
 }
 
 class IsolateCommand extends Command {
   final name = 'isolate';
   final helpShort = 'Isolate control';
   void printHelp(Debugger debugger, List<String> args) {
     debugger.cmdo.print('''
 ----- isolate -----
@@ skipping 83 matching lines @@
           } else if (isolate.loading) {
             // TODO(turnidge): This is weird in a command line debugger.
             sb.write('(not available)');
           }
           sb.write('\n');
         }
         cmdo.print(sb);
       });
     return new Future.value();
   }
+
+  List<String> complete(List<String> commandParts) {
+    if (commandParts.isEmpty) {
+      return ['$name ${commandParts.join(" ")}'];
+    } else {
+      var completions =  _commands.complete(commandParts);
+      return completions.map((completion) {
+          return '$name $completion';
+        });
+    }
+  }
 }
 
 class QuitCommand extends Command {
   final name = 'quit';
   final helpShort = 'Quit the debugger.';
   void printHelp(Debugger debugger, List<String> args) {
     debugger.cmdo.print('''
 ----- quit -----
 
 Quit the debugger.
 
 Usage:
   quit
 ''');
   }
 
   Future run(Debugger debugger, List<String> args) {
     var cmdo = debugger.cmdo;
     if (args.length > 1) {
       cmdo.print("Unexpected arguments to $name command.");
       return new Future.value();
     }
     return debugger.quit();
   }
 }
-
-List<Command> commandList =
-    [ new AttachCommand(),
-      new DetachCommand(),
-      new HelpCommand(),
-      new IsolateCommand(),
-      new QuitCommand() ];
-
-List<Command> matchCommand(String commandName, bool exactMatchWins) {
-  var matches = [];
-  for (var command in commandList) {
-    if (command.name.startsWith(commandName)) {
-      if (exactMatchWins && command.name == commandName) {
-        // Exact match
-        return [command];
-      } else {
-        matches.add(command);
-      }
-    }
-  }
-  return matches;
-}
-
-List<String> completeCommand(List<String> commandParts) {
-  var completions = new List<String>();
-  if (commandParts.length == 1) {
-    String prefix = commandParts[0];
-    for (var command in commandList) {
-      if (command.name.startsWith(prefix)) {
-        completions.add(command.name);
-      }
-    }
-  }
-  return completions;
-}