Supports 'diw' command.

Author: springcomp

PSReadLine/Cmdlets.cs

@@ -141,7 +141,7 @@ public class PSConsoleReadLineOptions
         public const int DefaultCompletionQueryItems = 100;
 
         // Default includes all characters PowerShell treats like a dash - em dash, en dash, horizontal bar
-        public const string DefaultWordDelimiters = @";:,.[]{}()/\|^&*-=+'""" + "\u2013\u2014\u2015";
+        public const string DefaultWordDelimiters = @";:,.[]{}()/\|!?^&*-=+'""" + "\u2013\u2014\u2015";
 
         /// <summary>
         /// When ringing the bell, what should be done?

PSReadLine/KeyBindings.vi.cs

@@ -45,6 +45,8 @@ internal static ConsoleColor AlternateBackground(ConsoleColor bg)
         private static Dictionary<PSKeyInfo, KeyHandler> _viChordYTable;
         private static Dictionary<PSKeyInfo, KeyHandler> _viChordDGTable;
 
+        private static Dictionary<PSKeyInfo, KeyHandler> _viChordTextObjectsTable;
+
         private static Dictionary<PSKeyInfo, Dictionary<PSKeyInfo, KeyHandler>> _viCmdChordTable;
         private static Dictionary<PSKeyInfo, Dictionary<PSKeyInfo, KeyHandler>> _viInsChordTable;
 
@@ -231,6 +233,7 @@ private void SetDefaultViBindings()
                 { Keys.ucG,             MakeKeyHandler( DeleteEndOfBuffer,            "DeleteEndOfBuffer") },
                 { Keys.ucE,             MakeKeyHandler( ViDeleteEndOfGlob,            "ViDeleteEndOfGlob") },
                 { Keys.H,               MakeKeyHandler( BackwardDeleteChar,           "BackwardDeleteChar") },
+                { Keys.I,               MakeKeyHandler( ViChordDeleteTextObject,      "ChordViTextObject") },               
                 { Keys.J,               MakeKeyHandler( DeleteNextLines,              "DeleteNextLines") },
                 { Keys.K,               MakeKeyHandler( DeletePreviousLines,          "DeletePreviousLines") },
                 { Keys.L,               MakeKeyHandler( DeleteChar,                   "DeleteChar") },
@@ -289,6 +292,11 @@ private void SetDefaultViBindings()
                 { Keys.Percent,         MakeKeyHandler( ViYankPercent,         "ViYankPercent") },
             };
 
+            _viChordTextObjectsTable = new Dictionary<PSKeyInfo, KeyHandler>
+            {
+                { Keys.W,               MakeKeyHandler(ViHandleTextObject,     "WordTextObject")},
+            };
+            
             _viChordDGTable = new Dictionary<PSKeyInfo, KeyHandler>
             {
                 { Keys.G,               MakeKeyHandler( DeleteRelativeLines,   "DeleteRelativeLines") },

PSReadLine/StringBuilderCharacterExtensions.cs

@@ -34,6 +34,18 @@ public static bool InWord(this StringBuilder buffer, int i, string wordDelimiter
             return Character.IsInWord(buffer[i], wordDelimiters);
         }
 
+        /// <summary>
+        /// Returns true if the character at the specified position is 
+        /// at the end of the buffer
+        /// </summary>
+        /// <param name="buffer"></param>
+        /// <param name="i"></param>
+        /// <returns></returns>
+        public static bool IsAtEndOfBuffer(this StringBuilder buffer, int i)
+        {
+            return i >= (buffer.Length - 1);
+        }
+
         /// <summary>
         /// Returns true if the character at the specified position is
         /// a unicode whitespace character.

PSReadLine/StringBuilderTextObjectExtensions.cs

@@ -0,0 +1,114 @@
+using System;
+using System.Text;
+
+namespace Microsoft.PowerShell
+{
+    internal static partial class StringBuilderTextObjectExtensions
+    {
+        /// <summary>
+        /// Returns the position of the beginning of the current word as delimited by white space and delimiters
+        /// This method differs from <see cref="ViFindPreviousWordPoint(string)" />:
+        /// When the cursor location is on the first character of a word, <see cref="ViFindPreviousWordPoint(string)" />
+        /// returns the position of the previous word, whereas this method returns the cursor location.
+        ///
+        /// When the cursor location is in a word, both methods return the same result.
+        ///
+        /// This method supports VI "iw" text object.
+        /// </summary>
+        public static int ViFindBeginningOfWordObjectBoundary(this StringBuilder buffer, int position, string wordDelimiters)
+        {
+            // cursor may be past the end of the buffer when calling this method
+            // this may happen if the cursor is at the beginning of a new line
+
+            var i = Math.Min(position, buffer.Length - 1);
+
+            // if starting on a word consider a text object as a sequence of characters excluding the delimiters
+            // otherwise, consider a word as a sequence of delimiters
+
+            var delimiters = wordDelimiters + '\n';
+            if (buffer.InWord(i, wordDelimiters))
+            {
+                delimiters += " \t";
+            }
+            if (delimiters.IndexOf(buffer[i]) == -1 && buffer.IsWhiteSpace(i))
+            {
+                delimiters = " \t";
+            }
+
+            var isTextObjectChar = buffer.InWord(i, wordDelimiters)
+                    ? (Func<char, bool>)(c => delimiters.IndexOf(c) == -1)
+                    : c => delimiters.IndexOf(c) != -1
+                ;
+
+            var beginning = i;
+            while (i >= 0 && isTextObjectChar(buffer[i]))
+            {
+                beginning = i--;
+            }
+
+            return beginning;
+        }
+
+        /// <summary>
+        /// Finds the position of the beginning of the next word object starting from the specified position.
+        /// If positioned on the last word in the buffer, returns buffer length + 1.
+        /// This method supports VI "iw" text-object.
+        /// iw: "inner word", select words. White space between words is counted too.
+        /// </summary>
+        public static int ViFindBeginningOfNextWordObjectBoundary(this StringBuilder buffer, int position, string wordDelimiters)
+        {
+            // cursor may be past the end of the buffer when calling this method
+            // this may happen if the cursor is at the beginning of a new line
+
+            var i = Math.Min(position, buffer.Length - 1);
+
+            // always skip the first newline character
+
+            if (buffer[i] == '\n' && i < buffer.Length - 1)
+            {
+                // try to skip a second newline characters
+                // to replicate vim behaviour
+
+                ++i;
+            }
+
+            // if starting on a word consider a text object as a sequence of characters excluding the delimiters
+            // otherwise, consider a word as a sequence of delimiters
+
+            var delimiters = wordDelimiters;
+
+            if (buffer.InWord(i, wordDelimiters))
+            {
+                delimiters += " \t\n";
+            }
+            if (buffer.IsWhiteSpace(i))
+            {
+                delimiters = " \t";
+            }
+
+            var isTextObjectChar = buffer.InWord(i, wordDelimiters)
+                    ? (Func<char, bool>)(c => delimiters.IndexOf(c) == -1)
+                    : c => delimiters.IndexOf(c) != -1
+                ;
+
+            // try to skip a second newline characters
+            // to replicate vim behaviour
+
+            if (buffer[i] == '\n' && i < buffer.Length - 1)
+            {
+                ++i;
+            }
+
+            // skip to next non word characters
+
+            while (i < buffer.Length && isTextObjectChar(buffer[i]))
+            {
+                ++i;
+            }
+
+            // make sure end includes the starting position
+
+            return Math.Max(i, position);
+        }
+    }
+}

PSReadLine/TextObjects.Vi.cs

@@ -0,0 +1,198 @@
+using System;
+using System.Collections.Generic;
+
+namespace Microsoft.PowerShell
+{
+    public partial class PSConsoleReadLine
+    {
+        internal enum TextObjectOperation
+        {
+            None,
+            Change,
+            Delete,
+        }
+
+        internal enum TextObjectSpan
+        {
+            None,
+            Around,
+            Inner,
+        }
+
+        private TextObjectOperation _textObjectOperation = TextObjectOperation.None;
+        private TextObjectSpan _textObjectSpan = TextObjectSpan.None;
+
+        private readonly IDictionary<TextObjectOperation, IDictionary<TextObjectSpan, KeyHandler>> _textObjectHandlers
+            = new Dictionary<TextObjectOperation, IDictionary<TextObjectSpan, KeyHandler>>
+            {
+                {
+                    TextObjectOperation.Delete,
+                    new Dictionary<TextObjectSpan, KeyHandler>
+                    {
+                        {TextObjectSpan.Inner, MakeKeyHandler(ViDeleteInnerWord, "ViDeleteInnerWord")}
+                    }
+                }
+            };
+
+        private void ViChordDeleteTextObject(ConsoleKeyInfo? key = null, object arg = null)
+        {
+            _textObjectOperation = TextObjectOperation.Delete;
+            ViChordTextObject(key, arg);
+        }
+
+        private void ViChordTextObject(ConsoleKeyInfo? key = null, object arg = null)
+        {
+            if (!key.HasValue)
+            {
+                ResetTextObjectState();
+                throw new ArgumentNullException(nameof(key));
+            }
+
+            _textObjectSpan = GetRequestedTextObjectSpan(key.Value);
+
+            // handle text object
+
+            var textObjectKey = ReadKey();
+            if (_viChordTextObjectsTable.TryGetValue(textObjectKey, out _))
+            {
+                _singleton.ProcessOneKey(textObjectKey, _viChordTextObjectsTable, ignoreIfNoAction: true, arg: arg);
+            }
+            else
+            {
+                ResetTextObjectState();
+                Ding();
+            }
+        }
+
+        private TextObjectSpan GetRequestedTextObjectSpan(ConsoleKeyInfo key)
+        {
+            if (key.KeyChar == 'i')
+            {
+                return TextObjectSpan.Inner;
+            }
+            else if (key.KeyChar == 'a')
+            {
+                return TextObjectSpan.Around;
+            }
+            else
+            {
+                System.Diagnostics.Debug.Assert(false);
+                throw new NotSupportedException();
+            }
+        }
+
+        private static void ViHandleTextObject(ConsoleKeyInfo? key = null, object arg = null)
+        {
+            if (
+                !_singleton._textObjectHandlers.TryGetValue(_singleton._textObjectOperation, out var textObjectHandler) ||
+                !textObjectHandler.TryGetValue(_singleton._textObjectSpan, out var handler)
+            )
+            {
+                ResetTextObjectState();
+                Ding();
+                return;
+            }
+
+            handler.Action(key, arg);
+        }
+
+        private static void ResetTextObjectState()
+        {
+            _singleton._textObjectOperation = TextObjectOperation.None;
+            _singleton._textObjectSpan = TextObjectSpan.None;
+        }
+
+        private static void ViDeleteInnerWord(ConsoleKeyInfo? key = null, object arg = null)
+        {
+            var delimiters = _singleton.Options.WordDelimiters;
+
+            if (!TryGetArgAsInt(arg, out var numericArg, 1))
+                return;
+
+            if (_singleton._buffer.Length == 0)
+            {
+                if (numericArg > 1)
+                {
+                    Ding();
+                }
+                return;
+            }
+
+            // unless at the end of the buffer a single delete word should not delete backwards
+            // so if the cursor is on an empty line, do nothing
+
+            if (
+                numericArg == 1 &&
+                _singleton._current < _singleton._buffer.Length &&
+                _singleton._buffer.IsLogigalLineEmpty(_singleton._current)
+            )
+            {
+                return;
+            }
+
+            var start = _singleton._buffer.ViFindBeginningOfWordObjectBoundary(_singleton._current, delimiters);
+            var end = _singleton._current;
+
+            // attempting to find a valid position for multiple words
+            // if no valid position is found, this is a no-op
+
+            {
+                while (numericArg-- > 0 && end < _singleton._buffer.Length)
+                {
+                    end = _singleton._buffer.ViFindBeginningOfNextWordObjectBoundary(end, delimiters);
+                }
+
+                // attempting to delete too many words should ding
+
+                if (numericArg > 0)
+                {
+                    Ding();
+                    return;
+                }
+            }
+
+            if (end > 0 && _singleton._buffer.IsAtEndOfBuffer(end - 1) && _singleton._buffer.InWord(end - 1, delimiters))
+            {
+                _singleton._shouldAppend = true;
+            }
+
+            _singleton.RemoveTextToClipboard(start, end - start);
+            _singleton.AdjustCursorPosition(start);
+            _singleton.Render();
+        }
+
+        /// <summary>
+        /// Attempt to set the cursor at the specified position.
+        /// </summary>
+        /// <param name="position"></param>
+        /// <returns></returns>
+        private int AdjustCursorPosition(int position)
+        {
+            // this method might prove useful in a more general case
+
+            if (_buffer.Length == 0)
+            {
+                _current = 0;
+                return 0;
+            }
+
+            var maxPosition = _buffer[_buffer.Length - 1] == '\n'
+                ? _buffer.Length
+                : _buffer.Length - 1
+                ;
+
+            var newCurrent = Math.Min(position, maxPosition);
+
+            var beginning = GetBeginningOfLinePos(newCurrent);
+
+            if (newCurrent < _buffer.Length && _buffer[newCurrent] == '\n' && (newCurrent + ViEndOfLineFactor > beginning))
+            {
+                newCurrent += ViEndOfLineFactor;
+            }
+
+            _current = newCurrent;
+
+            return newCurrent;
+        }
+    }
+}

test/StringBuilderTextObjectExtensionsTests.cs

@@ -0,0 +1,77 @@
+using Microsoft.PowerShell;
+using System.Text;
+using Xunit;
+
+namespace Test
+{
+    public sealed class StringBuilderTextObjectExtensionsTests
+    {
+        [Fact]
+        public void StringBuilderTextObjectExtensions_ViFindBeginningOfWordObjectBoundary()
+        {
+            const string wordDelimiters = PSConsoleReadLineOptions.DefaultWordDelimiters;
+
+            var buffer = new StringBuilder("Hello, world!\ncruel   world.\none\n\n\n\n\ntwo\n three four.");
+            Assert.Equal(0, buffer.ViFindBeginningOfWordObjectBoundary(1, wordDelimiters));
+        }
+
+        [Fact]
+        public void StringBuilderTextObjectExtensions_ViFindBeginningOfWordObjectBoundary_whitespace()
+        {
+            const string wordDelimiters = PSConsoleReadLineOptions.DefaultWordDelimiters;
+
+            var buffer = new StringBuilder("Hello,   world!");
+            Assert.Equal(6, buffer.ViFindBeginningOfWordObjectBoundary(7, wordDelimiters));
+        }
+
+        [Fact]
+        public void StringBuilderTextObjectExtensions_ViFindBeginningOfWordObjectBoundary_backwards()
+        {
+            const string wordDelimiters = PSConsoleReadLineOptions.DefaultWordDelimiters;
+
+            var buffer = new StringBuilder("Hello!\nworld!");
+            Assert.Equal(5, buffer.ViFindBeginningOfWordObjectBoundary(6, wordDelimiters));
+        }
+
+        [Fact]
+        public void StringBuilderTextObjectExtensions_ViFindBeginningOfWordObjectBoundary_end_of_buffer()
+        {
+            const string wordDelimiters = PSConsoleReadLineOptions.DefaultWordDelimiters;
+
+            var buffer = new StringBuilder("Hello, world!");
+            Assert.Equal(12, buffer.ViFindBeginningOfWordObjectBoundary(buffer.Length, wordDelimiters));
+        }
+
+        [Fact]
+        public void StringBuilderTextObjectExtensions_ViFindBeginningOfNextWordObjectBoundary()
+        {
+            const string wordDelimiters = PSConsoleReadLineOptions.DefaultWordDelimiters;
+
+            var buffer = new StringBuilder("Hello, world!\ncruel world.\none\n\n\n\n\ntwo\n three four.");
+
+            // Words |Hello|,| |world|!|\n|cruel |world|.|\n|one\n\n|\n\n|\n|two|\n |three| |four|.|
+            // Pos    01234 5 6 78901 2 _3 456789 01234 5 _6 789_0_1 _2_3 _4 567 _89 01234 5 6789 0
+            // Pos    0            1              2              3                   4            5
+
+            // system under test
+
+            Assert.Equal(5, buffer.ViFindBeginningOfNextWordObjectBoundary(0, wordDelimiters));
+            Assert.Equal(6, buffer.ViFindBeginningOfNextWordObjectBoundary(5, wordDelimiters));
+            Assert.Equal(7, buffer.ViFindBeginningOfNextWordObjectBoundary(6, wordDelimiters));
+            Assert.Equal(12, buffer.ViFindBeginningOfNextWordObjectBoundary(7, wordDelimiters));
+            Assert.Equal(13, buffer.ViFindBeginningOfNextWordObjectBoundary(12, wordDelimiters));
+            Assert.Equal(19, buffer.ViFindBeginningOfNextWordObjectBoundary(13, wordDelimiters));
+            Assert.Equal(20, buffer.ViFindBeginningOfNextWordObjectBoundary(19, wordDelimiters));
+            Assert.Equal(25, buffer.ViFindBeginningOfNextWordObjectBoundary(20, wordDelimiters));
+            Assert.Equal(26, buffer.ViFindBeginningOfNextWordObjectBoundary(25, wordDelimiters));
+            Assert.Equal(30, buffer.ViFindBeginningOfNextWordObjectBoundary(26, wordDelimiters));
+            Assert.Equal(32, buffer.ViFindBeginningOfNextWordObjectBoundary(30, wordDelimiters));
+            Assert.Equal(34, buffer.ViFindBeginningOfNextWordObjectBoundary(32, wordDelimiters));
+            Assert.Equal(38, buffer.ViFindBeginningOfNextWordObjectBoundary(34, wordDelimiters));
+            Assert.Equal(40, buffer.ViFindBeginningOfNextWordObjectBoundary(38, wordDelimiters));
+            Assert.Equal(45, buffer.ViFindBeginningOfNextWordObjectBoundary(40, wordDelimiters));
+            Assert.Equal(46, buffer.ViFindBeginningOfNextWordObjectBoundary(45, wordDelimiters));
+            Assert.Equal(50, buffer.ViFindBeginningOfNextWordObjectBoundary(46, wordDelimiters));
+        }
+    }
+}

test/TextObjects.Vi.Tests.cs

@@ -0,0 +1,176 @@
+using Microsoft.PowerShell;
+using Xunit;
+
+namespace Test
+{
+    public partial class ReadLine
+    {
+        [SkippableFact]
+        public void ViTextObject_diw()
+        {
+            TestSetup(KeyMode.Vi);
+
+            Test("\"hello, \ncruel world!\"", Keys(
+                _.DQuote, 
+                "hello, world!", _.Enter,
+                "cruel world!", _.DQuote,
+                _.Escape,
+
+                // move cursor to the 'o' in 'world'
+                "gg9l",
+
+                // delete text object
+                "diw",
+                CheckThat(() => AssertLineIs("\"hello, !\ncruel world!\"")),
+                CheckThat(() => AssertCursorLeftIs(8)),
+
+                // delete
+                "diw",
+                CheckThat(() => AssertLineIs("\"hello, \ncruel world!\"")),
+                CheckThat(() => AssertCursorLeftIs(7))
+            ));
+        }
+
+        [SkippableFact]
+        public void ViTextObject_diw_digit_arguments()
+        {
+            TestSetup(KeyMode.Vi);
+
+            Test("\"hello, world!\"", Keys(
+                _.DQuote, 
+                "hello, world!", _.Enter,
+                "cruel world!", _.DQuote,
+                _.Escape,
+
+                // move cursor to the 'o' in 'world'
+                "gg9l",
+
+                // delete text object
+                "diw",
+                CheckThat(() => AssertLineIs("\"hello, !\ncruel world!\"")),
+                CheckThat(() => AssertCursorLeftIs(8)),
+
+                // delete multiple text objects (spans multiple lines)
+                "3diw",
+                CheckThat(() => AssertLineIs("\"hello, world!\"")),
+                CheckThat(() => AssertCursorLeftIs(8))
+            ));
+        }
+
+
+        [SkippableFact]
+        public void ViTextObject_diw_noop()
+        {
+            TestSetup(KeyMode.Vi);
+
+            TestMustDing("\"hello, world!\ncruel world!\"", Keys(
+                _.DQuote, 
+                "hello, world!", _.Enter,
+                "cruel world!", _.DQuote,
+                _.Escape,
+
+                // move cursor to the 'o' in 'world'
+                "gg9l",
+
+                // attempting to delete too many words must ding
+                "1274diw"
+            ));
+        }
+
+        [SkippableFact]
+        public void ViTextObject_diw_empty_line()
+        {
+            TestSetup(KeyMode.Vi);
+
+            var continuationPrefixLength = PSConsoleReadLineOptions.DefaultContinuationPrompt.Length;
+
+            Test("\"\nhello, world!\n\noh, bitter world!\n\"", Keys(
+                _.DQuote, _.Enter, 
+                "hello, world!", _.Enter,
+                _.Enter,
+                "oh, bitter world!", _.Enter,
+                _.DQuote, _.Escape,
+
+                // move cursor to the second line
+                "ggjj",
+
+                // deleting single word cannot move backwards to previous line (noop)
+                "diw", 
+                CheckThat(() => AssertLineIs("\"\nhello, world!\n\noh, bitter world!\n\""))
+            ));
+        }
+
+        [SkippableFact]
+        public void ViTextObject_diw_end_of_buffer()
+        {
+            TestSetup(KeyMode.Vi);
+
+            var continuationPrefixLength = PSConsoleReadLineOptions.DefaultContinuationPrompt.Length;
+
+            Test("", Keys(
+                _.DQuote, 
+                "hello, world!", _.Enter,
+                "cruel world!", _.DQuote,
+                _.Escape,
+
+                // move to end of buffer
+                "G$",
+
+                // delete text object (deletes backwards)
+                "diw", CheckThat(() => AssertLineIs("\"hello, world!\ncruel world")),
+                "diw", CheckThat(() => AssertLineIs("\"hello, world!\ncruel ")),
+                "diw", CheckThat(() => AssertLineIs("\"hello, world!\ncruel")),
+                "diw", CheckThat(() => AssertLineIs("\"hello, world!\n")),
+                "diw", CheckThat(() => AssertLineIs("\"hello, world")),
+                "diw", CheckThat(() => AssertLineIs("\"hello, ")),
+                "diw", CheckThat(() => AssertLineIs("\"hello,")),
+                "diw", CheckThat(() => AssertLineIs("\"hello")),
+                "diw", CheckThat(() => AssertLineIs("\"")),
+                "diw", CheckThat(() => AssertLineIs(""))
+            ));
+        }
+
+        [SkippableFact]
+        public void ViTextObject_diw_empty_buffer()
+        {
+            TestSetup(KeyMode.Vi);
+            Test("", Keys(_.Escape, "diw"));
+            TestMustDing("", Keys(_.Escape, "d2iw"));
+        }
+
+        [SkippableFact]
+        public void ViTextObject_diw_new_lines()
+        {
+            TestSetup(KeyMode.Vi);
+
+            var continuationPrefixLength = PSConsoleReadLineOptions.DefaultContinuationPrompt.Length;
+
+            Test("\"\ntwo\n\"", Keys(
+                _.DQuote, _.Enter,
+                "one", _.Enter,
+                _.Enter, _.Enter,
+                _.Enter, _.Enter,
+                _.Enter,
+                "two", _.Enter, _.DQuote,
+                _.Escape,
+
+                // move to the beginning of 'one'
+                "gg0j",
+
+                // delete text object
+                "2diw",
+                CheckThat(() => AssertLineIs("\"\n\n\n\n\ntwo\n\"")),
+
+                "ugg0j", // currently undo does not move the cursor to the correct position
+                // delete multiple text objects (spans multiple lines)
+                "3diw",
+                CheckThat(() => AssertLineIs("\"\n\n\ntwo\n\"")),
+
+                "ugg0j", // currently undo does not move the cursor to the correct position
+                // delete multiple text objects (spans multiple lines)
+                "4diw",
+                CheckThat(() => AssertLineIs("\"\ntwo\n\""))
+            ));
+        }
+    }
+}