'cache destroy' command

CONTRIBUTING.md

@@ -60,7 +60,7 @@ Follow below steps if you want to contribute with a new command:
 Example: CustomCommandOptions
 
 ```
-    public class ScanCommandOptions : CommandOptions
+    public class CustomCommandOptions : CommandOptions
     {
         public string YourArgument { get ; set; }
         public string YourOption { get ; set; }
@@ -69,28 +69,39 @@ Example: CustomCommandOptions
     }
 ```
 
-2) Add a new class called _**YourNewCommandNameCommand**_ into the **Commands folder** and inherit it from the base class _**Command**_. You do not need to implement anything to allow the **cache-dir** option, as this is added globally.
+2) Add a new class called _**YourNewCommandNameCommand**_ into the **Commands folder** and inherit it from either the generic base class _**RunnableCommand<>**_ (for commands that be executed) or the base class _**Command**_ (for commands that only store subcommands). You do not need to implement anything to allow the **cache-dir** option, as this is added globally.
 
     Example: CustomCommand
 
 ```
-    public class CustomCommand : Command
+    public class CustomCommand : RunnableCommand<CustomCommandOptions>
     {
         public CustomCommand() : base("custom", "Custom command description")
         {
-          // add your arguments and/or options definitioins here. For detailed information
-          // you have to reference the command-line-api library documentation. Below are just
-          // examples. See the Commands/ScanCommand.cs for an example or go to the Command Line Api (https://github.com/dotnet/command-line-api) repository for detailed information.
+           // add your arguments and/or options definitioins here. For detailed information
+           // you have to reference the command-line-api library documentation. Below are just
+           // examples. See the Commands/ScanCommand.cs for an example or go to the Command Line Api (https://github.com/dotnet/command-line-api) repository for detailed information.
 
-           Option<string> yourOption= new(new[] { "--alias1", "alias2" }, description: "Option  Description");
-           AddOption(yourOption);
+            Option<string> yourOption= new(new[] { "--alias1", "alias2" }, description: "Option  Description");
+            AddOption(yourOption);
 
-           Argument<string> yourArgument = new("yourargumentname", "Argument Description")
-           AddArgument(yourArgument);
+            Argument<string> yourArgument = new("yourargumentname", "Argument Description")
+            AddArgument(yourArgument);
         }
     }
 ```
 
+Typically you will not need to implement the **Run()** method for your **CustomCommand** class, as this is provided by **RunnableCommand<>**. However, if you want to augment this behavior
+apart from the **CommandRunner** (see step 3), you can override that method:
+
+```
+        protected override int Run(IHost host, InvocationContext context, CustomCommandOptions options)
+        {
+            // your custom logic here
+            return base.Run(host, context, options);
+        }
+```
+
 3) Add a new class called _**YourNewCommandNameCommandRunner**_ into the **CommandRunners** folder and inherit it from **CommandRunner**.
 Implement the Run method.
 

Corgibytes.Freshli.Cli.Test/Commands/CacheCommandTest.cs

@@ -1,8 +1,6 @@
-using System.CommandLine.Builder;
-using System.CommandLine.IO;
-using System.CommandLine.Parsing;
-using System.Threading.Tasks;
+using System.CommandLine;
 using Corgibytes.Freshli.Cli.Commands;
+using Corgibytes.Freshli.Cli.Commands.Cache;
 using Corgibytes.Freshli.Cli.Test.Common;
 using FluentAssertions;
 using Xunit;
@@ -12,8 +10,6 @@ namespace Corgibytes.Freshli.Cli.Test.Commands
 {
     public class CacheCommandTest : FreshliTest
     {
-        private readonly TestConsole _console = new();
-
         public CacheCommandTest(ITestOutputHelper output) : base(output) { }
 
         [Fact]
@@ -29,5 +25,19 @@ public void Verify_prepare_handler_configuration()
             CachePrepareCommand cachePrepareCommand = new();
             cachePrepareCommand.Handler.Should().NotBeNull();
         }
+
+        [Fact]
+        public void Verify_destroy_handler_configuration()
+        {
+            CacheDestroyCommand cacheDestroyCommand = new();
+            cacheDestroyCommand.Handler.Should().NotBeNull();
+        }
+
+        [Theory]
+        [InlineData("--force")]
+        public void Verify_force_option_configuration(string alias)
+        {
+            TestHelpers.VerifyAlias<CacheDestroyCommand>(alias, ArgumentArity.ZeroOrOne, false);
+        }
     }
 }

Corgibytes.Freshli.Cli/CommandOptions/CacheCommandOptions.cs

@@ -7,4 +7,9 @@ public class CacheCommandOptions : CommandOptions
     public class CachePrepareCommandOptions : CommandOptions
     {
     }
+
+    public class CacheDestroyCommandOptions : CommandOptions
+    {
+        public bool Force { get; set; }
+    }
 }

Corgibytes.Freshli.Cli/CommandRunners/Cache/DestroyCommandRunner.cs

@@ -0,0 +1,43 @@
+using System;
+using System.CommandLine.Invocation;
+using System.CommandLine.IO;
+using Corgibytes.Freshli.Cli.CommandOptions;
+using Corgibytes.Freshli.Cli.Extensions;
+using Corgibytes.Freshli.Cli.Functionality;
+using Corgibytes.Freshli.Lib;
+
+namespace Corgibytes.Freshli.Cli.CommandRunners.Cache
+{
+    public class CacheDestroyCommandRunner : CommandRunner<CacheDestroyCommandOptions>
+    {
+        public CacheDestroyCommandRunner(IServiceProvider serviceProvider, Runner runner)
+            : base(serviceProvider, runner)
+        {
+
+        }
+
+        public override int Run(CacheDestroyCommandOptions options, InvocationContext context)
+        {
+            // Unless the --force flag is passed, prompt the user whether they want to destroy the cache
+            if (!options.Force && !Confirm($"Do you want to completely DELETE the directory {options.CacheDir.FullName}?", context))
+            {
+                context.Console.Out.WriteLine("Operation aborted. Cache not destroyed.");
+                return true.ToExitCode();
+            }
+
+            // Destroy the cache
+            context.Console.Out.WriteLine($"Destroying cache at {options.CacheDir}");
+            try
+            {
+                return Functionality.Cache.Destroy(options.CacheDir).ToExitCode();
+            }
+            // Catch errors
+            catch (CacheException error)
+            {
+                context.Console.Error.WriteLine(error.Message);
+                return error.IsWarning.ToExitCode();
+            }
+
+        }
+    }
+}

Corgibytes.Freshli.Cli/CommandRunners/Cache/PrepareCacheRunner.cs

@@ -0,0 +1,33 @@
+using System;
+using System.CommandLine.Invocation;
+using System.CommandLine.IO;
+using Corgibytes.Freshli.Cli.CommandOptions;
+using Corgibytes.Freshli.Cli.Extensions;
+using Corgibytes.Freshli.Cli.Functionality;
+using Corgibytes.Freshli.Lib;
+
+namespace Corgibytes.Freshli.Cli.CommandRunners.Cache
+{
+    public class CachePrepareCommandRunner : CommandRunner<CachePrepareCommandOptions>
+    {
+        public CachePrepareCommandRunner(IServiceProvider serviceProvider, Runner runner)
+            : base(serviceProvider, runner)
+        {
+
+        }
+
+        public override int Run(CachePrepareCommandOptions options, InvocationContext context)
+        {
+            context.Console.Out.WriteLine($"Preparing cache at {options.CacheDir}");
+            try
+            {
+                return Functionality.Cache.Prepare(options.CacheDir).ToExitCode();
+            }
+            catch (CacheException e)
+            {
+                context.Console.Error.WriteLine(e.Message);
+                return false.ToExitCode();
+            }
+        }
+    }
+}

Corgibytes.Freshli.Cli/CommandRunners/CacheCommandRunner.cs

@@ -1,6 +1,6 @@
 using System;
+using System.CommandLine.Invocation;
 using Corgibytes.Freshli.Cli.CommandOptions;
-using Corgibytes.Freshli.Cli.Functionality;
 using Corgibytes.Freshli.Lib;
 
 namespace Corgibytes.Freshli.Cli.CommandRunners
@@ -13,25 +13,9 @@ public CacheCommandRunner(IServiceProvider serviceProvider, Runner runner)
 
         }
 
-        public override int Run(CacheCommandOptions options)
+        public override int Run(CacheCommandOptions options, InvocationContext context)
         {
             return 0;
         }
     }
-
-    public class CachePrepareCommandRunner : CommandRunner<CachePrepareCommandOptions>
-    {
-        public CachePrepareCommandRunner(IServiceProvider serviceProvider, Runner runner)
-            : base(serviceProvider, runner)
-        {
-
-        }
-
-        public override int Run(CachePrepareCommandOptions options)
-        {
-            bool success = Cache.Prepare(options.CacheDir);
-            return success ? 0 : 1;
-        }
-    }
 }
-

Corgibytes.Freshli.Cli/CommandRunners/CommandRunner.cs

@@ -1,4 +1,6 @@
 using System;
+using System.Collections.Generic;
+using System.CommandLine.Invocation;
 using Corgibytes.Freshli.Lib;
 
 namespace Corgibytes.Freshli.Cli.CommandRunners
@@ -8,13 +10,26 @@ public abstract class CommandRunner<T> : ICommandRunner<T> where T : CommandOpti
         protected Runner Runner { get; }
         protected IServiceProvider Services { get; }
 
-        public CommandRunner(IServiceProvider serviceProvider, Runner runner)
+        protected CommandRunner(IServiceProvider serviceProvider, Runner runner)
         {
             Runner = runner;
             Services = serviceProvider;
         }
 
-        public abstract int Run(T options);
+        protected static bool Confirm(string message, InvocationContext context, bool defaultYes = false)
+        {
+            // Prompt the user whether they want to proceed
+            string prompt = defaultYes ? "[Y/n]" : "[y/N]";
+            context.Console.Out.Write($"{message} {prompt} ");
+            string choice = Console.In.ReadLine();
+
+            var yesChoices = new List<string> {"y", "Y"};
+            var noChoices = new List<string> {"n", "N"};
+
+            return (defaultYes ? !noChoices.Contains(choice) : yesChoices.Contains(choice));
+        }
+
+        public abstract int Run(T options, InvocationContext context);
 
     }
 }

Corgibytes.Freshli.Cli/CommandRunners/ICommandRunner.cs

@@ -1,9 +1,9 @@
-using Corgibytes.Freshli.Cli.CommandOptions;
+using System.CommandLine.Invocation;
 
 namespace Corgibytes.Freshli.Cli.CommandRunners
 {
     public interface ICommandRunner<T> where T : CommandOptions.CommandOptions
     {
-        public int Run(T options);
+        public int Run(T options, InvocationContext context);
     }
 }

Corgibytes.Freshli.Cli/CommandRunners/ScanCommandRunner.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.CommandLine.Invocation;
 using Corgibytes.Freshli.Cli.CommandOptions;
 using Corgibytes.Freshli.Cli.Formatters;
 using Corgibytes.Freshli.Cli.OutputStrategies;
@@ -16,7 +17,7 @@ public ScanCommandRunner(IServiceProvider serviceProvider, Runner runner): base(
 
         }
 
-        public override int Run(ScanCommandOptions options)
+        public override int Run(ScanCommandOptions options, InvocationContext context)
         {
             if (string.IsNullOrWhiteSpace(options.Path?.FullName))
             {

Corgibytes.Freshli.Cli/Commands/Cache/DestroyCommand.cs

@@ -0,0 +1,20 @@
+using System.CommandLine;
+using Corgibytes.Freshli.Cli.CommandOptions;
+
+namespace Corgibytes.Freshli.Cli.Commands.Cache
+{
+    public class CacheDestroyCommand : RunnableCommand<CacheDestroyCommandOptions>
+    {
+        public CacheDestroyCommand()
+            : base("destroy", "Deletes the Freshli cache.")
+        {
+            Option<bool> forceOption = new("--force", "Don't prompt to confirm destruction of cache.")
+            {
+                Arity = ArgumentArity.ZeroOrOne
+            };
+
+            AddOption(forceOption);
+        }
+    }
+
+}

Corgibytes.Freshli.Cli/Commands/Cache/PrepareCommand.cs

@@ -0,0 +1,11 @@
+using Corgibytes.Freshli.Cli.CommandOptions;
+
+namespace Corgibytes.Freshli.Cli.Commands.Cache
+{
+    public class CachePrepareCommand : RunnableCommand<CachePrepareCommandOptions>
+    {
+        public CachePrepareCommand()
+            : base("prepare", "Ensures the cache directory exists and contains a valid cache database.")
+        {}
+    }
+}

Corgibytes.Freshli.Cli/Commands/CacheCommand.cs

@@ -1,36 +1,21 @@
 using System.CommandLine;
-using System.CommandLine.Invocation;
-using System.CommandLine.NamingConventionBinder;
-using Corgibytes.Freshli.Cli.CommandOptions;
-using Corgibytes.Freshli.Cli.CommandRunners;
-using Microsoft.Extensions.DependencyInjection;
-using Microsoft.Extensions.Hosting;
+using Corgibytes.Freshli.Cli.Commands.Cache;
 
 namespace Corgibytes.Freshli.Cli.Commands
 {
     public class CacheCommand : Command
     {
-        public CacheCommand() : base("cache", "Manages the local cache database")
+        public CacheCommand()
+            : base("cache", "Manages the local cache database")
         {
             CachePrepareCommand prepare = new();
             AddCommand(prepare);
+
+            CacheDestroyCommand destroy = new();
+            AddCommand(destroy);
         }
     }
 
-    public class CachePrepareCommand : Command
-    {
-        public CachePrepareCommand() : base("prepare",
-            "Ensures the cache directory exists and contains a valid cache database.")
-        {
-            Handler = CommandHandler.Create<IHost, InvocationContext, CachePrepareCommandOptions>(Run);
-        }
 
-        private int Run(IHost host, InvocationContext context, CachePrepareCommandOptions options)
-        {
-            using IServiceScope scope = host.Services.CreateScope();
-            ICommandRunner<CachePrepareCommandOptions> runner = scope.ServiceProvider.GetRequiredService<ICommandRunner<CachePrepareCommandOptions>>();
-            return runner.Run(options);
-        }
-    }
 
 }

Corgibytes.Freshli.Cli/Commands/RunnableCommand.cs

@@ -0,0 +1,25 @@
+using System.CommandLine;
+using System.CommandLine.Invocation;
+using System.CommandLine.NamingConventionBinder;
+using Corgibytes.Freshli.Cli.CommandRunners;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Hosting;
+
+namespace Corgibytes.Freshli.Cli.Commands;
+
+#nullable enable
+public abstract class RunnableCommand<T> : Command where T: CommandOptions.CommandOptions
+{
+    protected RunnableCommand(string name, string? description = null) : base(name, description)
+    {
+        Handler = CommandHandler.Create<IHost, InvocationContext, T>(Run);
+    }
+
+    protected virtual int Run(IHost host, InvocationContext context, T options)
+    {
+        using IServiceScope scope = host.Services.CreateScope();
+        ICommandRunner<T> runner = scope.ServiceProvider.GetRequiredService<ICommandRunner<T>>();
+        return runner.Run(options, context);
+    }
+}
+#nullable restore