repl: add possibility to edit multiline commands while adding them

Author: puskin

lib/internal/readline/interface.js

@@ -100,7 +100,6 @@ const kMaxLengthOfKillRing = 32;
 
 // TODO(puskin94): make this configurable
 const kMultilinePrompt = Symbol('| ');
-const kLastCommandErrored = Symbol('_lastCommandErrored');
 
 const kAddHistory = Symbol('_addHistory');
 const kBeforeEdit = Symbol('_beforeEdit');
@@ -131,6 +130,8 @@ const kPrompt = Symbol('_prompt');
 const kPushToKillRing = Symbol('_pushToKillRing');
 const kPushToUndoStack = Symbol('_pushToUndoStack');
 const kQuestionCallback = Symbol('_questionCallback');
+const kReverseString = Symbol('_reverseString');
+const kLastCommandErrored = Symbol('_lastCommandErrored');
 const kQuestionReject = Symbol('_questionReject');
 const kRedo = Symbol('_redo');
 const kRedoStack = Symbol('_redoStack');
@@ -151,6 +152,12 @@ const kYank = Symbol('_yank');
 const kYanking = Symbol('_yanking');
 const kYankPop = Symbol('_yankPop');
 const kNormalizeHistoryLineEndings = Symbol('_normalizeHistoryLineEndings');
+const kSavePreviousState = Symbol('_savePreviousState');
+const kRestorePreviousState = Symbol('_restorePreviousState');
+const kPreviousLine = Symbol('_previousLine');
+const kPreviousCursor = Symbol('_previousCursor');
+const kPreviousPrevRows = Symbol('_previousPrevRows');
+const kAddNewLineOnTTY = Symbol('_addNewLineOnTTY');
 
 function InterfaceConstructor(input, output, completer, terminal) {
   this[kSawReturnAt] = 0;
@@ -430,7 +437,7 @@ class Interface extends InterfaceConstructor {
     }
   }
 
-  [kSetLine](line) {
+  [kSetLine](line = '') {
     this.line = line;
     this[kIsMultiline] = StringPrototypeIncludes(line, '\n');
   }
@@ -477,15 +484,26 @@ class Interface extends InterfaceConstructor {
     // Reversing the multilines is necessary when adding / editing and displaying them
     if (reverse) {
       // First reverse the lines for proper order, then convert separators
-      return ArrayPrototypeJoin(
-        ArrayPrototypeReverse(StringPrototypeSplit(line, from)),
-        to,
-      );
+      return this[kReverseString](line, from, to);
     }
     // For normal cases (saving to history or non-multiline entries)
     return StringPrototypeReplaceAll(line, from, to);
   }
 
+  [kReverseString](line, from, to) {
+    const parts = StringPrototypeSplit(line, from);
+
+    // This implementation should be faster than
+    // ArrayPrototypeJoin(ArrayPrototypeReverse(StringPrototypeSplit(line, from)), to);
+    let result = '';
+    for (let i = parts.length - 1; i > 0; i--) {
+      result += parts[i] + to;
+    }
+    result += parts[0];
+
+    return result;
+  }
+
   [kAddHistory]() {
     if (this.line.length === 0) return '';
 
@@ -494,22 +512,30 @@ class Interface extends InterfaceConstructor {
 
     // If the trimmed line is empty then return the line
     if (StringPrototypeTrim(this.line).length === 0) return this.line;
+
+    // This is necessary because each like would be saved in the history while creating
+    // A new multiline, and we don't want that.
+    if (this[kIsMultiline] && this.historyIndex === -1) {
+      ArrayPrototypeShift(this.history);
+    }
+    // If the last command errored and we are trying to edit the history to fix it
+    // Remove the broken one from the history
+    if (this[kLastCommandErrored] && this.history.length > 0) {
+      ArrayPrototypeShift(this.history);
+    }
+
     const normalizedLine = this[kNormalizeHistoryLineEndings](this.line, '\n', '\r', false);
 
     if (this.history.length === 0 || this.history[0] !== normalizedLine) {
-      if (this[kLastCommandErrored] && this.historyIndex === 0) {
-        // If the last command errored, remove it from history.
-        // The user is issuing a new command starting from the errored command,
-        // Hopefully with the fix
-        ArrayPrototypeShift(this.history);
-      }
       if (this.removeHistoryDuplicates) {
         // Remove older history line if identical to new one
         const dupIndex = ArrayPrototypeIndexOf(this.history, this.line);
         if (dupIndex !== -1) ArrayPrototypeSplice(this.history, dupIndex, 1);
       }
 
-      ArrayPrototypeUnshift(this.history, this.line);
+      ArrayPrototypeUnshift(this.history, this[kIsMultiline] ?
+        this[kReverseString](normalizedLine, '\r', '\r') :
+        normalizedLine);
 
       // Only store so many
       if (this.history.length > this.historySize)
@@ -521,7 +547,7 @@ class Interface extends InterfaceConstructor {
     // The listener could change the history object, possibly
     // to remove the last added entry if it is sensitive and should
     // not be persisted in the history, like a password
-    const line = this.history[0];
+    const line = this[kIsMultiline] ? this[kReverseString](this.history[0], '\r', '\r') : this.history[0];
 
     // Emit history event to notify listeners of update
     this.emit('history', this.history);
@@ -938,6 +964,18 @@ class Interface extends InterfaceConstructor {
     }
   }
 
+  [kSavePreviousState]() {
+    this[kPreviousLine] = this.line;
+    this[kPreviousCursor] = this.cursor;
+    this[kPreviousPrevRows] = this.prevRows;
+  }
+
+  [kRestorePreviousState]() {
+    this[kSetLine](this[kPreviousLine]);
+    this.cursor = this[kPreviousCursor];
+    this.prevRows = this[kPreviousPrevRows];
+  }
+
   clearLine() {
     this[kMoveCursor](+Infinity);
     this[kWriteToOutput]('\r\n');
@@ -947,13 +985,110 @@ class Interface extends InterfaceConstructor {
   }
 
   [kLine]() {
+    this[kSavePreviousState]();
     const line = this[kAddHistory]();
     this[kUndoStack] = [];
     this[kRedoStack] = [];
     this.clearLine();
     this[kOnLine](line);
   }
 
+  // When this function is called, the actual cursor is at the very end of the whole string,
+  // No matter where the new line was entered.
+  // This function should only be used when the output is a TTY
+  [kAddNewLineOnTTY]() {
+    if (!this.terminal) {
+      return;
+    }
+
+    this[kRestorePreviousState]();
+    const originalLine = this.line;
+
+    // Before the cursor
+    const beg = StringPrototypeSlice(this.line, 0, this.cursor);
+    // After the cursor
+    let end = StringPrototypeSlice(this.line, this.cursor, this.line.length);
+
+    // Add the new line where the cursor is at
+    this[kSetLine](`${beg}\n${end}`);
+
+    // To account for the new line
+    this.cursor += 1;
+
+    const hasContentAfterCursor = end.length > 0;
+    const cursorIsNotOnFirstLine = this.prevRows > 0;
+    const lineParts = hasContentAfterCursor ? StringPrototypeSplit(beg, '\n') : null;
+
+    // Handle cursor positioning based on different scenarios
+    if (hasContentAfterCursor) {
+      // If the cursor is not on the first line
+      if (cursorIsNotOnFirstLine) {
+        const splitEnd = StringPrototypeSplit(end, '\n');
+        // If the cursor when I pressed enter was at least on the second line
+        // I need to completely erase the line where the cursor was pressed because it is possible
+        // That it was pressed in the middle of the line, hence I need to write the whole line.
+        // To achieve that, I need to reach the line above the current line coming from the end
+        const dy = splitEnd.length + 1;
+        // Calculate how many Xs we need to move on the right to get to the end of the line
+        const dxEndOfLineAbove = lineParts[lineParts.length - 2].length + kMultilinePrompt.description.length;
+        moveCursor(this.output, dxEndOfLineAbove, -dy);
+        // This is the line that was split in the middle
+        // Just add it to the rest of the line that will be printed later
+        end = `${lineParts[lineParts.length - 1]}\n${end}`;
+      } else {
+        // Otherwise, go to the very beginning of the first line and erase everything
+        const dy = StringPrototypeSplit(originalLine, '\n').length;
+        moveCursor(this.output, 0, -dy);
+      }
+    } else {
+      // Otherwise, go to the very beginning of the currentLine
+      // We need to rewrite everything
+      cursorTo(this.output, 0);
+    }
+
+    // Erase from the cursor to the end of the line
+    clearScreenDown(this.output);
+
+    // Handle new line output for multiline case
+    if (hasContentAfterCursor && cursorIsNotOnFirstLine) {
+      this[kWriteToOutput]('\n');
+    }
+
+    // Determine if we need to rewrite the first line
+    const needsRewriteFirstLine = lineParts && lineParts.length < 2;
+    if (needsRewriteFirstLine) {
+      this[kWriteToOutput](`${this[kPrompt]}${beg}\n${kMultilinePrompt.description}`);
+    } else {
+      this[kWriteToOutput](kMultilinePrompt.description);
+    }
+
+    // Write the rest and restore the cursor to where the user left it
+    if (hasContentAfterCursor) {
+      // Save the cursor pos, we need to come back here
+      const oldCursor = this.getCursorPos();
+
+      // Write everything after the cursor which has been deleted by clearScreenDown
+      for (const letter of end) {
+        if (letter === '\n') {
+          this[kWriteToOutput](`\n${kMultilinePrompt.description}`);
+        } else {
+          this[kWriteToOutput](letter);
+        }
+      }
+
+      const newCursor = this[kGetDisplayPos](this.line);
+      // Go back to where the cursor was, with relative movement
+      moveCursor(this.output, oldCursor.cols - newCursor.cols, oldCursor.rows - newCursor.rows);
+      // Setting how many rows we have on top of the cursor
+      // Necessary for kRefreshLine
+      this.prevRows = oldCursor.rows;
+    } else {
+      // Setting how many rows we have on top of the cursor
+      // Necessary for kRefreshLine
+      this.prevRows = StringPrototypeSplit(this.line, '\n').length - 1;
+    }
+  }
+
   [kPushToUndoStack](text, cursor) {
     if (ArrayPrototypePush(this[kUndoStack], { text, cursor }) >
         kMaxUndoRedoStackSize) {
@@ -1370,6 +1505,14 @@ class Interface extends InterfaceConstructor {
         case 'y': // Doing yank pop
           this[kYankPop]();
           break;
+
+        case 'return': // ((meta|option) + enter) Inserting a new line, this might work on few terminals only
+          // The next 2 lines are to standardize the behavior simulating what [kLine]() does.
+          // The internal calculations in [kAddNewLineOnTTY] are expecting certain state to be set.
+          this[kSavePreviousState]();
+          this.clearLine();
+          this[kAddNewLineOnTTY]();
+          break;
       }
     } else {
       /* No modifier keys used */
@@ -1525,6 +1668,7 @@ module.exports = {
   kWordRight,
   kWriteToOutput,
   kMultilinePrompt,
+  kRestorePreviousState,
+  kAddNewLineOnTTY,
   kLastCommandErrored,
-  kNormalizeHistoryLineEndings,
 };

lib/repl.js

@@ -53,7 +53,6 @@ const {
   ArrayPrototypePop,
   ArrayPrototypePush,
   ArrayPrototypePushApply,
-  ArrayPrototypeReverse,
   ArrayPrototypeShift,
   ArrayPrototypeSlice,
   ArrayPrototypeSome,
@@ -196,8 +195,8 @@ const {
 } = require('internal/vm');
 const {
   kMultilinePrompt,
+  kAddNewLineOnTTY,
   kLastCommandErrored,
-  kNormalizeHistoryLineEndings,
 } = require('internal/readline/interface');
 let nextREPLResourceNumber = 1;
 // This prevents v8 code cache from getting confused and using a different
@@ -361,6 +360,7 @@ function REPLServer(prompt,
   this.editorMode = false;
   // Context id for use with the inspector protocol.
   this[kContextId] = undefined;
+  this[kLastCommandErrored] = false;
 
   if (this.breakEvalOnSigint && eval_) {
     // Allowing this would not reflect user expectations.
@@ -929,8 +929,6 @@ function REPLServer(prompt,
       debug('finish', e, ret);
       ReflectApply(_memory, self, [cmd]);
 
-      self[kLastCommandErrored] = false;
-
       if (e && !self[kBufferedCommandSymbol] &&
           StringPrototypeStartsWith(StringPrototypeTrim(cmd), 'npm ') &&
           !(e instanceof Recoverable)
@@ -943,33 +941,15 @@ function REPLServer(prompt,
       }
 
       // If error was SyntaxError and not JSON.parse error
-      if (e) {
-        if (e instanceof Recoverable && !sawCtrlD) {
-          // Start buffering data like that:
-          // {
-          // ...  x: 1
-          // ... }
+      // We can start a multiline command
+      if (e && e instanceof Recoverable && !sawCtrlD) {
+        if (self.terminal) {
+          self[kAddNewLineOnTTY]();
+        } else {
           self[kBufferedCommandSymbol] += cmd + '\n';
           self.displayPrompt();
-          return;
-        }
-      }
-
-      // In the next two if blocks, we do not use os.EOL instead of '\n'
-      // because on Windows it is '\r\n'
-      if (StringPrototypeIncludes(cmd, '\n')) { // If you are editing a multiline command
-        self.history[0] = self[kNormalizeHistoryLineEndings](cmd, '\n', '\r');
-      } else if (self[kBufferedCommandSymbol]) { // If a new multiline command was entered
-        // Remove the first N lines from the self.history array
-        // where N is the number of lines in the buffered command
-
-        const lines = StringPrototypeSplit(self[kBufferedCommandSymbol], '\n');
-        self.history = ArrayPrototypeSlice(self.history, lines.length);
-        lines[lines.length - 1] = cmd;
-        const newHistoryLine = ArrayPrototypeJoin(ArrayPrototypeReverse(lines), '\r');
-        if (self.history[0] !== newHistoryLine) {
-          ArrayPrototypeUnshift(self.history, newHistoryLine);
         }
+        return;
       }
 
       if (e) {
@@ -997,6 +977,7 @@ function REPLServer(prompt,
       // Display prompt again (unless we already did by emitting the 'error'
       // event on the domain instance).
       if (!e) {
+        self[kLastCommandErrored] = false;
         self.displayPrompt();
       }
     }