Update the inline suggestion rendering to not exceed the max window buffer (PowerShell#2892)

Author: daxian-dbw

PSReadLine/Prediction.Views.cs

@@ -578,6 +578,7 @@ private class PredictionInlineView : PredictionViewBase
  private uint? _predictorSession;
  private string _suggestionText;
  private string _lastInputText;
+ private int _renderedLength;
  private bool _alreadyAccepted;
 
  internal string SuggestionText => _suggestionText;
@@ -671,11 +672,59 @@ internal override void RenderSuggestion(List<StringBuilder> consoleBufferLines,
  }
 
  int inputLength = _inputText.Length;
+ int totalLength = _suggestionText.Length;
+
+ // Get the maximum buffer cells that could be available to the current command line.
+ int maxBufferCells = _singleton._console.BufferHeight * _singleton._console.BufferWidth - _singleton._initialX;
+ bool skipRendering = false;
+
+ // Assuming the suggestion text contains wide characters only (1 character takes up 2 buffer cells),
+ // if it still can fit in the console buffer, then we are all good; otherwise, it is possible that
+ // it could not fit, and thus more calculation is needed to check if that's really the case.
+ if (totalLength * 2 > maxBufferCells)
+ {
+ int length = SubstringLengthByCells(_suggestionText, maxBufferCells);
+ if (length <= inputLength)
+ {
+ // Even the user input cannot fit in the console buffer without having part of it scrolled up-off the buffer.
+ // We don't attempt to render the suggestion text in this case.
+ skipRendering = true;
+ }
+ else if (length < totalLength)
+ {
+ // The whole suggestion text cannot fit in the console buffer without having part of it scrolled up off the buffer.
+ // We truncate the end part and append ellipsis.
+
+ // We need to truncate 4 buffer cells ealier (just to be safe), so we have enough room to add the ellipsis.
+ int lenFromEnd = SubstringLengthByCellsFromEnd(_suggestionText, length - 1, countOfCells: 4);
+ totalLength = length - lenFromEnd;
+ if (totalLength <= inputLength)
+ {
+ // No suggestion left after truncation, so no need to render.
+ skipRendering = true;
+ }
+ }
+ }
+
+ if (skipRendering)
+ {
+ _renderedLength = 0;
+ return;
+ }
+
+ _renderedLength = totalLength;
  StringBuilder currentLineBuffer = consoleBufferLines[currentLogicalLine];
 
- currentLineBuffer.Append(_singleton._options._inlinePredictionColor)
- .Append(_suggestionText, inputLength, _suggestionText.Length - inputLength)
- .Append(VTColorUtils.AnsiReset);
+ currentLineBuffer
+ .Append(_singleton._options._inlinePredictionColor)
+ .Append(_suggestionText, inputLength, _renderedLength - inputLength);
+
+ if (_renderedLength < _suggestionText.Length)
+ {
+ currentLineBuffer.Append("...");
+ }
+
+ currentLineBuffer.Append(VTColorUtils.AnsiReset);
  }
 
  internal override void OnSuggestionAccepted()
@@ -702,34 +751,38 @@ internal override void Clear(bool cursorAtEol)
  return;
  }
 
- int left, top;
- int inputLen = _inputText.Length;
- IConsole console = _singleton._console;
-
- if (cursorAtEol)
+ if (_renderedLength > 0)
  {
- left = console.CursorLeft;
- top = console.CursorTop;
- console.BlankRestOfLine();
- }
- else
- {
- Point bufferEndPoint = _singleton.ConvertOffsetToPoint(inputLen);
- left = bufferEndPoint.X;
- top = bufferEndPoint.Y;
- _singleton.WriteBlankRestOfLine(left, top);
- }
+ // Clear the suggestion only if we actually rendered it.
+ int left, top;
+ int inputLen = _inputText.Length;
+ IConsole console = _singleton._console;
 
- int bufferWidth = console.BufferWidth;
- int columns = LengthInBufferCells(_suggestionText, inputLen, _suggestionText.Length);
+ if (cursorAtEol)
+ {
+ left = console.CursorLeft;
+ top = console.CursorTop;
+ console.BlankRestOfLine();
+ }
+ else
+ {
+ Point bufferEndPoint = _singleton.ConvertOffsetToPoint(inputLen);
+ left = bufferEndPoint.X;
+ top = bufferEndPoint.Y;
+ _singleton.WriteBlankRestOfLine(left, top);
+ }
 
- int remainingLenInCells = bufferWidth - left;
- columns -= remainingLenInCells;
- if (columns > 0)
- {
- int extra = columns % bufferWidth > 0 ? 1 : 0;
- int count = columns / bufferWidth + extra;
- _singleton.WriteBlankLines(top + 1, count);
+ int bufferWidth = console.BufferWidth;
+ int columns = LengthInBufferCells(_suggestionText, inputLen, _renderedLength);
+
+ int remainingLenInCells = bufferWidth - left;
+ columns -= remainingLenInCells;
+ if (columns > 0)
+ {
+ int extra = columns % bufferWidth > 0 ? 1 : 0;
+ int count = columns / bufferWidth + extra;
+ _singleton.WriteBlankLines(top + 1, count);
+ }
  }
 
  Reset();
@@ -742,6 +795,7 @@ internal override void Reset()
  _predictorId = Guid.Empty;
  _predictorSession = null;
  _alreadyAccepted = false;
+ _renderedLength = 0;
  }
 
  /// <summary>

PSReadLine/Render.Helper.cs

@@ -122,16 +122,22 @@ private static int SubstringLengthByCells(string text, int start, int countOfCel
 
  for (int i = start; i < text.Length; i++)
  {
- if (cellLength >= countOfCells)
+ cellLength += LengthInBufferCells(text[i]);
+
+ if (cellLength > countOfCells)
  {
  return charLength;
  }
 
- cellLength += LengthInBufferCells(text[i]);
  charLength++;
+
+ if (cellLength == countOfCells)
+ {
+ return charLength;
+ }
  }
 
- return 0;
+ return charLength;
  }
 
  private static int SubstringLengthByCellsFromEnd(string text, int countOfCells)
@@ -146,16 +152,22 @@ private static int SubstringLengthByCellsFromEnd(string text, int start, int cou
 
  for (int i = start; i >= 0; i--)
  {
- if (cellLength >= countOfCells)
+ cellLength += LengthInBufferCells(text[i]);
+
+ if (cellLength > countOfCells)
  {
  return charLength;
  }
 
- cellLength += LengthInBufferCells(text[i]);
  charLength++;
+
+ if (cellLength == countOfCells)
+ {
+ return charLength;
+ }
  }
 
- return 0;
+ return charLength;
  }
  }
 }

PSReadLine/UndoRedo.cs

@@ -20,7 +20,7 @@ private void RemoveEditsAfterUndo()
  _edits.RemoveRange(_undoEditIndex, removeCount);
  if (_edits.Count < _editGroupStart)
  {
- // Reset the group start index if any edits before setting the start mark were undone.
+ // Reset the group start index if any edits after setting the start mark were undone.
  _editGroupStart = -1;
  }
  }

PSReadLine/YankPaste.vi.cs

@@ -71,7 +71,7 @@ private void SaveLinesToClipboard(int lineIndex, int lineCount)
  }
 
  /// <summary>
- /// Remove a portion of text from the buffer, save it to the vi register
+ /// Remove a portion of text from the buffer, save it to the vi register
  /// and also save it to the edit list to support undo.
  /// </summary>
  /// <param name="start"></param>

test/InlinePredictionTest.cs

@@ -727,5 +727,28 @@ public void Inline_HistoryAndPluginSource_ExecutionStatus()
 
  Assert.Null(_mockedMethods.lastCommandRunStatus);
  }
+
+ [SkippableFact]
+ public void Inline_TruncateVeryLongSuggestion()
+ {
+ TestSetup(new TestConsole(width: 10, height: 2, keyboardLayout: _), KeyMode.Cmd);
+ using var disp = SetPrediction(PredictionSource.History, PredictionViewStyle.InlineView);
+
+ // Truncate long suggestion to make sure the user input is not scrolled up-off the console buffer.
+ SetHistory(new string('v', 25));
+ Test("vv", Keys(
+ 'v', CheckThat(() => AssertScreenIs(2,
+ TokenClassification.Command, 'v',
+ TokenClassification.InlinePrediction, new string('v', 9),
+ TokenClassification.InlinePrediction, new string('v', 6) + "...")),
+ 'v', CheckThat(() => AssertScreenIs(2,
+ TokenClassification.Command, "vv",
+ TokenClassification.InlinePrediction, new string('v', 8),
+ TokenClassification.InlinePrediction, new string('v', 6) + "...")),
+ // Once accepted, the suggestion text should be blanked out.
+ _.Enter, CheckThat(() => AssertScreenIs(1,
+ TokenClassification.Command, "vv"))
+ ));
+ }
  }
 }

test/MockConsole.cs

@@ -84,6 +84,19 @@ internal TestConsole(dynamic keyboardLayout)
  ClearBuffer();
  }
 
+ internal TestConsole(int width, int height, dynamic keyboardLayout)
+ {
+ _keyboardLayout = keyboardLayout;
+ BackgroundColor = ReadLine.BackgroundColors[0];
+ ForegroundColor = ReadLine.Colors[0];
+ CursorLeft = 0;
+ CursorTop = 0;
+ _bufferWidth = _windowWidth = width;
+ _bufferHeight = _windowHeight = height; // big enough to avoid the need to implement scrolling
+ buffer = new CHAR_INFO[BufferWidth * BufferHeight];
+ ClearBuffer();
+ }
+
  internal void Init(object[] items)
  {
  this.index = 0;

test/UnitTestReadLine.cs

@@ -537,11 +537,16 @@ private static string MakeCombinedColor(ConsoleColor fg, ConsoleColor bg)
  => VTColorUtils.AsEscapeSequence(fg) + VTColorUtils.AsEscapeSequence(bg, isBackground: true);
 
  private void TestSetup(KeyMode keyMode, params KeyHandler[] keyHandlers)
+ {
+ TestSetup(console: null, keyMode, keyHandlers);
+ }
+
+ private void TestSetup(TestConsole console, KeyMode keyMode, params KeyHandler[] keyHandlers)
  {
  Skip.If(WindowsConsoleFixtureHelper.GetKeyboardLayout() != this.Fixture.Lang,
  $"Keyboard layout must be set to {this.Fixture.Lang}");
 
- _console = new TestConsole(_);
+ _console = console ?? new TestConsole(_);
  _mockedMethods = new MockedMethods();
  var instance = (PSConsoleReadLine)typeof(PSConsoleReadLine)
  .GetField("_singleton", BindingFlags.Static | BindingFlags.NonPublic).GetValue(null);