Improve testability using StringBuilder extensions classes.

Author: springcomp

PSReadLine/Position.cs

@@ -114,22 +114,12 @@ private static int GetFirstNonBlankOfLogicalLinePos(int current)
 
             var newCurrent = beginningOfLine;
 
-            while (IsVisibleBlank(newCurrent))
+            while (_singleton._buffer.IsVisibleBlank(newCurrent))
             {
                 newCurrent++;
             }
 
             return newCurrent;
         }
-
-        private static bool IsVisibleBlank(int newCurrent)
-        {
-            var c = _singleton._buffer[newCurrent];
-
-            // [:blank:] of vim's pattern matching behavior
-            // defines blanks as SPACE and TAB characters.
-
-            return c == ' ' || c == '\t';
-        }
     }
 }

PSReadLine/Prediction.Views.cs

@@ -743,12 +743,12 @@ internal int FindForwardSuggestionWordPoint(int currentIndex, string wordDelimit
                 }
 
                 int i = currentIndex;
-                if (!_singleton.InWord(_suggestionText[i], wordDelimiters))
+                if (!Character.IsInWord(_suggestionText[i], wordDelimiters))
                 {
                     // Scan to end of current non-word region
                     while (++i < _suggestionText.Length)
                     {
-                        if (_singleton.InWord(_suggestionText[i], wordDelimiters))
+                        if (Character.IsInWord(_suggestionText[i], wordDelimiters))
                         {
                             break;
                         }
@@ -759,7 +759,7 @@ internal int FindForwardSuggestionWordPoint(int currentIndex, string wordDelimit
                 {
                     while (++i < _suggestionText.Length)
                     {
-                        if (!_singleton.InWord(_suggestionText[i], wordDelimiters))
+                        if (!Character.IsInWord(_suggestionText[i], wordDelimiters))
                         {
                             if (_suggestionText[i] == ' ')
                             {

PSReadLine/StringBuilderCharacterExtensions.cs

@@ -0,0 +1,66 @@
+using System.Text;
+
+namespace Microsoft.PowerShell
+{
+    internal static partial class StringBuilderExtensions
+    {
+        /// <summary>
+        /// Returns true if the character at the specified position is a visible whitespace character.
+        /// A blank character is defined as a SPACE or a TAB.
+        /// </summary>
+        /// <param name="buffer"></param>
+        /// <param name="i"></param>
+        /// <returns></returns>
+        public static bool IsVisibleBlank(this StringBuilder buffer, int i)
+        {
+            var c = buffer[i];
+
+            // [:blank:] of vim's pattern matching behavior
+            // defines blanks as SPACE and TAB characters.
+
+            return c == ' ' || c == '\t';
+        }
+
+        /// <summary>
+        /// Returns true if the character at the specified position is
+        /// not present in a list of word-delimiter characters.
+        /// </summary>
+        /// <param name="buffer"></param>
+        /// <param name="i"></param>
+        /// <param name="wordDelimiters"></param>
+        /// <returns></returns>
+        public static bool InWord(this StringBuilder buffer, int i, string wordDelimiters)
+        {
+            return Character.IsInWord(buffer[i], wordDelimiters);
+        }
+
+        /// <summary>
+        /// Returns true if the character at the specified position is
+        /// a unicode whitespace character.
+        /// </summary>
+        /// <param name="buffer"></param>
+        /// <param name="i"></param>
+        /// <returns></returns>
+        public static bool IsWhiteSpace(this StringBuilder buffer, int i)
+        { 
+            // Treat just beyond the end of buffer as whitespace because
+            // it looks like whitespace to the user even though they haven't
+            // entered a character yet.
+            return i >= buffer.Length || char.IsWhiteSpace(buffer[i]);
+        }
+    }
+
+    public static class Character
+    {
+        /// <summary>
+        /// Returns true if the character not present in a list of word-delimiter characters.
+        /// </summary>
+        /// <param name="c"></param>
+        /// <param name="wordDelimiters"></param>
+        /// <returns></returns>
+        public static bool IsInWord(char c, string wordDelimiters)
+        {
+            return !char.IsWhiteSpace(c) && wordDelimiters.IndexOf(c) < 0;
+        }
+    }
+}

PSReadLine/StringBuilderExtensions.cs renamed to PSReadLine/StringBuilderLinewiseExtensions.cs

@@ -14,7 +14,7 @@ internal Range(int offset, int count)
         internal int Count { get; }
     }
 
-    internal static class StringBuilderLinewiseExtensions
+    internal static partial class StringBuilderLinewiseExtensions
     {
         /// <summary>
         /// Determines the offset and the length of the fragment
@@ -72,6 +72,23 @@ internal static Range GetRange(this StringBuilder buffer, int lineIndex, int lin
                 endPosition - startPosition + 1
                 );
         }
+
+        /// <summary>
+        /// Returns true if the specified position
+        /// is on an empty logical line
+        /// </summary>
+        /// <param name="buffer"></param>
+        /// <param name="cursor"></param>
+        /// <returns></returns>
+        public static bool IsLogigalLineEmpty(this StringBuilder buffer, int cursor)
+        {
+            return 
+                buffer.Length == 0 ||
+                (cursor == buffer.Length && buffer[cursor - 1] == '\n') ||
+                (cursor > 0 && buffer[cursor] == '\n') ||
+                (cursor > 0 && buffer[cursor] == '\n' && cursor < buffer.Length - 1 && buffer[cursor - 1] == '\n')
+                ;
+        }
     }
 
     internal static class StringBuilderPredictionExtensions

PSReadLine/Words.cs

@@ -90,13 +90,12 @@ private Token FindToken(int current, FindTokenMode mode)
 
         private bool InWord(int index, string wordDelimiters)
         {
-            char c = _buffer[index];
-            return InWord(c, wordDelimiters);
+            return _buffer.InWord(index, wordDelimiters);
         }
 
         private bool InWord(char c, string wordDelimiters)
         {
-            return !char.IsWhiteSpace(c) && wordDelimiters.IndexOf(c) < 0;
+            return Character.IsInWord(c, wordDelimiters);
         }
 
         /// <summary>

PSReadLine/Words.vi.cs

@@ -2,6 +2,8 @@
 Copyright (c) Microsoft Corporation.  All rights reserved.
 --********************************************************************/
 
+using System;
+
 namespace Microsoft.PowerShell
 {
     public partial class PSConsoleReadLine
@@ -106,10 +108,7 @@ private int ViFindNextWordFromWord(int i, string wordDelimiters)
         /// </summary>
         private bool IsWhiteSpace(int i)
         {
-            // Treat just beyond the end of buffer as whitespace because
-            // it looks like whitespace to the user even though they haven't
-            // entered a character yet.
-            return i >= _buffer.Length || char.IsWhiteSpace(_buffer[i]);
+            return _buffer.IsWhiteSpace(i);
         }
 
         /// <summary>

PSReadLine/YankPaste.vi.cs

@@ -70,6 +70,26 @@ private void SaveLinesToClipboard(int lineIndex, int lineCount)
             _clipboard.LinewiseRecord(_buffer.ToString(range.Offset, range.Count));
         }
 
+        /// <summary>
+        /// Removes a portion of text from the buffer
+        /// and saves it to the clipboard in order to support undo.
+        /// </summary>
+        /// <param name="start"></param>
+        /// <param name="count"></param>
+        /// <param name="instigator"></param>
+        /// <param name="arg"></param>
+        private void RemoveTextToClipboard(int start, int count, Action<ConsoleKeyInfo?, object> instigator = null, object arg = null)
+        {
+            _singleton.SaveToClipboard(start, count);
+            _singleton.SaveEditItem(EditItemDelete.Create(
+                _clipboard,
+                start,
+                instigator,
+                arg
+                ));
+            _singleton._buffer.Remove(start, count);
+        }
+
         /// <summary>
         /// Yank the entire buffer.
         /// </summary>

test/StringBuilderCharacterExtensionsTests.cs

@@ -0,0 +1,46 @@
+using Microsoft.PowerShell;
+using System.Text;
+using Xunit;
+
+namespace Test
+{
+    public sealed class StringBuilderCharacterExtensionsTests
+    {
+        [Fact]
+        public void StringBuilderCharacterExtensions_IsVisibleBlank()
+        {
+            var buffer = new StringBuilder(" \tn");
+
+            // system under test
+
+            Assert.True(buffer.IsVisibleBlank(0));
+            Assert.True(buffer.IsVisibleBlank(1));
+            Assert.False(buffer.IsVisibleBlank(2));
+        }
+
+        [Fact]
+        public void StringBuilderCharacterExtensions_InWord()
+        {
+            var buffer = new StringBuilder("hello, world!");
+            const string wordDelimiters = " ";
+
+            // system under test
+
+            Assert.True(buffer.InWord(2, wordDelimiters));
+            Assert.True(buffer.InWord(5, wordDelimiters));
+        }
+
+        [Fact]
+        public void StringBuilderCharacterExtensions_IsWhiteSpace()
+        {
+            var buffer = new StringBuilder("a c");
+
+
+            // system under test
+
+            Assert.False(buffer.IsWhiteSpace(0));
+            Assert.True(buffer.IsWhiteSpace(1));
+            Assert.False(buffer.IsWhiteSpace(2));
+        }
+    }
+}