Merge pull request #79 from xt0rted/globbing

Support for globbing in script names

Author: xt0rted

CHANGELOG.md

@@ -8,6 +8,7 @@
 ### Added
 
 - Ability to run multiple scripts in a single call (e.g. `dotnet r build test pack`) ([#10](https://github.com/xt0rted/dotnet-run-script/pull/10))
+- Support for globbing in script names (e.g `dotnet r test:*` will match `test:unit` and `test:integration`) ([#79](https://github.com/xt0rted/dotnet-run-script/pull/79))
 
 ### Updated
 
@@ -22,7 +23,8 @@
 
 ## [0.2.0](https://github.com/xt0rted/dotnet-run-script/compare/v0.1.0...v0.2.0) - 2022-04-23
 
-> ℹ️ This version broke conditional script execution (`cmd1 && cmd2`) in `cmd.exe`
+> **Note**
+> This version broke conditional script execution (`cmd1 && cmd2`) in `cmd.exe`
 
 ### Added
 

README.md

@@ -21,7 +21,8 @@ dotnet new tool-manifest
 dotnet tool install run-script
 ```
 
-> ⚠️ It's not recommended to install this tool globally.
+> **Warning**
+> Installing this tool globally is not recommended.
 > PowerShell defines the alias `r` for the `Invoke-History` command which prevents this from being called.
 > You'll also run into issues calling this from your scripts since global tools don't use the `dotnet` prefix.
 
@@ -79,9 +80,10 @@ In your project's `global.json` add a `scripts` object:
 }
 ```
 
-ℹ️ The shell used depends on the OS.
-On Windows `CMD` is used, on Linux, macOS, and WSL `sh` is used.
-This can be overridden by setting the `scriptShell` property or by passing the `--script-shell` option with the name of the shell to use.
+> **Note**
+> The shell used depends on the OS.
+> On Windows `CMD` is used, on Linux, macOS, and WSL `sh` is used.
+> This can be overridden by setting the `scriptShell` property or by passing the `--script-shell` option with the name of the shell to use.
 
 The `env` command is a special built-in command that lists all available environment variables.
 You can override this with your own command if you wish.
@@ -139,6 +141,13 @@ In this example both the `--configuration` and `--framework` options will be pas
 dotnet r build test:unit test:integration package -- --configuration Release --framework net6.0
 ```
 
+### Globbing or wildcard support
+
+Multiple scripts can be run at the same time using globbing.
+This means `dotnet r test:*` will match `test:unit` and `test:integration` and run them in series in the order they're listed in the `global.json` file.
+
+Globbing is handled by the [DotNet.Glob](https://github.com/dazinator/DotNet.Glob) library and currently supports all of its patterns and wildcards.
+
 ### Working directory
 
 The working directory is set to the root of the project where the `global.json` is located.

package-lock.json

@@ -0,0 +1,15 @@
+#if !NET5_0_OR_GREATER
+namespace System.Runtime.CompilerServices
+{
+    using System.ComponentModel;
+
+    /// <summary>
+    /// Reserved to be used by the compiler for tracking metadata.
+    /// This class should not be used by developers in source code.
+    /// </summary>
+    [EditorBrowsable(EditorBrowsableState.Never)]
+    internal static class IsExternalInit
+    {
+    }
+}
+#endif

src/Polyfills/IsExternalInit.cs

@@ -5,7 +5,7 @@ namespace RunScript;
 
 using System.Diagnostics;
 
-internal static class Polyfills
+internal static class TaskExtensions
 {
 #if !NET5_0_OR_GREATER
     public static async Task WaitForExitAsync(this Process process, CancellationToken cancellationToken)

src/Polyfills.cs renamed to src/Polyfills/TaskExtensions.cs

@@ -0,0 +1,3 @@
+namespace RunScript;
+
+internal record RunResult(string Name, int ExitCode);

src/RunResult.cs

@@ -2,6 +2,8 @@ namespace RunScript;
 
 using System.CommandLine.Invocation;
 
+using DotNet.Globbing;
+
 internal class RunScriptCommand : RootCommand, ICommandHandler
 {
     private readonly IEnvironment _environment;
@@ -77,32 +79,29 @@ public async Task<int> InvokeAsync(InvocationContext context)
             return 0;
         }
 
-        // The `env` script is special so if it's not explicitly declared we act like it was
-        var scriptsToRun = scripts
-            .Select(script => (name: script, exists: project.Scripts!.ContainsKey(script) || script == "env"))
-            .ToList();
+        var scriptsToRun = FindScripts(project.Scripts!, scripts);
 
         // When `--if-present` isn't specified and a script wasn't found in the config then we show an error and stop
-        if (scriptsToRun.Any(s => !s.exists) && !ifPresent)
+        if (scriptsToRun.Any(s => !s.Exists) && !ifPresent)
         {
             writer.Error(
                 "Script not found: {0}",
                 string.Join(
                     ", ",
                     scriptsToRun
-                        .Where(script => !script.exists)
-                        .Select(script => script.name)));
+                        .Where(script => !script.Exists)
+                        .Select(script => script.Name)));
 
             return 1;
         }
 
-        var runResults = new List<(string scriptName, int exitCode)>();
+        var runResults = new List<RunResult>();
 
-        foreach (var (scriptName, scriptExists) in scriptsToRun)
+        foreach (var script in scriptsToRun)
         {
-            if (!scriptExists)
+            if (!script.Exists)
             {
-                writer.Banner($"Skipping script {scriptName}");
+                writer.Banner($"Skipping script {script.Name}");
 
                 continue;
             }
@@ -115,10 +114,10 @@ public async Task<int> InvokeAsync(InvocationContext context)
             var scriptRunner = builder.CreateGroupRunner(context.GetCancellationToken());
 
             var result = await scriptRunner.RunAsync(
-                scriptName,
+                script.Name,
                 scriptArgs);
 
-            runResults.Add((scriptName, result));
+            runResults.Add(new(script.Name, result));
 
             if (result != 0)
             {
@@ -129,24 +128,70 @@ public async Task<int> InvokeAsync(InvocationContext context)
         return RunResults(writer, runResults);
     }
 
-    private static int RunResults(IConsoleWriter writer, List<(string scriptName, int exitCode)> results)
+    internal static List<ScriptResult> FindScripts(
+        IDictionary<string, string?> projectScripts,
+        string[] scripts)
+    {
+        var results = new List<ScriptResult>();
+
+        foreach (var script in scripts)
+        {
+            // The `env` script is special so if it's not explicitly declared we act like it was
+            if (projectScripts.ContainsKey(script) || string.Equals(script, "env", StringComparison.OrdinalIgnoreCase))
+            {
+                results.Add(new(script, true));
+
+                continue;
+            }
+
+            var hadMatch = false;
+            var matcher = Glob.Parse(
+                script,
+                new GlobOptions
+                {
+                    Evaluation =
+                    {
+                        CaseInsensitive = true,
+                    }
+                });
+
+            foreach (var projectScript in projectScripts.Keys)
+            {
+                if (matcher.IsMatch(projectScript.AsSpan()))
+                {
+                    hadMatch = true;
+
+                    results.Add(new(projectScript, true));
+                }
+            }
+
+            if (!hadMatch)
+            {
+                results.Add(new(script, false));
+            }
+        }
+
+        return results;
+    }
+
+    internal static int RunResults(IConsoleWriter writer, List<RunResult> results)
     {
         // If only 1 script ran we don't need a report of the results
         if (results.Count == 1)
         {
-            return results[0].exitCode;
+            return results[0].ExitCode;
         }
 
         var hadError = false;
 
-        foreach (var (scriptName, exitCode) in results.Where(r => r.exitCode != 0))
+        foreach (var result in results.Where(r => r.ExitCode != 0))
         {
             hadError = true;
 
             writer.Line(
                 "ERROR: \"{0}\" exited with {1}",
-                writer.ColorText(ConsoleColor.Blue, scriptName),
-                writer.ColorText(ConsoleColor.Green, exitCode));
+                writer.ColorText(ConsoleColor.Blue, result.Name),
+                writer.ColorText(ConsoleColor.Green, result.ExitCode));
         }
 
         return hadError ? 1 : 0;

src/RunScriptCommand.cs

@@ -0,0 +1,3 @@
+namespace RunScript;
+
+internal record ScriptResult(string Name, bool Exists);

src/ScriptResult.cs

@@ -46,6 +46,7 @@
   </ItemGroup>
 
   <ItemGroup>
+    <PackageReference Include="DotNet.Glob" Version="3.1.3" />
     <PackageReference Include="Microsoft.SourceLink.GitHub" Version="1.1.1">
       <IncludeAssets>runtime; build; native; contentfiles; analyzers</IncludeAssets>
       <PrivateAssets>all</PrivateAssets>

src/run-script.csproj

@@ -0,0 +1,8 @@
+{
+  IsErrorRedirected: false,
+  IsInputRedirected: false,
+  IsOutputRedirected: false,
+  Out:
+ERROR: "test" exited with 1
+
+}