Merge branch 'feature/spectreconsoleGH-1264' of https://github.com/ni…

…ls-a/spectre.console into nils-a-feature/spectreconsoleGH-1264

docs/input/cli/exceptions.md

@@ -53,7 +53,11 @@ Using the `SetExceptionHandler()` during configuration it is possible to handle
 This method comes in two flavours: One that uses the default exitCode (or `return` value) of `-1` and one
 where the exitCode needs to be supplied.
 
-### Using `SetExceptionHandler(Func<Exception, int> handler)`
+The `ITypeResolver?` parameter will be null, when the exception occurs while no `ITypeResolver` is available.
+(Basically the `ITypeResolver` will be set, when the exception occurs during a command execution, but not
+during the parsing phase and construction of the command.)
+
+### Using `SetExceptionHandler(Func<Exception, ITypeResolver?, int> handler)`
 
 Using this method exceptions can be handled in a custom way. The return value of the handler is used as
 the exitCode for the application.
@@ -71,7 +75,7 @@ namespace MyApp
 
             app.Configure(config =>
             {
-                config.SetExceptionHandler(ex =>
+                config.SetExceptionHandler((ex, resolver) =>
                 {
                     AnsiConsole.WriteException(ex, ExceptionFormats.ShortenEverything);
                     return -99;
@@ -84,9 +88,9 @@ namespace MyApp
 }
 ```
 
-### Using `SetExceptionHandler(Action<Exception> handler)`
+### Using `SetExceptionHandler(Action<Exception, ITypeResolver?> handler)`
 
-Using this method exceptions can be handled in a custom way, much the same as with the `SetExceptionHandler(Func<Exception, int> handler)`.
+Using this method exceptions can be handled in a custom way, much the same as with the `SetExceptionHandler(Func<Exception, ITypeResolver?, int> handler)`.
 Using the `Action` as the handler however, it is not possible (or required) to supply a return value.
 The exitCode for the application will be `-1`.
 
@@ -103,7 +107,7 @@ namespace MyApp
 
             app.Configure(config =>
             {
-                config.SetExceptionHandler(ex =>
+                config.SetExceptionHandler((ex, resolver) =>
                 {
                     AnsiConsole.WriteException(ex, ExceptionFormats.ShortenEverything);
                 });

src/Spectre.Console.Cli/CommandApp.cs

@@ -102,7 +102,7 @@ public async Task<int> RunAsync(IEnumerable<string> args)
 
             if (_configurator.Settings.ExceptionHandler != null)
             {
-                return _configurator.Settings.ExceptionHandler(ex);
+                return _configurator.Settings.ExceptionHandler(ex, null);
             }
 
             // Render the exception.

src/Spectre.Console.Cli/ConfiguratorExtensions.cs

@@ -367,11 +367,11 @@ public static ICommandConfigurator AddAsyncDelegate<TSettings>(
     /// <param name="configurator">The configurator.</param>
     /// <param name="exceptionHandler">The Action that handles the exception.</param>
     /// <returns>A configurator that can be used to configure the application further.</returns>
-    public static IConfigurator SetExceptionHandler(this IConfigurator configurator, Action<Exception> exceptionHandler)
+    public static IConfigurator SetExceptionHandler(this IConfigurator configurator, Action<Exception, ITypeResolver?> exceptionHandler)
     {
-        return configurator.SetExceptionHandler(ex =>
+        return configurator.SetExceptionHandler((ex, resolver) =>
         {
-            exceptionHandler(ex);
+            exceptionHandler(ex, resolver);
             return -1;
         });
     }
@@ -382,7 +382,7 @@ public static IConfigurator SetExceptionHandler(this IConfigurator configurator,
     /// <param name="configurator">The configurator.</param>
     /// <param name="exceptionHandler">The Action that handles the exception.</param>
     /// <returns>A configurator that can be used to configure the application further.</returns>
-    public static IConfigurator SetExceptionHandler(this IConfigurator configurator, Func<Exception, int>? exceptionHandler)
+    public static IConfigurator SetExceptionHandler(this IConfigurator configurator, Func<Exception, ITypeResolver?, int>? exceptionHandler)
     {
         if (configurator == null)
         {

src/Spectre.Console.Cli/ICommandAppSettings.cs

@@ -90,6 +90,8 @@ public interface ICommandAppSettings
     /// <summary>
     /// Gets or sets a handler for Exceptions.
     /// <para>This handler will not be called, if <see cref="PropagateExceptions"/> is set to <c>true</c>.</para>
+    /// The <see cref="ITypeResolver"/> argument will only be not-null, when the exception occurs during execution of
+    /// a command. I.e. only when the resolver is available.
     /// </summary>
-    public Func<Exception, int>? ExceptionHandler { get; set; }
+    public Func<Exception, ITypeResolver?, int>? ExceptionHandler { get; set; }
 }

src/Spectre.Console.Cli/Internal/CommandExecutor.cs

@@ -128,19 +128,26 @@ private static Task<int> Execute(
         ITypeResolver resolver,
         IConfiguration configuration)
     {
-        // Bind the command tree against the settings.
-        var settings = CommandBinder.Bind(tree, leaf.Command.SettingsType, resolver);
-        configuration.Settings.Interceptor?.Intercept(context, settings);
-
-        // Create and validate the command.
-        var command = leaf.CreateCommand(resolver);
-        var validationResult = command.Validate(context, settings);
-        if (!validationResult.Successful)
+        try
         {
-            throw CommandRuntimeException.ValidationFailed(validationResult);
-        }
+            // Bind the command tree against the settings.
+            var settings = CommandBinder.Bind(tree, leaf.Command.SettingsType, resolver);
+            configuration.Settings.Interceptor?.Intercept(context, settings);
+
+            // Create and validate the command.
+            var command = leaf.CreateCommand(resolver);
+            var validationResult = command.Validate(context, settings);
+            if (!validationResult.Successful)
+            {
+                throw CommandRuntimeException.ValidationFailed(validationResult);
+            }
 
-        // Execute the command.
-        return command.Execute(context, settings);
+            // Execute the command.
+            return command.Execute(context, settings);
+        }
+        catch (Exception ex) when (configuration.Settings is { ExceptionHandler: not null, PropagateExceptions: false })
+        {
+            return Task.FromResult(configuration.Settings.ExceptionHandler(ex, resolver));
+        }
     }
 }

src/Spectre.Console.Cli/Internal/Configuration/CommandAppSettings.cs

@@ -20,7 +20,7 @@ internal sealed class CommandAppSettings : ICommandAppSettings
     public ParsingMode ParsingMode =>
         StrictParsing ? ParsingMode.Strict : ParsingMode.Relaxed;
 
-    public Func<Exception, int>? ExceptionHandler { get; set; }
+    public Func<Exception, ITypeResolver?, int>? ExceptionHandler { get; set; }
 
     public CommandAppSettings(ITypeRegistrar registrar)
     {

test/Spectre.Console.Cli.Tests/Unit/CommandAppTests.Exceptions.cs

@@ -51,7 +51,7 @@ public void Should_Handle_Exceptions_If_ExceptionHandler_Is_Set_Using_Action()
             app.Configure(config =>
             {
                 config.AddCommand<ThrowingCommand>("throw");
-                config.SetExceptionHandler(_ =>
+                config.SetExceptionHandler((_, _) =>
                 {
                     exceptionHandled = true;
                 });
@@ -74,7 +74,7 @@ public void Should_Handle_Exceptions_If_ExceptionHandler_Is_Set_Using_Function()
             app.Configure(config =>
             {
                 config.AddCommand<ThrowingCommand>("throw");
-                config.SetExceptionHandler(_ =>
+                config.SetExceptionHandler((_, _) =>
                 {
                     exceptionHandled = true;
                     return -99;
@@ -88,5 +88,49 @@ public void Should_Handle_Exceptions_If_ExceptionHandler_Is_Set_Using_Function()
             result.ExitCode.ShouldBe(-99);
             exceptionHandled.ShouldBeTrue();
         }
+
+        [Fact]
+        public void Should_Have_Resolver_Set_When_Exception_Occurs_In_Command_Execution()
+        {
+            // Given
+            ITypeResolver resolver = null;
+            var app = new CommandAppTester();
+            app.Configure(config =>
+            {
+                config.AddCommand<ThrowingCommand>("throw");
+                config.SetExceptionHandler((_, r) =>
+                {
+                    resolver = r;
+                });
+            });
+
+            // When
+            app.Run(new[] { "throw" });
+
+            // Then
+            resolver.ShouldNotBeNull();
+        }
+
+        [Fact]
+        public void Should_Not_Have_Resolver_Set_When_Exception_Occurs_Before_Command_Execution()
+        {
+            // Given
+            ITypeResolver resolver = null;
+            var app = new CommandAppTester();
+            app.Configure(config =>
+            {
+                config.AddCommand<DogCommand>("Лайка");
+                config.SetExceptionHandler((_, r) =>
+                {
+                    resolver = r;
+                });
+            });
+
+            // When
+            app.Run(new[] { "throw", "on", "arg", "parsing" });
+
+            // Then
+            resolver.ShouldBeNull();
+        }
     }
 }