Feat: Working Async methods & params

code-of-chaos · Apr 28, 2024 · b0a9a20 · b0a9a20
1 parent b388571
commit b0a9a20
Show file tree

Hide file tree

Showing 11 changed files with 52 additions and 37 deletions.
diff --git a/examples/CliArgsParser.Examples.RegisterAtlas/ArgsTest.cs b/examples/CliArgsParser.Examples.RegisterAtlas/ArgsTest.cs
@@ -3,13 +3,13 @@
 // ---------------------------------------------------------------------------------------------------------------------
 
 using CliArgsParser.Attributes;
+using CliArgsParser.Contracts;
 
 namespace CliArgsParser.Examples.RegisterAtlas;
 
 // ---------------------------------------------------------------------------------------------------------------------
 // Code
 // ---------------------------------------------------------------------------------------------------------------------
-[Parameters]
-public class ArgsTest {
-    [AutoArgFlag("username")] public string Username { get; set; } = "undefined";
+public class ArgsTest : IParameters {
+    [AutoArgValue("username")]public string Username { get; set; } = "undefined";
 }
diff --git a/examples/CliArgsParser.Examples.RegisterAtlas/HelloAtlas.cs b/examples/CliArgsParser.Examples.RegisterAtlas/HelloAtlas.cs
@@ -24,8 +24,13 @@ public async Task CommmandHelloAsync() {
     }
 
     [Command<ArgsTest>("hello-test")]
-    public void CommmandHelloAsyncArgsTest(ArgsTest argsTest) {
-        // await Task.Delay(100);
+    public void CommmandTestArgs(ArgsTest argsTest) {
+        Console.WriteLine($"IT WORKS! & with args : {argsTest.Username}");
+    }
+
+    [Command<ArgsTest>("hello-test-async")]
+    public async Task CommmandTestArgsAsync(ArgsTest argsTest) {
+        await Task.Delay(100);
         Console.WriteLine($"IT WORKS! in ASYNC & with args : {argsTest.Username}");
     }
 }
diff --git a/examples/CliArgsParser.Examples.RegisterAtlas/Program.cs b/examples/CliArgsParser.Examples.RegisterAtlas/Program.cs
@@ -11,7 +11,10 @@ namespace CliArgsParser.Examples.RegisterAtlas;
 // ---------------------------------------------------------------------------------------------------------------------
 static class Program {
     public static async Task MainAsync(IParser parser, string[] args) {
-        await parser.TryParseAsync("hello && hello-async && hello-test --username=andreas");
+        // await parser.TryParseAsync("hello");
+        // await parser.TryParseAsync("hello-async ");
+        // await parser.TryParseAsync("""hello-test --username="andreas" """);
+        await parser.TryParseAsync("hello-test-async --username=andreas");
     }
 
     public static void Main(string[] args) {

diff --git a/src/CliArgsParser.Contracts/IParameterParser.cs b/src/CliArgsParser.Contracts/IParameterParser.cs
@@ -8,5 +8,6 @@ namespace CliArgsParser.Contracts;
 // Code
 // ---------------------------------------------------------------------------------------------------------------------
 public interface IParameterParser {
-    public object? Parse(Dictionary<string, string>? args);
+    public Type ParamsType { get; }
+    public IParameters? Parse(Dictionary<string, string>? args);
 }
diff --git a/...sParser/Attributes/ParametersAttribute.cs → src/CliArgsParser.Contracts/IParameters.cs b/...sParser/Attributes/ParametersAttribute.cs → src/CliArgsParser.Contracts/IParameters.cs
@@ -2,12 +2,12 @@
 // Imports
 // ---------------------------------------------------------------------------------------------------------------------
 
-namespace CliArgsParser.Attributes;
+namespace CliArgsParser.Contracts;
 
 // ---------------------------------------------------------------------------------------------------------------------
 // Code
 // ---------------------------------------------------------------------------------------------------------------------
-[AttributeUsage(AttributeTargets.Class)]
-public class ParametersAttribute : Attribute {
+
+public interface IParameters {
 
 }
diff --git a/src/CliArgsParser/CommandMethodInfo.cs b/src/CliArgsParser/CommandMethodInfo.cs
@@ -40,15 +40,15 @@ public static Delegate GetDelegate(MethodInfo info, object atlas, ILogger logger
         try {
             switch (info.GetParameters().Length) {
                 // Method is async and has parameters
-                case > 1 when isAsync && parameterType != typeof(NoArgs): {
+                case >= 1 when isAsync && parameterType != typeof(NoArgs): {
                     Type delegateType = typeof(Func<,>).MakeGenericType(parameterType, typeof(Task));
                     commandDelegate = Delegate.CreateDelegate(delegateType, atlas, info);
                     logger.Debug("Created a delegate of type: {delegateType}", delegateType.Name);
                     break;
                 }
 
                 // If method is non-async action and has parameters
-                case > 1 when !isAsync && parameterType != typeof(NoArgs): {
+                case >= 1 when !isAsync && parameterType != typeof(NoArgs): {
                     Type delegateType = typeof(Action<>).MakeGenericType(parameterType);
                     commandDelegate = Delegate.CreateDelegate(delegateType, atlas, info);
                     logger.Debug("Created a delegate of type: {delegateType}", delegateType.Name);
@@ -78,7 +78,7 @@ public static Delegate GetDelegate(MethodInfo info, object atlas, ILogger logger
 
         return commandDelegate;
     }
-
+    
     private static IParameterParser CreateParameterParser(MethodInfo info) {
         return new ParameterParser(GetCommandAttribute(info)?.ArgsType ?? typeof(NoArgs));
     }

diff --git a/src/CliArgsParser/ParameterParser.cs b/src/CliArgsParser/ParameterParser.cs
@@ -3,7 +3,6 @@
 // Imports
 // ---------------------------------------------------------------------------------------------------------------------
 using System.Reflection;
-using CliArgsParser.Attributes;
 using CliArgsParser.Contracts;
 using CliArgsParser.Contracts.Attributes;
 
@@ -16,13 +15,13 @@ public class ParameterParser : IParameterParser {
     private readonly Dictionary<string, PropertyInfo> _valueProperties = new();
     private readonly Dictionary<string, PropertyInfo> _flagProperties = new();
 
-    private Type _type; 
+    public Type ParamsType { get; private set; }
 
     // -----------------------------------------------------------------------------------------------------------------
     // Methods
     // -----------------------------------------------------------------------------------------------------------------
     public ParameterParser(Type type) {
-        _type = type;
+        ParamsType = type;
         PropertyInfo[] propertyInfos = type.GetProperties(BindingFlags.Public | BindingFlags.Instance );
 
         foreach (PropertyInfo? prop in propertyInfos) {
@@ -44,10 +43,9 @@ public ParameterParser(Type type) {
     /// </summary>
     /// <param name="args">The command-line arguments.</param>
     /// <returns>An instance of the specified parameter options type.</returns>
-    public object? Parse(Dictionary<string, string>? args) {
-        object? result = Activator.CreateInstance(_type);
-
-        if (args == null) {
+    public IParameters? Parse(Dictionary<string, string>? args) {
+        IParameters? result = (IParameters?)Activator.CreateInstance(ParamsType);
+        if (result == null) {
             return result;
         }
 

diff --git a/src/CliArgsParser/PreMade/Args/ForceArgs.cs b/src/CliArgsParser/PreMade/Args/ForceArgs.cs
@@ -3,13 +3,13 @@
 // ---------------------------------------------------------------------------------------------------------------------
 
 using CliArgsParser.Attributes;
+using CliArgsParser.Contracts;
 
 namespace CliArgsParser.PreMade.Args;
 
 // ---------------------------------------------------------------------------------------------------------------------
 // Code
 // ---------------------------------------------------------------------------------------------------------------------
-[Parameters]
-public class ForceArgs {
+public class ForceArgs : IParameters {
     [ArgFlag("force", "Forces stuff")] public bool IsForced { get; set; } = false;
 }
diff --git a/src/CliArgsParser/PreMade/Args/NoArgs.cs b/src/CliArgsParser/PreMade/Args/NoArgs.cs
@@ -1,15 +1,13 @@
 // ---------------------------------------------------------------------------------------------------------------------
 // Imports
 // ---------------------------------------------------------------------------------------------------------------------
-
-using CliArgsParser.Attributes;
+using CliArgsParser.Contracts;
 
 namespace CliArgsParser.PreMade.Args;
 
 // ---------------------------------------------------------------------------------------------------------------------
 // Code
 // ---------------------------------------------------------------------------------------------------------------------
-[Parameters]
-public class NoArgs {
+public class NoArgs : IParameters{
 
 }
diff --git a/src/CliArgsParser/PreMade/Parsers/AbstractParser.cs b/src/CliArgsParser/PreMade/Parsers/AbstractParser.cs
@@ -38,9 +38,9 @@ public Dictionary<string, string> GetArgs(string argsInput) {
             .Matches(argsInput)
             .Where(match => match.Success)
             .ToDictionary(
-                match => match.Groups[1].Value,
-                match => match.Groups[2].Success 
-                    ? match.Groups[2].Value.Trim('"') 
+                match => match.Groups[2].Value,
+                match => match.Groups[3].Success 
+                    ? match.Groups[3].Value.Trim('"') 
                     : "True"
             );
     }
@@ -69,7 +69,7 @@ public IEnumerable<string> GetCommands(string input) {
             .Select(s => s.Trim());
     }
 
-    [GeneratedRegex("""(--|-)(\w+)(=\"[^\"]*\"|\w*)?""")]
+    [GeneratedRegex("""(--|-)(\w+)(?:=(\"[^\"]*\"|\w*))?""")]
     public static partial Regex ArgsRegex();
 
     [GeneratedRegex("""&&(?=(?:[^\"]*\"[^\"]*\")*[^\"]*$)""")]

diff --git a/src/CliArgsParser/PreMade/Parsers/ArgsParser.cs b/src/CliArgsParser/PreMade/Parsers/ArgsParser.cs
@@ -2,6 +2,7 @@
 // Imports
 // ---------------------------------------------------------------------------------------------------------------------
 
+using CliArgsParser.Contracts;
 using CliArgsParser.Contracts.Common;
 using CliArgsParser.PreMade.Args;
 
@@ -24,7 +25,8 @@ public class ArgsParser : AbstractParser {
             }
 
             try {
-                object? parameters = commandRecord.ParameterParser.Parse(args);
+                var parameters = commandRecord.ParameterParser.Parse(args);
+
                 if(parameters?.GetType() == typeof(NoArgs)) {
                     output = (T)commandRecord.Delegate.DynamicInvoke()!;
                     return true;
@@ -66,11 +68,16 @@ public override async Task<bool> TryParseAsync(string input) {
             }
 
             try {
-                Log.Debug($"Parsing parameters for command: {commandName}");
-                object? parameters = commandRecord?.ParameterParser.Parse(args);
+
+                Log.Debug("Parsing parameters for command: {name}",commandName);
+
+                IParameters? parameters = commandRecord.ParameterParser.Parse(args);
+
+                Log.Debug("Found params : {@params}", parameters);
+
                 if (parameters?.GetType() == typeof(NoArgs)) {
                     Log.Debug($"Command: {commandName} has no parameters.");
-                    if (commandRecord?.Delegate is Func<Task> func) {
+                    if (commandRecord.Delegate is Func<Task> func) {
                         Log.Debug("Invoking async delegate without parameters.");
                         await func(); // For Async methods without parameters
                         continue;
@@ -81,14 +88,17 @@ public override async Task<bool> TryParseAsync(string input) {
                         continue;
                     }
                 }
-                if (commandRecord.Delegate is Func<object?, Task> funcWithParam) {
+
+                Log.Debug("{@a}", commandRecord?.Delegate?.Method);
+                if (commandRecord is { IsAsync: true }) {
                     Log.Debug("Invoking async delegate with parameters.");
-                    await funcWithParam(parameters); // For Async methods with parameters
+                    var task = (Task)commandRecord.Delegate?.DynamicInvoke(parameters)!;
+                    await task;
                     continue;
                 }
 
                 Log.Debug("Invoking synchronous delegate with parameters.");
-                commandRecord.Delegate.DynamicInvoke(parameters); // For non-async methods with parameters
+                commandRecord?.Delegate?.DynamicInvoke(parameters); // For non-async methods with parameters
             }
             catch (Exception e) {
                 Log.Error(e, "Error occurred during command execution.");