Supports '_' and '$' to move to the beginning and end of the logical line in Vi mode. (#812)

Fix #795

Author: springcomp

PSReadLine/KeyBindings.vi.cs

@@ -196,6 +196,7 @@ private void SetDefaultViBindings()
                 { Keys.Pound,           MakeKeyHandler(PrependAndAccept,     "PrependAndAccept") },
                 { Keys.Pipe,            MakeKeyHandler(GotoColumn,           "GotoColumn") },
                 { Keys.Uphat,           MakeKeyHandler(GotoFirstNonBlankOfLine, "GotoFirstNonBlankOfLine") },
+                { Keys.Underbar,        MakeKeyHandler(GotoFirstNonBlankOfLine, "GotoFirstNonBlankOfLine") },
                 { Keys.Tilde,           MakeKeyHandler(InvertCase,           "InvertCase") },
                 { Keys.Slash,           MakeKeyHandler(ViSearchHistoryBackward,   "ViSearchHistoryBackward") },
                 { Keys.CtrlR,           MakeKeyHandler(ViSearchHistoryBackward,   "ViSearchHistoryBackward") },

PSReadLine/Movement.vi.cs

@@ -152,7 +152,18 @@ public static void ViEndOfPreviousGlob(ConsoleKeyInfo? key = null, object arg =
         /// </summary>
         public static void MoveToEndOfLine(ConsoleKeyInfo? key = null, object arg = null)
         {
-            _singleton.MoveCursor(Math.Max(0, _singleton._buffer.Length + ViEndOfLineFactor));
+            if (_singleton.LineIsMultiLine())
+            {
+                var eol = GetEndOfLogicalLinePos(_singleton._current);
+                if (eol != _singleton._current)
+                {
+                    _singleton.MoveCursor(eol);
+                }
+            }
+            else
+            {
+                _singleton.MoveCursor(Math.Max(0, _singleton._buffer.Length + ViEndOfLineFactor));
+            }
         }
 
         /// <summary>
@@ -175,7 +186,8 @@ public static void NextWordEnd(ConsoleKeyInfo? key = null, object arg = null)
         public static void GotoColumn(ConsoleKeyInfo? key = null, object arg = null)
         {
             int col = arg as int? ?? -1;
-            if (col < 0 ) {
+            if (col < 0)
+            {
                 Ding();
                 return;
             }
@@ -195,14 +207,11 @@ public static void GotoColumn(ConsoleKeyInfo? key = null, object arg = null)
         /// Move the cursor to the first non-blank character in the line.
         /// </summary>
         public static void GotoFirstNonBlankOfLine(ConsoleKeyInfo? key = null, object arg = null)
-        {
-            for (int i = 0; i < _singleton._buffer.Length; i++)
-            {
-                if (!Char.IsWhiteSpace(_singleton._buffer[i]))
-                {
-                    _singleton.MoveCursor(i);
-                    return;
-                }
+        {
+            var newCurrent = GetFirstNonBlankOfLogicalLinePos(_singleton._current);
+            if (newCurrent != _singleton._current)
+            {
+                _singleton.MoveCursor(newCurrent);
             }
         }
 

PSReadLine/Position.cs

@@ -8,8 +8,7 @@ public partial class PSConsoleReadLine
         /// Returns the position of the beginning of line
         /// starting from the specified "current" position.
         /// </summary>
-        /// <param name="current"></param>
-        /// <returns></returns>
+        /// <param name="current">The position in the current logical line.</param>
         private static int GetBeginningOfLinePos(int current)
         {
             var newCurrent = current;
@@ -35,5 +34,57 @@ private static int GetBeginningOfLinePos(int current)
 
             return newCurrent;
         }
+
+        /// <summary>
+        /// Returns the position of the end of the logical line
+        /// as specified by the "current" position.
+        /// </summary>
+        /// <param name="current"></param>
+        /// <returns></returns>
+        private static int GetEndOfLogicalLinePos(int current)
+        {
+            var newCurrent = current;
+
+            for (var position = newCurrent; position < _singleton._buffer.Length; position++)
+            {
+                if (_singleton._buffer[position] == '\n')
+                {
+                    break;
+                }
+
+                newCurrent = position;
+            }
+
+            return newCurrent;
+        }
+
+        /// <summary>
+        /// Returns the position of the first non whitespace character in
+        /// the current logical line as specified by the "current" position.
+        /// </summary>
+        /// <param name="current">The position in the current logical line.</param>
+        private static int GetFirstNonBlankOfLogicalLinePos(int current)
+        {
+            var beginningOfLine = GetBeginningOfLinePos(current);
+
+            var newCurrent = beginningOfLine;
+
+            while (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';
+        }
     }
-}
+}

test/MovementTest.VI.Multiline.cs

@@ -58,6 +58,57 @@ public void ViMoveToFirstLogicalLine_MustDing_ForSingleLine()
             ViJumpMustDing(buffer, keys);
         }
 
+        [Fact]
+        public void ViMoveToFirstNonBlankOfLogicalLineThenJumpToEndOfLogicalLine()
+        {
+            TestSetup(KeyMode.Vi);
+
+            var continuationPrefixLength = PSConsoleReadLineOptions.DefaultContinuationPrompt.Length;
+
+            const string buffer = "\"\n  line\"";
+
+            Test(buffer, Keys(
+                _.DQuote, _.Enter, "  line", _.DQuote, _.Escape, CheckThat(() => AssertCursorLeftIs(continuationPrefixLength + 6)),
+                _.Underbar, CheckThat(() => AssertCursorLeftTopIs(continuationPrefixLength + 2, 1)),
+                _.Dollar, CheckThat(() => AssertCursorLeftTopIs(continuationPrefixLength + 6, 1)),
+                // also works forward
+                '0', CheckThat(() => AssertCursorLeftTopIs(continuationPrefixLength, 1)),
+                _.Underbar, CheckThat(() => AssertCursorLeftTopIs(continuationPrefixLength + 2, 1))
+                ));
+        }
+
+        [Fact]
+        public void ViMoveToFirstNonBlankOfLogicalLine_NoOp_OnEmptyLine()
+        {
+            TestSetup(KeyMode.Vi);
+
+            var continuationPrefixLength = PSConsoleReadLineOptions.DefaultContinuationPrompt.Length;
+
+            const string buffer = "\"\n\n\"";
+
+            Test(buffer, Keys(
+                _.DQuote, _.Enter, _.Enter, _.DQuote, _.Escape, _.K,
+                CheckThat(() => AssertCursorLeftTopIs(continuationPrefixLength + 0, 1)),
+                _.Underbar, CheckThat(() => AssertCursorLeftTopIs(continuationPrefixLength + 0, 1))
+            ));
+        }
+
+        [Fact]
+        public void ViMoveToEndOfLine_NoOp_OnEmptyLine()
+        {
+            TestSetup(KeyMode.Vi);
+
+            var continuationPrefixLength = PSConsoleReadLineOptions.DefaultContinuationPrompt.Length;
+
+            const string buffer = "\"\n\n\"";
+
+            Test(buffer, Keys(
+                _.DQuote, _.Enter, _.Enter, _.DQuote, _.Escape, _.K,
+                CheckThat(() => AssertCursorLeftTopIs(continuationPrefixLength + 0, 1)),
+                _.Dollar, CheckThat(() => AssertCursorLeftTopIs(continuationPrefixLength + 0, 1))
+            ));
+        }
+
         private void ViJumpMustDing(string expectedResult, params object[] keys)
         {
             TestSetup(KeyMode.Vi);