Supports di' and di" text objects

springcomp · springcomp · commit a93af4419ad2 · 2023-08-24T01:25:04.000+02:00
diff --git a/PSReadLine/KeyBindings.vi.cs b/PSReadLine/KeyBindings.vi.cs
@@ -301,6 +301,8 @@ private void SetDefaultViBindings()
 
             _viChordTextObjectsTable = new Dictionary<PSKeyInfo, KeyHandler>
             {
+                { Keys.DQuote,          MakeKeyHandler(ViHandleTextObject,     "QuoteTextObject")},
+                { Keys.SQuote,          MakeKeyHandler(ViHandleTextObject,     "QuoteTextObject")},
                 { Keys.W,               MakeKeyHandler(ViHandleTextObject,     "WordTextObject")},
             };
             
diff --git a/PSReadLine/Position.cs b/PSReadLine/Position.cs
@@ -10,19 +10,7 @@ public partial class PSConsoleReadLine
         /// </summary>
         /// <param name="current">The position in the current logical line.</param>
         private static int GetBeginningOfLinePos(int current)
-        {
-            int i = Math.Max(0, current);
-            while (i > 0)
-            {
-                if (_singleton._buffer[--i] == '\n')
-                {
-                    i += 1;
-                    break;
-                }
-            }
-
-            return i;
-        }
+            => _singleton._buffer.GetBeginningOfLogicalLinePos(current);
 
         /// <summary>
         /// Returns the position of the beginning of line
@@ -66,21 +54,7 @@ private static int GetBeginningOfNthLinePos(int lineIndex)
         /// <param name="current"></param>
         /// <returns></returns>
         private static int GetEndOfLogicalLinePos(int current)
-        {
-            var newCurrent = current;
-
-            for (var position = current; position < _singleton._buffer.Length; position++)
-            {
-                if (_singleton._buffer[position] == '\n')
-                {
-                    break;
-                }
-
-                newCurrent = position;
-            }
-
-            return newCurrent;
-        }
+            => _singleton._buffer.GetEndOfLogicalLinePos(current);
 
         /// <summary>
         /// Returns the position of the end of the logical line
diff --git a/PSReadLine/StringBuilderTextObjectExtensions.cs b/PSReadLine/StringBuilderTextObjectExtensions.cs
@@ -109,5 +109,105 @@ public static int ViFindBeginningOfNextWordObjectBoundary(this StringBuilder buf
             // Make sure end includes the starting position.
             return Math.Max(i, position);
         }
+
+        /// <summary>
+        /// Returns the position of the first delimiter in the buffer, started at the specified position.
+        /// This method attempts to find the position of a delimiter within the logical line at the specified position.
+        /// If the position refers to the given delimiter, the method returns the position immediately.
+        /// If not, it first attempts to look backwards to find the first delimiter and returns its position if found.
+        /// Otherwise, it look forwards to find the first delimiter and returns its position if found.
+        /// Otherwise, it return -1.
+        /// This method supports VI i' and i" text objects.
+        /// </summary>
+        public static int ViFindBeginningOfQuotedTextObjectBoundary(this StringBuilder buffer, char delimiter, int position)
+        {
+            // 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 pos = Math.Min(position, buffer.Length - 1);
+
+            var beginning = buffer.GetBeginningOfLogicalLinePos(pos); 
+            var end = buffer.GetEndOfLogicalLinePos(pos);
+
+            // if on a quote we may be on a beginning or end quote
+            // we need to parse the line to find out
+
+            if (buffer[pos] == delimiter) {
+                var count = 1;
+                for (var offset = pos - 1; offset > beginning; offset--)
+                {
+                    if (buffer[offset] == delimiter)
+                        count++;
+                }
+
+                // if there are an odd number of quotes up to the current position
+                // the position refers to the beginning a quoted text
+
+                if (count % 2 == 1)
+                {
+                    return pos;
+                }
+            }
+
+            // look backwards
+
+            for (var offset = pos - 1; offset > beginning; offset--)
+            {
+                if (buffer[offset] == delimiter)
+                    return offset;
+            }
+
+            // if not found, look forwards
+
+            for (var offset = pos; offset < end; offset++)
+            {
+                if (buffer[offset] == delimiter)
+                    return offset;
+            }
+
+            return -1;
+        }
+
+        /// <summary>
+        /// Returns the position of the beginning of line
+        /// starting from the specified "current" position.
+        /// </summary>
+        /// <param name="current">The position in the current logical line.</param>
+        internal static int GetBeginningOfLogicalLinePos(this StringBuilder buffer, int current)
+        {
+            int i = Math.Max(0, current);
+            while (i > 0)
+            {
+                if (buffer[--i] == '\n')
+                {
+                    i += 1;
+                    break;
+                }
+            }
+
+            return i;
+        }
+
+        /// <summary>
+        /// Returns the position of the end of the logical line
+        /// as specified by the "current" position.
+        /// </summary>
+        /// <param name="current"></param>
+        /// <returns></returns>
+        internal static int GetEndOfLogicalLinePos(this StringBuilder buffer, int current)
+        {
+            var newCurrent = current;
+
+            for (var position = current; position < buffer.Length; position++)
+            {
+                if (buffer[position] == '\n')
+                {
+                    break;
+                }
+
+                newCurrent = position;
+            }
+
+            return newCurrent;
+        }
     }
 }
diff --git a/PSReadLine/TextObjects.Vi.cs b/PSReadLine/TextObjects.Vi.cs
@@ -1,6 +1,7 @@
 using System;
 using System.Collections.Generic;
-
+using System.Runtime.CompilerServices;
+
 namespace Microsoft.PowerShell
 {
     public partial class PSConsoleReadLine
@@ -22,9 +23,17 @@ internal enum TextObjectSpan
         private TextObjectOperation _textObjectOperation = TextObjectOperation.None;
         private TextObjectSpan _textObjectSpan = TextObjectSpan.None;
 
-        private readonly Dictionary<TextObjectOperation, Dictionary<TextObjectSpan, KeyHandler>> _textObjectHandlers = new()
+        private readonly Dictionary<TextObjectOperation, Dictionary<TextObjectSpan, Dictionary<PSKeyInfo, KeyHandler>>> _textObjectHandlers = new()
         {
-            [TextObjectOperation.Delete] = new() { [TextObjectSpan.Inner] = MakeKeyHandler(ViDeleteInnerWord, "ViDeleteInnerWord") },
+            [TextObjectOperation.Delete] = new()
+            {
+                [TextObjectSpan.Inner] = new()
+                {
+                    [Keys.DQuote] = MakeKeyHandler(ViDeleteInnerDQuote, "ViDeleteInnerDQuote"),
+                    [Keys.SQuote] = MakeKeyHandler(ViDeleteInnerSQuote, "ViDeleteInnerSQuote"),
+                    [Keys.W] = MakeKeyHandler(ViDeleteInnerWord, "ViDeleteInnerWord"),
+                }
+            },
         };
 
         private void ViChordDeleteTextObject(ConsoleKeyInfo? key = null, object arg = null)
@@ -75,8 +84,12 @@ private TextObjectSpan GetRequestedTextObjectSpan(ConsoleKeyInfo key)
 
         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))
+            System.Diagnostics.Debug.Assert(key != null);
+            var keyInfo = PSKeyInfo.FromConsoleKeyInfo(key.Value);
+
+            if (!_singleton._textObjectHandlers.TryGetValue(_singleton._textObjectOperation, out var textObjectSpanHandlers) ||
+                !textObjectSpanHandlers.TryGetValue(_singleton._textObjectSpan, out var textObjectKeyHandlers) ||
+                !textObjectKeyHandlers.TryGetValue(keyInfo, out var handler))
             {
                 ResetTextObjectState();
                 Ding();
@@ -92,6 +105,77 @@ private static void ResetTextObjectState()
             _singleton._textObjectSpan = TextObjectSpan.None;
         }
 
+        private static void ViDeleteInnerSQuote(ConsoleKeyInfo? key = null, object arg = null)
+            => ViDeleteInnerQuotes('\'', key, arg);
+        private static void ViDeleteInnerDQuote(ConsoleKeyInfo? key = null, object arg = null)
+            => ViDeleteInnerQuotes('\"', key, arg);
+
+        private static void ViDeleteInnerQuotes(char delimiter, ConsoleKeyInfo? key = null, object arg = null)
+        {
+            if (!TryGetArgAsInt(arg, out var numericArg, 1))
+            {
+                return;
+            }
+
+            if (_singleton._buffer.Length == 0)
+            {
+                Ding();
+                return;
+            }
+
+            var start = _singleton._buffer.ViFindBeginningOfQuotedTextObjectBoundary(delimiter, _singleton._current);
+            if (start == -1)
+            {
+                Ding();
+                return;
+            }
+
+            // find the position of the ending delimiter by walking forward
+            if (start + 1 >= _singleton._buffer.Length)
+            {
+                Ding();
+                return;
+            }
+
+            var end = -1;
+
+            for (var offset = start + 1; offset < _singleton._buffer.Length; offset++)
+            {
+                if (_singleton._buffer[offset] == delimiter)
+                {
+                    end = offset;
+                    break;
+                }
+                if (_singleton._buffer[offset] == '\n')
+                {
+                    break;
+                }
+            }
+
+            if (end == -1)
+            {
+                Ding();
+                return;
+            }
+
+            var position = start + 1;
+
+            // deleting multiple times
+            // removes the surrounding quotes
+
+            if (numericArg > 1)
+            {
+                position = start;
+                // TODO:
+                // make sure we can do that
+                end = end + 1;
+            }
+
+            _singleton.RemoveTextToViRegister(position, end - position);
+            _singleton.AdjustCursorPosition(position);
+            _singleton.Render();
+        }
+
         private static void ViDeleteInnerWord(ConsoleKeyInfo? key = null, object arg = null)
         {
             var delimiters = _singleton.Options.WordDelimiters;
diff --git a/test/StringBuilderTextObjectExtensionsTests.cs b/test/StringBuilderTextObjectExtensionsTests.cs
@@ -73,5 +73,33 @@ public void StringBuilderTextObjectExtensions_ViFindBeginningOfNextWordObjectBou
             Assert.Equal(46, buffer.ViFindBeginningOfNextWordObjectBoundary(45, wordDelimiters));
             Assert.Equal(50, buffer.ViFindBeginningOfNextWordObjectBoundary(46, wordDelimiters));
         }
+
+        [Theory]
+        [InlineData('\'')]
+        [InlineData('\"')]
+        public void StringBuilderTextObjectExtensions_ViFindBeginningOfQuotedTextObjectBoundary(char delimiter)
+        {
+            var buffer = new StringBuilder($"_{delimiter}_{delimiter} {delimiter}_{delimiter} {delimiter}_{delimiter}");
+
+            // text:     _"_" "_" "_"
+            // position: 012345678901
+            //           -         1
+            // boundary: 111135557888
+            
+            Assert.Equal(1, buffer.ViFindBeginningOfQuotedTextObjectBoundary(delimiter, 0));
+            Assert.Equal(1, buffer.ViFindBeginningOfQuotedTextObjectBoundary(delimiter, 1));
+            Assert.Equal(1, buffer.ViFindBeginningOfQuotedTextObjectBoundary(delimiter, 2));
+            Assert.Equal(1, buffer.ViFindBeginningOfQuotedTextObjectBoundary(delimiter, 3));
+            Assert.Equal(3, buffer.ViFindBeginningOfQuotedTextObjectBoundary(delimiter, 4));
+            Assert.Equal(5, buffer.ViFindBeginningOfQuotedTextObjectBoundary(delimiter, 5));
+            Assert.Equal(5, buffer.ViFindBeginningOfQuotedTextObjectBoundary(delimiter, 6));
+            Assert.Equal(5, buffer.ViFindBeginningOfQuotedTextObjectBoundary(delimiter, 7));
+            Assert.Equal(7, buffer.ViFindBeginningOfQuotedTextObjectBoundary(delimiter, 8));
+            Assert.Equal(9, buffer.ViFindBeginningOfQuotedTextObjectBoundary(delimiter, 9));
+            Assert.Equal(9, buffer.ViFindBeginningOfQuotedTextObjectBoundary(delimiter, 10));
+            Assert.Equal(9, buffer.ViFindBeginningOfQuotedTextObjectBoundary(delimiter, 11));
+
+            Assert.Equal(9, buffer.ViFindBeginningOfQuotedTextObjectBoundary(delimiter, 12));
+        }
     }
 }
diff --git a/test/TextObjectsr.Vi.diquotes.Tests.cs b/test/TextObjectsr.Vi.diquotes.Tests.cs

Original file line number	Diff line number	Diff line change
`@@ -301,6 +301,8 @@ private void SetDefaultViBindings()`
`301`	`301`
`302`	`302`	`_viChordTextObjectsTable = new Dictionary<PSKeyInfo, KeyHandler>`
`303`	`303`	`{`
	`304`	`+ { Keys.DQuote, MakeKeyHandler(ViHandleTextObject, "QuoteTextObject")},`
	`305`	`+ { Keys.SQuote, MakeKeyHandler(ViHandleTextObject, "QuoteTextObject")},`
`304`	`306`	`{ Keys.W, MakeKeyHandler(ViHandleTextObject, "WordTextObject")},`
`305`	`307`	`};`
`306`	`308`