Merge branch 'main' into feature/spectreconsoleGH-1264

docs/input/cli/commandApp.md

@@ -81,9 +81,12 @@ Hint: If you do write your own implementation of `TypeRegistrar` and `TypeResolv
 there is a utility `TypeRegistrarBaseTests` available that can be used to ensure your implementations adhere to the required implementation. Simply call `TypeRegistrarBaseTests.RunAllTests()` and expect no `TypeRegistrarBaseTests.TestFailedException` to be thrown.
 
 ## Interception
+Interceptors can be registered with the `TypeRegistrar` (or with a custom DI-Container). Alternatively, `CommandApp` also provides a `SetInterceptor` configuration.
 
-`CommandApp` also provides a `SetInterceptor` configuration. An interceptor is run before all commands are executed. This is typically used for configuring logging or other infrastructure concerns.
+All interceptors must implement `ICommandInterceptor`. Upon execution of a command, The `Intercept`-Method of an instance of your interceptor will be called with the parsed settings. This provides an opportunity for configuring any infrastructure or modifying the settings.
+When the command has been run, the `InterceptResult`-Method of the same instance is called with the result of the command.
+This provides an opportunity to modify the result and also to tear down any infrastructure in use.
 
-All interceptors must implement `ICommandInterceptor`. Upon execution of a command, an instance of your interceptor will be called with the parsed settings. This provides an opportunity for configuring any infrastructure or modifying the settings.
+The `Intercept`-Method of each interceptor is run before the command is executed and the `InterceptResult`-Method is run after it. These are typically used for configuring logging or other infrastructure concerns.
 
 For an example of using the interceptor to configure logging, see the [Serilog demo](https://github.com/spectreconsole/spectre.console/tree/main/examples/Cli/Logging).

docs/input/quick-start.md

@@ -8,9 +8,10 @@ to install the NuGet package.
 
 ```text
 > dotnet add package Spectre.Console
+> dotnet add package Spectre.Console.Cli
 ```
 
-After that you will need to reference the `Spectre.Console` namespace.
+After that you will need to reference the `Spectre.Console` and `Spectre.Console.Cli` namespaces.
 Once that is done, you can start using all the available features.
 
 ```csharp

examples/Console/Canvas/Program.cs

@@ -10,18 +10,14 @@ public static class Program
 {
     public static void Main()
     {
-        // Draw a mandelbrot set using a Canvas
-        var mandelbrot = Mandelbrot.Generate(32, 32);
-        Render(mandelbrot, "Mandelbrot");
-
         // Draw an image using CanvasImage powered by ImageSharp.
         // This requires the "Spectre.Console.ImageSharp" NuGet package.
         var image = new CanvasImage("cake.png");
         image.BilinearResampler();
         image.MaxWidth(16);
         Render(image, "Image from file (16 wide)");
 
-        // Draw image again, but without render width
+        // Draw image again, but without max width
         image.NoMaxWidth();
         image.Mutate(ctx => ctx.Grayscale().Rotate(-45).EntropyCrop());
         Render(image, "Image from file (fit, greyscale, rotated)");

src/Directory.Build.props

@@ -30,8 +30,9 @@
     <PublishRepositoryUrl>true</PublishRepositoryUrl>
     <EmbedUntrackedSources>true</EmbedUntrackedSources>
   </PropertyGroup>
-
-  <ItemGroup Label="Package References">
+
+  <!-- Allow folks to build with minimal dependencies (though they will need to provide their own Version data) -->
+  <ItemGroup Label="Build Tools Package References" Condition="'$(UseBuildTimeTools)' != 'false'">
     <PackageReference Include="MinVer" PrivateAssets="All" Version="4.2.0" />
     <PackageReference Include="Microsoft.SourceLink.GitHub" PrivateAssets="All" Version="1.1.1" />
     <PackageReference Include="StyleCop.Analyzers" Version="1.2.0-beta.435">

src/Spectre.Console.Cli/ConfiguratorExtensions.cs

@@ -229,7 +229,7 @@ public static IConfigurator SetInterceptor(this IConfigurator configurator, ICom
             throw new ArgumentNullException(nameof(configurator));
         }
 
-        configurator.Settings.Interceptor = interceptor;
+        configurator.Settings.Registrar.RegisterInstance<ICommandInterceptor>(interceptor);
         return configurator;
     }
 

src/Spectre.Console.Cli/ICommandAppSettings.cs

@@ -50,6 +50,7 @@ public interface ICommandAppSettings
     /// Gets or sets the <see cref="ICommandInterceptor"/> used
     /// to intercept settings before it's being sent to the command.
     /// </summary>
+    [Obsolete("Register the interceptor with the ITypeRegistrar.")]
     ICommandInterceptor? Interceptor { get; set; }
 
     /// <summary>

src/Spectre.Console.Cli/ICommandInterceptor.cs

@@ -12,5 +12,25 @@ public interface ICommandInterceptor
     /// </summary>
     /// <param name="context">The intercepted <see cref="CommandContext"/>.</param>
     /// <param name="settings">The intercepted <see cref="CommandSettings"/>.</param>
-    void Intercept(CommandContext context, CommandSettings settings);
+    void Intercept(CommandContext context, CommandSettings settings)
+#if NETSTANDARD2_0
+    ;
+#else
+    {
+    }
+#endif
+
+    /// <summary>
+    /// Intercepts a command result before it's passed as the result.
+    /// </summary>
+    /// <param name="context">The intercepted <see cref="CommandContext"/>.</param>
+    /// <param name="settings">The intercepted <see cref="CommandSettings"/>.</param>
+    /// <param name="result">The result from the command execution.</param>
+    void InterceptResult(CommandContext context, CommandSettings settings, ref int result)
+#if NETSTANDARD2_0
+    ;
+#else
+    {
+    }
+#endif
 }

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

@@ -121,7 +121,7 @@ private static string ResolveApplicationVersion(IConfiguration configuration)
             VersionHelper.GetVersion(Assembly.GetEntryAssembly());
     }
 
-    private static Task<int> Execute(
+    private static async Task<int> Execute(
         CommandTree leaf,
         CommandTree tree,
         CommandContext context,
@@ -132,7 +132,19 @@ private static Task<int> Execute(
         {
             // Bind the command tree against the settings.
             var settings = CommandBinder.Bind(tree, leaf.Command.SettingsType, resolver);
-            configuration.Settings.Interceptor?.Intercept(context, settings);
+            var interceptors =
+                ((IEnumerable<ICommandInterceptor>?)resolver.Resolve(typeof(IEnumerable<ICommandInterceptor>))
+                ?? Array.Empty<ICommandInterceptor>()).ToList();
+#pragma warning disable CS0618 // Type or member is obsolete
+            if (configuration.Settings.Interceptor != null)
+            {
+                interceptors.Add(configuration.Settings.Interceptor);
+            }
+#pragma warning restore CS0618 // Type or member is obsolete
+            foreach (var interceptor in interceptors)
+            {
+                interceptor.Intercept(context, settings);
+            }
 
             // Create and validate the command.
             var command = leaf.CreateCommand(resolver);
@@ -143,7 +155,13 @@ private static Task<int> Execute(
             }
 
             // Execute the command.
-            return command.Execute(context, settings);
+            var result = await command.Execute(context, settings);
+            foreach (var interceptor in interceptors)
+            {
+                interceptor.InterceptResult(context, settings, ref result);
+            }
+
+            return result;
         }
         catch (Exception ex) when (configuration.Settings is { ExceptionHandler: not null, PropagateExceptions: false })
         {

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

@@ -8,6 +8,7 @@ internal sealed class CommandAppSettings : ICommandAppSettings
     public int MaximumIndirectExamples { get; set; }
     public bool ShowOptionDefaultValues { get; set; }
     public IAnsiConsole? Console { get; set; }
+    [Obsolete("Register the interceptor with the ITypeRegistrar.")]
     public ICommandInterceptor? Interceptor { get; set; }
     public ITypeRegistrarFrontend Registrar { get; set; }
     public CaseSensitivity CaseSensitivity { get; set; }

src/Spectre.Console.Testing/Cli/CallbackCommandInterceptor.cs

@@ -21,4 +21,11 @@ public void Intercept(CommandContext context, CommandSettings settings)
     {
         _callback(context, settings);
     }
+
+#if NETSTANDARD2_0
+    /// <inheritdoc/>
+    public void InterceptResult(CommandContext context, CommandSettings settings, ref int result)
+    {
+    }
+#endif
 }

src/Spectre.Console/Prompts/List/ListPrompt.cs

@@ -89,10 +89,10 @@ private IRenderable BuildRenderable(ListPromptState<T> state)
             skip = Math.Max(0, state.Index - middleOfList);
             take = Math.Min(pageSize, state.ItemCount - skip);
 
-            if (state.ItemCount - state.Index < middleOfList)
+            if (take < pageSize)
             {
-                // Pointer should be below the end of the list
-                var diff = middleOfList - (state.ItemCount - state.Index);
+                // Pointer should be below the middle of the (visual) list
+                var diff = pageSize - take;
                 skip -= diff;
                 take += diff;
                 cursorIndex = middleOfList + diff;

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

@@ -0,0 +1,90 @@
+namespace Spectre.Console.Tests.Unit.Cli;
+
+public sealed partial class CommandAppTests
+{
+    public sealed class Interceptor
+    {
+        public sealed class NoCommand : Command<NoCommand.Settings>
+        {
+            public sealed class Settings : CommandSettings
+            {
+            }
+
+            public override int Execute(CommandContext context, Settings settings)
+            {
+                return 0;
+            }
+        }
+
+        public sealed class MyInterceptor : ICommandInterceptor
+        {
+            private readonly Action<CommandContext, CommandSettings> _action;
+
+            public MyInterceptor(Action<CommandContext, CommandSettings> action)
+            {
+                _action = action;
+            }
+
+            public void Intercept(CommandContext context, CommandSettings settings)
+            {
+                _action(context, settings);
+            }
+        }
+
+        public sealed class MyResultInterceptor : ICommandInterceptor
+        {
+            private readonly Func<CommandContext, CommandSettings, int, int> _function;
+
+            public MyResultInterceptor(Func<CommandContext, CommandSettings, int, int> function)
+            {
+                _function = function;
+            }
+
+            public void InterceptResult(CommandContext context, CommandSettings settings, ref int result)
+            {
+                result = _function(context, settings, result);
+            }
+        }
+
+        [Fact]
+        public void Should_Run_The_Interceptor()
+        {
+            // Given
+            var count = 0;
+            var app = new CommandApp<NoCommand>();
+            var interceptor = new MyInterceptor((_, _) =>
+            {
+                count += 1;
+            });
+            app.Configure(config => config.SetInterceptor(interceptor));
+
+            // When
+            app.Run(Array.Empty<string>());
+
+            // Then
+            count.ShouldBe(1); // to be sure
+        }
+
+        [Fact]
+        public void Should_Run_The_ResultInterceptor()
+        {
+            // Given
+            var count = 0;
+            const int Expected = 123;
+            var app = new CommandApp<NoCommand>();
+            var interceptor = new MyResultInterceptor((_, _, _) =>
+            {
+                count += 1;
+                return Expected;
+            });
+            app.Configure(config => config.SetInterceptor(interceptor));
+
+            // When
+            var actual = app.Run(Array.Empty<string>());
+
+            // Then
+            count.ShouldBe(1);
+            actual.ShouldBe(Expected);
+        }
+    }
+}