Add RootHandler capabilities

README.md

@@ -21,8 +21,8 @@ using MinimalCli;
 
 public class HelloWorld
 {
-    // Just decorate the method with the command attribute!
-    [Handler("hello")]
+    // Just decorate the method with the RootHandler attribute!
+    [RootHandler]
     public void Execute(string message)
     {
         Console.WriteLine("Hello World!  {0}", message);
@@ -74,6 +74,7 @@ using MinimalCli;
 
 public class MyCommand
 {
+    // use the handler attribute to add additional commands
     [Handler("my-command")]
     public void Run(string myArgument, string? myOption = null)
     {

src/HelloWorld/HelloWorldClass.cs

@@ -4,7 +4,7 @@ namespace Hello;
 
 public class HelloWorldClass
 {
-    [Handler("hello-world")]
+    [RootHandler]
     public void Execute(
         string message, 
         string option1 = "opt 1 default value", 

src/HelloWorld/Properties/launchSettings.json

@@ -3,9 +3,8 @@
     "HelloWorld": {
       "commandName": "Project",
       //"commandLineArgs": "-h"
-      "commandLineArgs": "hi -h"
-      //"commandLineArgs": "hi \"Hello everybody..\" --option1 \"My Option 1\" --option2 \"My Option 2\""
-
+      "commandLineArgs": "\"Hello everybody..\""
+      //"commandLineArgs": "\"Hello everybody..\" --option1 \"My Option 1\" --option2 \"My Option 2\""
     }
   }
 }

src/MinimalCli.Core/Bindings/CommandBindingFactory.cs

@@ -1,6 +1,4 @@
-using System.Collections.Generic;
-
-namespace MinimalCli.Bindings;
+namespace MinimalCli.Bindings;
 
 public class CommandBindingFactory
 {
@@ -11,6 +9,11 @@ public CommandBindingFactory()
         this.options = [];
     }
 
+    public void AddRootCommand(CommandOptions rootOptions)
+    {
+        this.options.Add(rootOptions.Command.Name, rootOptions);
+    }
+
     public void AddCommandOptions(string commandName, CommandOptions options)
     {
         this.options.Add(commandName, options);

src/MinimalCli.Core/MinimalCommandLineApp.cs

@@ -1,8 +1,6 @@
 using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Hosting;
-using System.Collections.Generic;
-using MinimalCli.Bindings;
 using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
@@ -13,19 +11,17 @@
 {
     private readonly string[] args;
     private readonly CommandExecutionMode cmdExecutionMode;
-    private readonly IReadOnlyList<CommandOptions> commandOptionsCollection;
 
     private CommandExecutorCli CliCommandExecutor => this.Services.GetRequiredService<CommandExecutorCli>();
     private CommandExecutorShell ShellCommandExecutor => this.Services.GetRequiredService<CommandExecutorShell>();
 
-    internal MinimalCommandLineApp(MinimalCommandLineBuilder builder, IReadOnlyList<CommandOptions> commandOptionsCollection, string[] args)
+    internal MinimalCommandLineApp(MinimalCommandLineBuilder builder, string[] args)
     {
         this.Host = builder.builder.Build();
-        this.commandOptionsCollection = commandOptionsCollection;
         this.cmdExecutionMode = builder.cmdExecutionMode;
         this.Configuration = builder.Configuration;
         this.args = args;
         this.RootCommand = builder.RootCommand;
     }
 
     internal readonly Dictionary<string, Func<ParseResult, object?>> ArgumentParsers = new();

src/MinimalCli.Core/MinimalCommandLineBuilder.cs

@@ -3,8 +3,8 @@
 using Microsoft.Extensions.Diagnostics.Metrics;
 using Microsoft.Extensions.Hosting;
 using Microsoft.Extensions.Logging;
-using System.Collections.Generic;
 using MinimalCli.Bindings;
+using System.Linq;
 
 namespace MinimalCli;
 
@@ -47,7 +47,7 @@ public TOptions TryRegisterCommandOptions<TOptions>()
         return newOptions;
     }
 
-    internal RootCommand RootCommand { get; } = new();
+    internal RootCommand? RootCommand { get; private set; }
     public MinimalCommandLineApp Build()
     {
         // add required services
@@ -58,6 +58,19 @@ public MinimalCommandLineApp Build()
         CommandBindingFactory cmdBindingFactory = new();
         this.Services.AddSingleton(cmdBindingFactory);
 
+        // check if there was a generated root command
+        var rootOptions = commandOptionsCollection.FirstOrDefault(opt => opt.Command is RootCommand);
+        if (rootOptions is not null)
+        {
+            this.RootCommand = (RootCommand)rootOptions.Command;
+            cmdBindingFactory.AddRootCommand(rootOptions);
+            commandOptionsCollection.Remove(rootOptions);
+            ParameterBinding[] bindings = rootOptions.SetupCommandParameterBindings();
+        }
+        else
+        {
+            this.RootCommand = new();
+        }
         // NOTES: going to have to create a factory to get the correct instance of the CommandOptions
         // for the command that was invoked, inside the Handler(serivces) function, can call
         // var factory = services.GetRequiredService<CommandOptionsFactory>();
@@ -107,7 +120,7 @@ public MinimalCommandLineApp Build()
         }
 
         // pass in args from builder
-        MinimalCommandLineApp app = new(this, this.commandOptionsCollection, this.args);
+        MinimalCommandLineApp app = new(this, this.args);
 
         return app;
     }

src/MinimalCli.Core/RootHandlerAttribute.cs

@@ -0,0 +1,10 @@
+namespace MinimalCli;
+
+/// <summary>
+/// Designates this method as the root handler for the command. This will become the default command if no other command matches.
+/// </summary>
+[AttributeUsage(AttributeTargets.Method)]
+public sealed class RootHandlerAttribute : Attribute
+{
+    public RootHandlerAttribute() { }
+}

src/MinimalCli.SourceGenerator/ArgumentBinding.cs

@@ -0,0 +1,13 @@
+using MinimalCli.SourceGeneration.Conventions;
+
+namespace MinimalCli.SourceGeneration;
+
+internal record ArgumentBinding(string OriginalParameterName, string Type, string? DefaultValueConstant, bool IsCollectionType)
+    : ParameterBinding(OriginalParameterName, Type, DefaultValueConstant, IsCollectionType)
+{
+    /// <summary>
+    /// The Argument name in title case, e.g. "myParameterName" becomes "My Parameter Name"
+    /// </summary>
+    public string ConventionalArgumentName 
+        => ParameterNameConversion.ToArgumentName(this.OriginalParameterName);
+}