Refactor command handling

Author: WeihanLi

src/HTTPie/Middleware/HttpSSLMiddleware.cs

@@ -16,30 +16,27 @@ public HttpSslMiddleware(HttpRequestModel requestModel)
         _requestModel = requestModel;
     }
 
-    private static readonly Option<bool> DisableSslVerifyOption = new(new[] { "--no-verify", "--verify=no" }, "disable ssl cert check");
-    private static readonly Option<SslProtocols> SslProtocalOption = new("--ssl", "specific the ssl protocols, ssl3, tls, tls1.1, tls1.2, tls1.3");
+    private static readonly Option<bool> DisableSslVerifyOption =
+        new(new[] { "--no-verify", "--verify=no" }, "disable ssl cert check");
 
-    public Option[] SupportedOptions() => new Option[]
-        {
-            DisableSslVerifyOption,
-            SslProtocalOption,
-        };
+    private static readonly Option<SslProtocols?> SslProtocalOption =
+        new("--ssl", "specific the ssl protocols, ssl3, tls, tls1.1, tls1.2, tls1.3");
+
+    public Option[] SupportedOptions() => new Option[] { DisableSslVerifyOption, SslProtocalOption, };
 
     public Task Invoke(HttpClientHandler httpClientHandler, Func<HttpClientHandler, Task> next)
     {
-        if (_requestModel.Options.Contains("--verify=no")
-            || _requestModel.ParseResult.HasOption(DisableSslVerifyOption))
+        if (_requestModel.ParseResult.HasOption(DisableSslVerifyOption))
         {
             // ignore server cert
             httpClientHandler.ServerCertificateCustomValidationCallback = (_, _, _, _) => true;
         }
+
         // sslProtocols
-        var sslOption = _requestModel.Options.FirstOrDefault(x => x.StartsWith("--ssl="))?["--ssl=".Length..];
-        if (!string.IsNullOrEmpty(sslOption))
+        var sslOption = _requestModel.ParseResult.GetValueForOption(SslProtocalOption);
+        if (sslOption.HasValue)
         {
-            sslOption = sslOption.Replace(".", string.Empty);
-            if (Enum.TryParse(sslOption, out SslProtocols sslProtocols))
-                httpClientHandler.SslProtocols = sslProtocols;
+            httpClientHandler.SslProtocols = sslOption.Value;
         }
 
         return next(httpClientHandler);

src/HTTPie/Models/HttpContext.cs

@@ -2,6 +2,7 @@
 // Licensed under the MIT license.
 
 using Newtonsoft.Json;
+using System.CommandLine.Invocation;
 using WeihanLi.Common.Abstractions;
 
 namespace HTTPie.Models;
@@ -25,7 +26,12 @@ public HttpContext(HttpRequestModel request, HttpResponseModel? response = null)
 
     [System.Text.Json.Serialization.JsonIgnore]
     [JsonIgnore]
-    public CancellationToken CancellationToken { get; set; }
+    public CancellationToken CancellationToken => InvocationContext.GetCancellationToken();
+
+    [System.Text.Json.Serialization.JsonIgnore]
+    [JsonIgnore]
+    public InvocationContext InvocationContext { get; set; } = null!;
+
     public IDictionary<string, object?> Properties { get; } = new Dictionary<string, object?>();
 
     public void UpdateFlag(string flagName, bool value)

src/HTTPie/Program.cs

@@ -29,11 +29,12 @@
     }
     builder.SetMinimumLevel(debugEnabled ? LogLevel.Debug : LogLevel.Warning);
 });
-serviceCollection.RegisterHTTPieServices();
+serviceCollection.RegisterApplicationServices();
 await using var services = serviceCollection.BuildServiceProvider();
-DependencyResolver.SetDependencyResolver(services);
-Helpers.InitializeSupportOptions(services);
-if (args is not { Length: > 0 })
+
+// output helps when no argument or there's only "-h"/"/h"
+if (args is not { Length: > 0 } || 
+    (args.Length == 1 && args[0] is "-h" or "/h"))
 {
     args = new[] { "--help" };
 }
@@ -45,12 +46,4 @@
 
 var logger = services.GetRequiredService<ILogger>();
 logger.PrintInputParameters(args.StringJoin(";"));
-try
-{
-    return await services.Handle(args);
-}
-catch (Exception e)
-{
-    logger.InvokeRequestException(e);
-    return -1;
-}
+return await services.Handle(args);

src/HTTPie/Utilities/Helpers.cs

@@ -9,6 +9,7 @@
 using Microsoft.Extensions.DependencyInjection.Extensions;
 using Microsoft.Extensions.Logging;
 using System.CommandLine.Builder;
+using System.CommandLine.Invocation;
 using System.CommandLine.IO;
 using System.Text.Encodings.Web;
 using System.Text.Json;
@@ -27,15 +28,13 @@ public static class Helpers
         HttpMethod.Delete.Method,
         HttpMethod.Options.Method
     };
-
+    
     public static readonly JsonSerializerOptions JsonSerializerOptions = new()
     {
         WriteIndented = true,
         Encoder = JavaScriptEncoder.UnsafeRelaxedJsonEscaping
     };
 
-    private static readonly HashSet<Option> SupportedOptions = new();
-
     private static IServiceCollection AddHttpHandlerMiddleware<THttpHandlerMiddleware>(
         this IServiceCollection serviceCollection)
         where THttpHandlerMiddleware : IHttpHandlerMiddleware
@@ -63,26 +62,11 @@ private static IServiceCollection AddResponseMiddleware<TResponseMiddleware>(
         return serviceCollection;
     }
 
-    public static void InitializeSupportOptions(IServiceProvider serviceProvider)
+    private static Parser ConstructCommand(this IServiceProvider serviceProvider, Func<InvocationContext, Task>? handler = null)
     {
-        if (SupportedOptions.Count == 0)
-        {
-            foreach (var option in
-                serviceProvider
-                    .GetServices<IHttpHandlerMiddleware>().SelectMany(x => x.SupportedOptions())
-                    .Union(serviceProvider.GetServices<IRequestMiddleware>().SelectMany(x => x.SupportedOptions())
-                    .Union(serviceProvider.GetServices<IResponseMiddleware>().SelectMany(x => x.SupportedOptions()))
-                    .Union(serviceProvider.GetRequiredService<IOutputFormatter>().SupportedOptions())
-                    .Union(serviceProvider.GetRequiredService<IRequestExecutor>().SupportedOptions()))
-                    .Union(serviceProvider.GetRequiredService<ILoadTestExporterSelector>().SupportedOptions())
-                    .Union(serviceProvider.GetServices<ILoadTestExporter>().SelectMany(x => x.SupportedOptions()))
-                    )
-            {
-                SupportedOptions.Add(option);
-            }
-        }
-        var command = InitializeCommand();
+        var command = InitializeCommandInternal(serviceProvider, handler);
         var builder = new CommandLineBuilder(command);
+        // builder.UseDefaults();
         builder
             .UseHelp("--help", "-?", "/?")
             .UseEnvironmentVariableDirective()
@@ -95,54 +79,93 @@ public static void InitializeSupportOptions(IServiceProvider serviceProvider)
             .CancelOnProcessTermination()
             .AddMiddleware(async (invocationContext, next) =>
             {
-                var context = DependencyResolver.ResolveRequiredService<HttpContext>();
-                context.CancellationToken = invocationContext.GetCancellationToken();
-                await DependencyResolver.ResolveRequiredService<IRequestExecutor>()
-                    .ExecuteAsync(context);
-                var output = await DependencyResolver.ResolveRequiredService<IOutputFormatter>()
-                    .GetOutput(context);
-                invocationContext.Console.Out.WriteLine(output.Trim());
-
+                var context = serviceProvider.GetRequiredService<HttpContext>();
+                context.InvocationContext = invocationContext;
+                
+                var requestModel = context.Request;
+                requestModel.ParseResult = invocationContext.ParseResult;
+
+                var method = requestModel.ParseResult.UnmatchedTokens
+                    .FirstOrDefault(x => HttpMethods.Contains(x));
+                if (!string.IsNullOrEmpty(method))
+                {
+                    requestModel.Method = new HttpMethod(method);
+                }
+                // Url
+                requestModel.Url = requestModel.ParseResult.UnmatchedTokens.FirstOrDefault(x =>
+                                       !x.StartsWith("-", StringComparison.Ordinal)
+                                       && !HttpMethods.Contains(x))
+                                   ?? string.Empty;
+                if (string.IsNullOrEmpty(requestModel.Url))
+                {
+                    throw new InvalidOperationException("The request url can not be null");
+                }
+                requestModel.RequestItems = requestModel.ParseResult.UnmatchedTokens
+                    .Except(new[] { method, requestModel.Url })
+                    .WhereNotNull()
+                    .Where(x => !x.StartsWith('-'))
+                    .ToArray();
+                
                 await next(invocationContext);
-            });
-        _commandParser = builder.Build();
+            })
+            ;
+        return builder.Build();
     }
 
-    private static Parser _commandParser = null!;
-
-    private static Command InitializeCommand()
+    private static Command InitializeCommandInternal(IServiceProvider serviceProvider, Func<InvocationContext, Task>? handler = null)
     {
         var command = new RootCommand()
         {
             Name = "http",
         };
-        //var methodArgument = new Argument<HttpMethod>("method")
-        //{
-        //    Description = "Request method",
-        //    Arity = ArgumentArity.ZeroOrOne,
-        //};
-        //methodArgument.SetDefaultValue(HttpMethod.Get.Method);
-        //var allowedMethods = HttpMethods.ToArray();
-        //methodArgument.AddSuggestions(allowedMethods);
-
-        //command.AddArgument(methodArgument);
-        //var urlArgument = new Argument<string>("url")
-        //{
-        //    Description = "Request url",
-        //    Arity = ArgumentArity.ExactlyOne
-        //};
-        //command.AddArgument(urlArgument);
-
-        foreach (var option in SupportedOptions)
+        
+        // var methodArgument = new Argument<HttpMethod>("method")
+        // {
+        //     Description = "Request method",
+        //     Arity = ArgumentArity.ZeroOrOne,
+        // };
+        // methodArgument.SetDefaultValue(HttpMethod.Get.Method);
+        // var allowedMethods = HttpMethods.ToArray();
+        // methodArgument.AddCompletions(allowedMethods);
+        // command.AddArgument(methodArgument);
+        
+        // var urlArgument = new Argument<string>("url")
+        // {
+        //     Description = "Request url",
+        //     Arity = ArgumentArity.ExactlyOne
+        // };
+        // command.AddArgument(urlArgument);
+        
+        // options
+        foreach (var option in
+                 serviceProvider
+                     .GetServices<IHttpHandlerMiddleware>().SelectMany(x => x.SupportedOptions())
+                     .Union(serviceProvider.GetServices<IRequestMiddleware>().SelectMany(x => x.SupportedOptions())
+                         .Union(serviceProvider.GetServices<IResponseMiddleware>().SelectMany(x => x.SupportedOptions()))
+                         .Union(serviceProvider.GetRequiredService<IOutputFormatter>().SupportedOptions())
+                         .Union(serviceProvider.GetRequiredService<IRequestExecutor>().SupportedOptions()))
+                     .Union(serviceProvider.GetRequiredService<ILoadTestExporterSelector>().SupportedOptions())
+                     .Union(serviceProvider.GetServices<ILoadTestExporter>().SelectMany(x => x.SupportedOptions()))
+                )
         {
             command.AddOption(option);
         }
         command.TreatUnmatchedTokensAsErrors = false;
+        
+        handler ??= async invocationContext =>
+        {
+            var context = serviceProvider.ResolveRequiredService<HttpContext>();
+            await serviceProvider.ResolveRequiredService<IRequestExecutor>()
+                .ExecuteAsync(context);
+            var output = await serviceProvider.ResolveRequiredService<IOutputFormatter>()
+                .GetOutput(context);
+            invocationContext.Console.Out.WriteLine(output.Trim());
+        };
+        command.SetHandler(handler);
         return command;
     }
-
-    // ReSharper disable once InconsistentNaming
-    public static IServiceCollection RegisterHTTPieServices(this IServiceCollection serviceCollection)
+    
+    public static IServiceCollection RegisterApplicationServices(this IServiceCollection serviceCollection)
     {
         serviceCollection
             .AddSingleton<IRequestExecutor, RequestExecutor>()
@@ -207,54 +230,16 @@ public static IServiceCollection RegisterHTTPieServices(this IServiceCollection
             .AddResponseMiddleware<JsonSchemaValidationMiddleware>()
             ;
     }
-
-    public static void InitRequestModel(HttpContext httpContext, string commandLine)
-        => InitRequestModel(httpContext, CommandLineStringSplitter.Instance.Split(commandLine).ToArray());
-
-    public static void InitRequestModel(HttpContext httpContext, string[] args)
-    {
-        // should output helps
-        if (args.Contains("-?") || args.Contains("--help"))
-        {
-            return;
-        }
-        var requestModel = httpContext.Request;
-        requestModel.ParseResult = _commandParser.Parse(args);
-
-        var method = requestModel.ParseResult.UnmatchedTokens.FirstOrDefault(x => HttpMethods.Contains(x));
-        if (!string.IsNullOrEmpty(method))
-        {
-            requestModel.Method = new HttpMethod(method);
-        }
-        // Url
-        requestModel.Url = requestModel.ParseResult.UnmatchedTokens.FirstOrDefault(x =>
-              !x.StartsWith("-", StringComparison.Ordinal)
-              && !HttpMethods.Contains(x))
-            ?? string.Empty;
-        if (string.IsNullOrEmpty(requestModel.Url))
-        {
-            throw new InvalidOperationException("The request url can not be null");
-        }
-        requestModel.Options = args
-            .Where(x => x.StartsWith('-'))
-            .ToArray();
-#nullable disable
-        requestModel.RequestItems = requestModel.ParseResult.UnmatchedTokens
-            .Except(new[] { method, requestModel.Url })
-            .Where(x => !x.StartsWith('-'))
-            .ToArray();
-#nullable restore
-    }
-
+    
     public static async Task<int> Handle(this IServiceProvider services, string[] args)
     {
-        InitRequestModel(services.GetRequiredService<HttpContext>(), args);
-        return await _commandParser.InvokeAsync(args);
+        var commandParser = services.ConstructCommand();
+        return await commandParser.InvokeAsync(args);
     }
-
-    public static async Task<int> Handle(this IServiceProvider services, string commandLine)
+    
+    public static async Task<int> Handle(this IServiceProvider services, string commandLine, Func<InvocationContext, Task>? handler = null)
     {
-        InitRequestModel(services.GetRequiredService<HttpContext>(), commandLine);
-        return await _commandParser.InvokeAsync(commandLine);
+        var commandParser = services.ConstructCommand(handler);
+        return await commandParser.InvokeAsync(commandLine);
     }
 }

tests/HTTPie.IntegrationTest/HttpTestBase.cs

@@ -17,10 +17,8 @@ protected HttpTestBase()
     {
         Services = new ServiceCollection()
             .AddLogging()
-            .RegisterHTTPieServices()
+            .RegisterApplicationServices()
             .BuildServiceProvider();
-        DependencyResolver.SetDependencyResolver(Services);
-        Helpers.InitializeSupportOptions(Services);
     }
 
     protected IServiceProvider Services { get; }
@@ -42,12 +40,7 @@ protected HttpResponseModel GetResponse()
 
     protected async Task<int> Handle(string input)
     {
-        return await Helpers.Handle(Services, input);
-    }
-
-    protected async Task<int> Handle(string[] args)
-    {
-        return await Services.Handle(args);
+        return await Services.Handle(input);
     }
 
     protected async Task<string> GetOutput(string input)

tests/HTTPie.UnitTest/HTTPie.UnitTest.csproj

@@ -3,6 +3,7 @@
     <PropertyGroup>
       <TargetFramework>net6.0</TargetFramework>
       <IsPackable>false</IsPackable>
+      <DefineConstants>$(DefineConstants);UnitTest</DefineConstants>
     </PropertyGroup>
     <ItemGroup>
       <Using Include="HTTPie" />