feat: enhance ILoggerExtensions and add new message writers for console logging

- Updated ProgressAsync and StatusAsync methods to use ProgressContext and StatusContext respectively.
- Introduced AskConsoleMessageWriter, ConfirmConsoleMessageWriter, and ProgressConsoleMessageWriter for handling specific log message types.
- Added new payload classes: AskPayload, ConfirmPayload, ProgressPayload, and StatusPayload to encapsulate execution logic.
- Removed obsolete ProgressStartPayload and ProgressFinishedPayload classes.
- Added SpectreConsoleLogSinkExtensions for disabling log sink filters.
- Updated tests for ProgressAsync and StatusAsync methods to reflect changes in method signatures and behavior.

Author: WolfBublitz

src/Extensions/ILoggerExtensions.cs

@@ -1,4 +1,5 @@
 using System;
+using System.Diagnostics.CodeAnalysis;
 using System.Threading;
 using System.Threading.Tasks;
 using Spectre.Console;
@@ -82,43 +83,46 @@ public static ILogger HorizontalRule(this ILogger @this, string? title = null)
     /// Logs a <see cref="Progress"/> to the console.
     /// </summary>
     /// <param name="this">The <see cref="ILogger"/> instance to log the progress to.</param>
-    /// <param name="action">An action that receives the <see cref="Progress"/> instance to configure it and add tasks to it.</param>
+    /// <param name="action">An action that receives the <see cref="ProgressContext"/> instance to configure it and add tasks to it.</param>
     /// <param name="cancellationToken">A cancellation token that can be used to cancel the progress operation.</param>
     /// <returns>A <see cref="Task"/> that represents the asynchronous progress operation.</returns>
-    public static async Task ProgressAsync(this ILogger @this, Func<Progress, Task> action, CancellationToken cancellationToken = default)
+    public static Task ProgressAsync(this ILogger @this, Func<ProgressContext, Task> action, CancellationToken cancellationToken = default)
     {
         ArgumentNullException.ThrowIfNull(@this);
-        ArgumentNullException.ThrowIfNull(action);
-
-        ProgressStartPayload startPayload = new()
-        {
-            CancellationToken = cancellationToken,
-        };
-
-        @this.Log(null, startPayload);
-
-        Progress progress = await startPayload.WaitForProgressAsync().ConfigureAwait(false);
 
-        await action(progress).ConfigureAwait(false);
+        TaskCompletionSource taskCompletionSource = new(TaskCreationOptions.RunContinuationsAsynchronously);
 
-        ProgressFinishedPayload finishedPayload = new()
+        ProgressPayload payload = new()
         {
-            CancellationToken = cancellationToken,
+            ExecuteAsync = async console =>
+            {
+                try
+                {
+                    await console.Progress().StartAsync(action).ConfigureAwait(false);
+
+                    taskCompletionSource.SetResult();
+                }
+                catch (Exception exception)
+                {
+                    taskCompletionSource.SetException(exception);
+                }
+            },
         };
 
-        @this.Log(null, finishedPayload);
+        @this.Log(null, payload);
 
-        await finishedPayload.WaitForFinishedAsync().ConfigureAwait(false);
+        return taskCompletionSource.Task;
     }
 
     /// <summary>
     /// Logs a <see cref="Status"/> to the console.
     /// </summary>
     /// <param name="this">The <see cref="ILogger"/> instance to log the status to.</param>
+    /// <param name="status">The status text to display.</param>
     /// <param name="action">An action that receives the <see cref="Status"/> instance to configure it and add tasks to it.</param>
     /// <param name="cancellationToken">A cancellation token that can be used to cancel the status operation.</param>
     /// <returns>A <see cref="Task"/> that represents the asynchronous status operation.</returns>
-    public static async Task StatusAsync(this ILogger @this, Func<Status, Task> action, CancellationToken cancellationToken = default)
+    public static Task StatusAsync(this ILogger @this, string status, Func<StatusContext, Task> action, CancellationToken cancellationToken = default)
     {
         ArgumentNullException.ThrowIfNull(@this);
         ArgumentNullException.ThrowIfNull(action);
@@ -128,19 +132,88 @@ public static async Task StatusAsync(this ILogger @this, Func<Status, Task> acti
             CancellationToken = cancellationToken,
         };
 
-        @this.Log(null, startPayload);
+        TaskCompletionSource taskCompletionSource = new(TaskCreationOptions.RunContinuationsAsynchronously);
 
-        Status status = await startPayload.WaitForStatusAsync().ConfigureAwait(false);
+        StatusPayload statusPayload = new()
+        {
+            ExecuteAsync = async console =>
+            {
+                try
+                {
+                    await console.Status().StartAsync(status, action).ConfigureAwait(false);
+
+                    taskCompletionSource.SetResult();
+                }
+                catch (Exception exception)
+                {
+                    taskCompletionSource.SetException(exception);
+                }
+            },
+        };
 
-        await action(status).ConfigureAwait(false);
+        @this.Log(null, statusPayload);
 
-        StatusFinishedPayload finishedPayload = new()
+        return taskCompletionSource.Task;
+    }
+
+    [SuppressMessage("Design", "CA1031:Do not catch general exception types", Justification = "We want to catch all exceptions to set them on the payload.")]
+    public static Task<bool> ConfirmAsync(this ILogger @this, string prompt, bool defaultValue = true, CancellationToken cancellationToken = default)
+    {
+        ArgumentNullException.ThrowIfNull(@this);
+        ArgumentNullException.ThrowIfNull(prompt);
+
+        TaskCompletionSource<bool> taskCompletionSource = new(TaskCreationOptions.RunContinuationsAsynchronously);
+
+        ConfirmPayload payload = new()
         {
-            CancellationToken = cancellationToken,
+            ExecuteAsync = async console =>
+            {
+                try
+                {
+                    bool result = await console.ConfirmAsync(prompt, defaultValue, cancellationToken: cancellationToken).ConfigureAwait(false);
+
+                    taskCompletionSource.SetResult(result);
+                }
+                catch (Exception exception)
+                {
+                    taskCompletionSource.SetException(exception);
+                }
+            },
+        };
+
+        @this.Log(null, payload);
+
+        return taskCompletionSource.Task;
+    }
+
+    [SuppressMessage("Design", "CA1031:Do not catch general exception types", Justification = "We want to catch all exceptions to set them on the payload.")]
+    public static Task<T> AskAsync<T>(this ILogger @this, string prompt, CancellationToken cancellationToken = default)
+        where T : notnull
+    {
+        ArgumentNullException.ThrowIfNull(@this);
+        ArgumentNullException.ThrowIfNull(prompt);
+
+        TaskCompletionSource<T> taskCompletionSource = new(TaskCreationOptions.RunContinuationsAsynchronously);
+
+        AskPayload payload = new()
+        {
+            ExecuteAsync = async console =>
+            {
+                try
+                {
+                    T result = await console.AskAsync<T>(prompt, cancellationToken: cancellationToken).ConfigureAwait(false);
+
+                    taskCompletionSource.TrySetResult(result);
+                }
+                catch (Exception exception)
+                {
+                    taskCompletionSource.TrySetException(exception);
+                }
+            },
         };
 
-        @this.Log(null, finishedPayload);
+        @this.Log(null, payload);
 
-        await finishedPayload.WaitForFinishedAsync().ConfigureAwait(false);
+        return taskCompletionSource.Task;
     }
 }

src/Extensions/SpectreConsoleLogSinkExtensions.cs

@@ -0,0 +1,10 @@
+using System;
+
+namespace WB.Logging.LogSinks.Console.Spectre;
+
+internal static class SpectreConsoleLogSinkExtensions
+{
+    internal static IDisposable Disable(this SpectreConsoleLogSink logSink)
+        => logSink.AddFilter(_ => false);
+}
+

src/LogMessageWriters/AskConsoleMessageWriter.cs

@@ -0,0 +1,17 @@
+using System;
+using System.Diagnostics.CodeAnalysis;
+using System.Threading;
+using System.Threading.Tasks;
+using WB.Logging.LogSinks.Base;
+
+namespace WB.Logging.LogSinks.Console.Spectre;
+
+internal sealed class AskConsoleMessageWriter(SpectreConsoleLogSink logSink) : IAsyncLogMessageWriter<AskPayload>
+{
+    public async ValueTask WriteAsync(ILogMessage<AskPayload> logMessage, CancellationToken cancellationToken)
+    {
+        using IDisposable filter = logSink.Disable();
+
+        await logMessage.Payload.ExecuteAsync(logSink.Console).ConfigureAwait(false);
+    }
+}

src/LogMessageWriters/ConfirmConsoleMessageWriter.cs

@@ -0,0 +1,18 @@
+using System;
+using System.Diagnostics.CodeAnalysis;
+using System.Threading;
+using System.Threading.Tasks;
+
+using WB.Logging.LogSinks.Base;
+
+namespace WB.Logging.LogSinks.Console.Spectre;
+
+internal sealed class ConfirmConsoleMessageWriter(SpectreConsoleLogSink logSink) : IAsyncLogMessageWriter<ConfirmPayload>
+{
+    public async ValueTask WriteAsync(ILogMessage<ConfirmPayload> logMessage, CancellationToken cancellationToken)
+    {
+        using IDisposable filter = logSink.Disable();
+
+        await logMessage.Payload.ExecuteAsync(logSink.Console).ConfigureAwait(false);
+    }
+}

src/LogMessageWriters/ProgressConsoleMessageWriter.cs

@@ -1,9 +1,6 @@
 using System;
-using System.Collections.Generic;
-using System.Diagnostics.CodeAnalysis;
 using System.Threading;
 using System.Threading.Tasks;
-using Spectre.Console;
 using WB.Logging.LogSinks.Base;
 
 namespace WB.Logging.LogSinks.Console.Spectre;
@@ -13,38 +10,16 @@ namespace WB.Logging.LogSinks.Console.Spectre;
 /// render progress updates in the console.
 /// </summary>
 internal sealed class ProgressConsoleMessageWriter(SpectreConsoleLogSink logSink)
-    : IAsyncLogMessageWriter<ProgressStartPayload>
-    , IAsyncLogMessageWriter<ProgressFinishedPayload>
+    : IAsyncLogMessageWriter<ProgressPayload>
 {
-    private IDisposable? logSinkDisabledSubscription;
-
     // ┌─────────────────────────────────────────────────────────────────────────────┐
     // │ Public Methods                                                              │
     // └─────────────────────────────────────────────────────────────────────────────┘
 
-    public ValueTask WriteAsync(ILogMessage<ProgressStartPayload> logMessage, CancellationToken cancellationToken)
-    {
-        if (logSinkDisabledSubscription is null)
-        {
-            logSinkDisabledSubscription = logSink.AddFilter<ProgressFinishedPayload>(lm => lm.Payload is ProgressFinishedPayload);
-
-            logMessage.Payload.SetProgress(logSink.Console.Progress());
-        }
-
-        return ValueTask.CompletedTask;
-    }
-
-    public ValueTask WriteAsync(ILogMessage<ProgressFinishedPayload> logMessage, CancellationToken cancellationToken)
+    public async ValueTask WriteAsync(ILogMessage<ProgressPayload> logMessage, CancellationToken cancellationToken)
     {
-        if (logSinkDisabledSubscription is not null)
-        {
-            logSinkDisabledSubscription.Dispose();
-            logSinkDisabledSubscription = null;
+        using IDisposable filter = logSink.Disable();
 
-            logMessage.Payload.SetFinished();
-        }
-
-        return ValueTask.CompletedTask;
+        await logMessage.Payload.ExecuteAsync(logSink.Console).ConfigureAwait(false);
     }
-
 }

src/LogMessageWriters/StatusConsoleMessageWriter.cs

@@ -12,49 +12,17 @@ namespace WB.Logging.LogSinks.Console.Spectre;
 /// A log message writer that uses Spectre.Console's status to 
 /// render status updates in the console.
 /// </summary>
-internal sealed class StatusConsoleMessageWriter
-    : IAsyncLogMessageWriter<StatusStartPayload>
-    , IAsyncLogMessageWriter<StatusFinishedPayload>
+internal sealed class StatusConsoleMessageWriter(SpectreConsoleLogSink logSink)
+    : IAsyncLogMessageWriter<StatusPayload>
 {
-    private IDisposable? logSinkDisabledSubscription;
-
-    // ┌─────────────────────────────────────────────────────────────────────────────┐
-    // │ Public Properties                                                           │
-    // └─────────────────────────────────────────────────────────────────────────────┘
-
-    /// <inheritdoc/>
-    public IAnsiConsole Writer { get; set; } = AnsiConsole.Console;
-
-    /// <inheritdoc/>
-    [NotNull]
-    public SpectreConsoleLogSink? LogSink { get; set; }
-
     // ┌─────────────────────────────────────────────────────────────────────────────┐
     // │ Public Methods                                                              │
     // └─────────────────────────────────────────────────────────────────────────────┘
 
-    public ValueTask WriteAsync(ILogMessage<StatusStartPayload> logMessage, CancellationToken cancellationToken)
+    public async ValueTask WriteAsync(ILogMessage<StatusPayload> logMessage, CancellationToken cancellationToken)
     {
-        if (logSinkDisabledSubscription is null && LogSink is not null)
-        {
-            logSinkDisabledSubscription = LogSink.AddFilter<object>(lm => lm.Payload is StatusFinishedPayload);
-
-            logMessage.Payload.SetStatus(LogSink.Console.Status());
-        }
-
-        return ValueTask.CompletedTask;
-    }
-
-    public ValueTask WriteAsync(ILogMessage<StatusFinishedPayload> logMessage, CancellationToken cancellationToken)
-    {
-        if (logSinkDisabledSubscription is not null)
-        {
-            logSinkDisabledSubscription.Dispose();
-            logSinkDisabledSubscription = null;
-
-            logMessage.Payload.SetFinished();
-        }
+        using IDisposable filter = logSink.Disable();
 
-        return ValueTask.CompletedTask;
+        await logMessage.Payload.ExecuteAsync(logSink.Console).ConfigureAwait(false);
     }
 }

src/Payloads/AskPayload.cs

@@ -0,0 +1,10 @@
+using System;
+using System.Threading.Tasks;
+using Spectre.Console;
+
+namespace WB.Logging.LogSinks.Console.Spectre;
+
+internal sealed class AskPayload
+{
+    public required Func<IAnsiConsole, Task> ExecuteAsync { get; init; }
+}

src/Payloads/ConfirmPayload.cs

@@ -0,0 +1,11 @@
+using System;
+using System.Threading;
+using System.Threading.Tasks;
+using Spectre.Console;
+
+namespace WB.Logging.LogSinks.Console.Spectre;
+
+internal sealed class ConfirmPayload
+{
+    public required Func<IAnsiConsole, Task> ExecuteAsync { get; init; }
+}

src/Payloads/ProgressFinishedPayload.cs

@@ -0,0 +1,10 @@
+using System;
+using System.Threading.Tasks;
+using Spectre.Console;
+
+namespace WB.Logging.LogSinks.Console.Spectre;
+
+internal sealed class ProgressPayload
+{
+    public required Func<IAnsiConsole, Task> ExecuteAsync { get; init; }
+}