Merge pull request #2410 from microsoft/dependabot/nuget/performance/resultsComparer/multi-51f7fe1af4

Bump Microsoft.OpenApi.OData and 3 others

Author: baywet

performance/resultsComparer/Program.cs

@@ -11,7 +11,8 @@ public class Program
     public static async Task<int> Main(string[] args)
     {
         var rootCommand = CreateRootCommand();
-        return await rootCommand.InvokeAsync(args);
+        var parseResult = rootCommand.Parse(args);
+        return await parseResult.InvokeAsync();
     }
     internal static RootCommand CreateRootCommand()
     {
@@ -21,25 +22,40 @@ internal static RootCommand CreateRootCommand()
         {
             Description = "Compare the benchmark results."
         };
-        var oldResultsPathArgument = new Argument<string>("existingReportPath", () => ExistingReportPath, "The path to the existing benchmark report.");
-        compareCommand.AddArgument(oldResultsPathArgument);
-        var newResultsPathArgument = new Argument<string>("newReportPath", () => ExistingReportPath, "The path to the new benchmark report.");
-        compareCommand.AddArgument(newResultsPathArgument);
-        var logLevelOption = new Option<LogLevel>(["--log-level", "-l"], () => LogLevel.Warning, "The log level to use.");
-        compareCommand.AddOption(logLevelOption);
+        var oldResultsPathArgument = new Argument<string>("existingReportPath")
+        {
+            DefaultValueFactory = (_) => ExistingReportPath,
+            Description = "The path to the existing benchmark report.",
+        };
+        compareCommand.Arguments.Add(oldResultsPathArgument);
+        var newResultsPathArgument = new Argument<string>("newReportPath")
+        {
+            DefaultValueFactory = (_) => ExistingReportPath,
+            Description = "The path to the new benchmark report.",
+        };
+        compareCommand.Arguments.Add(newResultsPathArgument);
+        var logLevelOption = new Option<LogLevel>("--log-level", "-l")
+        {
+            DefaultValueFactory = (_) => LogLevel.Warning,
+            Description = "The log level to use.",
+        };
+        compareCommand.Options.Add(logLevelOption);
         var allPolicyNames = IBenchmarkComparisonPolicy.GetAllPolicies().Select(static p => p.Name).Order(StringComparer.OrdinalIgnoreCase).ToArray();
-        var policiesOption = new Option<string[]>(["--policies", "-p"], () => ["all"], $"The policies to use for comparison: {string.Join(',', allPolicyNames)}.")
+        var policiesOption = new Option<string[]>("--policies", "-p")
         {
-            Arity = ArgumentArity.ZeroOrMore
+            Arity = ArgumentArity.ZeroOrMore,
+            DefaultValueFactory = (_) => ["all"],
+            Description = $"The policies to use for comparison: {string.Join(',', allPolicyNames)}.",
         };
-        compareCommand.AddOption(policiesOption);
-        compareCommand.Handler = new CompareCommandHandler
+        compareCommand.Options.Add(policiesOption);
+        var compareCommandHandler = new CompareCommandHandler
         {
             OldResultsPath = oldResultsPathArgument,
             NewResultsPath = newResultsPathArgument,
             LogLevel = logLevelOption,
             Policies = policiesOption,
         };
+        compareCommand.SetAction(compareCommandHandler.InvokeAsync);
         rootCommand.Add(compareCommand);
         return rootCommand;
     }

performance/resultsComparer/handlers/AsyncCommandHandler.cs

@@ -3,30 +3,38 @@
 using System.CommandLine.Invocation;
 using System.Text.Json;
 using System.Text.Json.Serialization;
-using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Logging;
 using resultsComparer.Models;
 using resultsComparer.Policies;
 
 namespace resultsComparer.Handlers;
 
-internal class CompareCommandHandler : AsyncCommandHandler
+internal class CompareCommandHandler : AsynchronousCommandLineAction
 {
     public required Argument<string> OldResultsPath { get; set; }
     public required Argument<string> NewResultsPath { get; set; }
     public required Option<LogLevel> LogLevel { get; set; }
     public required Option<string[]> Policies { get; set; }
 
-    public override Task<int> InvokeAsync(InvocationContext context)
+    public override Task<int> InvokeAsync(ParseResult parseResult, CancellationToken cancellationToken = default)
     {
-        var cancellationToken = context.BindingContext.GetRequiredService<CancellationToken>();
-        var oldResultsPath = context.ParseResult.GetValueForArgument(OldResultsPath);
-        var newResultsPath = context.ParseResult.GetValueForArgument(NewResultsPath);
-        var policyNames = context.ParseResult.GetValueForOption(Policies) ?? [];
+        var oldResultsPath = parseResult.GetValue(OldResultsPath);
+        var newResultsPath = parseResult.GetValue(NewResultsPath);
+        var policyNames = parseResult.GetValue(Policies) ?? [];
         var policies = IBenchmarkComparisonPolicy.GetSelectedPolicies(policyNames).ToArray();
-        var logLevel = context.ParseResult.GetValueForOption(LogLevel);
+        var logLevel = parseResult.GetValue(LogLevel);
         using var loggerFactory = Logger.ConfigureLogger(logLevel);
         var logger = loggerFactory.CreateLogger<CompareCommandHandler>();
+        if (string.IsNullOrWhiteSpace(oldResultsPath))
+        {
+            logger.LogError("Old results path is required.");
+            return Task.FromResult(1);
+        }
+        if (string.IsNullOrWhiteSpace(newResultsPath))
+        {
+            logger.LogError("New results path is required.");
+            return Task.FromResult(1);
+        }
         return CompareResultsAsync(oldResultsPath, newResultsPath, logger, policies, cancellationToken);
     }
     private static async Task<int> CompareResultsAsync(string existingReportPath, string newReportPath, ILogger logger, IBenchmarkComparisonPolicy[] comparisonPolicies, CancellationToken cancellationToken = default)

performance/resultsComparer/handlers/CompareCommandHandler.cs

@@ -12,7 +12,7 @@
     <PackageReference Include="Microsoft.Extensions.Logging" Version="9.0.6" />
     <PackageReference Include="Microsoft.Extensions.Logging.Console" Version="9.0.6" />
     <PackageReference Include="Microsoft.Extensions.Logging.Debug" Version="9.0.6" />
-    <PackageReference Include="System.CommandLine" Version="2.0.0-beta4.22272.1" />
+    <PackageReference Include="System.CommandLine" Version="2.0.0-beta5.25306.1" />
     <PackageReference Include="system.text.json" Version="9.0.6" />
   </ItemGroup>
 

performance/resultsComparer/resultsComparer.csproj

@@ -12,7 +12,7 @@ public static void AddOptions(this Command command, IReadOnlyList<Option> option
         {
             foreach (var option in options)
             {
-                command.AddOption(option);
+                command.Options.Add(option);
             }
         }
     }

src/Microsoft.OpenApi.Hidi/Extensions/CommandExtensions.cs

@@ -2,26 +2,25 @@
 // Licensed under the MIT license.
 
 using System;
+using System.CommandLine;
 using System.CommandLine.Invocation;
 using System.Threading;
 using System.Threading.Tasks;
-using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Logging;
 using Microsoft.OpenApi.Hidi.Options;
 
 namespace Microsoft.OpenApi.Hidi.Handlers
 {
-    internal class PluginCommandHandler : AsyncCommandHandler
+    internal class PluginCommandHandler : AsynchronousCommandLineAction
     {
         public CommandOptions CommandOptions { get; }
         public PluginCommandHandler(CommandOptions commandOptions)
         {
             CommandOptions = commandOptions;
         }
-        public override async Task<int> InvokeAsync(InvocationContext context)
+        public override async Task<int> InvokeAsync(ParseResult parseResult, CancellationToken cancellationToken = default)
         {
-            var hidiOptions = new HidiOptions(context.ParseResult, CommandOptions);
-            var cancellationToken = (CancellationToken)context.BindingContext.GetRequiredService(typeof(CancellationToken));
+            var hidiOptions = new HidiOptions(parseResult, CommandOptions);
 
             using var loggerFactory = Logger.ConfigureLogger(hidiOptions.LogLevel);
             var logger = loggerFactory.CreateLogger<PluginCommandHandler>();

src/Microsoft.OpenApi.Hidi/Handlers/AsyncCommandHandler.cs

@@ -2,26 +2,25 @@
 // Licensed under the MIT license.
 
 using System;
+using System.CommandLine;
 using System.CommandLine.Invocation;
 using System.Threading;
 using System.Threading.Tasks;
-using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Logging;
 using Microsoft.OpenApi.Hidi.Options;
 
 namespace Microsoft.OpenApi.Hidi.Handlers
 {
-    internal class ShowCommandHandler : AsyncCommandHandler
+    internal class ShowCommandHandler : AsynchronousCommandLineAction
     {
         public CommandOptions CommandOptions { get; set; }
         public ShowCommandHandler(CommandOptions commandOptions)
         {
             CommandOptions = commandOptions;
         }
-        public override async Task<int> InvokeAsync(InvocationContext context)
+        public override async Task<int> InvokeAsync(ParseResult parseResult, CancellationToken cancellationToken = default)
         {
-            var hidiOptions = new HidiOptions(context.ParseResult, CommandOptions);
-            var cancellationToken = (CancellationToken)context.BindingContext.GetRequiredService(typeof(CancellationToken));
+            var hidiOptions = new HidiOptions(parseResult, CommandOptions);
 
             using var loggerFactory = Logger.ConfigureLogger(hidiOptions.LogLevel);
             var logger = loggerFactory.CreateLogger<ShowCommandHandler>();

src/Microsoft.OpenApi.Hidi/Handlers/PluginCommandHandler.cs

@@ -2,26 +2,25 @@
 // Licensed under the MIT license.
 
 using System;
+using System.CommandLine;
 using System.CommandLine.Invocation;
 using System.Threading;
 using System.Threading.Tasks;
-using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Logging;
 using Microsoft.OpenApi.Hidi.Options;
 
 namespace Microsoft.OpenApi.Hidi.Handlers
 {
-    internal class TransformCommandHandler : AsyncCommandHandler
+    internal class TransformCommandHandler : AsynchronousCommandLineAction
     {
         public CommandOptions CommandOptions { get; }
         public TransformCommandHandler(CommandOptions commandOptions)
         {
             CommandOptions = commandOptions;
         }
-        public override async Task<int> InvokeAsync(InvocationContext context)
+        public override async Task<int> InvokeAsync(ParseResult parseResult, CancellationToken cancellationToken = default)
         {
-            var hidiOptions = new HidiOptions(context.ParseResult, CommandOptions);
-            var cancellationToken = (CancellationToken)context.BindingContext.GetRequiredService(typeof(CancellationToken));
+            var hidiOptions = new HidiOptions(parseResult, CommandOptions);
 
             using var loggerFactory = Logger.ConfigureLogger(hidiOptions.LogLevel);
             var logger = loggerFactory.CreateLogger<TransformCommandHandler>();

src/Microsoft.OpenApi.Hidi/Handlers/ShowCommandHandler.cs

@@ -2,27 +2,26 @@
 // Licensed under the MIT license.
 
 using System;
+using System.CommandLine;
 using System.CommandLine.Invocation;
 using System.Threading;
 using System.Threading.Tasks;
-using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Logging;
 using Microsoft.OpenApi.Hidi.Options;
 
 namespace Microsoft.OpenApi.Hidi.Handlers
 {
-    internal class ValidateCommandHandler : AsyncCommandHandler
+    internal class ValidateCommandHandler : AsynchronousCommandLineAction
     {
         public CommandOptions CommandOptions { get; }
 
         public ValidateCommandHandler(CommandOptions commandOptions)
         {
             CommandOptions = commandOptions;
         }
-        public override async Task<int> InvokeAsync(InvocationContext context)
+        public override async Task<int> InvokeAsync(ParseResult parseResult, CancellationToken cancellationToken = default)
         {
-            var hidiOptions = new HidiOptions(context.ParseResult, CommandOptions);
-            var cancellationToken = (CancellationToken)context.BindingContext.GetRequiredService(typeof(CancellationToken));
+            var hidiOptions = new HidiOptions(parseResult, CommandOptions);
             using var loggerFactory = Logger.ConfigureLogger(hidiOptions.LogLevel);
             var logger = loggerFactory.CreateLogger<ValidateCommandHandler>();
             try

src/Microsoft.OpenApi.Hidi/Handlers/TransformCommandHandler.cs

@@ -36,11 +36,11 @@
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
       <PrivateAssets>all</PrivateAssets>
     </PackageReference>
-    <PackageReference Include="System.CommandLine" Version="2.0.0-beta4.22272.1" />
+    <PackageReference Include="System.CommandLine" Version="2.0.0-beta5.25306.1" />
     <PackageReference Include="Microsoft.OData.Edm" Version="8.2.3" />
     <PackageReference Include="Microsoft.OpenApi.OData" Version="2.0.0-preview.15" />
     <PackageReference Include="Microsoft.OpenApi.ApiManifest" Version="2.0.0-preview5" />
-    <PackageReference Include="System.CommandLine.Hosting" Version="0.4.0-alpha.22272.1" />
+    <PackageReference Include="System.CommandLine.Hosting" Version="0.4.0-alpha.25306.1" />
   </ItemGroup>
 
   <ItemGroup>