CommandExtensions.cs

using CliWrap.Builders;
using CliWrap.EventStream;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;

namespace CliWrap;

public static class CommandExtensions
{
    /// <summary>
    /// Executes a <see cref="Command"/> as a <c>dotnet</c> command that starts a long-running application, and waits
    /// for the app to be started.
    /// </summary>
    public static Task ExecuteDotNetApplicationAsync(
        this Command command,
        Action<StandardErrorCommandEvent>? stdErrHandler = default,
        CancellationToken cancellationToken = default) =>
        command.ExecuteUntilOutputAsync("Application started. Press Ctrl+C to shut down.", stdErrHandler, cancellationToken);

    /// <summary>
    /// Executes a <see cref="Command"/> until the given output is received, then returns.
    /// </summary>
    public static async Task ExecuteUntilOutputAsync(
        this Command command,
        string outputToWaitFor,
        Action<StandardErrorCommandEvent>? stdErrHandler = default,
        CancellationToken cancellationToken = default)
    {
        await foreach (var commandEvent in command.ListenAsync(cancellationToken))
        {
            if (commandEvent is StandardOutputCommandEvent stdOut &&
                stdOut.Text.ContainsOrdinalIgnoreCase(outputToWaitFor))
            {
                return;
            }

            if (commandEvent is StandardErrorCommandEvent stdErr)
            {
                stdErrHandler?.Invoke(stdErr);
            }
        }
    }

    /// <summary>
    /// Same as <see cref="Command.WithArguments(Action{ArgumentsBuilder})"/>, but the configuration delegate is
    /// asynchronous.
    /// </summary>
    public static async Task<Command> WithArgumentsAsync(this Command command, Func<ArgumentsBuilder, Task> configureAsync)
    {
        var builder = new ArgumentsBuilder();
        await configureAsync(builder);

        return command.WithArguments(builder.Build());
    }

    /// <summary>
    /// Same as <see cref="Command.WithEnvironmentVariables(IReadOnlyDictionary{string,string?})"/>, but the values can
    /// be any type. If a value is <see cref="IConvertible"/>, like all C# primitive types then <see
    /// cref="NumberExtensions.ToTechnicalString(IConvertible)"/> is called, otherwise <see cref="object.ToString"/>.
    /// </summary>
    public static Command WithEnvironmentVariables(this Command command, IEnumerable<KeyValuePair<string?, object?>> variables) =>
        command.WithEnvironmentVariables(variables
            .Where(pair => pair is { Key: { } })
            .ToDictionary(
                pair => pair.Key!,
                pair => pair.Value switch
                {
                    string text => text,
                    IConvertible convertible => convertible.ToTechnicalString(),
                    _ => pair.Value?.ToString(),
                }));
}