Add support for pasting text in multiline editors

Author: patriksvensson

src/RadLine.Tests/Utilities/TestInputSource.cs

@@ -1,14 +1,14 @@
 using System;
 using System.Collections.Generic;
-using System.Threading;
-using System.Threading.Tasks;
 
 namespace RadLine.Tests
 {
     public sealed class TestInputSource : IInputSource
     {
         private readonly Queue<ConsoleKeyInfo> _input;
 
+        public bool ByPassProcessing => true;
+
         public TestInputSource()
         {
             _input = new Queue<ConsoleKeyInfo>();
@@ -64,25 +64,19 @@ public TestInputSource Push(ConsoleKey input, ConsoleModifiers modifiers)
             return this;
         }
 
-        public ConsoleKeyInfo? ReadKey(bool intercept)
+        public bool IsKeyAvailable()
         {
-            if (_input.Count == 0)
-            {
-                throw new InvalidOperationException("No input available.");
-            }
-
-            return _input.Dequeue();
+            return _input.Count > 0;
         }
 
-        Task<ConsoleKeyInfo?> IInputSource.ReadKey(CancellationToken cancellationToken)
+        ConsoleKeyInfo IInputSource.ReadKey()
         {
             if (_input.Count == 0)
             {
                 throw new InvalidOperationException("No keys available");
             }
 
-            var key = _input.Dequeue();
-            return Task.FromResult<ConsoleKeyInfo?>(key);
+            return _input.Dequeue();
         }
     }
 }

src/RadLine/IInputSource.cs

@@ -1,11 +1,12 @@
 using System;
-using System.Threading;
-using System.Threading.Tasks;
 
 namespace RadLine
 {
     public interface IInputSource
     {
-        Task<ConsoleKeyInfo?> ReadKey(CancellationToken cancellationToken);
+        bool ByPassProcessing { get; }
+
+        bool IsKeyAvailable();
+        ConsoleKeyInfo ReadKey();
     }
 }

src/RadLine/Internal/DefaultInputSource.cs

@@ -1,6 +1,4 @@
 using System;
-using System.Threading;
-using System.Threading.Tasks;
 using Spectre.Console;
 
 namespace RadLine
@@ -9,12 +7,19 @@ internal sealed class DefaultInputSource : IInputSource
     {
         private readonly IAnsiConsole _console;
 
+        public bool ByPassProcessing => false;
+
         public DefaultInputSource(IAnsiConsole console)
         {
             _console = console ?? throw new ArgumentNullException(nameof(console));
         }
 
-        public async Task<ConsoleKeyInfo?> ReadKey(CancellationToken cancellationToken)
+        public bool IsKeyAvailable()
+        {
+            return Console.KeyAvailable;
+        }
+
+        public ConsoleKeyInfo ReadKey()
         {
             if (!_console.Profile.Out.IsTerminal
                 || !_console.Profile.Capabilities.Interactive)
@@ -23,21 +28,6 @@ public DefaultInputSource(IAnsiConsole console)
             }
 
             // TODO: Put terminal in raw mode
-            while (true)
-            {
-                if (cancellationToken.IsCancellationRequested)
-                {
-                    return null;
-                }
-
-                if (Console.KeyAvailable)
-                {
-                    break;
-                }
-
-                await Task.Delay(5, cancellationToken).ConfigureAwait(false);
-            }
-
             return Console.ReadKey(true);
         }
     }

src/RadLine/Internal/InputBuffer.cs

@@ -0,0 +1,131 @@
+using System;
+using System.Collections.Generic;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace RadLine
+{
+    internal sealed class InputBuffer
+    {
+        private readonly IInputSource _source;
+        private readonly Queue<ConsoleKeyInfo> _queue;
+        private KeyBinding? _newLineBinding;
+        private KeyBinding? _submitBinding;
+
+        public InputBuffer(IInputSource source)
+        {
+            _source = source ?? throw new ArgumentNullException(nameof(source));
+            _queue = new Queue<ConsoleKeyInfo>();
+        }
+
+        public void Initialize(KeyBindings bindings)
+        {
+            bindings.TryFindKeyBindings<NewLineCommand>(out _newLineBinding);
+            bindings.TryFindKeyBindings<SubmitCommand>(out _submitBinding);
+        }
+
+        public async Task<ConsoleKeyInfo?> ReadKey(bool multiline, CancellationToken cancellationToken)
+        {
+            if (_queue.Count > 0)
+            {
+                return _queue.Dequeue();
+            }
+
+            // Wait for the user to enter a key
+            var key = await ReadKeyFromSource(wait: true, cancellationToken);
+            if (key == null)
+            {
+                return null;
+            }
+            else
+            {
+                _queue.Enqueue(key.Value);
+            }
+
+            if (_source.IsKeyAvailable())
+            {
+                // Read all remaining keys from the buffer
+                await ReadRemainingKeys(multiline, cancellationToken);
+            }
+
+            // Got something?
+            if (_queue.Count > 0)
+            {
+                return _queue.Dequeue();
+            }
+
+            return null;
+        }
+
+        private async Task ReadRemainingKeys(bool multiline, CancellationToken cancellationToken)
+        {
+            var keys = new Queue<ConsoleKeyInfo>();
+
+            while (true)
+            {
+                var key = await ReadKeyFromSource(wait: false, cancellationToken);
+                if (key == null)
+                {
+                    break;
+                }
+
+                keys.Enqueue(key.Value);
+            }
+
+            if (keys.Count > 0)
+            {
+                // Process the input when we're somewhat sure that
+                // the input has been automated in some fashion,
+                // and the editor support multiline. The input source
+                // can bypass this kind of behavior, so we need to check
+                // it as well to see if we should do any processing.
+                var shouldProcess = multiline && keys.Count >= 5 && !_source.ByPassProcessing;
+
+                while (keys.Count > 0)
+                {
+                    var key = keys.Dequeue();
+
+                    if (shouldProcess && _submitBinding != null && _newLineBinding != null)
+                    {
+                        // Is the key trying to submit?
+                        if (_submitBinding.Equals(key))
+                        {
+                            // Insert a new line instead
+                            key = _newLineBinding.AsConsoleKeyInfo();
+                        }
+                    }
+
+                    _queue.Enqueue(key);
+                }
+            }
+        }
+
+        private async Task<ConsoleKeyInfo?> ReadKeyFromSource(bool wait, CancellationToken cancellationToken)
+        {
+            if (wait)
+            {
+                while (true)
+                {
+                    if (cancellationToken.IsCancellationRequested)
+                    {
+                        return null;
+                    }
+
+                    if (_source.IsKeyAvailable())
+                    {
+                        break;
+                    }
+
+                    await Task.Delay(5, cancellationToken).ConfigureAwait(false);
+                }
+            }
+
+            if (_source.IsKeyAvailable())
+            {
+                return _source.ReadKey();
+            }
+
+            return null;
+        }
+    }
+}

src/RadLine/Internal/KeyBinding.cs

@@ -2,7 +2,7 @@
 
 namespace RadLine
 {
-    internal sealed class KeyBinding
+    internal sealed class KeyBinding : IEquatable<ConsoleKeyInfo>
     {
         public ConsoleKey Key { get; }
         public ConsoleModifiers? Modifiers { get; }
@@ -12,5 +12,29 @@ public KeyBinding(ConsoleKey key, ConsoleModifiers? modifiers = null)
             Key = key;
             Modifiers = modifiers;
         }
+
+        public ConsoleKeyInfo AsConsoleKeyInfo()
+        {
+            return new ConsoleKeyInfo(
+                (char)0, Key,
+                HasModifier(ConsoleModifiers.Shift),
+                HasModifier(ConsoleModifiers.Alt),
+                HasModifier(ConsoleModifiers.Control));
+        }
+
+        private bool HasModifier(ConsoleModifiers modifier)
+        {
+            if (Modifiers != null)
+            {
+                return Modifiers.Value.HasFlag(modifier);
+            }
+
+            return false;
+        }
+
+        public bool Equals(ConsoleKeyInfo other)
+        {
+            return other.Modifiers == (Modifiers ?? 0) && other.Key == Key;
+        }
     }
 }

src/RadLine/KeyBindings.cs

@@ -1,28 +1,39 @@
 using System;
 using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
 using System.Linq;
 
 namespace RadLine
 {
     public sealed class KeyBindings
     {
         private readonly Dictionary<KeyBinding, Func<LineEditorCommand>> _bindings;
+        private readonly Dictionary<Type, KeyBinding> _bindingLookup;
 
         public int Count => _bindings.Count;
 
         public KeyBindings()
         {
             _bindings = new Dictionary<KeyBinding, Func<LineEditorCommand>>(new KeyBindingComparer());
+            _bindingLookup = new Dictionary<Type, KeyBinding>();
         }
 
-        internal void Add(KeyBinding binding, Func<LineEditorCommand> command)
+        internal void Add<TCommand>(KeyBinding binding, Func<TCommand> command)
+            where TCommand : LineEditorCommand
         {
             if (binding is null)
             {
                 throw new ArgumentNullException(nameof(binding));
             }
 
-            _bindings[binding] = command;
+            _bindings[binding] = () => command();
+            _bindingLookup[typeof(TCommand)] = binding;
+        }
+
+        internal bool TryFindKeyBindings<TCommand>([NotNullWhen(true)] out KeyBinding? binding)
+            where TCommand : LineEditorCommand
+        {
+            return _bindingLookup.TryGetValue(typeof(TCommand), out binding);
         }
 
         internal void Remove(KeyBinding binding)

src/RadLine/LineEditor.cs

@@ -15,6 +15,7 @@ public sealed class LineEditor : IHighlighterAccessor
         private readonly IAnsiConsole _console;
         private readonly LineEditorRenderer _renderer;
         private readonly LineEditorHistory _history;
+        private readonly InputBuffer _input;
 
         public KeyBindings KeyBindings { get; }
         public bool MultiLine { get; init; } = false;
@@ -32,6 +33,7 @@ public LineEditor(IAnsiConsole? terminal = null, IInputSource? source = null, IS
             _provider = provider;
             _renderer = new LineEditorRenderer(_console, this);
             _history = new LineEditorHistory();
+            _input = new InputBuffer(_source);
 
             KeyBindings = new KeyBindings();
             KeyBindings.AddDefault();
@@ -56,6 +58,7 @@ public static bool IsSupported(IAnsiConsole console)
             var state = new LineEditorState(Prompt, Text);
 
             _history.Reset();
+            _input.Initialize(KeyBindings);
             _renderer.Refresh(state);
 
             while (true)
@@ -155,7 +158,7 @@ public static bool IsSupported(IAnsiConsole console)
 
                 // Get command
                 var command = default(LineEditorCommand);
-                var key = await _source.ReadKey(cancellationToken).ConfigureAwait(false);
+                var key = await _input.ReadKey(MultiLine, cancellationToken).ConfigureAwait(false);
                 if (key != null)
                 {
                     if (key.Value.KeyChar != 0 && !char.IsControl(key.Value.KeyChar))