Add script key tests and simplify internal logic

Author: xt0rted

src/Program.cs

@@ -11,10 +11,9 @@
 Environment.SetEnvironmentVariable("INIT_CWD", workingDirectory);
 
 Project? project;
-Dictionary<string, string?> scripts;
 try
 {
-    (project, scripts, workingDirectory) = await new ProjectLoader().LoadAsync(workingDirectory);
+    (project, workingDirectory) = await new ProjectLoader().LoadAsync(workingDirectory);
 }
 catch (Exception ex)
 {
@@ -29,19 +28,18 @@
 rootCommand.AddGlobalOption(GlobalOptions.ScriptShell);
 rootCommand.AddGlobalOption(GlobalOptions.Verbose);
 
-foreach (var (name, script) in scripts.OrderBy(s => s.Key))
+foreach (var (name, script) in project.Scripts!.OrderBy(s => s.Key))
 {
     var runScript = new RunScriptCommand(
         name,
         script,
-        project.ScriptShell,
-        scripts,
+        project,
         workingDirectory);
 
     rootCommand.AddCommand(runScript);
 }
 
-if (!scripts.ContainsKey("env"))
+if (!project.Scripts!.ContainsKey("env"))
 {
     rootCommand.AddCommand(new EnvironmentCommand());
 }

src/Project.cs

@@ -1,8 +1,13 @@
 namespace RunScript;
 
+using System.Text.Json.Serialization;
+
+using RunScript.Serialization;
+
 public class Project
 {
     public string? ScriptShell { get; set; }
 
+    [JsonConverter(typeof(CaseInsensitiveDictionaryConverter<string?>))]
     public Dictionary<string, string?>? Scripts { get; set; }
 }

src/ProjectLoader.cs

@@ -4,7 +4,7 @@ namespace RunScript;
 
 public class ProjectLoader
 {
-    public async Task<(Project, Dictionary<string, string?>, string)> LoadAsync(string executingDirectory)
+    public async Task<(Project, string)> LoadAsync(string executingDirectory)
     {
         var jsonPath = CheckFolderForFile(executingDirectory, "global.json");
         if (jsonPath is null)
@@ -23,13 +23,12 @@ public class ProjectLoader
             throw new RunScriptException("Error parsing global.json");
         }
 
-        var scripts = LoadScripts(project);
-        if (scripts is null)
+        if (project.Scripts is null || project.Scripts.Count == 0)
         {
-            throw new RunScriptException("Error loading scripts");
+            throw new RunScriptException("No scripts found in the global.json");
         }
 
-        return (project, scripts, workingDirectory);
+        return (project, workingDirectory);
     }
 
     private string? CheckFolderForFile(string path, string file)
@@ -55,29 +54,17 @@ public class ProjectLoader
 
         try
         {
-            var globalJson = JsonSerializer.Deserialize<Project>(json, new JsonSerializerOptions
-            {
-                PropertyNameCaseInsensitive = true,
-                ReadCommentHandling = JsonCommentHandling.Skip,
-            });
-
-            return globalJson;
+            return JsonSerializer.Deserialize<Project>(
+                json,
+                new JsonSerializerOptions
+                    {
+                        PropertyNameCaseInsensitive = true,
+                        ReadCommentHandling = JsonCommentHandling.Skip,
+                    });
         }
         catch
         {
             return null;
         }
     }
-
-    private static Dictionary<string, string?> LoadScripts(Project project)
-    {
-        if (project is null) throw new ArgumentNullException(nameof(project));
-
-        if (project.Scripts is null || project.Scripts.Count == 0)
-        {
-            throw new RunScriptException("No scripts found in the global.json");
-        }
-
-        return new Dictionary<string, string?>(project.Scripts, StringComparer.OrdinalIgnoreCase);
-    }
 }

src/RunScriptCommand.cs

@@ -14,24 +14,21 @@ public class RunScriptCommand : Command, ICommandHandler
     private readonly bool _isWindows = RuntimeInformation.IsOSPlatform(OSPlatform.Windows);
     private readonly string? _comspec = Environment.GetEnvironmentVariable("COMSPEC");
 
-    private string? _projectScriptshell;
-    private readonly IDictionary<string, string?> _scripts;
+    private readonly Project _project;
     private readonly string _workingDirectory;
 
     private readonly ImmutableArray<string> _scriptNames;
 
     public RunScriptCommand(
         string name,
         string? description,
-        string? projectScriptShell,
-        IDictionary<string, string?> scripts,
+        Project project,
         string workingDirectory)
         : base(name, description)
     {
         if (string.IsNullOrEmpty(workingDirectory)) throw new ArgumentException($"'{nameof(workingDirectory)}' cannot be null or empty.", nameof(workingDirectory));
 
-        _projectScriptshell = projectScriptShell;
-        _scripts = scripts ?? throw new ArgumentNullException(nameof(scripts));
+        _project = project ?? throw new ArgumentNullException(nameof(project));
         _workingDirectory = workingDirectory;
 
         _scriptNames = ImmutableArray.Create(new[] { "pre" + Name, Name, "post" + Name });
@@ -47,16 +44,11 @@ public async Task<int> InvokeAsync(InvocationContext context)
         console.AlertAboutVerbose();
 
         var scriptShell = context.ParseResult.GetValueForOption(GlobalOptions.ScriptShell);
-        if (scriptShell is not null)
-        {
-            _projectScriptshell = scriptShell;
-        }
-
-        var (shell, isCmd) = GetScriptShell();
+        var (shell, isCmd) = GetScriptShell(scriptShell ?? _project.ScriptShell);
 
         var ct = context.GetCancellationToken();
 
-        foreach (var script in _scriptNames.Where(scriptName => _scripts.ContainsKey(scriptName)).ToImmutableArray())
+        foreach (var script in _scriptNames.Where(scriptName => _project.Scripts!.ContainsKey(scriptName)).ToImmutableArray())
         {
             var args = script == Name
                 ? context.ParseResult.UnparsedTokens
@@ -65,7 +57,7 @@ public async Task<int> InvokeAsync(InvocationContext context)
             var result = await RunScriptAsync(
                 console,
                 script,
-                _scripts[script],
+                _project.Scripts![script],
                 shell,
                 isCmd,
                 args,
@@ -80,10 +72,8 @@ public async Task<int> InvokeAsync(InvocationContext context)
         return 0;
     }
 
-    private (string shell, bool isCmd) GetScriptShell()
+    private (string shell, bool isCmd) GetScriptShell(string? shell)
     {
-        var shell = _projectScriptshell;
-
         shell ??= _isWindows
             ? _comspec ?? "cmd"
             : "sh";

src/Serialization/CaseInsensitiveDictionaryConverter.cs

@@ -0,0 +1,31 @@
+namespace RunScript.Serialization;
+
+using System.Text.Json;
+using System.Text.Json.Serialization;
+
+internal class CaseInsensitiveDictionaryConverter<TValue> : JsonConverter<Dictionary<string, TValue>>
+{
+    public override Dictionary<string, TValue> Read(
+        ref Utf8JsonReader reader,
+        Type typeToConvert,
+        JsonSerializerOptions options)
+    {
+        var dict = (Dictionary<string, TValue>)JsonSerializer
+            .Deserialize(ref reader, typeToConvert, options)!;
+
+        return dict.ToDictionary(
+            i => i.Key.ToLowerInvariant(),
+            i => i.Value,
+            StringComparer.OrdinalIgnoreCase);
+    }
+
+    public override void Write(
+        Utf8JsonWriter writer,
+        Dictionary<string, TValue> value,
+        JsonSerializerOptions options)
+        => JsonSerializer.Serialize(
+            writer,
+            value,
+            value.GetType(),
+            options);
+}

test/ProjectLoaderTests.Should_treat_script_names_as_lowercase.verified.txt

@@ -1,7 +1,7 @@
 {
   Scripts: {
-    bUiLD: build,
+    build: build,
     pack: pack,
-    TEST: test
+    test: test
   }
 }

test/ProjectLoaderTests.cs

@@ -55,19 +55,13 @@ public async Task Should_find_in_root()
         var projectLoader = new ProjectLoader();
 
         // When
-        var (project, scripts, workingDirectory) = await projectLoader.LoadAsync(testPath);
+        var (project, workingDirectory) = await projectLoader.LoadAsync(testPath);
 
         // Then
         project.ShouldNotBeNull();
 
         await Verify(project);
 
-        scripts.ShouldBeEquivalentTo(
-            new Dictionary<string, string>
-            {
-                { "test", "echo \"dir1\" && exit 1" },
-            });
-
         workingDirectory.ShouldBe(TestPath("dir1"));
     }
 
@@ -79,18 +73,13 @@ public async Task Should_look_up_the_tree()
         var projectLoader = new ProjectLoader();
 
         // When
-        var (project, scripts, workingDirectory) = await projectLoader.LoadAsync(testPath);
+        var (project, workingDirectory) = await projectLoader.LoadAsync(testPath);
 
         // Then
         project.ShouldNotBeNull();
 
         await Verify(project);
 
-        scripts.ShouldBeEquivalentTo(
-            new Dictionary<string, string>
-            {
-                { "test", "echo \"dir1\" && exit 1" },
-            });
         workingDirectory.ShouldBe(TestPath("dir1"));
     }
 
@@ -102,20 +91,12 @@ public async Task Should_treat_script_names_as_lowercase()
         var projectLoader = new ProjectLoader();
 
         // When
-        var (project, scripts, _) = await projectLoader.LoadAsync(testPath);
+        var (project, _) = await projectLoader.LoadAsync(testPath);
 
         // Then
-        project.Scripts.ShouldNotBeNull();
-
-        project.Scripts["bUiLD"].ShouldBe("build");
-        project.Scripts["TEST"].ShouldBe("test");
-        project.Scripts["pack"].ShouldBe("pack");
+        project.Scripts?.Comparer.ShouldBe(StringComparer.OrdinalIgnoreCase);
 
         await Verify(project);
-
-        scripts["build"].ShouldBe("build");
-        scripts["test"].ShouldBe("test");
-        scripts["pack"].ShouldBe("pack");
     }
 
     private string TestPath(params string[] folders)