Merge pull request #10 from xt0rted/multiple-script-execution

Add the ability to run multiple scripts in series

Author: xt0rted

.editorconfig

@@ -21,6 +21,9 @@ indent_size = 2
 [*.json]
 indent_size = 2
 
+[*.verified.txt]
+insert_final_newline = false
+
 [*.yml]
 indent_size = 2
 

.github/workflows/ci.yml

@@ -161,6 +161,8 @@ jobs:
 
       - run: dotnet r integration:ci --verbose -- --logger "trx;LogFilePrefix=ci test"
 
+      - run: dotnet r clean:bin build test --verbose
+
   release:
     if: github.event_name == 'push'
 

CHANGELOG.md

@@ -2,6 +2,8 @@
 
 ## Unreleased
 
+- added: Ability to run multiple scripts in a single call (e.g. `dotnet r build test pack`)
+
 ## [0.3.0](https://github.com/xt0rted/dotnet-run-script/compare/v0.2.0...v0.3.0) - 2022-04-24
 
 - fixed: Don't escape the script passed to `cmd.exe`, just the double dash arguments

README.md

@@ -40,6 +40,12 @@ Name | Description
 `--version` | Show version information
 `--help` | Show help and usage information
 
+Arguments passed after the double dash are passed through to the executing script.
+
+```console
+dotnet r build --verbose -- --configuration Release
+```
+
 ### Color output
 
 This tool supports the `DOTNET_SYSTEM_CONSOLE_ALLOW_ANSI_COLOR_REDIRECTION` environment variable.
@@ -82,7 +88,7 @@ You can override this with your own command if you wish.
 
 ## Usage
 
-Use `dotnet r <command>` to run the scripts.
+Use `dotnet r [<scripts>...] [options]` to run the scripts.
 Anything you can run from the command line can be used in a script.
 You can also call other scripts to chain them together such as a `ci` script that calls the `build`, `test`, and `package` scripts.
 
@@ -101,12 +107,44 @@ This is an example of a `pre` script that clears the build artifacts folder, and
 }
 ```
 
+### Multiple script execution
+
+Multiple scripts can be called at the same time like so:
+
+```console
+dotnet r build test
+```
+
+This will run the `build` script and if it returns a `0` exit code it will then run the `test` script.
+The `--if-present` option can be used to skip scripts that don't exist.
+
+```json
+{
+  "scripts": {
+    "build": "dotnet build",
+    "test:unit": "dotnet test",
+    "package": "dotnet pack"
+  }
+}
+```
+
+```console
+dotnet r build test:unit test:integration package --if-present
+```
+
+Arguments passed after the double dash are passed through to each executing script.
+In this example both the `--configuration` and `--framework` options will be passed to each of the four scripts when running them.
+
+```console
+dotnet r build test:unit test:integration package -- --configuration Release --framework net6.0
+```
+
 ### Working directory
 
 The working directory is set to the root of the project where the `global.json` is located.
 If you need to get the folder the command was executed from you can do so using the `INIT_CWD` environment variable.
 
-### Common build environments
+## Common build environments
 
 When using this tool on a build server, such as GitHub Actions, you might want to use a generic workflow that calls a common set of scripts such as `build`, `test`, and `package`.
 These might not be defined in all of your projects and if a script that doesn't exist is called an error is returned.

global.json

@@ -13,6 +13,11 @@
     "test:31": "dotnet r test -- --framework netcoreapp3.1",
     "test:5": "dotnet r test -- --framework net5.0",
     "test:6": "dotnet r test -- --framework net6.0",
+
+    "testbase": "dotnet test --no-build --logger \"trx;LogFilePrefix=tests\" --results-directory \"./.coverage\"",
+    "test:unit": "dotnet r testbase -- --filter \"category=unit\"",
+    "test:int": "dotnet r testbase -- --filter \"category=integration\"",
+
     "pack": "dotnet pack --no-build --output \"./artifacts\"",
 
     "build:release": "dotnet r build -- --configuration Release",

src/CommandBuilder.cs

@@ -0,0 +1,68 @@
+namespace RunScript;
+
+using System.Text.RegularExpressions;
+
+internal class CommandBuilder
+{
+    // This is the same regex used by npm's run-script library
+    public static readonly Regex IsCmdCheck = new("(?:^|\\\\)cmd(?:\\.exe)?$", RegexOptions.IgnoreCase);
+
+    private readonly IConsoleWriter _writer;
+    private readonly IEnvironment _environment;
+    private readonly Project _project;
+    private readonly string _workingDirectory;
+    private readonly bool _captureOutput;
+
+    public CommandBuilder(
+        IConsoleWriter writer,
+        IEnvironment environment,
+        Project project,
+        string workingDirectory,
+        bool captureOutput)
+    {
+        if (string.IsNullOrEmpty(workingDirectory)) throw new ArgumentException($"'{nameof(workingDirectory)}' cannot be null or empty.", nameof(workingDirectory));
+
+        _writer = writer ?? throw new ArgumentNullException(nameof(writer));
+        _environment = environment ?? throw new ArgumentNullException(nameof(environment));
+        _project = project ?? throw new ArgumentNullException(nameof(project));
+        _workingDirectory = workingDirectory;
+        _captureOutput = captureOutput;
+    }
+
+    public ProcessContext? ProcessContext { get; private set; }
+
+    public void SetUpEnvironment(string? scriptShellOverride)
+    {
+        var (scriptShell, isCmd) = GetScriptShell(scriptShellOverride ?? _project.ScriptShell);
+
+        ProcessContext = ProcessContext.Create(scriptShell, isCmd, _workingDirectory);
+
+        _writer.LineVerbose("Using shell: {0}", scriptShell);
+        _writer.BlankLine();
+    }
+
+    public ICommandGroupRunner CreateGroupRunner(CancellationToken cancellationToken)
+        => new CommandGroupRunner(
+            _writer,
+            _environment,
+            _project.Scripts!,
+            ProcessContext!,
+            _captureOutput,
+            cancellationToken);
+
+    /// <summary>
+    /// Gets the script shell to use.
+    /// </summary>
+    /// <param name="shell">A optional custom shell to use instead of the system default.</param>
+    /// <returns>The shell to use and if it's <c>cmd</c> or not.</returns>
+    private (string shell, bool isCmd) GetScriptShell(string? shell)
+    {
+        shell ??= _environment.IsWindows
+            ? _environment.GetEnvironmentVariable("COMSPEC") ?? "cmd"
+            : "sh";
+
+        var isCmd = IsCmdCheck.IsMatch(shell);
+
+        return (shell, isCmd);
+    }
+}

src/CommandGroupRunner.cs

@@ -0,0 +1,70 @@
+namespace RunScript;
+
+using System.Collections.Immutable;
+
+internal class CommandGroupRunner : ICommandGroupRunner
+{
+    private readonly IConsoleWriter _writer;
+    private readonly IEnvironment _environment;
+    private readonly IDictionary<string, string?> _scripts;
+    private readonly ProcessContext _processContext;
+    private readonly bool _captureOutput;
+    private readonly CancellationToken _cancellationToken;
+
+    public CommandGroupRunner(
+        IConsoleWriter writer,
+        IEnvironment environment,
+        IDictionary<string, string?> scripts,
+        ProcessContext processContext,
+        bool captureOutput,
+        CancellationToken cancellationToken)
+    {
+        _writer = writer ?? throw new ArgumentNullException(nameof(writer));
+        _environment = environment ?? throw new ArgumentNullException(nameof(environment));
+        _scripts = scripts ?? throw new ArgumentNullException(nameof(scripts));
+        _processContext = processContext ?? throw new ArgumentNullException(nameof(processContext));
+        _captureOutput = captureOutput;
+        _cancellationToken = cancellationToken;
+    }
+
+    public virtual ICommandRunner BuildCommand()
+        => new CommandRunner(
+            _writer,
+            _processContext,
+            _captureOutput,
+            _cancellationToken);
+
+    public async Task<int> RunAsync(string name, string[]? scriptArgs)
+    {
+        var scriptNames = ImmutableArray.Create(new[] { "pre" + name, name, "post" + name });
+
+        foreach (var subScript in scriptNames.Where(scriptName => _scripts.ContainsKey(scriptName) || scriptName == "env"))
+        {
+            // At this point we should have done enough checks to make sure the only not found script is `env`
+            if (!_scripts.ContainsKey(subScript))
+            {
+                GlobalCommands.PrintEnvironmentVariables(_writer, _environment);
+
+                continue;
+            }
+
+            var command = BuildCommand();
+
+            var args = subScript == name
+                ? scriptArgs
+                : null;
+
+            var result = await command.RunAsync(
+                subScript,
+                _scripts[subScript]!,
+                args);
+
+            if (result != 0)
+            {
+                return result;
+            }
+        }
+
+        return 0;
+    }
+}

src/CommandLineBuilderExtensions.cs

@@ -0,0 +1,84 @@
+namespace RunScript;
+
+using System.Diagnostics;
+
+internal class CommandRunner : ICommandRunner
+{
+    private readonly IConsoleWriter _writer;
+    private readonly ProcessContext _processContext;
+    private readonly bool _captureOutput;
+    private readonly CancellationToken _cancellationToken;
+
+    public CommandRunner(
+        IConsoleWriter writer,
+        ProcessContext processContext,
+        bool captureOutput,
+        CancellationToken cancellationToken)
+    {
+        _writer = writer ?? throw new ArgumentNullException(nameof(writer));
+        _processContext = processContext ?? throw new ArgumentNullException(nameof(processContext));
+        _captureOutput = captureOutput;
+        _cancellationToken = cancellationToken;
+    }
+
+    public async Task<int> RunAsync(string name, string cmd, string[]? args)
+    {
+        _cancellationToken.ThrowIfCancellationRequested();
+
+        _writer.Banner(name, ArgumentBuilder.ConcatinateCommandAndArgArrayForDisplay(cmd, args));
+
+        using (var process = new Process())
+        {
+            process.StartInfo.WorkingDirectory = _processContext.WorkingDirectory;
+            process.StartInfo.FileName = _processContext.Shell;
+
+            var outStream = new StreamForwarder();
+            var errStream = new StreamForwarder();
+            Task? taskOut = null;
+            Task? taskErr = null;
+
+            if (_captureOutput)
+            {
+                process.StartInfo.RedirectStandardOutput = true;
+                process.StartInfo.RedirectStandardError = true;
+
+                outStream.Capture();
+                errStream.Capture();
+            }
+
+            if (_processContext.IsCmd)
+            {
+                process.StartInfo.Arguments = string.Concat(
+                    "/d /s /c \"",
+                    ArgumentBuilder.EscapeAndConcatenateCommandAndArgArrayForCmdProcessStart(cmd, args),
+                    "\"");
+            }
+            else
+            {
+                process.StartInfo.ArgumentList.Add("-c");
+                process.StartInfo.ArgumentList.Add(ArgumentBuilder.EscapeAndConcatenateCommandAndArgArrayForProcessStart(cmd, args));
+            }
+
+            process.Start();
+
+            if (_captureOutput)
+            {
+                taskOut = outStream.BeginReadAsync(process.StandardOutput);
+                taskErr = errStream.BeginReadAsync(process.StandardError);
+            }
+
+            await process.WaitForExitAsync(_cancellationToken);
+
+            if (_captureOutput)
+            {
+                await taskOut!.WaitAsync(_cancellationToken);
+                await taskErr!.WaitAsync(_cancellationToken);
+
+                _writer.Raw(outStream.CapturedOutput);
+                _writer.Error(errStream.CapturedOutput);
+            }
+
+            return process.ExitCode;
+        }
+    }
+}