GH-173 Add @rootroute annotation. Add an option to create all commands in one class. Add unit test for @rootroute annotation. (#174)

* GH-173 Add @rootroute annotation. Add an option to create all commands in one class. Add unit test for @rootroute annotation.

* Fix unit test.

Author: Rollczi

litecommands-core/src/main/java/dev/rollczi/litecommands/command/root/RootRoute.java

@@ -0,0 +1,16 @@
+package dev.rollczi.litecommands.command.root;
+
+import dev.rollczi.litecommands.factory.FactoryAnnotationResolver;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Target({ ElementType.TYPE, ElementType.METHOD})
+@Retention(RetentionPolicy.RUNTIME)
+public @interface RootRoute {
+
+    FactoryAnnotationResolver<RootRoute> RESOLVER = new RootRouteAnnotationResolver();
+
+}

litecommands-core/src/main/java/dev/rollczi/litecommands/command/root/RootRouteAnnotationResolver.java

@@ -0,0 +1,23 @@
+package dev.rollczi.litecommands.command.root;
+
+import dev.rollczi.litecommands.factory.CommandState;
+import dev.rollczi.litecommands.factory.FactoryAnnotationResolver;
+import dev.rollczi.litecommands.shared.StringUtils;
+import panda.std.Option;
+
+class RootRouteAnnotationResolver implements FactoryAnnotationResolver<RootRoute> {
+
+    @Override
+    public Option<CommandState> resolve(RootRoute annotation, CommandState commandState) {
+        return Option.of(commandState
+            .name(StringUtils.EMPTY)
+            .cancel(false)
+        );
+    }
+
+    @Override
+    public Class<RootRoute> getAnnotationClass() {
+        return RootRoute.class;
+    }
+
+}

litecommands-core/src/main/java/dev/rollczi/litecommands/factory/CommandStateFactory.java

@@ -4,10 +4,11 @@
 import panda.std.Option;
 
 import java.lang.annotation.Annotation;
+import java.util.List;
 
 public interface CommandStateFactory<SENDER> {
 
-    Option<CommandSection<SENDER>> create(Object instance);
+    Option<List<CommandSection<SENDER>>> create(Object instance);
 
     <A extends Annotation> void annotationResolver(FactoryAnnotationResolver<A> resolver);
 

litecommands-core/src/main/java/dev/rollczi/litecommands/implementation/LiteCommandFactory.java

@@ -22,10 +22,12 @@
 import java.lang.reflect.Method;
 import java.lang.reflect.Parameter;
 import java.util.ArrayList;
+import java.util.Collections;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
+import java.util.stream.Collectors;
 
 class LiteCommandFactory<SENDER> implements CommandStateFactory<SENDER> {
 
@@ -43,16 +45,31 @@ class LiteCommandFactory<SENDER> implements CommandStateFactory<SENDER> {
     }
 
     @Override
-    public Option<CommandSection<SENDER>> create(Object instance) {
+    public Option<List<CommandSection<SENDER>>> create(Object instance) {
         CommandState state = this.createState(instance);
 
-        if (state.getName() == null || state.getName().isEmpty() || state.isCanceled()) {
+        if (state.getName() == null || state.isCanceled()) {
             return Option.none();
         }
 
         CommandSection<SENDER> section = this.stateToSection(state, instance);
+        List<CommandSection<SENDER>> sections = this.unpackEmptySection(section);
 
-        return Option.of(section);
+        return Option.of(sections);
+    }
+
+    private List<CommandSection<SENDER>> unpackEmptySection(CommandSection<SENDER> section) {
+        if (section.getName().isEmpty()) {
+            if (!section.executors().isEmpty()) {
+                throw new IllegalStateException("Empty section cannot have executors without name");
+            }
+
+            return section.childrenSection().stream()
+                .flatMap(child -> this.unpackEmptySection(child).stream())
+                .collect(Collectors.toList());
+        }
+
+        return Collections.singletonList(section);
     }
 
     @Override
@@ -131,9 +148,10 @@ private CommandSection<SENDER> stateToSection(CommandState state, Object instanc
         section = this.resolveStateOnSection(section, instance, state);
 
         PandaStream.of(instance.getClass().getDeclaredClasses())
-                .mapOpt(type -> Option.supplyThrowing(InjectException.class, () -> injector.createInstance(type)))
-                .mapOpt(this::create)
-                .forEach(section::childSection);
+            .mapOpt(type -> Option.supplyThrowing(InjectException.class, () -> this.injector.createInstance(type)))
+            .mapOpt(this::create)
+            .flatMap(commandSections -> commandSections)
+            .forEach(section::childSection);
 
         return section;
     }

litecommands-core/src/main/java/dev/rollczi/litecommands/implementation/LiteCommandsBuilderImpl.java

@@ -269,24 +269,26 @@ public LiteCommands<SENDER> register() {
 
         List<CommandSection<SENDER>> commandSections = new ArrayList<>();
 
-        root:
         for (Object instance : this.commandsInstances) {
-            Option<CommandSection<SENDER>> option = this.commandStateFactory.create(instance);
+            Option<List<CommandSection<SENDER>>> listOption = this.commandStateFactory.create(instance);
 
-            if (option.isEmpty()) {
+            if (listOption.isEmpty()) {
                 continue;
             }
 
-            CommandSection<SENDER> currentCommand = option.get();
+            List<CommandSection<SENDER>> currentCommands = listOption.get();
 
-            for (CommandSection<SENDER> commandSection : commandSections) {
-                if (commandSection.isSimilar(currentCommand.getName())) {
-                    commandSection.mergeSection(currentCommand);
-                    continue root;
+            root:
+            for (CommandSection<SENDER> currentCommand : currentCommands) {
+                for (CommandSection<SENDER> commandSection : commandSections) {
+                    if (commandSection.isSimilar(currentCommand.getName())) {
+                        commandSection.mergeSection(currentCommand);
+                        continue root;
+                    }
                 }
-            }
 
-            commandSections.add(currentCommand);
+                commandSections.add(currentCommand);
+            }
         }
 
         for (CommandSection<SENDER> commandSection : commandSections) {

litecommands-core/src/main/java/dev/rollczi/litecommands/implementation/LiteFactory.java

@@ -50,6 +50,7 @@
 import dev.rollczi.litecommands.command.permission.ExecutedPermission;
 import dev.rollczi.litecommands.command.permission.Permission;
 import dev.rollczi.litecommands.command.permission.RequiredPermissions;
+import dev.rollczi.litecommands.command.root.RootRoute;
 import dev.rollczi.litecommands.command.route.Route;
 import dev.rollczi.litecommands.command.section.Section;
 import dev.rollczi.litecommands.handle.Redirector;
@@ -95,6 +96,7 @@ public static <SENDER> LiteCommandsBuilder<SENDER> builder(Class<SENDER> senderT
             .configureFactory(factory -> {
                 factory.annotationResolver(Section.RESOLVER);
                 factory.annotationResolver(Route.RESOLVER);
+                factory.annotationResolver(RootRoute.RESOLVER);
                 factory.annotationResolver(Execute.RESOLVER);
                 factory.annotationResolver(Permission.RESOLVER);
                 factory.annotationResolver(Permission.REPEATABLE_RESOLVER);

litecommands-core/src/test/java/dev/rollczi/litecommands/command/root/TestRootRouteCommand.java

@@ -0,0 +1,46 @@
+package dev.rollczi.litecommands.command.root;
+
+import dev.rollczi.litecommands.command.execute.Execute;
+import dev.rollczi.litecommands.command.permission.Permission;
+import dev.rollczi.litecommands.command.permission.RequiredPermissions;
+import dev.rollczi.litecommands.test.TestFactory;
+import dev.rollczi.litecommands.test.TestPlatform;
+import org.junit.jupiter.api.Test;
+
+import java.util.Arrays;
+
+import static dev.rollczi.litecommands.test.Assert.assertCollection;
+
+class TestRootRouteCommand {
+
+    TestPlatform platform = TestFactory.withCommands(RootCommands.class);
+
+    @RootRoute
+    static class RootCommands {
+        @Execute(route = "msg")
+        String msg() {
+            return "msg";
+        }
+
+        @Execute(route = "reply", aliases = {"r"})
+        @Permission("reply")
+        String reply() {
+            return "reply";
+        }
+    }
+
+    @Test
+    void testSimpleClassCommands() {
+        this.platform.execute("msg")
+            .assertSuccess()
+            .assertResult("msg");
+
+        RequiredPermissions permissions = this.platform.execute("reply")
+            .assertInvalid()
+            .assertResultIs(RequiredPermissions.class);
+
+        assertCollection(Arrays.asList("reply"), permissions.getPermissions());
+    }
+
+
+}