Use KeyedCollection instead of Dictionary

Author: xt0rted

CHANGELOG.md

@@ -2,6 +2,9 @@
 
 ## Unreleased
 
+- Script names are no longer case insensitive which matches NPM's behavior
+- Project scripts are no longer backed by `Dictionary<string, string>` which should guarantee they're executed in the order they're found in the `global.json`
+
 ## [0.5.0](https://github.com/xt0rted/dotnet-run-script/compare/v0.4.0...v0.5.0) - 2022-10-11
 
 ### Added

Directory.Build.props

@@ -1,7 +1,7 @@
 <Project>
 
   <PropertyGroup>
-    <TargetFrameworks>netcoreapp3.1;net6.0</TargetFrameworks>
+    <TargetFrameworks>net6.0;netcoreapp3.1</TargetFrameworks>
     <LangVersion>latest</LangVersion>
     <ImplicitUsings>enable</ImplicitUsings>
     <Nullable>enable</Nullable>

src/CommandGroupRunner.cs

@@ -6,15 +6,15 @@ internal class CommandGroupRunner : ICommandGroupRunner
 {
     private readonly IConsoleWriter _writer;
     private readonly IEnvironment _environment;
-    private readonly IDictionary<string, string?> _scripts;
+    private readonly ScriptCollection _scripts;
     private readonly ProcessContext _processContext;
     private readonly bool _captureOutput;
     private readonly CancellationToken _cancellationToken;
 
     public CommandGroupRunner(
         IConsoleWriter writer,
         IEnvironment environment,
-        IDictionary<string, string?> scripts,
+        ScriptCollection scripts,
         ProcessContext processContext,
         bool captureOutput,
         CancellationToken cancellationToken)
@@ -38,10 +38,10 @@ 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"))
+        foreach (var subScript in scriptNames.Where(scriptName => _scripts.Contains(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))
+            if (!_scripts.Contains(subScript))
             {
                 GlobalCommands.PrintEnvironmentVariables(_writer, _environment);
 
@@ -56,7 +56,7 @@ public async Task<int> RunAsync(string name, string[]? scriptArgs)
 
             var result = await command.RunAsync(
                 subScript,
-                _scripts[subScript]!,
+                _scripts[subScript].Script,
                 args);
 
             if (result != 0)

src/GlobalCommands.cs

@@ -7,15 +7,15 @@ internal static class GlobalCommands
     /// </summary>
     /// <param name="writer">The console logger instance to use.</param>
     /// <param name="scripts">The project's scripts.</param>
-    public static void PrintAvailableScripts(IConsoleWriter writer, IDictionary<string, string?> scripts)
+    public static void PrintAvailableScripts(IConsoleWriter writer, ScriptCollection scripts)
     {
         writer.Line("Available via `{0}`:", writer.ColorText(ConsoleColor.Blue, "dotnet r"));
         writer.BlankLine();
 
-        foreach (var script in scripts.Keys)
+        foreach (var (name, script) in scripts)
         {
-            writer.Line("  {0}", script);
-            writer.SecondaryLine("    {0}", scripts[script]);
+            writer.Line("  {0}", name);
+            writer.SecondaryLine("    {0}", script);
             writer.BlankLine();
         }
     }

src/Project.cs

@@ -2,12 +2,11 @@ namespace RunScript;
 
 using System.Text.Json.Serialization;
 
-using RunScript.Serialization;
-
 public class Project
 {
+    [JsonPropertyName("scriptShell")]
     public string? ScriptShell { get; set; }
 
-    [JsonConverter(typeof(CaseInsensitiveDictionaryConverter<string?>))]
-    public Dictionary<string, string?>? Scripts { get; set; }
+    [JsonPropertyName("scripts")]
+    public ScriptCollection? Scripts { get; set; }
 }

src/ProjectLoader.cs

@@ -57,10 +57,9 @@ internal class ProjectLoader
             return JsonSerializer.Deserialize<Project>(
                 json,
                 new JsonSerializerOptions
-                    {
-                        PropertyNameCaseInsensitive = true,
-                        ReadCommentHandling = JsonCommentHandling.Skip,
-                    });
+                {
+                    ReadCommentHandling = JsonCommentHandling.Skip,
+                });
         }
         catch
         {

src/RunScriptCommand.cs

@@ -134,15 +134,15 @@ public async Task<int> InvokeAsync(InvocationContext context)
     }
 
     internal static List<ScriptResult> FindScripts(
-        IDictionary<string, string?> projectScripts,
+        ScriptCollection 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))
+            if (projectScripts.Contains(script) || string.Equals(script, "env", StringComparison.Ordinal))
             {
                 results.Add(new(script, true));
 
@@ -160,7 +160,7 @@ internal static List<ScriptResult> FindScripts(
                     }
                 });
 
-            foreach (var projectScript in projectScripts.Keys)
+            foreach (var (projectScript, _) in projectScripts)
             {
                 if (matcher.IsMatch(projectScript.AsSpan()))
                 {

src/ScriptCollection.cs

@@ -0,0 +1,20 @@
+namespace RunScript;
+
+using System.Collections.ObjectModel;
+using System.Text.Json.Serialization;
+
+using RunScript.Serialization;
+
+[JsonConverter(typeof(ScriptCollectionConverter))]
+public class ScriptCollection : KeyedCollection<string, ScriptMapping>
+{
+    protected override string GetKeyForItem(ScriptMapping item)
+    {
+        if (item is null) throw new ArgumentNullException(nameof(item));
+
+        return item.Name;
+    }
+
+    public void Add(string name, string script)
+        => Add(new ScriptMapping(name, script));
+}

src/ScriptMapping.cs

@@ -0,0 +1,3 @@
+namespace RunScript;
+
+public record ScriptMapping(string Name, string Script);