Better multi-line editing

These changes provide a more seemless editing experience when
the command input has multiple lines.

The history recall functions now avoid recalling history if the
input has multiple lines _and_ we aren't in the middle of
recalling history.  If you do want to edit a recalled multi-line
line (ugh) then you can first use something like LeftArrow then
UpArrow will work like you would want.

BeginningOfLine/EndOfLine have been changed as well.  If you're
already at the start/end of a line, you'll go to the start/end
of the input, otherwise you'll go to the start/end of the line.

Two new functions have been added for moving up/down lines in case
somebody wants to bind those independently of history, but I don't
see those being used much.

Fixes #47

Author: lzybkr

PSReadLine/History.cs

@@ -294,6 +294,12 @@ private void SaveCurrentLine()
 
         private void HistoryRecall(int direction)
         {
+            if (_recallHistoryCommandCount == 0 && LineIsMultiLine())
+            {
+                MoveToLine(direction);
+                return;
+            }
+
             int newHistoryIndex;
             if (Options.HistoryNoDuplicates)
             {
@@ -340,23 +346,39 @@ private void HistoryRecall(int direction)
         /// </summary>
         public static void PreviousHistory(ConsoleKeyInfo? key = null, object arg = null)
         {
+            int numericArg;
+            TryGetArgAsInt(arg, out numericArg, -1);
+            if (numericArg > 0)
+            {
+                numericArg = -numericArg;
+            }
+
             _singleton.SaveCurrentLine();
-            _singleton.HistoryRecall(-1);
+            _singleton.HistoryRecall(numericArg);
         }
 
         /// <summary>
         /// Replace the current input with the 'next' item from PSReadline history.
         /// </summary>
         public static void NextHistory(ConsoleKeyInfo? key = null, object arg = null)
         {
+            int numericArg;
+            TryGetArgAsInt(arg, out numericArg, +1);
+
             _singleton.SaveCurrentLine();
-            _singleton.HistoryRecall(+1);
+            _singleton.HistoryRecall(numericArg);
         }
 
         private void HistorySearch(int direction)
         {
             if (_searchHistoryCommandCount == 0)
             {
+                if (LineIsMultiLine())
+                {
+                    MoveToLine(direction);
+                    return;
+                }
+
                 _searchHistoryPrefix = _buffer.ToString(0, _current);
                 _emphasisStart = 0;
                 _emphasisLength = _current;
@@ -416,8 +438,15 @@ public static void EndOfHistory(ConsoleKeyInfo? key = null, object arg = null)
         /// </summary>
         public static void HistorySearchBackward(ConsoleKeyInfo? key = null, object arg = null)
         {
+            int numericArg;
+            TryGetArgAsInt(arg, out numericArg, -1);
+            if (numericArg > 0)
+            {
+                numericArg = -numericArg;
+            }
+
             _singleton.SaveCurrentLine();
-            _singleton.HistorySearch(-1);
+            _singleton.HistorySearch(numericArg);
         }
 
         /// <summary>
@@ -426,8 +455,11 @@ public static void HistorySearchBackward(ConsoleKeyInfo? key = null, object arg
         /// </summary>
         public static void HistorySearchForward(ConsoleKeyInfo? key = null, object arg = null)
         {
+            int numericArg;
+            TryGetArgAsInt(arg, out numericArg, +1);
+
             _singleton.SaveCurrentLine();
-            _singleton.HistorySearch(+1);
+            _singleton.HistorySearch(numericArg);
         }
 
         private void UpdateHistoryDuringInteractiveSearch(string toMatch, int direction, ref int searchFromPoint)

PSReadLine/Movement.cs

@@ -6,21 +6,61 @@ namespace PSConsoleUtilities
 {
     public partial class PSConsoleReadLine
     {
+        private int _moveToLineCommandCount;
+        private int _moveToLineDesiredColumn;
+
         /// <summary>
-        /// Move the cursor to the end of the input.
+        /// If the input has multiple lines, move to the end of the current line,
+        /// or if already at the end of the line, move to the end of the input.
+        /// If the input has a single line, move to the end of the input.
         /// </summary>
         public static void EndOfLine(ConsoleKeyInfo? key = null, object arg = null)
         {
-            _singleton._current = _singleton._buffer.Length;
+            if (_singleton.LineIsMultiLine())
+            {
+                int i = _singleton._current;
+                for (; i < _singleton._buffer.Length; i++)
+                {
+                    if (_singleton._buffer[i] == '\n')
+                    {
+                        break;
+                    }
+                }
+
+                _singleton._current = (i == _singleton._current) ? _singleton._buffer.Length : i;
+            }
+            else
+            {
+                _singleton._current = _singleton._buffer.Length;
+            }
             _singleton.PlaceCursor();
         }
 
         /// <summary>
-        /// Move the cursor to the end of the input.
+        /// If the input has multiple lines, move to the start of the current line,
+        /// or if already at the start of the line, move to the start of the input.
+        /// If the input has a single line, move to the start of the input.
         /// </summary>
         public static void BeginningOfLine(ConsoleKeyInfo? key = null, object arg = null)
         {
-            _singleton._current = 0;
+            if (_singleton.LineIsMultiLine())
+            {
+                int i = Math.Max(0, _singleton._current - 1);
+                for (; i > 1; i--)
+                {
+                    if (_singleton._buffer[i] == '\n')
+                    {
+                        i += 1;
+                        break;
+                    }
+                }
+
+                _singleton._current = (i == _singleton._current) ? 0 : i;
+            }
+            else
+            {
+                _singleton._current = 0;
+            }
             _singleton.PlaceCursor();
         }
 
@@ -50,6 +90,68 @@ public static void BackwardChar(ConsoleKeyInfo? key = null, object arg = null)
             }
         }
 
+        private void MoveToLine(int numericArg)
+        {
+            const int endOfLine = int.MaxValue;
+
+            _moveToLineCommandCount += 1;
+            var coords = ConvertOffsetToCoordinates(_current);
+            if (_moveToLineCommandCount == 1)
+            {
+                _moveToLineDesiredColumn =
+                    (_current == _buffer.Length || _buffer[_current] == '\n')
+                        ? endOfLine
+                        : coords.X;
+            }
+
+            var topLine = _initialY + Options.ExtraPromptLineCount;
+
+            var newY = coords.Y + numericArg;
+            coords.Y = (short)Math.Max(newY, topLine);
+            if (_moveToLineDesiredColumn != endOfLine)
+            {
+                coords.X = (short)_moveToLineDesiredColumn;
+            }
+
+            var newCurrent = ConvertLineAndColumnToOffset(coords);
+            if (newCurrent != -1)
+            {
+                _current = newCurrent;
+                if (_moveToLineDesiredColumn == endOfLine)
+                {
+                    while (_current < _buffer.Length && _buffer[_current] != '\n')
+                    {
+                        _current += 1;
+                    }
+                }
+                PlaceCursor();
+            }
+        }
+
+        /// <summary>
+        /// Move the cursor to the previous line.
+        /// </summary>
+        public static void PreviousLine(ConsoleKeyInfo? key = null, object arg = null)
+        {
+            int numericArg;
+            if (TryGetArgAsInt(arg, out numericArg, 1))
+            {
+                _singleton.MoveToLine(-numericArg);
+            }
+        }
+
+        /// <summary>
+        /// Move the cursor to the next line.
+        /// </summary>
+        public static void NextLine(ConsoleKeyInfo? key = null, object arg = null)
+        {
+            int numericArg;
+            if (TryGetArgAsInt(arg, out numericArg, 1))
+            {
+                _singleton.MoveToLine(numericArg);
+            }
+        }
+
         /// <summary>
         /// Move the cursor forward to the start of the next word.
         /// Word boundaries are defined by a configurable set of characters.

PSReadLine/PSReadLineResources.Designer.cs

@@ -399,4 +399,10 @@ Exception:
 {2}
 -----------------------------------------------------------------------</value>
   </data>
+  <data name="NextLineDescription" xml:space="preserve">
+    <value>Move the cursor to the next line if the input has multiple lines.</value>
+  </data>
+  <data name="PreviousLineDescription" xml:space="preserve">
+    <value>Move the cursor to the previous line if the input has multiple lines.</value>
+  </data>
 </root>

PSReadLine/PSReadLineResources.resx

@@ -280,6 +280,7 @@ private string InputLoop()
                 var recallHistoryCommandCount = _recallHistoryCommandCount;
                 var yankLastArgCommandCount = _yankLastArgCommandCount;
                 var visualSelectionCommandCount = _visualSelectionCommandCount;
+                var movingAtEndOfLineCount = _moveToLineCommandCount;
 
                 var key = ReadKey();
                 ProcessOneKey(key, _dispatchTable, ignoreIfNoAction: false, arg: null);
@@ -340,6 +341,10 @@ private string InputLoop()
                     _visualSelectionCommandCount = 0;
                     Render();  // Clears the visual selection
                 }
+                if (movingAtEndOfLineCount == _moveToLineCommandCount)
+                {
+                    _moveToLineCommandCount = 0;
+                }
             }
         }
 

PSReadLine/ReadLine.cs

@@ -501,6 +501,61 @@ private COORD ConvertOffsetToCoordinates(int offset)
             return new COORD {X = (short)x, Y = (short)y};
         }
 
+        private int ConvertLineAndColumnToOffset(COORD coord)
+        {
+            int offset;
+            int x = _initialX;
+            int y = _initialY + Options.ExtraPromptLineCount;
+
+            int bufferWidth = Console.BufferWidth;
+            var continuationPromptLength = Options.ContinuationPrompt.Length;
+            for (offset = 0; offset < _buffer.Length; offset++)
+            {
+                // If we are on the correct line, return when we find
+                // the correct column
+                if (coord.Y == y && coord.X <= x)
+                {
+                    return offset;
+                }
+                char c = _buffer[offset];
+                if (c == '\n')
+                {
+                    // If we are about to move off of the correct line,
+                    // the line was shorter than the column we wanted so return.
+                    if (coord.Y == y)
+                    {
+                        return offset;
+                    }
+                    y += 1;
+                    x = continuationPromptLength;
+                }
+                else
+                {
+                    x += char.IsControl(c) ? 2 : 1;
+                    // Wrap?  No prompt when wrapping
+                    if (x >= bufferWidth)
+                    {
+                        x -= bufferWidth;
+                        y += 1;
+                    }
+                }
+            }
+
+            // Return -1 if y is out of range, otherwise the last line was shorter
+            // than we wanted, but still in range so just return the last offset.B
+            return (coord.Y == y) ? offset : -1;
+        }
+
+        private bool LineIsMultiLine()
+        {
+            for (int i = 0; i < _buffer.Length; i++)
+            {
+                if (_buffer[i] == '\n')
+                    return true;
+            }
+            return false;
+        }
+
         private int GetStatusLineCount()
         {
             if (_statusLinePrompt == null)

PSReadLine/Render.cs

@@ -28,11 +28,23 @@ LONG DESCRIPTION
 
     EndOfLine                (Cmd: <End>                Emacs: <End> or <Ctrl+E>)
 
-        Move the cursor to the end of the input.
+        If the input has multiple lines, move to the end of the current line,
+        or if already at the end of the line, move to the end of the input.
+        If the input has a single line, move to the end of the input.
 
     BeginningOfLine          (Cmd: <Home>               Emacs: <Home> or <Ctrl+A>)
 
-        Move the cursor to the start of the input.
+        If the input has multiple lines, move to the start of the current line,
+        or if already at the start of the line, move to the start of the input.
+        If the input has a single line, move to the start of the input.
+
+    NextLine                 (Cmd: unbound              Emacs: unbound)
+
+        Move the cursor to the next line if the input has multiple lines.
+
+    PreviousLine             (Cmd: unbound              Emacs: unbound)
+
+        Move the cursor to the previous line if the input has multiple lines.
 
     ForwardChar              (Cmd: <RightArrow>         Emacs: <RightArrow> or <Ctrl+F>)