Move most of the built in middlewares out of middleware

src/System.CommandLine.ApiCompatibility.Tests/ApiCompatibilityApprovalTests.System_CommandLine_api_is_not_changed.approved.txt

@@ -83,8 +83,8 @@ System.CommandLine
     public static CommandLineBuilder UseHelp(this CommandLineBuilder builder, System.Action<System.CommandLine.Help.HelpContext> customize, System.Nullable<System.Int32> maxWidth = null)
     public static TBuilder UseHelpBuilder<TBuilder>(this TBuilder builder, System.Func<System.CommandLine.Binding.BindingContext,System.CommandLine.Help.HelpBuilder> getHelpBuilder)
     public static CommandLineBuilder UseLocalizationResources(this CommandLineBuilder builder, LocalizationResources validationMessages)
-    public static CommandLineBuilder UseParseDirective(this CommandLineBuilder builder, System.Nullable<System.Int32> errorExitCode = null)
-    public static CommandLineBuilder UseParseErrorReporting(this CommandLineBuilder builder, System.Nullable<System.Int32> errorExitCode = null)
+    public static CommandLineBuilder UseParseDirective(this CommandLineBuilder builder, System.Int32 errorExitCode = 1)
+    public static CommandLineBuilder UseParseErrorReporting(this CommandLineBuilder builder, System.Int32 errorExitCode = 1)
     public static CommandLineBuilder UseSuggestDirective(this CommandLineBuilder builder)
     public static CommandLineBuilder UseTokenReplacer(this CommandLineBuilder builder, System.CommandLine.Parsing.TryReplaceToken replaceToken)
     public static CommandLineBuilder UseTypoCorrections(this CommandLineBuilder builder, System.Int32 maxLevenshteinDistance = 3)

src/System.CommandLine.Hosting.Tests/HostingHandlerTest.cs

@@ -55,7 +55,7 @@ public static async Task Parameter_is_available_in_property()
         }
 
         [Fact]
-        public static async Task Can_have_diferent_handlers_based_on_command()
+        public static async Task Can_have_different_handlers_based_on_command()
         {
             var root = new RootCommand();
 

src/System.CommandLine.Tests/ParseDirectiveTests.cs

@@ -46,6 +46,56 @@ public async Task Parse_directive_writes_parse_diagram()
                    .Be($"![ {RootCommand.ExecutableName} [ subcommand [ -c <34> ] ] ]   ???--> --nonexistent wat" + Environment.NewLine);
         }
 
+        [Fact]
+        public async Task When_parse_directive_is_used_the_help_is_not_displayed()
+        {
+            var rootCommand = new RootCommand();
+
+            var parser = new CommandLineBuilder(rootCommand)
+                         .UseParseDirective()
+                         .UseVersionOption()
+                         .UseHelp()
+                         .Build();
+
+            var result = parser.Parse("[parse] --help");
+
+            output.WriteLine(result.Diagram());
+
+            var console = new TestConsole();
+
+            await result.InvokeAsync(console);
+
+            console.Out
+                   .ToString()
+                   .Should()
+                   .Be($"[ {RootCommand.ExecutableName} [ --help ] ]" + Environment.NewLine);
+        }
+
+        [Fact]
+        public async Task When_parse_directive_is_used_the_version_is_not_displayed()
+        {
+            var rootCommand = new RootCommand();
+
+            var parser = new CommandLineBuilder(rootCommand)
+                         .UseParseDirective()
+                         .UseVersionOption()
+                         .UseHelp()
+                         .Build();
+
+            var result = parser.Parse("[parse] --version");
+
+            output.WriteLine(result.Diagram());
+
+            var console = new TestConsole();
+
+            await result.InvokeAsync(console);
+
+            console.Out
+                   .ToString()
+                   .Should()
+                   .Be($"[ {RootCommand.ExecutableName} [ --version ] ]" + Environment.NewLine);
+        }
+
         [Fact]
         public async Task When_there_are_no_errors_then_parse_directive_sets_exit_code_0()
         {

src/System.CommandLine/Builder/CommandLineBuilder.cs

@@ -14,6 +14,33 @@ namespace System.CommandLine
     /// </summary>
     public class CommandLineBuilder 
     {
+        /// <inheritdoc cref="CommandLineConfiguration.EnablePosixBundling"/>
+        internal bool EnablePosixBundling = true;
+
+        /// <inheritdoc cref="CommandLineConfiguration.EnableTokenReplacement"/>
+        internal bool EnableTokenReplacement = true;
+
+        /// <inheritdoc cref="CommandLineConfiguration.ParseErrorReportingExitCode"/>
+        internal int? ParseErrorReportingExitCode;
+
+        /// <inheritdoc cref="CommandLineConfiguration.EnableDirectives"/>
+        internal bool EnableDirectives = true;
+
+        /// <inheritdoc cref="CommandLineConfiguration.EnableEnvironmentVariableDirective"/>
+        internal bool EnableEnvironmentVariableDirective;
+
+        /// <inheritdoc cref="CommandLineConfiguration.ParseDirectiveExitCode"/>
+        internal int? ParseDirectiveExitCode;
+
+        /// <inheritdoc cref="CommandLineConfiguration.EnableSuggestDirective"/>
+        internal bool EnableSuggestDirective;
+
+        /// <inheritdoc cref="CommandLineConfiguration.MaxLevenshteinDistance"/>
+        internal int MaxLevenshteinDistance;
+
+        /// <inheritdoc cref="CommandLineConfiguration.ExceptionHandler"/>
+        internal Action<Exception, InvocationContext>? ExceptionHandler;
+
         // for every generic type with type argument being struct JIT needs to compile a dedicated version
         // (because each struct is of a different size)
         // that is why we don't use List<ValueTuple> for middleware
@@ -33,19 +60,6 @@ public CommandLineBuilder(Command? rootCommand = null)
         /// </summary>
         public Command Command { get; }
 
-        /// <summary>
-        /// Determines whether the parser recognizes command line directives.
-        /// </summary>
-        /// <seealso cref="DirectiveCollection"/>
-        internal bool EnableDirectives { get; set; } = true;
-
-        /// <summary>
-        /// Determines whether the parser recognize and expands POSIX-style bundled options.
-        /// </summary>
-        internal bool EnablePosixBundling { get; set; } = true;
-
-        internal bool EnableTokenReplacement { get; set; } = true;
-
         internal void CustomizeHelpLayout(Action<HelpContext> customize) => 
             _customizeHelpBuilder = customize;
 
@@ -68,19 +82,19 @@ HelpBuilder CreateHelpBuilder(BindingContext bindingContext)
             }
         }
 
-        internal HelpOption? HelpOption { get; set; }
+        internal HelpOption? HelpOption;
 
-        internal VersionOption? VersionOption { get; set; }
+        internal VersionOption? VersionOption;
 
-        internal int? MaxHelpWidth { get; set; }
+        internal int? MaxHelpWidth;
 
         internal LocalizationResources LocalizationResources
         {
             get => _localizationResources ??= LocalizationResources.Instance;
             set => _localizationResources = value;
         }
 
-        internal TryReplaceToken? TokenReplacer { get; set; }
+        internal TryReplaceToken? TokenReplacer;
 
         /// <summary>
         /// Creates a parser based on the configuration of the command line builder.
@@ -92,6 +106,12 @@ public Parser Build() =>
                     enablePosixBundling: EnablePosixBundling,
                     enableDirectives: EnableDirectives,
                     enableTokenReplacement: EnableTokenReplacement,
+                    enableEnvironmentVariableDirective: EnableEnvironmentVariableDirective,
+                    parseDirectiveExitCode: ParseDirectiveExitCode,
+                    enableSuggestDirective: EnableSuggestDirective,
+                    parseErrorReportingExitCode: ParseErrorReportingExitCode,
+                    maxLevenshteinDistance: MaxLevenshteinDistance,
+                    exceptionHandler: ExceptionHandler,
                     resources: LocalizationResources,
                     middlewarePipeline: _middlewareList is null
                                             ? Array.Empty<InvocationMiddleware>()

src/System.CommandLine/Builder/CommandLineBuilderExtensions.cs

@@ -8,7 +8,6 @@
 using System.CommandLine.IO;
 using System.CommandLine.Parsing;
 using System.IO;
-using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
 using static System.Environment;
@@ -230,27 +229,7 @@ await feature.EnsureRegistered(async () =>
         public static CommandLineBuilder UseEnvironmentVariableDirective(
             this CommandLineBuilder builder)
         {
-            builder.AddMiddleware((context, next) =>
-            {
-                if (context.ParseResult.Directives.TryGetValue("env", out var keyValuePairs))
-                {
-                    for (var i = 0; i < keyValuePairs.Count; i++)
-                    {
-                        var envDirective = keyValuePairs[i];
-                        var components = envDirective.Split(new[] { '=' }, count: 2);
-                        var variable = components.Length > 0 ? components[0].Trim() : string.Empty;
-                        if (string.IsNullOrEmpty(variable) || components.Length < 2)
-                        {
-                            continue;
-                        }
-
-                        var value = components[1].Trim();
-                        SetEnvironmentVariable(variable, value);
-                    }
-                }
-
-                return next(context);
-            }, MiddlewareOrderInternal.EnvironmentVariableDirective);
+            builder.EnableEnvironmentVariableDirective = true;
 
             return builder;
         }
@@ -302,17 +281,7 @@ public static CommandLineBuilder UseExceptionHandler(
             Action<Exception, InvocationContext>? onException = null,
             int? errorExitCode = null)
         {
-            builder.AddMiddleware(async (context, next) =>
-            {
-                try
-                {
-                    await next(context);
-                }
-                catch (Exception exception)
-                {
-                    (onException ?? Default)(exception, context);
-                }
-            }, MiddlewareOrderInternal.ExceptionHandler);
+            builder.ExceptionHandler = onException ?? Default;
 
             return builder;
 
@@ -397,14 +366,6 @@ internal static CommandLineBuilder UseHelp(
                 builder.HelpOption = helpOption;
                 builder.Command.AddGlobalOption(helpOption);
                 builder.MaxHelpWidth = maxWidth;
-
-                builder.AddMiddleware(async (context, next) =>
-                {
-                    if (!ShowHelp(context, builder.HelpOption))
-                    {
-                        await next(context);
-                    }
-                }, MiddlewareOrderInternal.HelpOption);
             }
             return builder;
         }
@@ -475,19 +436,9 @@ public static CommandLineBuilder AddMiddleware(
         /// <returns>The same instance of <see cref="CommandLineBuilder"/>.</returns>
         public static CommandLineBuilder UseParseDirective(
             this CommandLineBuilder builder,
-            int? errorExitCode = null)
+            int errorExitCode = 1)
         {
-            builder.AddMiddleware(async (context, next) =>
-            {
-                if (context.ParseResult.Directives.ContainsKey("parse"))
-                {
-                    context.InvocationResult = ctx => ParseDirectiveResult.Apply(ctx, errorExitCode);
-                }
-                else
-                {
-                    await next(context);
-                }
-            }, MiddlewareOrderInternal.ParseDirective);
+            builder.ParseDirectiveExitCode = errorExitCode;
 
             return builder;
         }
@@ -500,19 +451,9 @@ public static CommandLineBuilder UseParseDirective(
         /// <returns>The same instance of <see cref="CommandLineBuilder"/>.</returns>
         public static CommandLineBuilder UseParseErrorReporting(
             this CommandLineBuilder builder,
-            int? errorExitCode = null)
+            int errorExitCode = 1)
         {
-            builder.AddMiddleware(async (context, next) =>
-            {
-                if (context.ParseResult.Errors.Count > 0)
-                {
-                    context.InvocationResult = ctx => ParseErrorResult.Apply(ctx, errorExitCode);
-                }
-                else
-                {
-                    await next(context);
-                }
-            }, MiddlewareOrderInternal.ParseErrorReporting);
+            builder.ParseErrorReportingExitCode = errorExitCode;
 
             return builder;
         }
@@ -526,28 +467,7 @@ public static CommandLineBuilder UseParseErrorReporting(
         public static CommandLineBuilder UseSuggestDirective(
             this CommandLineBuilder builder)
         {
-            builder.AddMiddleware(async (context, next) =>
-            {
-                if (context.ParseResult.Directives.TryGetValue("suggest", out var values))
-                {
-                    int position;
-
-                    if (values.FirstOrDefault() is { } positionString)
-                    {
-                        position = int.Parse(positionString);
-                    }
-                    else
-                    {
-                        position = context.ParseResult.CommandLineText?.Length ?? 0;
-                    }
-
-                    context.InvocationResult = ctx => SuggestDirectiveResult.Apply(ctx, position);
-                }
-                else
-                {
-                    await next(context);
-                }
-            }, MiddlewareOrderInternal.SuggestDirective);
+            builder.EnableSuggestDirective = true;
 
             return builder;
         }
@@ -562,17 +482,12 @@ public static CommandLineBuilder UseTypoCorrections(
             this CommandLineBuilder builder,
             int maxLevenshteinDistance = 3)
         {
-            builder.AddMiddleware(async (context, next) =>
+            if (maxLevenshteinDistance <= 0)
             {
-                if (context.ParseResult.CommandResult.Command.TreatUnmatchedTokensAsErrors &&
-                    context.ParseResult.UnmatchedTokens.Count > 0)
-                {
-                    var typoCorrection = new TypoCorrection(maxLevenshteinDistance);
+                throw new ArgumentOutOfRangeException(nameof(maxLevenshteinDistance));
+            }
 
-                    typoCorrection.ProvideSuggestions(context.ParseResult, context.Console);
-                }
-                await next(context);
-            }, MiddlewareOrderInternal.TypoCorrection);
+            builder.MaxLevenshteinDistance = maxLevenshteinDistance;
 
             return builder;
         }
@@ -619,10 +534,8 @@ public static CommandLineBuilder UseVersionOption(
                 return builder;
             }
 
-            var versionOption = new VersionOption(builder);
-
-            builder.VersionOption = versionOption;
-            builder.Command.Options.Add(versionOption);
+            builder.VersionOption = new (builder);
+            builder.Command.Options.Add(builder.VersionOption);
 
             return builder;
         }
@@ -634,32 +547,15 @@ public static CommandLineBuilder UseVersionOption(
             this CommandLineBuilder builder,
             params string[] aliases)
         {
-            var command = builder.Command;
-
             if (builder.VersionOption is not null)
             {
                 return builder;
             }
 
-            var versionOption = new VersionOption(aliases, builder);
-
-            builder.VersionOption = versionOption;
-            command.Options.Add(versionOption);
+            builder.VersionOption = new (aliases, builder);
+            builder.Command.Options.Add(builder.VersionOption);
 
             return builder;
         }
-
-        private static bool ShowHelp(
-            InvocationContext context,
-            Option helpOption)
-        {
-            if (context.ParseResult.FindResultFor(helpOption) is { })
-            {
-                context.InvocationResult = HelpResult.Apply;
-                return true;
-            }
-
-            return false;
-        }
     }
 }