Update System.CommandLine dependency to allow setting empty values

Author: sleeuwen

dotnet-json.Tests/Commands/SetCommandTests.cs

@@ -0,0 +1,57 @@
+using System;
+using System.CommandLine;
+using System.CommandLine.IO;
+using System.IO;
+using System.Threading.Tasks;
+using dotnet_json.Commands;
+using FluentAssertions;
+using Newtonsoft.Json;
+using Newtonsoft.Json.Linq;
+using Xunit;
+
+namespace dotnet_json.Tests.Commands
+{
+    public class SetCommandTests : IDisposable
+    {
+        private readonly string _tmpDir;
+
+        public SetCommandTests()
+        {
+            _tmpDir = Path.Combine(Path.GetTempPath(), Path.GetRandomFileName());
+            Directory.CreateDirectory(_tmpDir);
+        }
+
+        public void Dispose()
+        {
+            Directory.Delete(_tmpDir, true);
+        }
+
+        [Theory]
+        [InlineData(@"{""key"": ""value""}", "key", "test")]
+        [InlineData(@"{""key"": ""value""}", "key", "")]
+        public async Task SavesNewValueToFile(string json, string key, string value)
+        {
+            await File.WriteAllTextAsync(Path.Join(_tmpDir, "test.json"), json);
+
+            var (exitCode, _) = await RunCommand(Path.Join(_tmpDir, "test.json"), key, value);
+
+            exitCode.Should().Be(0);
+
+            var contents = await File.ReadAllTextAsync(Path.Join(_tmpDir, "test.json"));
+            var result = JObject.Parse(contents)[key].ToString();
+
+            result.Should().Be(value);
+        }
+
+        private async Task<(int exitCode, IConsole console)> RunCommand(params string[] arguments)
+        {
+            var command = new SetCommand();
+
+            var console = new TestConsole();
+
+            var exitCode = await command.InvokeAsync(arguments, console);
+
+            return (exitCode, console);
+        }
+    }
+}

dotnet-json.Tests/JsonDocumentTests.cs

@@ -199,6 +199,22 @@ public void SetValue_ReplacesValue_WithObject()
                 .Which.Value.Should().Be("object");
         }
 
+        [Fact]
+        public void SetValue_ReplacesValue_WithEmptyString()
+        {
+            var document = new JsonDocument(JObject.Parse(@"{ ""key"": ""value"" }"));
+
+            document.SetValue("key", "");
+
+            document._json.Should().BeOfType<JObject>()
+                .Which.Should().ContainKey("key");
+
+            var value = document._json["key"].Should().BeOfType<JValue>().Subject;
+
+            value.Type.Should().Be(JTokenType.String);
+            value.Value.Should().Be("");
+        }
+
         [Fact]
         public void Merge_MergesTwoDocuments()
         {

dotnet-json/Commands/CommandBase.cs

@@ -31,6 +31,11 @@ protected CommandBase(string name, string? description = null, bool includeOutpu
             Handler = this;
         }
 
+        public int Invoke(InvocationContext context)
+        {
+            return InvokeAsync(context).GetAwaiter().GetResult();
+        }
+
         public Task<int> InvokeAsync(InvocationContext context)
         {
             Context = context;
@@ -76,12 +81,6 @@ protected T GetParameterValue<T>(Argument<T> argument)
                 .ParseResult.GetValueForArgument(argument);
         }
 
-        protected List<T>? GetMultiParameterValue<T>(Argument<T> argument)
-        {
-            return (Context ?? throw new Exception("GetMultiParameterValue() must be called from a command handler"))
-                .ParseResult.GetValueForArgument<List<T>>(argument);
-        }
-
         protected abstract Task<int> ExecuteAsync();
     }
 }

dotnet-json/Commands/FilesArgument.cs

@@ -0,0 +1,35 @@
+using System.Collections.Generic;
+using System.CommandLine;
+using System.IO;
+using System.Linq;
+
+namespace dotnet_json.Commands
+{
+    public class FilesArgument : Argument<List<string>>
+    {
+        public FilesArgument()
+        {
+            AddValidator();
+        }
+
+        public FilesArgument(string name, string? description = null)
+            : base(name, description)
+        {
+            AddValidator();
+        }
+
+        public bool AllowNewFile { get; set; }
+
+        private void AddValidator()
+        {
+            this.AddValidator(symbol =>
+                symbol.Tokens
+                    .Select(t => t.Value)
+                    .Where(_ => !AllowNewFile) // Need to check AllowNewFile at this point because AddValidator() is called from constructor
+                    .Where(filePath => filePath != "-")
+                    .Where(filePath => !File.Exists(filePath))
+                    .Select(filePath => $"File does not exist: {filePath}")
+                    .FirstOrDefault());
+        }
+    }
+}

dotnet-json/Commands/MergeCommand.cs

@@ -8,7 +8,7 @@ namespace dotnet_json.Commands
 {
     public class MergeCommand : CommandBase
     {
-        private FileArgument Files = new FileArgument("files", "The names of the files to merge with the first file.") { Arity = ArgumentArity.OneOrMore };
+        private FilesArgument Files = new FilesArgument("files", "The names of the files to merge with the first file.") { Arity = ArgumentArity.OneOrMore };
 
         public MergeCommand() : base("merge", "merge two or more json files into one")
         {
@@ -19,7 +19,7 @@ public MergeCommand() : base("merge", "merge two or more json files into one")
 
         protected override async Task<int> ExecuteAsync()
         {
-            var files = GetMultiParameterValue(Files) ?? throw new ArgumentException("Missing argument <files>");
+            var files = GetParameterValue(Files) ?? throw new ArgumentException("Missing argument <files>");
 
             JsonDocument document;
 

dotnet-json/dotnet-json.csproj

@@ -29,7 +29,7 @@
 
   <ItemGroup>
     <PackageReference Include="Newtonsoft.Json" Version="13.0.1" />
-    <PackageReference Include="System.CommandLine" Version="2.0.0-beta2.21617.1" />
+    <PackageReference Include="System.CommandLine" Version="2.0.0-beta4.22272.1" />
   </ItemGroup>
 
   <ItemGroup>