Migrate XPlat to System.CommandLine

Author: zivkan

src/NuGet.Core/NuGet.CommandLine.XPlat/Commands/CommandConstants.cs

@@ -3,7 +3,7 @@
 
 #nullable enable
 
-namespace NuGet.CommandLine.XPlat
+namespace NuGet.CommandLine.XPlat.Commands
 {
     internal static class CommandConstants
     {

src/NuGet.Core/NuGet.CommandLine.XPlat/Commands/CommandParsers.cs

@@ -7,7 +7,6 @@
 using System.CommandLine;
 using System.CommandLine.Help;
 using System.Threading.Tasks;
-using Microsoft.Extensions.CommandLineUtils;
 using NuGet.CommandLine.XPlat.Commands;
 using NuGet.Common;
 
@@ -78,15 +77,7 @@ internal static void LogException(Exception e, ILogger log)
             log.LogVerbose(e.ToString());
         }
 
-        internal static void Register(CommandLineApplication app)
-        {
-            app.Command("config", configCmd =>
-            {
-                configCmd.Description = Strings.Config_Description;
-            });
-        }
-
-        internal static Command Register(Command app, Func<ILogger> getLogger)
+        internal static Command Register(Command app, Func<ILoggerWithColor> getLogger)
         {
             var ConfigCmd = new DocumentedCommand(name: "config", description: Strings.Config_Description, "https://aka.ms/dotnet/nuget/config");
             ConfigCmd.Options.Add(HelpOption);

src/NuGet.Core/NuGet.CommandLine.XPlat/Commands/ConfigCommands/ConfigCommand.cs

@@ -4,94 +4,102 @@
 #nullable disable
 
 using System;
+using System.CommandLine;
 using System.Globalization;
-using Microsoft.Extensions.CommandLineUtils;
 using NuGet.Commands;
-using NuGet.Common;
 using NuGet.Configuration;
 using NuGet.Credentials;
 
 namespace NuGet.CommandLine.XPlat
 {
     internal static class DeleteCommand
     {
-        public static void Register(CommandLineApplication app, Func<ILogger> getLogger)
+        private static readonly Option<string> SourceOption = new Option<string>("--source", "-s")
         {
-            app.Command("delete", delete =>
+            Arity = ArgumentArity.ZeroOrOne,
+            Description = Strings.Source_Description,
+        };
+
+        private static readonly Option<bool> NonInteractiveOption = new Option<bool>("--non-interactive")
+        {
+            Arity = ArgumentArity.Zero,
+            Description = Strings.NonInteractive_Description,
+        };
+
+        private static readonly Option<string> ApiKeyOption = new Option<string>("--api-key", "-k")
+        {
+            Arity = ArgumentArity.ZeroOrOne,
+            Description = Strings.ApiKey_Description,
+        };
+
+        private static readonly Option<bool> NoServiceEndpointOption = new Option<bool>("--no-service-endpoint")
+        {
+            Arity = ArgumentArity.Zero,
+            Description = Strings.NoServiceEndpoint_Description,
+        };
+
+        private static readonly Option<bool> InteractiveOption = new Option<bool>("--interactive")
+        {
+            Arity = ArgumentArity.Zero,
+            Description = Strings.NuGetXplatCommand_Interactive,
+        };
+
+        private static readonly Argument<string> PackageIdArgument = new Argument<string>("PackageId")
+        {
+            Arity = ArgumentArity.ExactlyOne,
+            Description = Strings.Delete_PackageIdAndVersion_Description,
+        };
+
+        private static readonly Argument<string> PackageVersionArgument = new Argument<string>("PackageVersion")
+        {
+            Arity = ArgumentArity.ExactlyOne,
+            Description = Strings.Delete_PackageIdAndVersion_Description,
+        };
+
+        internal static void Register(Command parent, Func<ILoggerWithColor> getLogger)
+        {
+            var deleteCmd = new Command("delete", Strings.Delete_Description);
+
+            deleteCmd.Options.Add(SourceOption);
+            deleteCmd.Options.Add(NonInteractiveOption);
+            deleteCmd.Options.Add(ApiKeyOption);
+            deleteCmd.Options.Add(NoServiceEndpointOption);
+            deleteCmd.Options.Add(InteractiveOption);
+            deleteCmd.Arguments.Add(PackageIdArgument);
+            deleteCmd.Arguments.Add(PackageVersionArgument);
+
+            deleteCmd.SetAction(async (parseResult, cancellationToken) =>
             {
-                delete.Description = Strings.Delete_Description;
-                delete.HelpOption(XPlatUtility.HelpOption);
-
-                delete.Option(
-                    CommandConstants.ForceEnglishOutputOption,
-                    Strings.ForceEnglishOutput_Description,
-                    CommandOptionType.NoValue);
-
-                var source = delete.Option(
-                    "-s|--source <source>",
-                    Strings.Source_Description,
-                    CommandOptionType.SingleValue);
-
-                var nonInteractive = delete.Option(
-                    "--non-interactive",
-                    Strings.NonInteractive_Description,
-                    CommandOptionType.NoValue);
-
-                var apikey = delete.Option(
-                    "-k|--api-key <apiKey>",
-                    Strings.ApiKey_Description,
-                    CommandOptionType.SingleValue);
-
-                var arguments = delete.Argument(
-                    "[root]",
-                    Strings.Delete_PackageIdAndVersion_Description,
-                    multipleValues: true);
-
-                var noServiceEndpointDescription = delete.Option(
-                    "--no-service-endpoint",
-                    Strings.NoServiceEndpoint_Description,
-                    CommandOptionType.NoValue);
-
-                var interactive = delete.Option(
-                    "--interactive",
-                    Strings.NuGetXplatCommand_Interactive,
-                    CommandOptionType.NoValue);
-
-                delete.OnExecute(async () =>
-                {
-                    if (arguments.Values.Count < 2)
-                    {
-                        throw new ArgumentException(Strings.Delete_MissingArguments);
-                    }
-
-                    string packageId = arguments.Values[0];
-                    string packageVersion = arguments.Values[1];
-                    string sourcePath = source.Value();
-                    string apiKeyValue = apikey.Value();
-                    bool nonInteractiveValue = nonInteractive.HasValue();
-                    bool noServiceEndpoint = noServiceEndpointDescription.HasValue();
-
-                    DefaultCredentialServiceUtility.SetupDefaultCredentialService(getLogger(), !interactive.HasValue());
+                string packageId = parseResult.GetValue(PackageIdArgument);
+                string packageVersion = parseResult.GetValue(PackageVersionArgument);
+                string sourcePath = parseResult.GetValue(SourceOption);
+                string apiKeyValue = parseResult.GetValue(ApiKeyOption);
+                bool nonInteractiveValue = parseResult.GetValue(NonInteractiveOption);
+                bool noServiceEndpoint = parseResult.GetValue(NoServiceEndpointOption);
+                bool interactiveValue = parseResult.GetValue(InteractiveOption);
+
+                DefaultCredentialServiceUtility.SetupDefaultCredentialService(getLogger(), !interactiveValue);
 
 #pragma warning disable CS0618 // Type or member is obsolete
-                    PackageSourceProvider sourceProvider = new PackageSourceProvider(XPlatUtility.GetSettingsForCurrentWorkingDirectory(), enablePackageSourcesChangedEvent: false);
+                PackageSourceProvider sourceProvider = new PackageSourceProvider(XPlatUtility.GetSettingsForCurrentWorkingDirectory(), enablePackageSourcesChangedEvent: false);
 #pragma warning restore CS0618 // Type or member is obsolete
 
-                    await DeleteRunner.Run(
-                        sourceProvider.Settings,
-                        sourceProvider,
-                        packageId,
-                        packageVersion,
-                        sourcePath,
-                        apiKeyValue,
-                        nonInteractiveValue,
-                        noServiceEndpoint,
-                        Confirm,
-                        getLogger());
-
-                    return 0;
-                });
+                await DeleteRunner.Run(
+                    sourceProvider.Settings,
+                    sourceProvider,
+                    packageId,
+                    packageVersion,
+                    sourcePath,
+                    apiKeyValue,
+                    nonInteractiveValue,
+                    noServiceEndpoint,
+                    Confirm,
+                    getLogger());
+
+                return 0;
             });
+
+            parent.Subcommands.Add(deleteCmd);
         }
 
         private static bool Confirm(string description)
@@ -103,7 +111,7 @@ private static bool Confirm(string description)
                 Console.ForegroundColor = ConsoleColor.Yellow;
                 Console.WriteLine(string.Format(CultureInfo.CurrentCulture, Strings.ConsoleConfirmMessage, description));
                 var result = Console.ReadLine();
-                return result.StartsWith(Strings.ConsoleConfirmMessageAccept, StringComparison.OrdinalIgnoreCase);
+                return result != null && result.StartsWith(Strings.ConsoleConfirmMessageAccept, StringComparison.OrdinalIgnoreCase);
             }
             finally
             {

src/NuGet.Core/NuGet.CommandLine.XPlat/Commands/DeleteCommand.cs

@@ -4,79 +4,84 @@
 #nullable enable
 
 using System;
+using System.CommandLine;
+using System.Collections.Generic;
 using System.Globalization;
-using Microsoft.Extensions.CommandLineUtils;
+using System.Threading.Tasks;
 using NuGet.Commands;
-using NuGet.Common;
 
 namespace NuGet.CommandLine.XPlat
 {
     internal static class LocalsCommand
     {
-        public static void Register(CommandLineApplication app, Func<ILogger> getLogger)
+        private static readonly Option<bool> ClearOption = new Option<bool>("--clear", "-c")
         {
-            app.Command("locals", locals =>
-            {
-                locals.Description = Strings.LocalsCommand_Description;
-                locals.HelpOption(XPlatUtility.HelpOption);
+            Arity = ArgumentArity.Zero,
+            Description = Strings.LocalsCommand_ClearDescription,
+        };
 
-                locals.Option(
-                    CommandConstants.ForceEnglishOutputOption,
-                    Strings.ForceEnglishOutput_Description,
-                    CommandOptionType.NoValue);
+        private static readonly Option<bool> ListOption = new Option<bool>("--list", "-l")
+        {
+            Arity = ArgumentArity.Zero,
+            Description = Strings.LocalsCommand_ListDescription,
+        };
 
-                var clear = locals.Option(
-                    "-c|--clear",
-                    Strings.LocalsCommand_ClearDescription,
-                    CommandOptionType.NoValue);
+        private static readonly Argument<string> CacheLocationArgument = new Argument<string>("Cache Location(s)")
+        {
+            Arity = ArgumentArity.ZeroOrOne,
+            Description = Strings.LocalsCommand_ArgumentDescription,
+        };
 
-                var list = locals.Option(
-                    "-l|--list",
-                    Strings.LocalsCommand_ListDescription,
-                    CommandOptionType.NoValue);
+        internal static void Register(Command parent, Func<ILoggerWithColor> getLogger)
+        {
+            var localsCmd = new Command("locals", Strings.LocalsCommand_Description);
 
-                var arguments = locals.Argument(
-                    "Cache Location(s)",
-                    Strings.LocalsCommand_ArgumentDescription,
-                    multipleValues: false);
+            localsCmd.Options.Add(ClearOption);
+            localsCmd.Options.Add(ListOption);
+            localsCmd.Arguments.Add(CacheLocationArgument);
 
-                locals.OnExecute(() =>
-                {
-                    var logger = getLogger();
-                    var setting = XPlatUtility.GetSettingsForCurrentWorkingDirectory();
+            localsCmd.SetAction((parseResult, cancellationToken) =>
+            {
+                var logger = getLogger();
+                var setting = XPlatUtility.GetSettingsForCurrentWorkingDirectory();
 
-                    // Using both -clear and -list command options, or neither one of them, is not supported.
-                    // We use MinArgs = 0 even though the first argument is required,
-                    // to avoid throwing a command argument validation exception and
-                    // immediately show usage help for this command instead.
-                    if ((arguments.Values.Count < 1) || string.IsNullOrWhiteSpace(arguments.Values[0]))
-                    {
-                        throw new ArgumentException(string.Format(CultureInfo.CurrentCulture, Strings.LocalsCommand_NoArguments));
-                    }
-                    else if (clear.HasValue() && list.HasValue())
-                    {
-                        throw new ArgumentException(string.Format(CultureInfo.CurrentCulture, Strings.LocalsCommand_MultipleOperations));
-                    }
-                    else if (!clear.HasValue() && !list.HasValue())
-                    {
-                        throw new ArgumentException(string.Format(CultureInfo.CurrentCulture, Strings.LocalsCommand_NoOperation));
-                    }
-                    else
-                    {
-                        var localsArgs = new LocalsArgs(arguments.Values,
-                            setting,
-                            logger.LogInformation,
-                            logger.LogError,
-                            clear.HasValue(),
-                            list.HasValue());
+                string? cacheLocation = parseResult.GetValue(CacheLocationArgument);
+                bool clear = parseResult.GetValue(ClearOption);
+                bool list = parseResult.GetValue(ListOption);
 
-                        var localsCommandRunner = new LocalsCommandRunner();
-                        localsCommandRunner.ExecuteCommand(localsArgs);
-                    }
+                // Using both -clear and -list command options, or neither one of them, is not supported.
+                // We use MinArgs = 0 even though the first argument is required,
+                // to avoid throwing a command argument validation exception and
+                // immediately show usage help for this command instead.
+                if (string.IsNullOrWhiteSpace(cacheLocation))
+                {
+                    throw new ArgumentException(string.Format(CultureInfo.CurrentCulture, Strings.LocalsCommand_NoArguments));
+                }
+                else if (clear && list)
+                {
+                    throw new ArgumentException(string.Format(CultureInfo.CurrentCulture, Strings.LocalsCommand_MultipleOperations));
+                }
+                else if (!clear && !list)
+                {
+                    throw new ArgumentException(string.Format(CultureInfo.CurrentCulture, Strings.LocalsCommand_NoOperation));
+                }
+                else
+                {
+                    var localsArgs = new LocalsArgs(new List<string> { cacheLocation },
+                        setting,
+                        logger.LogInformation,
+                        logger.LogError,
+                        clear,
+                        list);
+
+                    var localsCommandRunner = new LocalsCommandRunner();
+                    localsCommandRunner.ExecuteCommand(localsArgs);
+                }
 
-                    return 0;
-                });
+                return Task.FromResult(0);
             });
+
+            parent.Subcommands.Add(localsCmd);
         }
     }
 }