feat: watchers & exec

Author: Jan Krems

lib/internal/inspect-repl.js

@@ -95,6 +95,90 @@ function convertResultToError(result) {
   return err;
 }
 
+class RemoteObject {
+  constructor(attributes) {
+    Object.assign(this, attributes);
+    if (this.type === 'number') {
+      this.value = this.unserializableValue ? +this.unserializableValue : +this.value;
+    }
+  }
+
+  [util.inspect.custom](depth, opts) {
+    function formatProperty(prop) {
+      switch (prop.type) {
+        case 'string':
+        case 'undefined':
+          return util.inspect(prop.value, opts);
+
+        case 'number':
+        case 'boolean':
+          return opts.stylize(prop.value, prop.type);
+
+        case 'object':
+        case 'symbol':
+          if (prop.subtype === 'date') {
+            return util.inspect(new Date(prop.value), opts);
+          }
+          if (prop.subtype === 'array') {
+            return opts.stylize(prop.value, 'special');
+          }
+          return opts.stylize(prop.value, prop.subtype || 'special');
+
+        default:
+          return prop.value;
+      }
+    }
+    switch (this.type) {
+      case 'boolean':
+      case 'number':
+      case 'string':
+      case 'undefined':
+        return util.inspect(this.value, opts);
+
+      case 'symbol':
+        return opts.stylize(this.description, 'special');
+
+      case 'object':
+        switch (this.subtype) {
+          case 'date':
+            return util.inspect(new Date(this.description), opts);
+
+          case 'null':
+            return util.inspect(null, opts);
+
+          case 'regexp':
+            return opts.stylize(this.description, 'regexp');
+
+          default:
+            break;
+        }
+        if (this.preview) {
+          const props = this.preview.properties
+            .map((prop, idx) => {
+              const value = formatProperty(prop);
+              if (prop.name === `${idx}`) return value;
+              return `${prop.name}: ${value}`;
+            });
+          if (this.preview.overflow) {
+            props.push('...');
+          }
+          const singleLine = props.join(', ');
+          const propString = singleLine.length > 60 ? props.join(',\n  ') : singleLine;
+          return this.subtype === 'array' ? `[ ${propString} ]` : `{ ${propString} }`;
+        }
+        return this.description;
+
+      default:
+        return this.description;
+    }
+  }
+}
+
+function convertResultToRemoteObject({ result, wasThrown }) {
+  if (wasThrown) return convertResultToError(result);
+  return new RemoteObject(result);
+}
+
 function copyOwnProperties(target, source) {
   Object.getOwnPropertyNames(source).forEach((prop) => {
     Object.defineProperty(target, prop, Object.getOwnPropertyDescriptor(source, prop));
@@ -122,6 +206,11 @@ function createRepl(inspector) {
 
   const print = inspector.print.bind(inspector);
 
+  const INSPECT_OPTIONS = { colors: inspector.stdout.isTTY };
+  function inspect(value) {
+    return util.inspect(value, INSPECT_OPTIONS);
+  }
+
   function isCurrentScript(script) {
     return selectedFrame && selectedFrame.location.scriptId === script.scriptId;
   }
@@ -199,8 +288,49 @@ function createRepl(inspector) {
     }
   }
 
-  function watchers() {
-    return Promise.resolve(watchedExpressions);
+  function debugEval(code) {
+    // Repl asked for scope variables
+    if (code === '.scope') {
+      return Promise.reject('client.reqScopes not implemented');
+    }
+
+    const params = {
+      callFrameId: selectedFrame.callFrameId,
+      expression: code,
+      objectGroup: 'node-inspect',
+      generatePreview: true,
+    };
+
+    return Debugger.evaluateOnCallFrame(params)
+        .then(convertResultToRemoteObject);
+  }
+
+  function watchers(verbose = false) {
+    if (!watchedExpressions.length) {
+      return Promise.resolve();
+    }
+
+    const inspectValue = expr =>
+      debugEval(expr)
+        // .then(formatValue)
+        .catch(error => `<${error.message}>`);
+
+    return Promise.all(watchedExpressions.map(inspectValue))
+      .then(values => {
+        if (verbose) print('Watchers:');
+
+        watchedExpressions.forEach((expr, idx) => {
+          const prefix = `${leftPad(idx, ' ', watchedExpressions.length - 1)}: ${expr} =`;
+          const value = inspect(values[idx], { colors: true });
+          if (value.indexOf('\n') === -1) {
+            print(`${prefix} ${value}`);
+          } else {
+            print(`${prefix}\n    ${value.split('\n').join('\n    ')}`);
+          }
+        });
+
+        if (verbose) print('');
+      });
   }
 
   // List source code
@@ -414,6 +544,27 @@ function createRepl(inspector) {
         return listBreakpoints();
       },
 
+      exec(expr) {
+        return debugEval(expr);
+      },
+
+      get watchers() {
+        return watchers();
+      },
+
+      watch(expr) {
+        watchedExpressions.push(expr);
+      },
+
+      unwatch(expr) {
+        const index = watchedExpressions.indexOf(expr);
+
+        // Unwatch by expression
+        // or
+        // Unwatch by watcher number
+        watchedExpressions.splice(index !== -1 ? index : +expr, 1);
+      },
+
       scripts: listScripts,
       setBreakpoint,
       list,

test/cli/watchers.test.js

@@ -0,0 +1,40 @@
+'use strict';
+const { test } = require('tap');
+
+const startCLI = require('./start-cli');
+
+test('stepping through breakpoints', (t) => {
+  const cli = startCLI(['examples/break.js']);
+
+  function onFatal(error) {
+    cli.quit();
+    throw error;
+  }
+
+  return cli.waitFor(/break/)
+    .then(() => cli.waitForPrompt())
+    .then(() => cli.command('watch("x")'))
+    .then(() => cli.command('watch("\\"Hello\\"")'))
+    .then(() => cli.command('watch("42")'))
+    .then(() => cli.command('watch("NaN")'))
+    .then(() => cli.command('watch("true")'))
+    .then(() => cli.command('watch("[1, 2]")'))
+    .then(() => cli.command('watch("process.env")'))
+    .then(() => cli.command('watchers'))
+    .then(() => {
+      t.match(cli.output, 'x is not defined');
+    })
+    .then(() => cli.command('unwatch("42")'))
+    .then(() => cli.stepCommand('n'))
+    .then(() => {
+      t.match(cli.output, '0: x = 10');
+      t.match(cli.output, '1: "Hello" = \'Hello\'');
+      t.match(cli.output, '2: NaN = NaN');
+      t.match(cli.output, '3: true = true');
+      t.match(cli.output, '4: [1, 2] = [ 1, 2 ]');
+      t.match(cli.output, /5: process\.env =\n\s+\{[\s\S]+,\n\s+\.\.\. \}/,
+        'shows "..." for process.env');
+    })
+    .then(() => cli.quit())
+    .then(null, onFatal);
+});