Merge pull request #152 from SkytAsul/v4

fix: sibling detection false positive when prefix

Author: Revxrsal

build.gradle.kts

@@ -16,7 +16,7 @@ plugins {
 }
 
 group = "io.github.revxrsal"
-version = "4.0.0-rc.14"
+version = "4.0.0-rc.15"
 
 java {
     toolchain {

common/build.gradle.kts

@@ -3,8 +3,8 @@ plugins {
 }
 
 dependencies {
-    testImplementation(platform("org.junit:junit-bom:5.10.0"))
-    testImplementation("org.junit.jupiter:junit-jupiter")
+    testImplementation("org.junit.jupiter:junit-jupiter:5.14.2")
+    testRuntimeOnly("org.junit.platform:junit-platform-launcher")
     compileOnly(kotlin("stdlib-jdk8"))
 }
 

common/src/main/java/revxrsal/commands/node/parser/Execution.java

@@ -57,7 +57,7 @@ final class Execution<A extends CommandActor> implements ExecutableCommand<A> {
     private final boolean isSecret;
     private final String description, usage;
     private final OptionalInt priority;
-    private final String siblingPath;
+    private final String[] siblingPath;
     private final String path;
     private final int flagCount;
     private final boolean lowPriority;
@@ -114,8 +114,8 @@ private String computePath() {
         return joiner.toString();
     }
 
-    private @NotNull String computeSiblingPath() {
-        StringJoiner joiner = new StringJoiner(" ");
+    private @NotNull String[] computeSiblingPath() {
+        List<String> path = new ArrayList<>();
         int index = 0;
         for (int i = nodes.size() - 1; i >= 0; i--) {
             CommandNode<A> n = nodes.get(i);
@@ -124,11 +124,20 @@ private String computePath() {
                 break;
             }
         }
-        for (int i = 0; i < index; i++) {
-            CommandNode<A> n = nodes.get(i);
-            joiner.add(n.representation());
+        if (index == 0) {
+            // This is a top-level command: the sibling path should be the
+            // actual command label.
+            CommandNode<A> n = nodes.get(0);
+            if (!n.isLiteral())
+                throw new IllegalArgumentException("The command does not start with a literal.");
+            path.add(n.representation());
+        } else {
+            for (int i = 0; i < index; i++) {
+                CommandNode<A> n = nodes.get(i);
+                path.add(n.representation());
+            }
         }
-        return joiner.toString();
+        return path.toArray(new String[0]);
     }
 
     @Override
@@ -243,8 +252,11 @@ && isSiblingOf(command)
     }
 
     @Override public boolean isSiblingOf(@NotNull ExecutableCommand<A> command) {
-        String otherPath = ((Execution<A>) command).siblingPath;
-        return command != this && otherPath.startsWith(siblingPath) || siblingPath.startsWith(otherPath);
+        if (command == this)
+            return false;
+
+        String[] otherPath = ((Execution<A>) command).siblingPath;
+        return Arrays.equals(siblingPath, otherPath);
     }
 
     @Override public boolean isChildOf(@NotNull ExecutableCommand<A> command) {

common/src/test/java/revxrsal/commands/command/ExecutableCommandHelpTest.java

@@ -0,0 +1,94 @@
+package revxrsal.commands.command;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import revxrsal.commands.Lamp;
+import revxrsal.commands.annotation.Command;
+import revxrsal.commands.annotation.CommandPlaceholder;
+import revxrsal.commands.annotation.Subcommand;
+import revxrsal.commands.help.Help;
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.stream.Collectors;
+
+class ExecutableCommandHelpTest {
+
+    private Lamp<CommandActor> lamp;
+
+    @BeforeEach
+    void setUp() {
+        lamp = Lamp.builder().build();
+    }
+
+    @Test
+    void testSiblingCommands() {
+        lamp.register(new CommandA(), new CommandB());
+        ExecutableCommand<CommandActor> commandA = getCommand("a");
+        ExecutableCommand<CommandActor> commandAA = getCommand("a a");
+        ExecutableCommand<CommandActor> commandB = getCommand("b");
+
+        assertPathsEquals(commandAA.siblingCommands(), "a b", "a");
+        assertPathsEquals(commandA.siblingCommands(), "a a", "a b");
+        assertPathsEquals(commandB.siblingCommands());
+    }
+
+    @Test
+    void testChildrenCommands() {
+        lamp.register(new CommandA(), new CommandB());
+        ExecutableCommand<CommandActor> commandA = getCommand("a");
+        ExecutableCommand<CommandActor> commandAA = getCommand("a a");
+        ExecutableCommand<CommandActor> commandB = getCommand("b");
+
+        assertPathsEquals(commandAA.childrenCommands());
+        assertPathsEquals(commandA.childrenCommands(), "a a", "a b");
+        assertPathsEquals(commandB.childrenCommands());
+    }
+
+    @Test
+    void testRelatedCommands() {
+        lamp.register(new CommandA(), new CommandB());
+        ExecutableCommand<CommandActor> commandA = getCommand("a");
+        ExecutableCommand<CommandActor> commandAA = getCommand("a a");
+        ExecutableCommand<CommandActor> commandB = getCommand("b");
+
+        assertPathsEquals(commandAA.relatedCommands(), "a b", "a");
+        assertPathsEquals(commandA.relatedCommands(), "a a", "a b");
+        assertPathsEquals(commandB.relatedCommands());
+    }
+
+    private ExecutableCommand<CommandActor> getCommand(String path) {
+        return lamp.registry().commands().stream().filter(cmd -> cmd.path().equals(path))
+                .findFirst().get();
+    }
+
+    private static void assertPathsEquals(Help.CommandList<CommandActor> commands,
+            String... paths) {
+        // we use sets here because we don't care about ordering
+        assertEquals(new HashSet<>(Arrays.asList(paths)),
+                commands.all().stream().map(cmd -> cmd.path()).collect(Collectors.toSet()));
+    }
+
+    @Command("a")
+    class CommandA {
+
+        @CommandPlaceholder
+        public void placeholder() {}
+
+        @Subcommand("a")
+        public void a() {}
+
+        @Subcommand("b")
+        public void b() {}
+
+    }
+
+    @Command("b")
+    class CommandB {
+
+        @CommandPlaceholder
+        public void b() {}
+
+    }
+
+}