Hotfix/internal converters

core/src/main/java/fr/traqueur/commands/api/CommandManager.java

@@ -49,7 +49,7 @@ public abstract class CommandManager<T, S> {
     /**
      * The argument converters registered in the command manager.
      */
-    private final Map<String, ArgumentConverter.Wrapper<?>> typeConverters;
+    private final Map<Class<?>, ArgumentConverter.Wrapper<?>> typeConverters;
 
     /**
      * The tab completer registered in the command manager.
@@ -202,7 +202,7 @@ public void unregisterCommand(Command<T, S> command, boolean subcommands) {
      * @param <C>       The type of the argument.
      */
     public <C> void registerConverter(Class<C> typeClass, ArgumentConverter<C> converter) {
-        this.typeConverters.put(typeClass.getName().toLowerCase(), new ArgumentConverter.Wrapper<>(typeClass, converter));
+        this.typeConverters.put(typeClass, new ArgumentConverter.Wrapper<>(typeClass, converter));
     }
 
     /**
@@ -251,8 +251,8 @@ public Map<String, Map<Integer, TabCompleter<S>>> getCompleters() {
      * @param type The type to check.
      * @return true if a TabCompleter is registered for this type.
      */
-    public boolean hasTabCompleterForType(String type) {
-        ArgumentConverter.Wrapper<?> wrapper = this.typeConverters.get(type.toLowerCase());
+    public boolean hasTabCompleterForType(Class<?> type) {
+        ArgumentConverter.Wrapper<?> wrapper = this.typeConverters.get(type);
         return wrapper != null && wrapper.converter() instanceof TabCompleter;
     }
 
@@ -263,8 +263,8 @@ public boolean hasTabCompleterForType(String type) {
      * @return The TabCompleter for this type, or null if none exists.
      */
     @SuppressWarnings("unchecked")
-    public TabCompleter<S> getTabCompleterForType(String type) {
-        ArgumentConverter.Wrapper<?> wrapper = this.typeConverters.get(type.toLowerCase());
+    public TabCompleter<S> getTabCompleterForType(Class<?> type) {
+        ArgumentConverter.Wrapper<?> wrapper = this.typeConverters.get(type);
         if (wrapper != null && wrapper.converter() instanceof TabCompleter) {
             return (TabCompleter<S>) wrapper.converter();
         }
@@ -411,7 +411,7 @@ private void addCompletionsForLabel(String[] labelParts) {
     private void addCompletionForArgs(String label, int commandSize, List<Argument<S>> args) {
         for (int i = 0; i < args.size(); i++) {
             Argument<S> arg = args.get(i);
-            String type = arg.type().key();
+            Class<?> type = arg.type().key();
             ArgumentConverter.Wrapper<?> entry = this.typeConverters.get(type);
             TabCompleter<S> argConverter = arg.tabCompleter();
             if (argConverter != null) {

core/src/main/java/fr/traqueur/commands/api/arguments/Argument.java

@@ -43,7 +43,7 @@ public Argument(String name, ArgumentType type) {
     }
 
     public String canonicalName() {
-        return this.name + ":" + this.type.key();
+        return this.name + ":" + this.type.key().getSimpleName().toLowerCase();
     }
 
 

core/src/main/java/fr/traqueur/commands/api/arguments/ArgumentType.java

@@ -9,7 +9,7 @@ static ArgumentType of(Class<?> clazz) {
         return new Simple(clazz);
     }
 
-    String key();
+    Class<?> key();
 
     /**
      * Check if this is the infinite type.
@@ -23,8 +23,8 @@ default boolean isInfinite() {
     record Simple(Class<?> clazz) implements ArgumentType {
 
         @Override
-        public String key() {
-            return clazz.getName().toLowerCase();
+        public Class<?> key() {
+            return clazz;
         }
 
     }
@@ -33,8 +33,8 @@ record Infinite() implements ArgumentType {
         public static final Infinite INSTANCE = new Infinite();
 
         @Override
-        public String key() {
-            return "infinite";
+        public Class<?> key() {
+            return fr.traqueur.commands.api.arguments.Infinite.class;
         }
     }
 

core/src/main/java/fr/traqueur/commands/impl/parsing/DefaultArgumentParser.java

@@ -20,10 +20,10 @@ public class DefaultArgumentParser<T, S> implements ArgumentParser<T, S, String[
 
     private static final int MAX_INFINITE_LENGTH = 10_000;
 
-    private final Map<String, ArgumentConverter.Wrapper<?>> typeConverters;
+    private final Map<Class<?>, ArgumentConverter.Wrapper<?>> typeConverters;
     private final Logger logger;
 
-    public DefaultArgumentParser(Map<String, ArgumentConverter.Wrapper<?>> typeConverters, Logger logger) {
+    public DefaultArgumentParser(Map<Class<?>, ArgumentConverter.Wrapper<?>> typeConverters, Logger logger) {
         this.typeConverters = typeConverters;
         this.logger = logger;
     }
@@ -80,15 +80,15 @@ public ParseResult parse(Command<T, S> command, String[] rawArgs) {
     }
 
     private ParseResult parseSingle(Arguments arguments, Argument<S> arg, String input) {
-        String typeKey = arg.type().key();
+        Class<?> typeKey = arg.type().key();
         ArgumentConverter.Wrapper<?> wrapper = typeConverters.get(typeKey);
 
         if (wrapper == null) {
             return ParseResult.error(new ParseError(
                     ParseError.Type.TYPE_NOT_FOUND,
                     arg.name(),
                     input,
-                    "No converter for type: " + typeKey
+                    "No converter for type: " + typeKey.getSimpleName()
             ));
         }
 

core/src/test/java/fr/traqueur/commands/impl/parsing/DefaultArgumentParserTest.java

@@ -22,16 +22,16 @@ class DefaultArgumentParserTest {
 
     @BeforeEach
     void setUp() {
-        Map<String, ArgumentConverter.Wrapper<?>> converters = new HashMap<>();
-        converters.put("string", new ArgumentConverter.Wrapper<>(String.class, s -> s));
-        converters.put("integer", new ArgumentConverter.Wrapper<>(Integer.class, s -> {
+        Map<Class<?>, ArgumentConverter.Wrapper<?>> converters = new HashMap<>();
+        converters.put(String.class, new ArgumentConverter.Wrapper<>(String.class, s -> s));
+        converters.put(Integer.class, new ArgumentConverter.Wrapper<>(Integer.class, s -> {
             try {
                 return Integer.valueOf(s);
             } catch (NumberFormatException e) {
                 return null;
             }
         }));
-        converters.put("double", new ArgumentConverter.Wrapper<>(Double.class, s -> {
+        converters.put(Double.class, new ArgumentConverter.Wrapper<>(Double.class, s -> {
             try {
                 return Double.valueOf(s);
             } catch (NumberFormatException e) {

jda/src/main/java/fr/traqueur/commands/jda/JDAPlatform.java

@@ -7,6 +7,8 @@
 import fr.traqueur.commands.api.resolver.SenderResolver;
 import net.dv8tion.jda.api.JDA;
 import net.dv8tion.jda.api.Permission;
+import net.dv8tion.jda.api.entities.*;
+import net.dv8tion.jda.api.entities.channel.middleman.GuildChannel;
 import net.dv8tion.jda.api.events.interaction.command.SlashCommandInteractionEvent;
 import net.dv8tion.jda.api.interactions.commands.OptionType;
 import net.dv8tion.jda.api.interactions.commands.build.*;
@@ -288,20 +290,56 @@ private boolean hasTabCompleter(Argument<JDAInteractionContext> arg) {
      * @param type The type string.
      * @return The corresponding OptionType.
      */
-    private OptionType mapToOptionType(String type) {
-        return switch (type.toLowerCase()) {
-            case "integer", "int", "long" -> OptionType.INTEGER;
-            case "boolean" -> OptionType.BOOLEAN;
-            case "user", "member" -> OptionType.USER;
-            case "role" -> OptionType.ROLE;
-            case "channel", "guildchannelunion" -> OptionType.CHANNEL;
-            case "double", "float" -> OptionType.NUMBER;
-            case "attachment" -> OptionType.ATTACHMENT;
-            case "mentionable" -> OptionType.MENTIONABLE;
+    private OptionType mapToOptionType(Class<?> type) {
+        return switch (type) {
+
+            // INTEGER
+            case Class<?> t when t == int.class
+                    || t == Integer.class
+                    || t == long.class
+                    || t == Long.class
+                    -> OptionType.INTEGER;
+
+            // BOOLEAN
+            case Class<?> t when t == boolean.class
+                    || t == Boolean.class
+                    -> OptionType.BOOLEAN;
+
+            // USER / MEMBER
+            case Class<?> t when User.class.isAssignableFrom(t)
+                    || Member.class.isAssignableFrom(t)
+                    -> OptionType.USER;
+
+            // ROLE
+            case Class<?> t when Role.class.isAssignableFrom(t)
+                    -> OptionType.ROLE;
+
+            // CHANNEL (tous types de channels)
+            case Class<?> t when GuildChannel.class.isAssignableFrom(t)
+                    -> OptionType.CHANNEL;
+
+            // NUMBER
+            case Class<?> t when t == double.class
+                    || t == Double.class
+                    || t == float.class
+                    || t == Float.class
+                    -> OptionType.NUMBER;
+
+            // ATTACHMENT
+            case Class<?> t when Message.Attachment.class.isAssignableFrom(t)
+                    -> OptionType.ATTACHMENT;
+
+            // MENTIONABLE
+            case Class<?> t when IMentionable.class.isAssignableFrom(t)
+                    -> OptionType.MENTIONABLE;
+
             default -> OptionType.STRING;
         };
     }
 
+
+
+
     /**
      * Synchronize all registered commands with Discord globally.
      * This may take up to 1 hour to update.