Safely render the rest of basic editing and undo/redo

andyleejordan · andyleejordan · commit e6f230113629 · 2025-07-22T17:44:49.000-07:00
Including revert line, forward delete, and case-changing.
Undo/redo tested across characters and strings, insertions and deletions.
diff --git a/PSReadLine/BasicEditing.cs b/PSReadLine/BasicEditing.cs
@@ -73,7 +73,8 @@ public static void RevertLine(ConsoleKeyInfo? key = null, object arg = null)
                 _singleton._edits[_singleton._undoEditIndex - 1].Undo();
                 _singleton._undoEditIndex--;
             }
-            _singleton.Render();
+            // Undo has already safely rendered the character removals
+            _singleton.SafeRender();
         }
 
         /// <summary>
@@ -86,8 +87,10 @@ public static void CancelLine(ConsoleKeyInfo? key = null, object arg = null)
             _singleton._current = _singleton._buffer.Length;
 
             using var _ = _singleton._prediction.DisableScoped();
+            // The behavior of this is as expected under a screen reader
             _singleton.ForceRender();
 
+            // Display a literal ^C in bright red then reset formatting
             _singleton._console.Write("\x1b[91m^C\x1b[0m");
 
             _singleton._buffer.Clear(); // Clear so we don't actually run the input
@@ -138,7 +141,8 @@ private static void ForwardDeleteImpl(int endPosition, Action<ConsoleKeyInfo?, o
                         !InViEditMode()));
 
                 buffer.Remove(current, length);
-                _singleton.Render();
+                // Moves cursor to current (backwards probably) and then deletes length
+                _singleton.SafeRender($"\x1b[{length}P", current);
             }
         }
 
@@ -168,6 +172,7 @@ private static void BackwardDeleteSubstring(int position, Action<ConsoleKeyInfo?
 
                 _singleton.RemoveTextToViRegister(position, count, instigator, arg: null, !InViEditMode());
                 _singleton._current = position;
+                // TODO: This seems to only be used in Vi mode which we need to evaluate under a screen reader
                 _singleton.Render();
             }
         }
@@ -268,7 +273,8 @@ private static void UpdateWordCase(bool toUpper)
             Replace(_singleton._current, wordlen, word);
 
             _singleton.MoveCursor(endOfWord);
-            _singleton.Render();
+            // Replace has already safely rendered the replacement
+            _singleton.SafeRender();
         }
 
         /// <summary>
@@ -311,7 +317,8 @@ public static void CapitalizeWord(ConsoleKeyInfo? key = null, object arg = null)
             }
 
             _singleton.MoveCursor(endOfWord);
-            _singleton.Render();
+            // Replace has already safely rendered the replacement
+            _singleton.SafeRender();
         }
 
         private bool AcceptLineImpl(bool validate)
@@ -337,6 +344,7 @@ private bool AcceptLineImpl(bool validate)
 
             if (renderNeeded)
             {
+                // TODO: Evaluate this under a screen reader
                 ForceRender();
             }
 
@@ -363,6 +371,7 @@ private bool AcceptLineImpl(bool validate)
                     _statusLinePrompt = "";
                     _statusBuffer.Append(errorMessage);
                     _statusIsErrorMessage = true;
+                    // TODO: Evaluate this under a screen reader
                     Render();
                     return false;
                 }
diff --git a/PSReadLine/Completion.cs b/PSReadLine/Completion.cs
@@ -236,6 +236,7 @@ private void CompleteImpl(bool menuSelect)
                 // completions, then we'll be showing the possible completions where it's very
                 // unlikely that we would add a trailing backslash.
 
+                // Replace has already safely rendered the replacement 
                 DoReplacementForCompletion(completions.CompletionMatches[0], completions);
                 return;
             }
@@ -835,6 +836,7 @@ private static string GetMenuItem(string item, int columnWidth)
             return item;
         }
 
+        // TODO: Test menu completions under a screen reader
         private void MenuCompleteImpl(Menu menu, CommandCompletion completions)
         {
             var menuStack = new Stack<Menu>(10);
diff --git a/PSReadLine/KeyBindings.cs b/PSReadLine/KeyBindings.cs
@@ -681,6 +681,7 @@ public static void ShowKeyBindings(ConsoleKeyInfo? key = null, object arg = null
         public static void WhatIsKey(ConsoleKeyInfo? key = null, object arg = null)
         {
             _singleton._statusLinePrompt = "what-is-key: ";
+            // TODO: Evaluate this under a screen reader
             _singleton.Render();
             var toLookup = ReadKey();
             var buffer = new StringBuilder();
diff --git a/PSReadLine/ReadLine.cs b/PSReadLine/ReadLine.cs
@@ -287,6 +287,7 @@ internal static PSKeyInfo ReadKey()
                                 _singleton._initialY = newCursorTop;
                                 if (bufferLen > 0)
                                 {
+                                    // TODO: Evaluate this under a screen reader
                                     _singleton.Render();
                                 }
                             }
@@ -332,6 +333,7 @@ internal static PSKeyInfo ReadKey()
                 _singleton._getNextHistoryIndex = _singleton._history.Count;
                 _singleton._current = 0;
                 _singleton._buffer.Clear();
+                // TODO: Evaluate this under a screen reader
                 _singleton.Render();
                 throw new OperationCanceledException();
             }
@@ -1110,6 +1112,8 @@ public static void InvokePrompt(ConsoleKeyInfo? key = null, object arg = null)
             _singleton._previousRender.UpdateConsoleInfo(console);
             _singleton._previousRender.initialY = _singleton._initialY;
 
+            // TODO: Evaluate this under a screen reader
+            // It appears that VS Code's shell integration injects into the prompt
             _singleton.Render();
             console.CursorVisible = true;
         }
diff --git a/PSReadLine/Render.cs b/PSReadLine/Render.cs
@@ -218,7 +218,7 @@ private void RenderWithPredictionQueryPaused()
             Render();
         }
 
-        private void SafeRender(string s, int? cursorBefore = null, int? cursorAfter = null)
+        private void SafeRender(string s = null, int? cursorBefore = null, int? cursorAfter = null)
         {
             // Render as usual if we're not supporting a screen reader
             if (!_singleton.Options.ScreenReader)
@@ -233,7 +233,8 @@ private void SafeRender(string s, int? cursorBefore = null, int? cursorAfter = n
 
             // Directly write without re-rendering
             // This means using ANSI escapes for movement
-            _console.Write(s);
+            if (!string.IsNullOrEmpty(s))
+                _console.Write(s);
 
             // Some commands adjust the cursor after writing
             if (cursorAfter.HasValue)
@@ -1707,6 +1708,7 @@ public static void Ding()
             _singleton._mockableMethods.Ding();
         }
 
+        // TODO: Evaluate this under a screen reader
         private bool PromptYesOrNo(string s)
         {
             _statusLinePrompt = s;
diff --git a/PSReadLine/UndoRedo.cs b/PSReadLine/UndoRedo.cs
@@ -127,7 +127,8 @@ public static void Undo(ConsoleKeyInfo? key = null, object arg = null)
                 {
                     _singleton._current = Math.Max(0, _singleton._buffer.Length + ViEndOfLineFactor);
                 }
-                _singleton.Render();
+                // Undo has already safely rendered the character removals
+                _singleton.SafeRender();
             }
             else
             {
@@ -144,7 +145,8 @@ public static void Redo(ConsoleKeyInfo? key = null, object arg = null)
             {
                 _singleton._edits[_singleton._undoEditIndex].Redo();
                 _singleton._undoEditIndex++;
-                _singleton.Render();
+                // Redo has already safely rendered the character removals
+                _singleton.SafeRender();
             }
             else
             {
@@ -183,12 +185,16 @@ public override void Undo()
                 Debug.Assert(_singleton._buffer[_insertStartPosition] == _insertedCharacter, "Character to undo is not what it should be");
                 _singleton._buffer.Remove(_insertStartPosition, 1);
                 _singleton._current = _insertStartPosition;
+                // Same as remove
+                _singleton.SafeRender("\x1b[1P", _insertStartPosition);
             }
 
             public override void Redo()
             {
                 _singleton._buffer.Insert(_insertStartPosition, _insertedCharacter);
                 _singleton._current++;
+                // Same as insert
+                _singleton.SafeRender(_insertedCharacter.ToString(), _insertStartPosition);
             }
         }
 
@@ -217,12 +223,16 @@ public override void Undo()
                     "Character to undo is not what it should be");
                 _singleton._buffer.Remove(_insertStartPosition, _insertedString.Length);
                 _singleton._current = _insertStartPosition;
+                // Same as remove
+                _singleton.SafeRender($"\x1b[{_insertedString.Length}P", _insertStartPosition);
             }
 
             public override void Redo()
             {
                 _singleton._buffer.Insert(_insertStartPosition, _insertedString);
                 _singleton._current += _insertedString.Length;
+                // Same as insert
+                _singleton.SafeRender(_insertedString, _insertStartPosition);
             }
         }
 
@@ -292,12 +302,16 @@ public override void Undo()
                 _singleton._current = _moveCursorToEndWhenUndo
                     ? _deleteStartPosition + _deletedString.Length
                     : _deleteStartPosition;
+                // Same as insert
+                _singleton.SafeRender(_deletedString, _deleteStartPosition, _singleton._current);
             }
 
             public override void Redo()
             {
                 _singleton._buffer.Remove(_deleteStartPosition, _deletedString.Length);
                 _singleton._current = _deleteStartPosition;
+                // Same as remove
+                _singleton.SafeRender($"\x1b[{_deletedString.Length}P", _deleteStartPosition);
             }
         }
 

Original file line number	Diff line number	Diff line change
`@@ -73,7 +73,8 @@ public static void RevertLine(ConsoleKeyInfo? key = null, object arg = null)`
`73`	`73`	`_singleton._edits[_singleton._undoEditIndex - 1].Undo();`
`74`	`74`	`_singleton._undoEditIndex--;`
`75`	`75`	`}`
`76`		`- _singleton.Render();`
	`76`	`+ // Undo has already safely rendered the character removals`
	`77`	`+ _singleton.SafeRender();`
`77`	`78`	`}`
`78`	`79`
`79`	`80`	`/// <summary>`
`@@ -86,8 +87,10 @@ public static void CancelLine(ConsoleKeyInfo? key = null, object arg = null)`
`86`	`87`	`_singleton._current = _singleton._buffer.Length;`
`87`	`88`
`88`	`89`	`using var _ = _singleton._prediction.DisableScoped();`
	`90`	`+ // The behavior of this is as expected under a screen reader`
`89`	`91`	`_singleton.ForceRender();`
`90`	`92`
	`93`	`+ // Display a literal ^C in bright red then reset formatting`
`91`	`94`	`_singleton._console.Write("\x1b[91m^C\x1b[0m");`
`92`	`95`
`93`	`96`	`_singleton._buffer.Clear(); // Clear so we don't actually run the input`
`@@ -138,7 +141,8 @@ private static void ForwardDeleteImpl(int endPosition, Action<ConsoleKeyInfo?, o`
`138`	`141`	`!InViEditMode()));`
`139`	`142`
`140`	`143`	`buffer.Remove(current, length);`
`141`		`- _singleton.Render();`
	`144`	`+ // Moves cursor to current (backwards probably) and then deletes length`
	`145`	`+ _singleton.SafeRender($"\x1b[{length}P", current);`
`142`	`146`	`}`
`143`	`147`	`}`
`144`	`148`
`@@ -168,6 +172,7 @@ private static void BackwardDeleteSubstring(int position, Action<ConsoleKeyInfo?`
`168`	`172`
`169`	`173`	`_singleton.RemoveTextToViRegister(position, count, instigator, arg: null, !InViEditMode());`
`170`	`174`	`_singleton._current = position;`
	`175`	`+ // TODO: This seems to only be used in Vi mode which we need to evaluate under a screen reader`
`171`	`176`	`_singleton.Render();`
`172`	`177`	`}`
`173`	`178`	`}`
`@@ -268,7 +273,8 @@ private static void UpdateWordCase(bool toUpper)`
`268`	`273`	`Replace(_singleton._current, wordlen, word);`
`269`	`274`
`270`	`275`	`_singleton.MoveCursor(endOfWord);`
`271`		`- _singleton.Render();`
	`276`	`+ // Replace has already safely rendered the replacement`
	`277`	`+ _singleton.SafeRender();`
`272`	`278`	`}`
`273`	`279`
`274`	`280`	`/// <summary>`
`@@ -311,7 +317,8 @@ public static void CapitalizeWord(ConsoleKeyInfo? key = null, object arg = null)`
`311`	`317`	`}`
`312`	`318`
`313`	`319`	`_singleton.MoveCursor(endOfWord);`
`314`		`- _singleton.Render();`
	`320`	`+ // Replace has already safely rendered the replacement`
	`321`	`+ _singleton.SafeRender();`
`315`	`322`	`}`
`316`	`323`
`317`	`324`	`private bool AcceptLineImpl(bool validate)`
`@@ -337,6 +344,7 @@ private bool AcceptLineImpl(bool validate)`
`337`	`344`
`338`	`345`	`if (renderNeeded)`
`339`	`346`	`{`
	`347`	`+ // TODO: Evaluate this under a screen reader`
`340`	`348`	`ForceRender();`
`341`	`349`	`}`
`342`	`350`
`@@ -363,6 +371,7 @@ private bool AcceptLineImpl(bool validate)`
`363`	`371`	`_statusLinePrompt = "";`
`364`	`372`	`_statusBuffer.Append(errorMessage);`
`365`	`373`	`_statusIsErrorMessage = true;`
	`374`	`+ // TODO: Evaluate this under a screen reader`
`366`	`375`	`Render();`
`367`	`376`	`return false;`
`368`	`377`	`}`
Original file line number	Diff line number	Diff line change
`@@ -236,6 +236,7 @@ private void CompleteImpl(bool menuSelect)`
`236`	`236`	`// completions, then we'll be showing the possible completions where it's very`
`237`	`237`	`// unlikely that we would add a trailing backslash.`
`238`	`238`
	`239`	`+ // Replace has already safely rendered the replacement`
`239`	`240`	`DoReplacementForCompletion(completions.CompletionMatches[0], completions);`
`240`	`241`	`return;`
`241`	`242`	`}`
`@@ -835,6 +836,7 @@ private static string GetMenuItem(string item, int columnWidth)`
`835`	`836`	`return item;`
`836`	`837`	`}`
`837`	`838`
	`839`	`+ // TODO: Test menu completions under a screen reader`
`838`	`840`	`private void MenuCompleteImpl(Menu menu, CommandCompletion completions)`
`839`	`841`	`{`
`840`	`842`	`var menuStack = new Stack<Menu>(10);`
Original file line number	Diff line number	Diff line change
`@@ -681,6 +681,7 @@ public static void ShowKeyBindings(ConsoleKeyInfo? key = null, object arg = null`
`681`	`681`	`public static void WhatIsKey(ConsoleKeyInfo? key = null, object arg = null)`
`682`	`682`	`{`
`683`	`683`	`_singleton._statusLinePrompt = "what-is-key: ";`
	`684`	`+ // TODO: Evaluate this under a screen reader`
`684`	`685`	`_singleton.Render();`
`685`	`686`	`var toLookup = ReadKey();`
`686`	`687`	`var buffer = new StringBuilder();`
Original file line number	Diff line number	Diff line change
`@@ -287,6 +287,7 @@ internal static PSKeyInfo ReadKey()`
`287`	`287`	`_singleton._initialY = newCursorTop;`
`288`	`288`	`if (bufferLen > 0)`
`289`	`289`	`{`
	`290`	`+ // TODO: Evaluate this under a screen reader`
`290`	`291`	`_singleton.Render();`
`291`	`292`	`}`
`292`	`293`	`}`
`@@ -332,6 +333,7 @@ internal static PSKeyInfo ReadKey()`
`332`	`333`	`_singleton._getNextHistoryIndex = _singleton._history.Count;`
`333`	`334`	`_singleton._current = 0;`
`334`	`335`	`_singleton._buffer.Clear();`
	`336`	`+ // TODO: Evaluate this under a screen reader`
`335`	`337`	`_singleton.Render();`
`336`	`338`	`throw new OperationCanceledException();`
`337`	`339`	`}`
`@@ -1110,6 +1112,8 @@ public static void InvokePrompt(ConsoleKeyInfo? key = null, object arg = null)`
`1110`	`1112`	`_singleton._previousRender.UpdateConsoleInfo(console);`
`1111`	`1113`	`_singleton._previousRender.initialY = _singleton._initialY;`
`1112`	`1114`
	`1115`	`+ // TODO: Evaluate this under a screen reader`
	`1116`	`+ // It appears that VS Code's shell integration injects into the prompt`
`1113`	`1117`	`_singleton.Render();`
`1114`	`1118`	`console.CursorVisible = true;`
`1115`	`1119`	`}`
Original file line number	Diff line number	Diff line change
`@@ -218,7 +218,7 @@ private void RenderWithPredictionQueryPaused()`
`218`	`218`	`Render();`
`219`	`219`	`}`
`220`	`220`
`221`		`- private void SafeRender(string s, int? cursorBefore = null, int? cursorAfter = null)`
	`221`	`+ private void SafeRender(string s = null, int? cursorBefore = null, int? cursorAfter = null)`
`222`	`222`	`{`
`223`	`223`	`// Render as usual if we're not supporting a screen reader`
`224`	`224`	`if (!_singleton.Options.ScreenReader)`
`@@ -233,7 +233,8 @@ private void SafeRender(string s, int? cursorBefore = null, int? cursorAfter = n`
`233`	`233`
`234`	`234`	`// Directly write without re-rendering`
`235`	`235`	`// This means using ANSI escapes for movement`
`236`		`- _console.Write(s);`
	`236`	`+ if (!string.IsNullOrEmpty(s))`
	`237`	`+ _console.Write(s);`
`237`	`238`
`238`	`239`	`// Some commands adjust the cursor after writing`
`239`	`240`	`if (cursorAfter.HasValue)`
`@@ -1707,6 +1708,7 @@ public static void Ding()`
`1707`	`1708`	`_singleton._mockableMethods.Ding();`
`1708`	`1709`	`}`
`1709`	`1710`
	`1711`	`+ // TODO: Evaluate this under a screen reader`
`1710`	`1712`	`private bool PromptYesOrNo(string s)`
`1711`	`1713`	`{`
`1712`	`1714`	`_statusLinePrompt = s;`
Original file line number	Diff line number	Diff line change
`@@ -127,7 +127,8 @@ public static void Undo(ConsoleKeyInfo? key = null, object arg = null)`
`127`	`127`	`{`
`128`	`128`	`_singleton._current = Math.Max(0, _singleton._buffer.Length + ViEndOfLineFactor);`
`129`	`129`	`}`
`130`		`- _singleton.Render();`
	`130`	`+ // Undo has already safely rendered the character removals`
	`131`	`+ _singleton.SafeRender();`
`131`	`132`	`}`
`132`	`133`	`else`
`133`	`134`	`{`
`@@ -144,7 +145,8 @@ public static void Redo(ConsoleKeyInfo? key = null, object arg = null)`
`144`	`145`	`{`
`145`	`146`	`_singleton._edits[_singleton._undoEditIndex].Redo();`
`146`	`147`	`_singleton._undoEditIndex++;`
`147`		`- _singleton.Render();`
	`148`	`+ // Redo has already safely rendered the character removals`
	`149`	`+ _singleton.SafeRender();`
`148`	`150`	`}`
`149`	`151`	`else`
`150`	`152`	`{`
`@@ -183,12 +185,16 @@ public override void Undo()`
`183`	`185`	`Debug.Assert(_singleton._buffer[_insertStartPosition] == _insertedCharacter, "Character to undo is not what it should be");`
`184`	`186`	`_singleton._buffer.Remove(_insertStartPosition, 1);`
`185`	`187`	`_singleton._current = _insertStartPosition;`
	`188`	`+ // Same as remove`
	`189`	`+ _singleton.SafeRender("\x1b[1P", _insertStartPosition);`
`186`	`190`	`}`
`187`	`191`
`188`	`192`	`public override void Redo()`
`189`	`193`	`{`
`190`	`194`	`_singleton._buffer.Insert(_insertStartPosition, _insertedCharacter);`
`191`	`195`	`_singleton._current++;`
	`196`	`+ // Same as insert`
	`197`	`+ _singleton.SafeRender(_insertedCharacter.ToString(), _insertStartPosition);`
`192`	`198`	`}`
`193`	`199`	`}`
`194`	`200`
`@@ -217,12 +223,16 @@ public override void Undo()`
`217`	`223`	`"Character to undo is not what it should be");`
`218`	`224`	`_singleton._buffer.Remove(_insertStartPosition, _insertedString.Length);`
`219`	`225`	`_singleton._current = _insertStartPosition;`
	`226`	`+ // Same as remove`
	`227`	`+ _singleton.SafeRender($"\x1b[{_insertedString.Length}P", _insertStartPosition);`
`220`	`228`	`}`
`221`	`229`
`222`	`230`	`public override void Redo()`
`223`	`231`	`{`
`224`	`232`	`_singleton._buffer.Insert(_insertStartPosition, _insertedString);`
`225`	`233`	`_singleton._current += _insertedString.Length;`
	`234`	`+ // Same as insert`
	`235`	`+ _singleton.SafeRender(_insertedString, _insertStartPosition);`
`226`	`236`	`}`
`227`	`237`	`}`
`228`	`238`
`@@ -292,12 +302,16 @@ public override void Undo()`
`292`	`302`	`_singleton._current = _moveCursorToEndWhenUndo`
`293`	`303`	`? _deleteStartPosition + _deletedString.Length`
`294`	`304`	`: _deleteStartPosition;`
	`305`	`+ // Same as insert`
	`306`	`+ _singleton.SafeRender(_deletedString, _deleteStartPosition, _singleton._current);`
`295`	`307`	`}`
`296`	`308`
`297`	`309`	`public override void Redo()`
`298`	`310`	`{`
`299`	`311`	`_singleton._buffer.Remove(_deleteStartPosition, _deletedString.Length);`
`300`	`312`	`_singleton._current = _deleteStartPosition;`
	`313`	`+ // Same as remove`
	`314`	`+ _singleton.SafeRender($"\x1b[{_deletedString.Length}P", _deleteStartPosition);`
`301`	`315`	`}`
`302`	`316`	`}`
`303`	`317`