Add interactive option (#486)

Author: Johnny A. dos Santos

ExchangeSharpConsole/ExchangeSharpConsole.csproj

@@ -1,4 +1,4 @@
-<Project Sdk="Microsoft.NET.Sdk">
+<Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
     <OutputType>Exe</OutputType>
@@ -15,6 +15,7 @@
 
   <ItemGroup>
     <PackageReference Include="CommandLineParser" Version="2.6.0" />
+    <PackageReference Include="ReadLine" Version="2.0.1" />
   </ItemGroup>
 
   <ItemGroup>

ExchangeSharpConsole/Options/BaseOption.cs

@@ -129,9 +129,14 @@ protected async Task RunWebSocket(string exchangeName, Func<IExchangeAPI, Task<I
 			Console.WriteLine("Connecting web socket to {0}...", api.Name);
 
 			IWebSocket socket = null;
+			var tcs = new TaskCompletionSource<bool>();
 
 			// ReSharper disable once AccessToModifiedClosure
-			var disposable = KeepSessionAlive(() => socket?.Dispose());
+			var disposable = KeepSessionAlive(() =>
+			{
+				socket?.Dispose();
+				tcs.TrySetResult(true);
+			});
 
 			try
 			{
@@ -148,10 +153,11 @@ protected async Task RunWebSocket(string exchangeName, Func<IExchangeAPI, Task<I
 
 					// ReSharper disable once AccessToDisposedClosure
 					disposable.Dispose();
-					WaitInteractively();
 
 					return Task.CompletedTask;
 				};
+
+				await tcs.Task;
 			}
 			catch
 			{

ExchangeSharpConsole/Options/InteractiveOption.cs

@@ -0,0 +1,128 @@
+using System;
+using System.IO;
+using System.Linq;
+using System.Reflection;
+using System.Text;
+using System.Threading.Tasks;
+using CommandLine;
+
+namespace ExchangeSharpConsole.Options
+{
+	[Verb("interactive", HelpText = "Enables an interactive session.")]
+	public class InteractiveOption : BaseOption
+	{
+		internal static readonly string HistoryFilePath =
+			Path.Combine(
+				Environment.GetFolderPath(Environment.SpecialFolder.UserProfile),
+				".exchange-sharp-history"
+			);
+
+		/// <summary>
+		/// UTF-8 No BOM
+		/// </summary>
+		internal static readonly Encoding HistoryFileEncoding = new UTF8Encoding(false, true);
+
+		internal const int HistoryMax = 100;
+
+		public override async Task RunCommand()
+		{
+			ReadLine.HistoryEnabled = true;
+			ReadLine.AutoCompletionHandler = new AutoCompleter();
+			Console.TreatControlCAsInput = true;
+			var program = Program.Instance;
+
+			LoadHistory();
+
+			try
+			{
+				await RunInteractiveSession(program);
+				Console.WriteLine();
+			}
+			finally
+			{
+				SaveHistory();
+			}
+		}
+
+		private void LoadHistory()
+		{
+			if (!File.Exists(HistoryFilePath))
+				return;
+
+			var lines = File.ReadLines(HistoryFilePath, HistoryFileEncoding)
+				.TakeLast(HistoryMax)
+				.ToArray();
+
+			ReadLine.AddHistory(lines);
+		}
+
+		private void SaveHistory()
+		{
+			var lines = ReadLine.GetHistory()
+				.TakeLast(HistoryMax)
+				.ToArray();
+
+			using var sw = File.CreateText(HistoryFilePath);
+
+			foreach (var line in lines)
+			{
+				sw.WriteLine(line);
+			}
+		}
+
+		private static async Task RunInteractiveSession(Program program)
+		{
+			while (true)
+			{
+				var command = ReadLine.Read("ExchangeSharp> ", "help");
+
+				if (command.Equals("exit", StringComparison.OrdinalIgnoreCase))
+					break;
+
+				var (error, help) = program.ParseArguments(
+					command.Split(' '),
+					out var options
+				);
+
+				if (error || help)
+					continue;
+
+				await program.Run(options, exitOnError: false);
+			}
+		}
+
+		public class AutoCompleter : IAutoCompleteHandler
+		{
+			private readonly string[] options;
+
+			public AutoCompleter()
+			{
+				var optionsList = Program.Instance.CommandOptions
+					.Where(t => typeof(InteractiveOption) != t)
+					.Select(t => t.GetCustomAttribute<VerbAttribute>(true))
+					.Where(v => !v.Hidden)
+					.Select(v => v.Name)
+					.ToList();
+
+				optionsList.Add("help");
+				optionsList.Add("exit");
+
+				options = optionsList
+					.OrderBy(o => o)
+					.ToArray();
+			}
+
+			public string[] GetSuggestions(string text, int index)
+			{
+				if (string.IsNullOrWhiteSpace(text))
+					return options;
+
+				return options
+					.Where(o => o.StartsWith(text, StringComparison.OrdinalIgnoreCase))
+					.ToArray();
+			}
+
+			public char[] Separators { get; set; } = {' ', '.', '/', '\"', '\''};
+		}
+	}
+}

ExchangeSharpConsole/Program.Main.cs

@@ -9,9 +9,11 @@ public partial class Program
 		internal const int ExitCodeOk = 0;
 		internal const int ExitCodeErrorParsing = -1;
 
+		public static Program Instance { get; } = new Program();
+
 		public static async Task<int> Main(string[] args)
 		{
-			var program = new Program();
+			var program = Instance;
 			var (error, help) = program.ParseArguments(args, out var options);
 
 			if (help)

ExchangeSharpConsole/Program.cs

@@ -10,11 +10,36 @@ namespace ExchangeSharpConsole
 {
 	public partial class Program
 	{
-		private readonly Parser parser;
+		internal readonly Parser Parser;
+
+		public Type[] CommandOptions { get; } =
+		{
+			typeof(BuyOption),
+			typeof(CancelOrderOption),
+			typeof(CandlesOption),
+			typeof(ConvertOption),
+			typeof(ExampleOption),
+			typeof(ExportOption),
+			typeof(InteractiveOption),
+			typeof(KeysOption),
+			typeof(MarketSymbolsMetadataOption),
+			typeof(MarketSymbolsOption),
+			typeof(OrderDetailsOption),
+			typeof(OrderHistoryOption),
+			typeof(SellOption),
+			typeof(StatsOption),
+			typeof(SupportedExchangesOption),
+			typeof(TestOption),
+			typeof(TickerOption),
+			typeof(TradeHistoryOption),
+			typeof(WebSocketsOrderbookOption),
+			typeof(WebSocketsTickersOption),
+			typeof(WebSocketsTradesOption)
+		};
 
 		public Program()
 		{
-			parser = new Parser(c =>
+			Parser = new Parser(c =>
 			{
 				c.AutoHelp = true;
 				c.AutoVersion = true;
@@ -27,36 +52,14 @@ public Program()
 			});
 		}
 
-		private (bool error, bool help) ParseArguments(string[] args, out List<BaseOption> options)
+		internal (bool error, bool help) ParseArguments(string[] args, out List<BaseOption> options)
 		{
 			var error = false;
 			var help = false;
 			var optionList = new List<BaseOption>();
 
-			parser
-				.ParseArguments(
-					args,
-					typeof(BuyOption),
-					typeof(CancelOrderOption),
-					typeof(CandlesOption),
-					typeof(ConvertOption),
-					typeof(ExampleOption),
-					typeof(ExportOption),
-					typeof(KeysOption),
-					typeof(MarketSymbolsMetadataOption),
-					typeof(MarketSymbolsOption),
-					typeof(OrderDetailsOption),
-					typeof(OrderHistoryOption),
-					typeof(SellOption),
-					typeof(StatsOption),
-					typeof(SupportedExchangesOption),
-					typeof(TestOption),
-					typeof(TickerOption),
-					typeof(TradeHistoryOption),
-					typeof(WebSocketsOrderbookOption),
-					typeof(WebSocketsTickersOption),
-					typeof(WebSocketsTradesOption)
-				)
+			Parser
+				.ParseArguments(args, CommandOptions)
 				.WithParsed(opt => optionList.Add((BaseOption) opt))
 				.WithNotParsed(errs => (error, help) = ValidateParseErrors(errs));
 
@@ -88,7 +91,7 @@ public Program()
 			return (error, help);
 		}
 
-		private async Task Run(List<BaseOption> actions)
+		internal async Task Run(List<BaseOption> actions, bool exitOnError = true)
 		{
 			foreach (var action in actions)
 			{
@@ -103,7 +106,8 @@ private async Task Run(List<BaseOption> actions)
 				catch (Exception e)
 				{
 					Console.Error.WriteLine(e.Message);
-					Environment.Exit(ExitCodeError);
+					if (exitOnError)
+						Environment.Exit(ExitCodeError);
 					return;
 				}
 			}

ExchangeSharpConsole/Utilities/ConsoleSessionKeeper.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Diagnostics;
+using System.Text;
 using System.Threading;
 
 namespace ExchangeSharpConsole.Utilities
@@ -9,16 +10,19 @@ public class ConsoleSessionKeeper : IDisposable
 		private readonly Action callback;
 		private readonly Thread threadCheckKey;
 		private bool shouldStop;
+		private readonly bool previousConsoleCtrlCConfig;
 
 		public ConsoleSessionKeeper(Action callback = null)
 		{
 			this.callback = callback;
+			previousConsoleCtrlCConfig = Console.TreatControlCAsInput;
+			Console.TreatControlCAsInput = false;
 
 			Console.WriteLine("Press CTRL-C or Q to quit");
 
 			threadCheckKey = new Thread(CheckKeyCombination)
 			{
-				Name = "console-waiter",
+				Name = $"console-waiter-{callback?.Method.Name}",
 				IsBackground = false
 			};
 
@@ -29,33 +33,30 @@ public ConsoleSessionKeeper(Action callback = null)
 
 		private void CheckKeyCombination()
 		{
-			ConsoleKeyInfo cki;
-			do
+			using var stdin = Console.OpenStandardInput();
+			var charArr = new byte[2];
+
+			while (stdin.Read(charArr, 0, 2) > 0)
 			{
-				while (Console.KeyAvailable == false)
-				{
-					if (shouldStop)
-					{
-						return;
-					}
+				if (shouldStop)
+					return;
 
-					Thread.Sleep(100);
-					Thread.Yield();
-				}
+				var c = Encoding.UTF8.GetChars(charArr)[0];
+				if (c == 'q' || c == 'Q')
+					break;
+			}
 
-				cki = Console.ReadKey(true);
-			} while (!(cki.Key == ConsoleKey.Q || cki.Key == ConsoleKey.Escape));
+			if (shouldStop)
+				return;
 
 			Debug.WriteLine("Q pressed.");
-			callback?.Invoke();
 			Dispose();
 		}
 
 		private void OnConsoleOnCancelKeyPress(object sender, ConsoleCancelEventArgs args)
 		{
 			Debug.WriteLine("CTRL-C pressed.");
 			args.Cancel = true;
-			callback?.Invoke();
 			Dispose();
 		}
 
@@ -64,7 +65,9 @@ public void Dispose()
 			if (shouldStop)
 				return;
 
+			callback?.Invoke();
 			Console.CancelKeyPress -= OnConsoleOnCancelKeyPress;
+			Console.TreatControlCAsInput = previousConsoleCtrlCConfig;
 			// this does not work on .net core
 			// threadCheckKey.Abort();
 			shouldStop = true;