Fixes #124 - Created alias variable by allowing multiple command attributes

src/ConsoleAppFramework/Command.cs

@@ -22,6 +22,8 @@ public record class Command
     public bool IsRootCommand => Name == "";
     public required string Name { get; init; }
 
+    public required string[] Aliases { get; set; }
+
     public required EquatableArray<CommandParameter> Parameters { get; init; }
     public required string Description { get; init; }
     public required MethodKind MethodKind { get; init; }

src/ConsoleAppFramework/CommandHelpBuilder.cs

@@ -217,7 +217,7 @@ static string BuildMethodListMessage(IEnumerable<Command> commands, out int maxW
         var formatted = commands
             .Select(x =>
             {
-                return (Command: x.Name, x.Description);
+                return (Command: string.Join(", ", Array.Empty<string>().Concat([x.Name]).Concat(x.Aliases)), x.Description);
             })
             .ToArray();
         maxWidth = formatted.Max(x => x.Command.Length);

src/ConsoleAppFramework/ConsoleAppGenerator.cs

@@ -144,7 +144,7 @@ internal sealed class ArgumentAttribute : Attribute
 {
 }
 
-[AttributeUsage(AttributeTargets.Method, AllowMultiple = false, Inherited = false)]
+[AttributeUsage(AttributeTargets.Class | AttributeTargets.Method, AllowMultiple = true, Inherited = false)]
 internal sealed class CommandAttribute : Attribute
 {
     public string Command { get; }

src/ConsoleAppFramework/Emitter.cs

@@ -1,4 +1,5 @@
 using Microsoft.CodeAnalysis;
+using System.Linq;
 using System.Reflection.Metadata;
 
 namespace ConsoleAppFramework;
@@ -447,6 +448,14 @@ void EmitRunBody(ILookup<string, CommandWithId> groupedCommands, int depth, bool
         {
             var leafCommand = groupedCommands[""].FirstOrDefault();
             IDisposable? ifBlcok = null;
+            if (leafCommand is not null && !leafCommand.Command.Name.Equals(""))
+            {
+                // Add or-ing of aliases 
+                foreach (var alias in leafCommand.Command.Aliases)
+                {
+                    sb.AppendLine($"case \"{alias}\":");
+                }
+            }
             if (!(groupedCommands.Count == 1 && leafCommand != null))
             {
                 ifBlcok = sb.BeginBlock($"if (args.Length == {depth})");
@@ -462,9 +471,15 @@ void EmitRunBody(ILookup<string, CommandWithId> groupedCommands, int depth, bool
                 return;
             }
 
+            IEnumerable<IGrouping<string, CommandWithId>> aliases = [];
+            if (leafCommand?.Command.Aliases.Length > 0)
+            {
+                aliases = leafCommand.Command.Aliases.SelectMany(lc => commandIds.GroupBy(a => lc));
+            }
+
             using (sb.BeginBlock($"switch (args[{depth}])"))
             {
-                foreach (var commands in groupedCommands.Where(x => x.Key != ""))
+                foreach (var commands in groupedCommands.Where(x => x.Key != "").Concat(aliases))
                 {
                     using (sb.BeginIndent($"case \"{commands.Key}\":"))
                     {

src/ConsoleAppFramework/Parser.cs

@@ -104,6 +104,15 @@ internal class Parser(DiagnosticReporter context, InvocationExpressionSyntax nod
             return [];
         }
 
+        List<string> rootAliases = [];
+        if (type.TypeKind.HasFlag(TypeKind.Class))
+        {
+            foreach (var item in type.GetAttributes().Where(x => x.AttributeClass?.Name == "CommandAttribute"))
+            {
+                rootAliases.Add((item.ConstructorArguments[0].Value as string)!);
+            }
+        }
+
         var hasIDisposable = type.AllInterfaces.Any(x => SymbolEqualityComparer.Default.Equals(x, wellKnownTypes.IDisposable));
         var hasIAsyncDisposable = type.AllInterfaces.Any(x => SymbolEqualityComparer.Default.Equals(x, wellKnownTypes.IAsyncDisposable));
 
@@ -141,8 +150,9 @@ internal class Parser(DiagnosticReporter context, InvocationExpressionSyntax nod
             .Select(x =>
             {
                 string commandName;
-                var commandAttribute = x.GetAttributes().FirstOrDefault(x => x.AttributeClass?.Name == "CommandAttribute");
-                if (commandAttribute != null)
+                var commandAttributes = x.GetAttributes().Where(x => x.AttributeClass?.Name == "CommandAttribute");
+                var firstCommandAttribute = commandAttributes.FirstOrDefault();
+                if (firstCommandAttribute != null)
                 {
                     commandName = (x.GetAttributes()[0].ConstructorArguments[0].Value as string)!;
                 }
@@ -154,6 +164,21 @@ internal class Parser(DiagnosticReporter context, InvocationExpressionSyntax nod
                 var command = ParseFromMethodSymbol(x, false, (commandPath == null) ? commandName : $"{commandPath.Trim()} {commandName}", typeFilters);
                 if (command == null) return null;
 
+                List<string> methodAliases = [];
+                if (commandAttributes.Count() > 0)
+                {
+                    methodAliases.AddRange(commandAttributes.Select((ca, i) => (x.GetAttributes()[i].ConstructorArguments[0].Value as string)!));
+                }
+
+                if (command.IsRootCommand)
+                {
+                    command.Aliases = methodAliases.Concat(rootAliases).Select(a => NameConverter.ToKebabCase(a)).Distinct().Where(s => !s.Equals(commandName)).ToArray();
+                }
+                else
+                {
+                    command.Aliases = methodAliases.Select(a => NameConverter.ToKebabCase(a)).Distinct().Where(s => !s.Equals(commandName)).ToArray();
+                }
+
                 command.CommandMethodInfo = methodInfoBase with { MethodName = x.Name };
                 return command;
             })
@@ -367,6 +392,7 @@ internal class Parser(DiagnosticReporter context, InvocationExpressionSyntax nod
         var cmd = new Command
         {
             Name = commandName,
+            Aliases = [],
             IsAsync = isAsync,
             IsVoid = isVoid,
             Parameters = parameters,
@@ -522,6 +548,7 @@ internal class Parser(DiagnosticReporter context, InvocationExpressionSyntax nod
         var cmd = new Command
         {
             Name = commandName,
+            Aliases = [],
             IsAsync = isAsync,
             IsVoid = isVoid,
             Parameters = parameters,

tests/ConsoleAppFramework.GeneratorTests/ConsoleAppBuilderTest.cs

@@ -241,6 +241,29 @@ public void Do()
 
         verifier.Execute(code, "nomunomu", "yeah");
     }
+
+    [Fact]
+    public void CommandAttrAlias()
+    {
+        var code = """
+var builder = ConsoleApp.Create();
+builder.Add<MyClass>();
+builder.Run(args);
+
+public class MyClass()
+{
+    [Command("nomunomu")]
+    [Command("nomunomu2")]
+    public void Do()
+    {
+        Console.Write("yeah");
+    }
+}
+""";
+
+        verifier.Execute(code, "nomunomu", "yeah");
+        verifier.Execute(code, "nomunomu2", "yeah");
+    }
 }