Refactor the set command in Observatory debugger.

runtime/observatory/lib/src/elements/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_page_element;
 
 import 'dart:async';
 import 'dart:html';
 import 'observatory_element.dart';
+import 'package:observatory/app.dart';
 import 'package:observatory/cli.dart';
 import 'package:observatory/debugger.dart';
 import 'package:observatory/service.dart';
 import 'package:logging/logging.dart';
 import 'package:polymer/polymer.dart';
 
 // TODO(turnidge): Move Debugger, DebuggerCommand to debugger library.
 abstract class DebuggerCommand extends Command {
   ObservatoryDebugger debugger;
 
@@ skipping 163 matching lines @@
       count = int.parse(args[0]);
     } else if (args.length > 1) {
       debugger.console.print('down expects 0 or 1 argument');
       return new Future.value(null);
     }
     if (debugger.currentFrame == null) {
       debugger.console.print('No stack');
       return new Future.value(null);
     }
     try {
-      debugger.currentFrame += count;
+      debugger.downFrame(count);
       debugger.console.print('frame = ${debugger.currentFrame}');
     } catch (e) {
       debugger.console.print('frame must be in range [${e.start},${e.end-1}]');
     }
     return new Future.value(null);
   }
 
   String helpShort = 'Move down one or more frames (hotkey: [Page Down])';
 
   String helpLong =
@@ skipping 14 matching lines @@
       count = int.parse(args[0]);
     } else if (args.length > 1) {
       debugger.console.print('up expects 0 or 1 argument');
       return new Future.value(null);
     }
     if (debugger.currentFrame == null) {
       debugger.console.print('No stack');
       return new Future.value(null);
     }
     try {
-      debugger.currentFrame -= count;
+      debugger.upFrame(count);
       debugger.console.print('frame = ${debugger.currentFrame}');
     } on RangeError catch (e) {
       debugger.console.print('frame must be in range [${e.start},${e.end-1}]');
     }
     return new Future.value(null);
   }
 
   String helpShort = 'Move up one or more frames (hotkey: [Page Up])';
 
   String helpLong =
@@ skipping 250 matching lines @@
   String helpLong =
       'Continue running the isolate until the current function exits.\n'
       '\n'
       'Syntax: finish\n';
 }
 
 class SetCommand extends DebuggerCommand {
   SetCommand(Debugger debugger)
       : super(debugger, 'set', []);
 
+  static var _boeValues = ['all', 'none', 'unhandled'];
+  static var _boolValues = ['false', 'true'];
+
+  static var _options = {
+    'break-on-exception': [_boeValues,
+                           _setBreakOnException,
+                           (debugger, _) => debugger.breakOnException],
+    'up-is-down': [_boolValues,
+                   _setUpIsDown,
+                   (debugger, _) => debugger.upIsDown],
+  };
+
+  static Future _setBreakOnException(debugger, name, value) async {
+    var result = await debugger.isolate.setExceptionPauseInfo(value);
+    if (result.isError) {
+      debugger.console.print(result.toString());
+    } else {
+      // Printing will occur elsewhere.
+      debugger.breakOnException = value;
+    }
+  }
+
+  static Future _setUpIsDown(debugger, name, value) async {
+    if (value == 'true') {
+      debugger.upIsDown = true;
+    } else {
+      debugger.upIsDown = false;
+    }
+    debugger.console.print('${name} = ${value}');
+  }
+
   Future run(List<String> args) async {
+    if (args.length == 0) {
+      for (var name in _options.keys) {
+        var getHandler = _options[name][2];
+        var value = await getHandler(debugger, name);
+        debugger.console.print("${name} = ${value}");
+      }
+    } else if (args.length == 1) {
+      var name = args[0].trim();
+      var optionInfo = _options[name];
+      if (optionInfo == null) {
+        debugger.console.print("unrecognized option: $name");
+        return;
+      } else {
+        var getHandler = optionInfo[2];
+        var value = await getHandler(debugger, name);
+        debugger.console.print("${name} = ${value}");
+      }
+    } else if (args.length == 2) {
+      var name = args[0].trim();
+      var value = args[1].trim();
+      var optionInfo = _options[name];
+      if (optionInfo == null) {
+        debugger.console.print("unrecognized option: $name");
+        return;
+      }
+      var validValues = optionInfo[0];
+      if (!validValues.contains(value)) {
+        debugger.console.print("'${value}' is not in ${validValues}");
+        return;
+      }
+      var setHandler = optionInfo[1];
+      await setHandler(debugger, name, value);
+    } else {
+      debugger.console.print("set expects 0, 1, or 2 arguments");
+    }
+  }
+
+  Future<List<String>> complete(List<String> args) {
+    if (args.length < 1 || args.length > 2) {
+      return new Future.value([args.join('')]);
+    }
+    var result = [];
+    if (args.length == 1) {
+      var prefix = args[0];
+      for (var option in _options.keys) {
+        if (option.startsWith(prefix)) {
+          result.add('${option} ');
+        }
+      }
+    }
     if (args.length == 2) {
-      var option = args[0].trim();
-      if (option == 'break-on-exceptions') {
-        var result = await debugger.isolate.setExceptionPauseInfo(args[1]);
-        if (result.isError) {
-          debugger.console.print(result.toString());
+      var name = args[0].trim();
+      var prefix = args[1];
+      var optionInfo = _options[name];
+      if (optionInfo != null) {
+        var validValues = optionInfo[0];
+        for (var value in validValues) {
+          if (value.startsWith(prefix)) {
+            result.add('${args[0]}${value} ');
+          }
         }
-      } else {
-        debugger.console.print("unknown option '$option'");
       }
-    } else {
-      debugger.console.print("set expects 2 arguments");
     }
+    return new Future.value(result);
   }
 
   String helpShort =
       'Set a debugger option';
 
   String helpLong =
-      'Set a debugger option'
+      'Set a debugger option.\n'
       '\n'
-      'Syntax: set break-on-exceptions "all" | "none" | "unhandled"\n';
+      'Known options:\n'
+      '  break-on-exceptions   # Should the debugger break on exceptions?\n'
+      "                        # {'all', 'none', 'unhandled'}\n"

[Cutch, 2015/08/07 19:55:10]

can you do string interpolation here and below?

e.g.:

# ${_boeValues}

[turnidge, 2015/08/07 20:16:42]

Done.

+      '  up-is-down            # Reverse meaning of up/down commands?\n'
+      "                        # {'false', 'true''}\n"
+      '\n'
+      'Syntax: set                    # Display all option settings\n'
+      '        set <option>           # Get current value for option\n'
+      '        set <option> <value>   # Set value for option';
 }
 
 class BreakCommand extends DebuggerCommand {
   BreakCommand(Debugger debugger) : super(debugger, 'break', []);
 
   Future run(List<String> args) async {
     if (args.length > 1) {
       debugger.console.print('not implemented');
       return new Future.value(null);
     }
@@ skipping 515 matching lines @@
     }
   }
 
   String _format(String isolateName, String streamName, String line) {
     return '${isolateName}:${streamName}> ${line}';
   }
 }
 
 // Tracks the state for an isolate debugging session.
 class ObservatoryDebugger extends Debugger {
+  SettingsGroup settings = new SettingsGroup('debugger');

[Cutch, 2015/08/07 19:55:10]

nit: add final

[turnidge, 2015/08/07 20:16:42]

Done.

   RootCommand cmd;
   DebuggerPageElement page;
   DebuggerConsoleElement console;
   DebuggerInputElement input;
   DebuggerStackElement stackElement;
   ServiceMap stack;
-  String exceptions = "none";  // Last known setting.
+  String breakOnException = "none";  // Last known setting.
 
   int get currentFrame => _currentFrame;
+
   void set currentFrame(int value) {
     if (value != null && (value < 0 || value >= stackDepth)) {
       throw new RangeError.range(value, 0, stackDepth);
     }
     _currentFrame = value;
     if (stackElement != null) {
       stackElement.setCurrentFrame(value);
     }
   }
   int _currentFrame = null;
 
+  bool get upIsDown => _upIsDown;
+  void set upIsDown(bool value) {
+    settings.set('up-is-down', value);
+    _upIsDown = value;
+  }
+  bool _upIsDown;
+
+  void upFrame(int count) {
+    if (_upIsDown) {
+      currentFrame += count;
+    } else {
+      currentFrame -= count;
+    }
+  }
+
+  void downFrame(int count) {
+    if (_upIsDown) {
+      currentFrame -= count;
+    } else {
+      currentFrame += count;
+    }
+  }
+
   int get stackDepth => stack['frames'].length;
 
   ObservatoryDebugger() {
+    _upIsDown = settings.get('up-is-down');

[Cutch, 2015/08/07 19:55:10]

maybe factor this into a helper:

_loadSettings();

_loadSettings() {
  _upIsDown = settings.get('up-is-down');
}

[turnidge, 2015/08/07 20:16:42]

Done.

     cmd = new RootCommand([
         new HelpCommand(this),
         new PrintCommand(this),
         new DownCommand(this),
         new UpCommand(this),
         new FrameCommand(this),
         new PauseCommand(this),
         new ContinueCommand(this),
         new NextCommand(this),
         new StepCommand(this),
@@ skipping 10 matching lines @@
         new ClsCommand(this),
     ]);
     _consolePrinter = new _ConsoleStreamPrinter(this);
   }
 
   VM get vm => page.app.vm;
 
   void updateIsolate(Isolate iso) {
     _isolate = iso;
     if (_isolate != null) {
-      if ((exceptions != iso.exceptionsPauseInfo) &&
+      if ((breakOnException != iso.exceptionsPauseInfo) &&
           (iso.exceptionsPauseInfo != null)) {
-        exceptions = iso.exceptionsPauseInfo;
-        console.print("Now pausing for $exceptions exceptions");
+        breakOnException = iso.exceptionsPauseInfo;
+        console.print("Now pausing for exceptions: $breakOnException");
       }
 
       _isolate.reload().then((response) {
         // TODO(turnidge): Currently the debugger relies on all libs
         // being loaded.  Fix this.
         var pending = [];
         for (var lib in _isolate.libraries) {
           if (!lib.loaded) {
             pending.add(lib.load());
           }
@@ skipping 174 matching lines @@
           if (iso == isolate) {
             console.print("The current isolate has exited");
           } else {
             console.print(
                 "Isolate ${iso.number} '${iso.name}' has exited");
           }
         }
         break;
 
       case ServiceEvent.kDebuggerSettingsUpdate:
-        if (exceptions != event.exceptions) {
-          exceptions = event.exceptions;
-          console.print("Now pausing for $exceptions exceptions");
+        if (breakOnException != event.exceptions) {
+          breakOnException = event.exceptions;

[Cutch, 2015/08/07 19:55:10]

Should this update the setting?

[turnidge, 2015/08/07 20:16:42]

Discussed offline -- this is all we need to do, but maybe this should become
some sort of per-isolate setting.

+          console.print("Now pausing for exceptions: $breakOnException");
         }
         break;
 
       case ServiceEvent.kIsolateUpdate:
         var iso = event.owner;
         console.print("Isolate ${iso.number} renamed to '${iso.name}'");
         break;
 
       case ServiceEvent.kPauseStart:
       case ServiceEvent.kPauseExit:
@@ skipping 787 matching lines @@
 
           case KeyCode.DOWN:
             e.preventDefault();
             text = debugger.historyNext(text);
             busy = false;
             break;
 
           case KeyCode.PAGE_UP:
             e.preventDefault();
             try {
-              debugger.currentFrame -= 1;
+              debugger.upFrame(1);
             } on RangeError catch (e) {
               // Ignore.
             }
             busy = false;
             break;
 
           case KeyCode.PAGE_DOWN:
             e.preventDefault();
             try {
-              debugger.currentFrame += 1;
+              debugger.downFrame(1);
             } on RangeError catch (e) {
               // Ignore.
             }
             busy = false;
             break;
 
           case KeyCode.F7:
             e.preventDefault();
             debugger.resume().whenComplete(() {
               busy = false;
@@ skipping 39 matching lines @@
         }
       });
   }
 
   void focus() {
     $['textBox'].focus();
   }
 
   DebuggerInputElement.created() : super.created();
 }