repl: replace ... with | and navigate multiline history with up / down

Author: puskin

lib/internal/readline/interface.js

@@ -24,9 +24,11 @@ const {
   SafeStringIterator,
   StringPrototypeCodePointAt,
   StringPrototypeEndsWith,
+  StringPrototypeIndexOf,
   StringPrototypeRepeat,
   StringPrototypeReplaceAll,
   StringPrototypeSlice,
+  StringPrototypeSplit,
   StringPrototypeStartsWith,
   StringPrototypeTrim,
   Symbol,
@@ -100,7 +102,9 @@ const kDeleteWordLeft = Symbol('_deleteWordLeft');
 const kDeleteWordRight = Symbol('_deleteWordRight');
 const kGetDisplayPos = Symbol('_getDisplayPos');
 const kHistoryNext = Symbol('_historyNext');
+const kMoveDownOrHistoryNext = Symbol('_moveDownOrHistoryNext');
 const kHistoryPrev = Symbol('_historyPrev');
+const kMoveUpOrHistoryPrev = Symbol('_moveUpOrHistoryPrev');
 const kInsertString = Symbol('_insertString');
 const kLine = Symbol('_line');
 const kLine_buffer = Symbol('_line_buffer');
@@ -929,6 +933,26 @@ class Interface extends InterfaceConstructor {
     this[kRefreshLine]();
   }
 
+  [kMoveDownOrHistoryNext]() {
+    const { cols, rows } = this.getCursorPos();
+    const splitLine = StringPrototypeSplit(this.line, '\n');
+    // Go to the next history only if the cursor is in the first line of the multiline input.
+    // Otherwise treat the "arrow down" as a movement to the next row.
+    if (splitLine.length > 1 && rows < splitLine.length - 1) {
+      const currentLine = splitLine[rows];
+      const nextLine = splitLine[rows + 1];
+      const amountToMove = (cols > nextLine.length) ?
+        +cols + nextLine.length - 1 :
+        +currentLine.length + 1;
+      // Go to the same position on the next line, or the end of the next line
+      // If the current position does not exist in the next line.
+      this[kMoveCursor](amountToMove);
+      return;
+    }
+
+    this[kHistoryNext]();
+  }
+
   // TODO(BridgeAR): Add underscores to the search part and a red background in
   // case no match is found. This should only be the visual part and not the
   // actual line content!
@@ -939,7 +963,9 @@ class Interface extends InterfaceConstructor {
   [kHistoryNext]() {
     if (this.historyIndex >= 0) {
       this[kBeforeEdit](this.line, this.cursor);
-      const search = this[kSubstringSearch] || '';
+      const isLineMultiline = StringPrototypeIndexOf(this.line, '\n') !== -1;
+
+      const search = isLineMultiline ? '' : this[kSubstringSearch] || '';
       let index = this.historyIndex - 1;
       while (
         index >= 0 &&
@@ -959,10 +985,31 @@ class Interface extends InterfaceConstructor {
     }
   }
 
+  [kMoveUpOrHistoryPrev]() {
+    const { cols, rows } = this.getCursorPos();
+    const splitLine = StringPrototypeSplit(this.line, '\n');
+    // Go to the previous history only if the cursor is in the first line of the multiline input.
+    // Otherwise treat the "arrow up" as a movement to the previous row.
+    if (splitLine.length > 1 && rows > 0) {
+      const previousLine = splitLine[rows - 1];
+      const amountToMove = (cols > previousLine.length) ?
+        -cols - 1 :
+        -previousLine.length - 1;
+      // Go to the same position on the previous line, or the end of the previous line
+      // If the current position does not exist in the previous line.
+      this[kMoveCursor](amountToMove);
+      return;
+    }
+
+    this[kHistoryPrev]();
+  }
+
   [kHistoryPrev]() {
     if (this.historyIndex < this.history.length && this.history.length) {
       this[kBeforeEdit](this.line, this.cursor);
-      const search = this[kSubstringSearch] || '';
+      const isLineMultiline = StringPrototypeIndexOf(this.line, '\n') !== -1;
+
+      const search = isLineMultiline ? '' : this[kSubstringSearch] || '';
       let index = this.historyIndex + 1;
       while (
         index < this.history.length &&
@@ -1309,11 +1356,11 @@ class Interface extends InterfaceConstructor {
           break;
 
         case 'up':
-          this[kHistoryPrev]();
+          this[kMoveUpOrHistoryPrev]();
           break;
 
         case 'down':
-          this[kHistoryNext]();
+          this[kMoveDownOrHistoryNext]();
           break;
 
         case 'tab':

lib/repl.js

@@ -1207,7 +1207,7 @@ REPLServer.prototype.resetContext = function() {
 REPLServer.prototype.displayPrompt = function(preserveCursor) {
   let prompt = this._initialPrompt;
   if (this[kBufferedCommandSymbol].length) {
-    prompt = '...';
+    prompt = '|';
     const len = this.lines.level.length ? this.lines.level.length - 1 : 0;
     const levelInd = StringPrototypeRepeat('..', len);
     prompt += levelInd + ' ';

test/parallel/test-repl-history-navigation.js

@@ -655,7 +655,7 @@ const tests = [
       prompt, ...'let a = ``',
       'undefined\n',
       prompt, ...'a = `I am a multiline strong',
-      '... ',
+      '| ',
       ...'which ends here`',
       "'I am a multiline strong\\nwhich ends here'\n",
       prompt,
@@ -669,6 +669,57 @@ const tests = [
     ],
     clean: true
   },
+  {
+    // Test that the previous multiline history can only be accessed going through the entirety of the current
+    // One navigating its all lines first.
+    env: { NODE_REPL_HISTORY: defaultHistoryPath },
+    skip: !process.features.inspector,
+    test: [
+      'let b = ``',
+      ENTER,
+      'b = `I am a multiline strong',
+      ENTER,
+      'which ends here`',
+      ENTER,
+      'let c = `I',
+      ENTER,
+      'am another one`',
+      ENTER,
+      UP,
+      UP,
+      UP,
+      UP,
+      // press RIGHT 10 times to reach the typo
+      ...Array(10).fill(RIGHT),
+      BACKSPACE,
+      'i',
+      ENTER,
+    ],
+    expected: [
+      prompt, ...'let b = ``',
+      'undefined\n',
+      prompt, ...'b = `I am a multiline strong',
+      '| ',
+      ...'which ends here`',
+      "'I am a multiline strong\\nwhich ends here'\n",
+      prompt, ...'let c = `I',
+      '| ',
+      ...'am another one`',
+      'undefined\n',
+      prompt,
+      `${prompt}let c = \`I\nam another one\``,
+      `${prompt}let c = \`I\nam another one\``,
+
+      `${prompt}b = \`I am a multiline strong\nwhich ends here\``,
+      `${prompt}b = \`I am a multiline strong\nwhich ends here\``,
+      `${prompt}b = \`I am a multiline strng\nwhich ends here\``,
+      `${prompt}b = \`I am a multiline string\nwhich ends here\``,
+      `${prompt}b = \`I am a multiline string\nwhich ends here\``,
+      "'I am a multiline string\\nwhich ends here'\n",
+      prompt,
+    ],
+    clean: true
+  },
 ];
 const numtests = tests.length;
 

test/parallel/test-repl-load-multiline-from-history.js

@@ -63,13 +63,19 @@ ActionStream.prototype.readable = true;
     ']'
     );
 
-    r.input.run([{ name: 'up' }]);
+    for (let i = 0; i < r.line.split('\n').length; i++) {
+      r.input.run([{ name: 'up' }]);
+    }
     assert.strictEqual(r.line, 'const c = [\n  {\n    a: 1,\n    b: 2,\n  }\n]');
 
-    r.input.run([{ name: 'up' }]);
+    for (let i = 0; i < r.line.split('\n').length; i++) {
+      r.input.run([{ name: 'up' }]);
+    }
     assert.strictEqual(r.line, '`const b = [\n  1,\n  2,\n  3,\n  4,\n]`');
 
-    r.input.run([{ name: 'up' }]);
+    for (let i = 0; i < r.line.split('\n').length; i++) {
+      r.input.run([{ name: 'up' }]);
+    }
     assert.strictEqual(r.line, 'a = `\nI am a multiline string\nI can be as long as I want`');
 
   });

test/parallel/test-repl-multiline.js

@@ -26,7 +26,7 @@ function run({ useColors }) {
     // Validate the output, which contains terminal escape codes.
     assert.strictEqual(actual.length, 6);
     assert.ok(actual[0].endsWith(input[0]));
-    assert.ok(actual[1].includes('... '));
+    assert.ok(actual[1].includes('| '));
     assert.ok(actual[1].endsWith(input[1]));
     assert.ok(actual[2].includes('undefined'));
     assert.ok(actual[3].endsWith(input[2]));

test/parallel/test-repl-recoverable.js

@@ -18,7 +18,7 @@ function customEval(code, context, file, cb) {
 const putIn = new ArrayStream();
 
 putIn.write = function(msg) {
-  if (msg === '... ') {
+  if (msg === '| ') {
     recovered = true;
   }
 

test/parallel/test-repl-top-level-await.js

@@ -96,7 +96,7 @@ async function ordinaryTests() {
     ['const m = foo(await koo());'],
     ['m', '4'],
     ['const n = foo(await\nkoo());',
-     ['const n = foo(await\r', '... koo());\r', 'undefined']],
+     ['const n = foo(await\r', '| koo());\r', 'undefined']],
     ['n', '4'],
     // eslint-disable-next-line no-template-curly-in-string
     ['`status: ${(await Promise.resolve({ status: 200 })).status}`',
@@ -145,29 +145,29 @@ async function ordinaryTests() {
     ],
     ['for (const x of [1,2,3]) {\nawait x\n}', [
       'for (const x of [1,2,3]) {\r',
-      '... await x\r',
-      '... }\r',
+      '| await x\r',
+      '| }\r',
       'undefined',
     ]],
     ['for (const x of [1,2,3]) {\nawait x;\n}', [
       'for (const x of [1,2,3]) {\r',
-      '... await x;\r',
-      '... }\r',
+      '| await x;\r',
+      '| }\r',
       'undefined',
     ]],
     ['for await (const x of [1,2,3]) {\nconsole.log(x)\n}', [
       'for await (const x of [1,2,3]) {\r',
-      '... console.log(x)\r',
-      '... }\r',
+      '| console.log(x)\r',
+      '| }\r',
       '1',
       '2',
       '3',
       'undefined',
     ]],
     ['for await (const x of [1,2,3]) {\nconsole.log(x);\n}', [
       'for await (const x of [1,2,3]) {\r',
-      '... console.log(x);\r',
-      '... }\r',
+      '| console.log(x);\r',
+      '| }\r',
       '1',
       '2',
       '3',
@@ -192,7 +192,7 @@ async function ordinaryTests() {
     } else if ('line' in options) {
       assert.strictEqual(lines[toBeRun.length + options.line], expected);
     } else {
-      const echoed = toBeRun.map((a, i) => `${i > 0 ? '... ' : ''}${a}\r`);
+      const echoed = toBeRun.map((a, i) => `${i > 0 ? '| ' : ''}${a}\r`);
       assert.deepStrictEqual(lines, [...echoed, expected, PROMPT]);
     }
   }

test/parallel/test-repl-unexpected-token-recoverable.js

@@ -12,7 +12,7 @@ const child = spawn(process.execPath, args);
 
 const input = 'const foo = "bar\\\nbaz"';
 // Match '...' as well since it marks a multi-line statement
-const expectOut = /> \.\.\. undefined\n/;
+const expectOut = /> \| undefined\n/;
 
 child.stderr.setEncoding('utf8');
 child.stderr.on('data', (d) => {