feat: version 4.2.1

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

@@ -145,9 +145,7 @@ public boolean isDebug() {
      */
     public void registerCommand(Command<T,S> command) {
         try {
-            List<String> aliases = new ArrayList<>(command.getAliases());
-            aliases.add(command.getName());
-            for (String alias : aliases) {
+            for (String alias : command.getAliases()) {
                 this.addCommand(command, alias);
                 this.registerSubCommands(alias, command.getSubcommands());
             }

core/src/main/java/fr/traqueur/commands/api/models/CommandInvoker.java

@@ -12,6 +12,7 @@
 
 import java.util.*;
 import java.util.stream.Collectors;
+import java.util.stream.Stream;
 
 /**
  * CommandInvoker is responsible for invoking and suggesting commands.
@@ -107,21 +108,53 @@ public boolean invoke(S source, String base, String[] rawArgs) {
      */
     public List<String> suggest(S source, String base, String[] args) {
         Optional<MatchResult<T, S>> found = manager.getCommands().findNode(base, args);
-        if (!found.isPresent()) return Collections.emptyList();
-        MatchResult<T, S> result = found.get();
-        CommandTree.CommandNode<T, S> node = result.node;
-        String[] rawArgs = result.args;
-        String label = node.getFullLabel() != null ? node.getFullLabel() : base;
-        Map<Integer, TabCompleter<S>> map = manager.getCompleters().get(label);
-        if (map != null && map.containsKey(args.length)) {
-            return map.get(args.length)
-                    .onCompletion(source, Arrays.asList(rawArgs))
-                    .stream()
-                    .filter(opt -> allowedSuggestion(source, label, opt))
-                    .filter(opt -> matchesPrefix(opt, args[args.length - 1]))
-                    .collect(Collectors.toList());
+        String lastArg = args.length > 0 ? args[args.length - 1] : "";
+        if (found.isPresent()) {
+            MatchResult<T, S> result = found.get();
+            CommandTree.CommandNode<T, S> node = result.node;
+            String[] rawArgs = result.args;
+            String label = Optional.ofNullable(node.getFullLabel()).orElse(base);
+            Map<Integer, TabCompleter<S>> map = manager.getCompleters().get(label);
+            if (map != null) {
+                TabCompleter<S> completer = map.get(args.length);
+                if (completer != null) {
+                    return completer.onCompletion(source, Arrays.asList(rawArgs)).stream()
+                            .filter(opt -> allowedSuggestion(source, label, opt))
+                            .filter(opt -> matchesPrefix(opt, lastArg))
+                            .collect(Collectors.toList());
+                }
+            }
+        }
+
+        CommandTree.CommandNode<T, S> current = manager.getCommands().getRoot().getChildren().get(base.toLowerCase());
+        if (current == null) return Collections.emptyList();
+
+        current = traverseNode(current, args);
+        String parentLabel = current.getFullLabel();
+
+        Stream<String> children = current.getChildren().keySet().stream();
+        if (args.length > 0 && current.getChildren().containsKey(lastArg.toLowerCase())) {
+            children = children.filter(opt -> matchesPrefix(opt, lastArg));
+        }
+
+        return children
+                .filter(opt -> allowedSuggestion(source, parentLabel, opt))
+                .collect(Collectors.toList());
+    }
+
+    private CommandTree.CommandNode<T, S> traverseNode(CommandTree.CommandNode<T, S> node, String[] args) {
+        int index = 0;
+        while (index < args.length - 1) {
+            String arg = args[index].toLowerCase();
+            CommandTree.CommandNode<T, S> child = node.getChildren().get(arg);
+            if (child != null) {
+                node = child;
+                index++;
+            } else {
+                break;
+            }
         }
-        return Collections.emptyList();
+        return node;
     }
 
     private boolean matchesPrefix(String candidate, String current) {

core/src/test/java/fr/traqueur/commands/api/models/CommandInvokerTest.java

@@ -9,6 +9,7 @@
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 
+import java.util.List;
 import java.util.concurrent.atomic.AtomicBoolean;
 
 import static org.junit.jupiter.api.Assertions.*;
@@ -121,6 +122,28 @@ public void execute(String sender, Arguments arguments) {
         assertTrue(executed.get());
     }
 
+    @Test
+    void valid_AliasWithSubCommand_executesSubCommand() {
+        cmd.addAlias("base.sub");
+
+        DummyCommand sub = new DummyCommand();
+        cmd.addSubCommand(sub);
+
+        tree.addCommand("base.sub", cmd);
+        tree.addCommand("base.sub.base", sub);
+        tree.addCommand("base.base", sub);
+
+        List<String> suggests = invoker.suggest("user", "base", new String[]{""});
+        assertTrue(suggests.contains("sub"));
+        assertTrue(suggests.contains("base"));
+
+        List<String> suggests3 = invoker.suggest("user", "base", new String[]{"sub"});
+        assertTrue(suggests3.contains("sub"));
+
+        List<String> suggests4 = invoker.suggest("user", "base", new String[]{"sub", ""});
+        assertTrue(suggests4.contains("base"));
+    }
+
     static class DummyCommand extends Command<String, String> {
         DummyCommand() { super(null, "base"); }
         @Override public void execute(String sender, Arguments args) {}

gradle.properties

@@ -1 +1 @@
-version=4.2.0
+version=4.2.1