Added String Parser and Executer

Author: maxfleetdev

Runtime/Core/CommandData.cs

@@ -34,7 +34,7 @@ public CommandData(string commandName, MethodInfo methodData,
         /// Retrieves the parameters assigned to this command
         /// </summary>
         /// <returns></returns>
-        public object[] GetParameters()
+        public ParameterInfo[] GetParameters()
         {
             return MethodData.GetParameters();
         }

Runtime/Core/CommandExecutor.cs

@@ -0,0 +1,44 @@
+using System;
+using Commander.Core;
+using UnityEngine;
+
+namespace Commander
+{
+    public static class CommandExecutor
+    {
+        public static void ExecuteCommand(string userInput)
+        {
+            // Split the users input into its command name and it's arguments
+            CommandParser.StringToCommand(userInput, out string command, out string[] args);
+            var parameters = CommandRegistry.GetParameters(command);
+
+            // Ensure enough parameters from input is present
+            if (parameters.Length != args.Length)
+            {
+                Debug.Log($"Command {command}: Not enough parameters passed");
+                return;
+            }
+
+            // Convert the raw input into the methods required parameters
+            var converted = new object[parameters.Length];
+            for (int i = 0; i < parameters.Length; i++)
+            {
+                var t = parameters[i].ParameterType;
+                try
+                {
+                    // Try converting the string into the parameter type
+                    converted[i] = CommandParser.ConvertStringToType(args[i], t);
+                }
+                catch (Exception e)
+                {
+                    // Failed (probably because DataType is not defined)
+                    Debug.LogWarning($"Command '{command}': Failed to convert \"{args[i]}\" to {t.Name}: {e.Message}");
+                    return;
+                }
+            }
+
+            // Try executing the command
+            CommandRegistry.TryExecuteCommand(command, converted);
+        }
+    }
+}

Runtime/Core/CommandExecutor.cs.meta

@@ -128,11 +128,25 @@ public static bool TryExecuteCommand(string commandName, object[] args)
                 Debug.Log($"[CommandRegistry] No command with name '{commandName}'");
                 return false;
             }
-            
+
             // Try executing command from CommandData
             return data.Execute(args);
         }
 
+        /// <summary>
+        /// Gets the parameters of a given command and it's linked method
+        /// </summary>
+        /// <param name="commandName">The command name</param>
+        /// <returns>ParameterInfo array</returns>
+        public static ParameterInfo[] GetParameters(string commandName)
+        {
+            if (_registeredCommands.TryGetValue(commandName, out var data))
+            {
+                return data.GetParameters();
+            }
+            return null;
+        }
+
         #endregion
     }
 }

Runtime/Core/CommandRegistry.cs

@@ -0,0 +1,89 @@
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.Linq;
+using System.Text.RegularExpressions;
+
+namespace Commander.Core
+{
+    public static class CommandParser
+    {
+        private static readonly Regex _tokeniser = new Regex(
+            @"[\""].+?[\""]|['].+?[']|[^ ]+",
+            RegexOptions.Compiled);
+
+        /// <summary>
+        /// Takes the raw input of the user and returns the command name and it's converted parameters
+        /// </summary>
+        /// <param name="rawInput">Input sent by user</param>
+        /// <param name="command">The commands name</param>
+        /// <param name="args">The command parameters</param>
+        public static void StringToCommand(string rawInput, out string command, out string[] args)
+        {
+            // Skip empty input
+            if (string.IsNullOrWhiteSpace(rawInput))
+            {
+                command = "";
+                args = Array.Empty<string>();
+                return;
+            }
+
+            // Keep strings which are surrounded by " or '
+            var matches = _tokeniser.Matches(rawInput.Trim());
+            var tokens = new List<string>(matches.Count);
+            foreach (Match m in matches)
+            {
+                var t = m.Value;
+
+                // Strip the quotes
+                if ((t.StartsWith("\"") && t.EndsWith("\"")) || (t.StartsWith("'") && t.EndsWith("'")))
+                {
+                    t = t.Substring(1, t.Length - 2);
+                }
+                tokens.Add(t);
+            }
+
+            // Skip if we found no tokens from past stripping
+            if (tokens.Count == 0)
+            {
+                command = "";
+                args = Array.Empty<string>();
+                return;
+            }
+
+            command = tokens[0];
+            args = tokens.Skip(1).ToArray();
+        }
+
+        /// <summary>
+        /// Convert string into it's given type. E.g "1" = int, "STATE_IDLE" = enum, etc...
+        /// </summary>
+        /// <param name="raw">The raw string</param>
+        /// <param name="targetType">Type of data we will convert to</param>
+        /// <returns></returns>
+        /// <exception cref="InvalidOperationException"></exception>
+        public static object ConvertStringToType(string raw, Type targetType)
+        {
+            // String Conversion
+            if (targetType == typeof(string))
+            {
+                return raw;
+            }
+
+            // Enum Conversion
+            if (targetType.IsEnum)
+            {
+                return Enum.Parse(targetType, raw, ignoreCase: true);
+            }
+
+            // IConvertible Primitive Converison
+            if (typeof(IConvertible).IsAssignableFrom(targetType))
+            {
+                return Convert.ChangeType(raw, targetType, CultureInfo.InvariantCulture);
+            }
+
+            // Data needs
+            throw new InvalidOperationException($"No converter for type {targetType.Name}! Create conversion in .../Commander/Runtime/Core/CommandParse.cs");
+        }
+    }
+}

Runtime/Parser.meta

@@ -7,18 +7,12 @@ public class TestCommand : MonoBehaviour
     void Awake()
     {
         CommandRegistry.RegisterInstanceCommands(this);
-        CommandRegistry.TryExecuteCommand("publictestcommand", new object[2] { "Test", "test" });
+        CommandExecutor.ExecuteCommand("test enum 'hello world'");
     }
 
-    [Command("PublicTestCommand", CommandRole.Any)]
+    [Command("test", CommandRole.Any)]
     public void PublicMyCommand(int a, string b)
     {
         Debug.Log($"Command executed with parameters: a = {a}, b = {b}");
     }
-
-    [Command("PrivateTestCommand", CommandRole.Any)]
-    private void PrivateMyCommand(int a, string b)
-    {
-        Debug.Log($"Command executed with parameters: a = {a}, b = {b}");
-    }
 }