Merge pull request #97 from WeihanLi/dev

0.11.0

Author: WeihanLi

Directory.Packages.props

@@ -4,19 +4,20 @@
     <ManagePackageVersionsCentrally>true</ManagePackageVersionsCentrally>
   </PropertyGroup>
   <ItemGroup>
-    <PackageVersion Include="JsonPath.Net" Version="1.1.6" />
+    <PackageVersion Include="JsonPath.Net" Version="2.1.1" />
     <PackageVersion Include="JsonSchema.Net" Version="7.3.4" />
     <PackageVersion Include="MathNet.Numerics.Signed" Version="5.0.0" />
-    <PackageVersion Include="System.CommandLine" Version="2.0.0-beta4.22272.1" />
-    <PackageVersion Include="WeihanLi.Common" Version="1.0.78" />
+    <PackageVersion Include="System.CommandLine" Version="2.0.0-beta5.25306.1" />
+    <PackageVersion Condition="!$([MSBuild]::IsTargetFrameworkCompatible('$(TargetFramework)', 'net10.0'))" Include="System.Linq.AsyncEnumerable" Version="10.0.0-preview.6.25358.103" />
+    <PackageVersion Include="WeihanLi.Common" Version="1.0.80" />
   </ItemGroup>
   <ItemGroup>
     <PackageVersion Include="Microsoft.NET.Test.Sdk" Version="17.14.1" />
-    <PackageVersion Include="FluentAssertions" Version="6.12.2" />
+    <PackageVersion Include="AwesomeAssertions" Version="7.0.0" />
     <PackageVersion Include="Moq" Version="4.20.72" />
     <PackageVersion Include="xunit" Version="2.9.3" />
     <PackageVersion Include="xunit.runner.visualstudio" Version="2.8.2" />
     <PackageVersion Include="Xunit.DependencyInjection" Version="9.9.1" />
     <PackageVersion Include="coverlet.collector" Version="6.0.4" />
   </ItemGroup>
-</Project>
+</Project>

build/version.props

@@ -1,7 +1,7 @@
 <Project>
   <PropertyGroup>
     <VersionMajor>0</VersionMajor>
-    <VersionMinor>10</VersionMinor>
+    <VersionMinor>11</VersionMinor>
     <VersionPatch>0</VersionPatch>
     <VersionPrefix>$(VersionMajor).$(VersionMinor).$(VersionPatch)</VersionPrefix>
     <InformationalVersion>$(PackageVersion)</InformationalVersion>

docs/ReleaseNotes.md

@@ -1,5 +1,9 @@
 # dotnet-httpie release notes
 
+## Unreleased
+
+- upgrade System.CommandLine
+
 ## [0.10.0](https://nuget.org/packages/dotnet-httpie/0.10.0)
 
 - Add http env file support for http file execution

src/HTTPie/Abstractions/IHttpParser.cs

@@ -9,7 +9,8 @@ public interface IHttpParser
 {
     string? Environment { get; set; }
 
-    Task<HttpRequestMessage> ParseScriptAsync(string script, CancellationToken cancellationToken = default);
+    IAsyncEnumerable<HttpRequestMessageWrapper> ParseScriptAsync(string script,
+        CancellationToken cancellationToken = default);
 
     IAsyncEnumerable<HttpRequestMessageWrapper> ParseFileAsync(string filePath,
         CancellationToken cancellationToken = default);

src/HTTPie/Commands/ExecuteCommand.cs

@@ -2,11 +2,12 @@
 // Licensed under the MIT license.
 
 using HTTPie.Abstractions;
+using HTTPie.Implement;
+using HTTPie.Middleware;
 using HTTPie.Utilities;
 using Json.Path;
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Logging;
-using System.CommandLine.Invocation;
 using System.Diagnostics;
 using System.Text;
 using System.Text.Json.Nodes;
@@ -17,58 +18,101 @@ namespace HTTPie.Commands;
 
 public sealed class ExecuteCommand : Command
 {
-    private static readonly Argument<string> FilePathArgument = new("scriptPath", "The script to execute");
+    private static readonly Argument<string> FilePathArgument = new("scriptPath")
+    {
+        Description = "The script to execute",
+        Arity = ArgumentArity.ZeroOrOne
+    };
 
     private static readonly Option<string> EnvironmentTypeOption =
-        new(["--env"], "The environment to execute script");
+        new("--env")
+        {
+            Description = "The environment to execute script"
+        };
 
     private static readonly Option<ExecuteScriptType> ExecuteScriptTypeOption =
-        new(["-t", "--type"], "The script type to execute");
+        new("-t", "--type")
+        {
+            Description = "The script type to execute"
+        };
 
     public ExecuteCommand() : base("exec", "execute http request")
     {
-        AddOption(ExecuteScriptTypeOption);
-        AddOption(EnvironmentTypeOption);
-        AddArgument(FilePathArgument);
+        Options.Add(ExecuteScriptTypeOption);
+        Options.Add(EnvironmentTypeOption);
+        Options.Add(DefaultRequestMiddleware.DebugOption);
+        Options.Add(OutputFormatter.OfflineOption);
+        Arguments.Add(FilePathArgument);
     }
 
-    public async Task InvokeAsync(InvocationContext invocationContext, IServiceProvider serviceProvider)
+    public async Task InvokeAsync(
+        ParseResult parseResult, CancellationToken cancellationToken, IServiceProvider serviceProvider
+        )
     {
-        var filePath = invocationContext.ParseResult.GetValueForArgument(FilePathArgument);
-        if (string.IsNullOrEmpty(filePath) || !File.Exists(filePath))
+        var scriptText = string.Empty;
+        var filePath = parseResult.GetValue(FilePathArgument);
+        if (string.IsNullOrEmpty(filePath))
+        {
+            // try to read script content from stdin
+            if (ConsoleHelper.HasStandardInput())
+            {
+                scriptText = (await Console.In.ReadToEndAsync(cancellationToken)).Trim();
+            }
+
+            if (string.IsNullOrEmpty(scriptText))
+            {
+                throw new InvalidOperationException("Invalid script to execute");
+            }
+        }
+        else
         {
-            throw new InvalidOperationException("Invalid filePath");
+            if (!File.Exists(filePath))
+            {
+                throw new InvalidOperationException($"Invalid filePath {filePath}");
+            }
         }
 
         var logger = serviceProvider.GetRequiredService<ILogger>();
         var requestExecutor = serviceProvider.GetRequiredService<IRawHttpRequestExecutor>();
-        var cancellationToken = invocationContext.GetCancellationToken();
-        var type = invocationContext.ParseResult.GetValueForOption(ExecuteScriptTypeOption);
-        var environment = invocationContext.ParseResult.GetValueForOption(EnvironmentTypeOption);
+        var type = parseResult.GetValue(ExecuteScriptTypeOption);
+        var environment = parseResult.GetValue(EnvironmentTypeOption);
         var parser = type switch
         {
             ExecuteScriptType.Http => serviceProvider.GetRequiredService<IHttpParser>(),
             ExecuteScriptType.Curl => serviceProvider.GetRequiredService<ICurlParser>(),
             _ => throw new InvalidOperationException($"Not supported request type: {type}")
         };
         parser.Environment = environment;
-        logger.LogDebug("Executing {ScriptType} http request {ScriptPath} with {ScriptExecutor}",
-            type, filePath, parser.GetType().Name);
-        await InvokeRequest(parser, requestExecutor, filePath, cancellationToken);
+        logger.LogDebug(
+            "Executing {ScriptType} http request with scriptPath: [{ScriptPath}], scriptText: ({ScriptText}), environment: {Environment} via {ScriptExecutor}",
+            type, filePath, scriptText, environment, parser.GetType().Name
+            );
+
+        var offline = parseResult.GetValue(OutputFormatter.OfflineOption);
+        await InvokeRequest(parser, requestExecutor, scriptText, filePath, offline, cancellationToken);
     }
 
-    private static async Task InvokeRequest(IHttpParser httpParser, IRawHttpRequestExecutor requestExecutor,
-        string filePath, CancellationToken cancellationToken)
+    private static async Task InvokeRequest(
+        IHttpParser httpParser, IRawHttpRequestExecutor requestExecutor, string scriptText,
+        string? filePath, bool offline, CancellationToken cancellationToken)
     {
         var responseList = new Dictionary<string, HttpResponseMessage>();
+
         try
         {
-            await foreach (var request in httpParser.ParseFileAsync(filePath, cancellationToken))
+            var getRequests = string.IsNullOrEmpty(filePath)
+                ? httpParser.ParseScriptAsync(scriptText, cancellationToken)
+                : httpParser.ParseFileAsync(filePath, cancellationToken)
+                ;
+            await foreach (var request in getRequests.WithCancellation(cancellationToken))
             {
                 await EnsureRequestVariableReferenceReplaced(request, responseList);
                 var response = await ExecuteRequest(
-                    requestExecutor, request.RequestMessage, cancellationToken, request.Name
+                    requestExecutor, request.RequestMessage, offline, cancellationToken, request.Name
                     );
+                if (response is null)
+                    continue;
+
                 responseList[request.Name] = response;
             }
         }
@@ -90,9 +134,10 @@ private static async Task InvokeRequest(IHttpParser httpParser, IRawHttpRequestE
         }
     }
 
-    private static async Task<HttpResponseMessage> ExecuteRequest(
+    private static async Task<HttpResponseMessage?> ExecuteRequest(
         IRawHttpRequestExecutor requestExecutor,
         HttpRequestMessage requestMessage,
+        bool offline,
         CancellationToken cancellationToken,
         string? requestName = null)
     {
@@ -101,6 +146,9 @@ private static async Task<HttpResponseMessage> ExecuteRequest(
 
         Console.WriteLine("Request message:");
         Console.WriteLine(await requestMessage.ToRawMessageAsync(cancellationToken));
+        if (offline)
+            return null;
+
         var startTimestamp = Stopwatch.GetTimestamp();
         var response = await requestExecutor.ExecuteAsync(requestMessage, cancellationToken);
         var requestDuration = ProfilerHelper.GetElapsedTime(startTimestamp);

src/HTTPie/HTTPie.csproj

@@ -43,6 +43,7 @@
     <PackageReference Include="JsonSchema.Net" />
     <PackageReference Include="MathNet.Numerics.Signed" />
     <PackageReference Include="System.CommandLine" />
+    <PackageReference Condition="!$([MSBuild]::IsTargetFrameworkCompatible('$(TargetFramework)', 'net10.0'))" Include="System.Linq.AsyncEnumerable" />
     <PackageReference Include="WeihanLi.Common" />
   </ItemGroup>
 </Project>

src/HTTPie/Implement/CurlParser.cs

@@ -5,16 +5,60 @@
 using HTTPie.Models;
 using HTTPie.Utilities;
 using System.Runtime.CompilerServices;
+using CommandLineParser = WeihanLi.Common.Helpers.CommandLineParser;
 
 namespace HTTPie.Implement;
 
-public sealed class CurlParser : ICurlParser
+public sealed class CurlParser : AbstractHttpRequestParser, ICurlParser
 {
-    public string? Environment { get; set; }
+    public override async IAsyncEnumerable<HttpRequestMessageWrapper> ParseScriptAsync
+        (string script, [EnumeratorCancellation] CancellationToken cancellationToken = default)
+    {
+        Guard.NotNullOrEmpty(script);
+        await foreach (var request in ParseHttpRequestsAsync(
+                           script.Split("\n###\n").ToAsyncEnumerable(), null,
+                           cancellationToken))
+        {
+            yield return request;
+        }
+    }
 
-    public Task<HttpRequestMessage> ParseScriptAsync(string curlScript, CancellationToken cancellationToken = default)
+    public override async IAsyncEnumerable<HttpRequestMessageWrapper> ParseFileAsync(
+        string filePath, [EnumeratorCancellation] CancellationToken cancellationToken = default)
+    {
+        Guard.NotNullOrEmpty(filePath);
+        var script = await File.ReadAllTextAsync(filePath, cancellationToken);
+        await foreach (var request in ParseHttpRequestsAsync(
+                           script.Split("\n###\n").ToAsyncEnumerable(), filePath,
+                           cancellationToken))
+        {
+            yield return request;
+        }
+    }
+
+    protected override async IAsyncEnumerable<HttpRequestMessageWrapper> ParseHttpRequestsAsync
+        (
+            IAsyncEnumerable<string> chunks,
+            string? filePath,
+            [EnumeratorCancellation] CancellationToken cancellationToken
+        )
+    {
+        var index = 0;
+        await foreach (var chunk in chunks.WithCancellation(cancellationToken))
+        {
+            var request = ParseCurlScript(chunk, cancellationToken);
+            var requestName = $"request#{index}";
+            index++;
+            yield return new HttpRequestMessageWrapper(requestName, request);
+        }
+    }
+
+    private static HttpRequestMessage ParseCurlScript(
+        string curlScript, CancellationToken cancellationToken = default
+        )
     {
         Guard.NotNullOrEmpty(curlScript);
+        cancellationToken.ThrowIfCancellationRequested();
         var normalizedScript = curlScript
             .Replace("\\\n", " ")
             .Replace("\\\r\n", " ")
@@ -26,7 +70,9 @@ public Task<HttpRequestMessage> ParseScriptAsync(string curlScript, Cancellation
             throw new ArgumentException($"Invalid curl script: {curlScript}", nameof(curlScript));
         }
 
-        var splits = CommandLineParser.ParseLine(normalizedScript).ToArray();
+        var splits = CommandLineParser.ParseLine(normalizedScript)
+            .Where(s => !string.IsNullOrEmpty(s))
+            .ToArray();
         string requestMethod = string.Empty, requestBody = string.Empty;
         Uri? uri = null;
         var headers = new List<KeyValuePair<string, string>>();
@@ -76,15 +122,20 @@ public Task<HttpRequestMessage> ParseScriptAsync(string curlScript, Cancellation
                 {
                     var header = splits[i].Trim('\'', '"');
                     var headerSplits = header.Split(':', 2, StringSplitOptions.TrimEntries);
-                    headers.Add(new KeyValuePair<string, string>(headerSplits[0],
-                        headerSplits.Length > 1 ? headerSplits[1] : string.Empty));
+                    if (headerSplits.Length == 2)
+                    {
+                        headers.Add(new KeyValuePair<string, string>(headerSplits[0], headerSplits[1].Trim()));
+                    }
                 }
             }
         }
 
-        if (string.IsNullOrEmpty(requestMethod)) requestMethod = "GET";
+        if (string.IsNullOrEmpty(requestMethod))
+        {
+            requestMethod = requestBody.IsNullOrEmpty() ? HttpMethod.Get.Method : HttpMethod.Post.Method;
+        }
 
-        if (uri is null) throw new ArgumentException("Url info not found");
+        if (uri is null) throw new ArgumentException("Request url info not found");
 
         var request = new HttpRequestMessage(new HttpMethod(requestMethod), uri);
         // request body
@@ -98,23 +149,10 @@ public Task<HttpRequestMessage> ParseScriptAsync(string curlScript, Cancellation
         {
             request.TryAddHeader(
                 headerGroup.Key,
-                headerGroup.Select(x => x.Value).StringJoin(",")
+                headerGroup.Select(x => x.Value).StringJoin(",").Trim(',', ' ')
             );
         }
 
-        return request.WrapTask();
-    }
-
-    public async IAsyncEnumerable<HttpRequestMessageWrapper> ParseFileAsync(string filePath,
-        [EnumeratorCancellation] CancellationToken cancellationToken = default)
-    {
-        var scripts = await File.ReadAllTextAsync(filePath, cancellationToken);
-        var index = 0;
-        foreach (var script in scripts.Split("\n###\n"))
-        {
-            var request = await ParseScriptAsync(script, cancellationToken);
-            yield return new HttpRequestMessageWrapper($"request#{index}", request);
-            index++;
-        }
+        return request;
     }
 }