GH-87 Add enum support. Better unit tests. (#87)

Rollczi · web-flow · commit b58d27cda05d · 2022-07-01T03:57:08.000+02:00
diff --git a/litecommands-core/src/main/java/dev/rollczi/litecommands/argument/ParameterHandler.java b/litecommands-core/src/main/java/dev/rollczi/litecommands/argument/ParameterHandler.java
@@ -5,11 +5,11 @@
 public interface ParameterHandler {
 
     default boolean canHandle(Class<?> type, Parameter parameter) {
-        return type.equals(parameter.getType());
+        return parameter.getType().equals(type);
     }
 
     default boolean canHandleAssignableFrom(Class<?> type, Parameter parameter) {
-        return type.isAssignableFrom(parameter.getType());
+        return parameter.getType().isAssignableFrom(type);
     }
 
 }
diff --git a/litecommands-core/src/main/java/dev/rollczi/litecommands/argument/block/BlockArgument.java b/litecommands-core/src/main/java/dev/rollczi/litecommands/argument/block/BlockArgument.java
@@ -49,4 +49,14 @@ public Option<String> getSchematic(Block annotation) {
         return Option.of(annotation.value());
     }
 
+    @Override
+    public boolean canHandle(Class<?> type, Parameter parameter) {
+        return true;
+    }
+
+    @Override
+    public boolean canHandleAssignableFrom(Class<?> type, Parameter parameter) {
+        return true;
+    }
+
 }
diff --git a/litecommands-core/src/main/java/dev/rollczi/litecommands/argument/option/OptionArgument.java b/litecommands-core/src/main/java/dev/rollczi/litecommands/argument/option/OptionArgument.java
@@ -87,7 +87,7 @@ public boolean canHandle(Class<?> type, Parameter parameter) {
     @Override
     public boolean canHandleAssignableFrom(Class<?> type, Parameter parameter) {
         return OptionUtils.extractOptionType(parameter)
-                .map(type::isAssignableFrom)
+                .map(paramType -> paramType.isAssignableFrom(type))
                 .orElseGet(false);
     }
 
diff --git a/litecommands-core/src/main/java/dev/rollczi/litecommands/handle/ExecuteResultHandler.java b/litecommands-core/src/main/java/dev/rollczi/litecommands/handle/ExecuteResultHandler.java
@@ -2,7 +2,6 @@
 
 import dev.rollczi.litecommands.command.execute.ExecuteResult;
 import dev.rollczi.litecommands.command.LiteInvocation;
-import dev.rollczi.litecommands.scheme.Scheme;
 import dev.rollczi.litecommands.scheme.SchemeFormat;
 import dev.rollczi.litecommands.scheme.SchemeGenerator;
 import dev.rollczi.litecommands.shared.MapUtil;
@@ -39,7 +38,7 @@ public void handle(SENDER sender, LiteInvocation invocation, ExecuteResult resul
         }
 
         Class<?> type = object.getClass();
-        Option<Handler<SENDER, ?>> handlerOpt = MapUtil.findByKeyAssignableFrom(type, this.handlers);
+        Option<Handler<SENDER, ?>> handlerOpt = MapUtil.findByAssignableFromKey(type, this.handlers);
 
         if (handlerOpt.isEmpty()) {
             Redirector<?, ?> forwarding = this.redirectors.get(type);
@@ -49,7 +48,7 @@ public void handle(SENDER sender, LiteInvocation invocation, ExecuteResult resul
             }
 
             Object to = handleForwarding(forwarding, object);
-            Handler<SENDER, ?> handler = MapUtil.findByKeyAssignableFrom(to.getClass(), this.handlers)
+            Handler<SENDER, ?> handler = MapUtil.findByAssignableFromKey(to.getClass(), this.handlers)
                     .orThrow(() -> new IllegalStateException("Missing result handler for type " + type + " or for redirected type " + to.getClass()));
 
             this.handle(handler, sender, invocation, to);
diff --git a/litecommands-core/src/main/java/dev/rollczi/litecommands/implementation/ArgumentsRegistry.java b/litecommands-core/src/main/java/dev/rollczi/litecommands/implementation/ArgumentsRegistry.java
@@ -6,8 +6,11 @@
 
 import java.lang.annotation.Annotation;
 import java.lang.reflect.Parameter;
+import java.util.ArrayList;
 import java.util.HashMap;
+import java.util.List;
 import java.util.Map;
+import java.util.Set;
 
 class ArgumentsRegistry<SENDER> {
 
diff --git a/litecommands-core/src/main/java/dev/rollczi/litecommands/implementation/LiteCommandFactory.java b/litecommands-core/src/main/java/dev/rollczi/litecommands/implementation/LiteCommandFactory.java
@@ -81,7 +81,7 @@ private CommandState createState(Object instance) {
 
         for (Annotation annotation : sectionClass.getAnnotations()) {
             for (FactoryAnnotationResolver<? extends Annotation> resolver : annotationResolvers) {
-                if (!annotation.annotationType().isAssignableFrom(resolver.getAnnotationClass())) {
+                if (!annotation.annotationType().equals(resolver.getAnnotationClass())) {
                     continue;
                 }
 
@@ -100,7 +100,7 @@ private CommandState createState(Object instance) {
 
             for (Annotation annotation : method.getAnnotations()) {
                 for (FactoryAnnotationResolver<? extends Annotation> resolver : annotationResolvers) {
-                    if (!annotation.annotationType().isAssignableFrom(resolver.getAnnotationClass())) {
+                    if (!annotation.annotationType().equals(resolver.getAnnotationClass())) {
                         continue;
                     }
 
diff --git a/litecommands-core/src/main/java/dev/rollczi/litecommands/implementation/LiteFactory.java b/litecommands-core/src/main/java/dev/rollczi/litecommands/implementation/LiteFactory.java
@@ -1,6 +1,10 @@
 package dev.rollczi.litecommands.implementation;
 
 import dev.rollczi.litecommands.LiteCommandsBuilder;
+import dev.rollczi.litecommands.argument.Arg;
+import dev.rollczi.litecommands.argument.ArgumentContext;
+import dev.rollczi.litecommands.argument.ParameterHandler;
+import dev.rollczi.litecommands.argument.SingleArgument;
 import dev.rollczi.litecommands.argument.block.Block;
 import dev.rollczi.litecommands.argument.block.BlockArgument;
 import dev.rollczi.litecommands.argument.flag.Flag;
@@ -9,25 +13,32 @@
 import dev.rollczi.litecommands.argument.joiner.JoinerArgument;
 import dev.rollczi.litecommands.argument.simple.OneArgument;
 import dev.rollczi.litecommands.command.LiteInvocation;
+import dev.rollczi.litecommands.command.MatchResult;
 import dev.rollczi.litecommands.command.amount.Between;
 import dev.rollczi.litecommands.command.amount.Max;
 import dev.rollczi.litecommands.command.amount.Min;
 import dev.rollczi.litecommands.command.amount.Required;
 import dev.rollczi.litecommands.command.execute.Execute;
 import dev.rollczi.litecommands.command.permission.ExecutedPermission;
-import dev.rollczi.litecommands.command.permission.ExecutedPermissions;
 import dev.rollczi.litecommands.command.permission.LitePermissions;
 import dev.rollczi.litecommands.command.permission.Permission;
-import dev.rollczi.litecommands.command.permission.Permissions;
 import dev.rollczi.litecommands.command.section.Section;
-import dev.rollczi.litecommands.handle.Redirector;
+import dev.rollczi.litecommands.command.sugesstion.Suggestion;
 import dev.rollczi.litecommands.platform.LiteSender;
 import dev.rollczi.litecommands.scheme.Scheme;
+import dev.rollczi.litecommands.shared.EnumUtil;
 import panda.std.Blank;
 import panda.std.Option;
 import panda.std.Result;
 
+import java.lang.annotation.ElementType;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.reflect.Parameter;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
 import java.util.function.Supplier;
+import java.util.stream.Collectors;
 
 import static dev.rollczi.litecommands.argument.simple.OneArgument.create;
 import static dev.rollczi.litecommands.command.sugesstion.Suggestion.of;
@@ -59,6 +70,39 @@ public final class LiteFactory {
     private LiteFactory() {
     }
 
+    private static class EnumArgument<SENDER> implements SingleArgument<SENDER, Arg>, ParameterHandler {
+
+        @Override
+        public MatchResult match(LiteInvocation invocation, ArgumentContext<Arg> context, String argument) {
+            return EnumUtil.parse(context.parameter().getType(), argument)
+                    .fold(MatchResult::matchedSingle, (exception) -> MatchResult.notMatched());
+        }
+
+        @Override
+        public List<Suggestion> suggestion(LiteInvocation invocation, Parameter parameter, Arg annotation) {
+            Object[] enumConstants = parameter.getType().getEnumConstants();
+
+            if (enumConstants == null) {
+                return Collections.emptyList();
+            }
+
+            return Arrays.stream(enumConstants)
+                    .map(Object::toString)
+                    .map(Suggestion::of)
+                    .collect(Collectors.toList());
+        }
+
+        @Override
+        public boolean canHandleAssignableFrom(Class<?> type, Parameter parameter) {
+            return Enum.class.isAssignableFrom(parameter.getType());
+        }
+
+    }
+
+    private static <T> Result<T, Blank> parse(Supplier<T> parse) {
+        return Result.attempt(NumberFormatException.class, parse::get).mapErrToBlank();
+    }
+
     public static <SENDER> LiteCommandsBuilder<SENDER> builder(Class<SENDER> senderType) {
         return LiteCommandsBuilderImpl.builder(senderType)
                 .configureFactory(factory -> {
@@ -96,6 +140,8 @@ public static <SENDER> LiteCommandsBuilder<SENDER> builder(Class<SENDER> senderT
                 .argument(char.class, CHARACTER_ARG)
                 .argument(Character.class, CHARACTER_ARG)
 
+                .argument(Arg.class, Enum.class, new EnumArgument<>())
+
                 .redirectResult(Scheme.class, String.class, scheme -> String.join(System.lineSeparator(), scheme.getSchemes()))
                 .redirectResult(LitePermissions.class, String.class, scheme -> String.join(System.lineSeparator(), scheme.getPermissions()))
 
@@ -105,8 +151,4 @@ public static <SENDER> LiteCommandsBuilder<SENDER> builder(Class<SENDER> senderT
                 .contextualBind(senderType, (sender, invocation) -> Result.ok(sender));
     }
 
-    private static <T> Result<T, Blank> parse(Supplier<T> parse) {
-        return Result.attempt(NumberFormatException.class, parse::get).mapErrToBlank();
-    }
-
 }
diff --git a/litecommands-core/src/main/java/dev/rollczi/litecommands/implementation/injector/InjectorContextProcessor.java b/litecommands-core/src/main/java/dev/rollczi/litecommands/implementation/injector/InjectorContextProcessor.java
@@ -42,7 +42,7 @@ Option<?> extract(Parameter parameter, Invocation<SENDER> invocation) {
 
         Map<Class<?>, Contextual<SENDER, ?>> binds = this.settings.getContextualBinds();
 
-        return MapUtil.findByKeyAssignableFrom(type, binds)
+        return MapUtil.findByAssignableFromKey(type, binds)
                 .map(contextual -> contextual.extract(invocation.handle(), invocation))
                 .<Object>map(result -> result.orThrow(LiteException::new))
                 .orElse(() -> this.extract(parameter));
@@ -57,7 +57,7 @@ Option<Object> extract(Parameter parameter) {
         Class<?> type = parameter.getType();
         Map<Class<?>, TypeBind<?>> binds = this.settings.getTypeBinds();
 
-        return MapUtil.findByKeyAssignableFrom(type, binds)
+        return MapUtil.findByAssignableFromKey(type, binds)
                 .map(typeBind -> typeBind.extract(parameter));
     }
 
diff --git a/litecommands-core/src/main/java/dev/rollczi/litecommands/shared/EnumUtil.java b/litecommands-core/src/main/java/dev/rollczi/litecommands/shared/EnumUtil.java
@@ -0,0 +1,14 @@
+package dev.rollczi.litecommands.shared;
+
+import panda.std.Result;
+
+public final class EnumUtil {
+
+    private EnumUtil() {}
+
+    @SuppressWarnings("unchecked")
+    public static Result<Enum<?>, Exception> parse(Class<?> type, String argument) {
+        return Result.attempt(Exception.class, () -> Enum.valueOf((Class<? extends Enum>) type, argument));
+    }
+
+}
diff --git a/litecommands-core/src/main/java/dev/rollczi/litecommands/shared/MapUtil.java b/litecommands-core/src/main/java/dev/rollczi/litecommands/shared/MapUtil.java
@@ -8,11 +8,11 @@ public final class MapUtil {
 
     private MapUtil() {}
 
-    public static <E> Option<E> findByKeyAssignableFrom(Class<?> type, Map<Class<?>, E> map) {
-        E handler = map.get(type);
+    public static <E> Option<E> findByAssignableFromKey(Class<?> type, Map<Class<?>, E> map) {
+        E element = map.get(type);
 
-        if (handler != null) {
-            return Option.of(handler);
+        if (element != null) {
+            return Option.of(element);
         }
 
         for (Map.Entry<Class<?>, E> entry : map.entrySet()) {
diff --git a/litecommands-core/src/test/java/dev/rollczi/litecommands/AssertSuggest.java b/litecommands-core/src/test/java/dev/rollczi/litecommands/AssertSuggest.java
@@ -0,0 +1,30 @@
+package dev.rollczi.litecommands;
+
+import dev.rollczi.litecommands.command.sugesstion.SuggestionStack;
+import org.junit.jupiter.api.Assertions;
+
+import java.util.List;
+
+public class AssertSuggest {
+
+    private final SuggestionStack suggestions;
+
+    public AssertSuggest(SuggestionStack suggestions) {
+        this.suggestions = suggestions;
+    }
+
+    public void assertEmpty() {
+        Assertions.assertTrue(suggestions.suggestions().isEmpty());
+    }
+
+    public void assertWith(String... suggestions) {
+        List<String> suggestionSet = this.suggestions.multilevelSuggestions();
+
+        Assertions.assertEquals(suggestionSet.size(), suggestions.length);
+
+        for (String suggestion : suggestions) {
+            Assertions.assertTrue(suggestionSet.contains(suggestion), "Suggestion '" + suggestion + "' not found");
+        }
+    }
+
+}
diff --git a/litecommands-core/src/test/java/dev/rollczi/litecommands/TestPlatform.java b/litecommands-core/src/test/java/dev/rollczi/litecommands/TestPlatform.java
@@ -2,7 +2,6 @@
 
 import dev.rollczi.litecommands.command.FindResult;
 import dev.rollczi.litecommands.command.Invocation;
-import dev.rollczi.litecommands.command.sugesstion.SuggestionStack;
 import dev.rollczi.litecommands.command.section.CommandSection;
 import dev.rollczi.litecommands.command.execute.ExecuteResult;
 import dev.rollczi.litecommands.command.LiteInvocation;
@@ -56,20 +55,23 @@ public ExecuteResult executeLegacy(String command, String... args) {
         return ExecuteResult.failure(FindResult.none(invocation.withHandle(handle)));
     }
 
-    public void assertSuccess(String command, String... args) {
-        this.execute(command, args).assertSuccess();
+    public AssertResult execute(String command, String... args) {
+        return new AssertResult(this.executeLegacy(command, args));
     }
 
-    public void assertFail(String command, String... args) {
-        this.execute(command, args).assertSuccess();
-    }
+    public AssertSuggest suggest(String command, String... args) {
+        TestHandle handle = new TestHandle();
+        for (Map.Entry<CommandSection<TestHandle>, Command> entry : commands.entrySet()) {
+            CommandSection<TestHandle> section = entry.getKey();
 
-    public void assertInvalid(String command, String... args) {
-        this.execute(command, args).assertSuccess();
-    }
+            Invocation<TestHandle> liteInvocation = new Invocation<>(handle, new TestSender(handle), command, command, args);
 
-    public AssertResult execute(String command, String... args) {
-        return new AssertResult(this.executeLegacy(command, args));
+            if (section.isSimilar(command)) {
+                return new AssertSuggest(section.findSuggestion(liteInvocation, 0).merge());
+            }
+        }
+
+        throw new IllegalArgumentException();
     }
 
     public FindResult<TestHandle> find(String command, String... args) {
diff --git a/litecommands-core/src/test/java/dev/rollczi/litecommands/argument/PrimitiveTypeTest.java b/litecommands-core/src/test/java/dev/rollczi/litecommands/argument/PrimitiveTypeTest.java
@@ -10,40 +10,43 @@ class PrimitiveTypeTest {
 
     TestPlatform platform = TestFactory.withCommands(Command.class);
 
+    @Section(route = "test")
+    private static class Command {
+        @Execute(route = "int")             void test(@Arg int __) {}
+        @Execute(route = "int-object")      void test(@Arg Integer __) {}
+
+        @Execute(route = "float")           void test(@Arg float __) {}
+        @Execute(route = "float-object")    void test(@Arg Float __) {}
+
+        @Execute(route = "double")          void test(@Arg double __) {}
+        @Execute(route = "double-object")   void test(@Arg Double __) {}
+
+        @Execute(route = "boolean")         void test(@Arg boolean __) {}
+        @Execute(route = "boolean-object")  void test(@Arg Boolean __) {}
+    }
+
     @Test
     void testInt() {
-        platform.assertSuccess("test", "int", "1");
-        platform.assertSuccess("test", "int-object", "1");
+        platform.execute("test", "int", "1").assertSuccess();
+        platform.execute("test", "int-object", "1").assertSuccess();
     }
 
     @Test
     void testFloat() {
-        platform.assertSuccess("test", "float", "0.5F");
-        platform.assertSuccess("test", "float-object", "0.5F");
+        platform.execute("test", "float", "0.5F").assertSuccess();
+        platform.execute("test", "float-object", "0.5F").assertSuccess();
     }
 
     @Test
     void testDouble() {
-        platform.assertSuccess("test", "double", "0.5D");
-        platform.assertSuccess("test", "double-object", "0.5D");
+        platform.execute("test", "double", "0.5D").assertSuccess();
+        platform.execute("test", "double-object", "0.5D").assertSuccess();
     }
 
     @Test
     void testBoolean() {
-        platform.assertSuccess("test", "boolean", "true");
-        platform.assertSuccess("test", "boolean-object", "false");
-    }
-
-    @Section(route = "test")
-    private static class Command {
-        @Execute(route = "int") void test(@Arg int __) {}
-        @Execute(route = "int-object") void test(@Arg Integer __) {}
-        @Execute(route = "float") void test(@Arg float __) {}
-        @Execute(route = "float-object") void test(@Arg Float __) {}
-        @Execute(route = "double") void test(@Arg double __) {}
-        @Execute(route = "double-object") void test(@Arg Double __) {}
-        @Execute(route = "boolean") void test(@Arg boolean __) {}
-        @Execute(route = "boolean-object") void test(@Arg Boolean __) {}
+        platform.execute("test", "boolean", "true").assertSuccess();
+        platform.execute("test", "boolean-object", "false").assertSuccess();
     }
 
 }
diff --git a/litecommands-core/src/test/java/dev/rollczi/litecommands/implementation/EnumArgumentTest.java b/litecommands-core/src/test/java/dev/rollczi/litecommands/implementation/EnumArgumentTest.java

Original file line number	Diff line number	Diff line change
`@@ -5,11 +5,11 @@`
`5`	`5`	`public interface ParameterHandler {`
`6`	`6`
`7`	`7`	`default boolean canHandle(Class<?> type, Parameter parameter) {`
`8`		`- return type.equals(parameter.getType());`
	`8`	`+ return parameter.getType().equals(type);`
`9`	`9`	`}`
`10`	`10`
`11`	`11`	`default boolean canHandleAssignableFrom(Class<?> type, Parameter parameter) {`
`12`		`- return type.isAssignableFrom(parameter.getType());`
	`12`	`+ return parameter.getType().isAssignableFrom(type);`
`13`	`13`	`}`
`14`	`14`
`15`	`15`	`}`
Original file line number	Diff line number	Diff line change
`@@ -49,4 +49,14 @@ public Option<String> getSchematic(Block annotation) {`
`49`	`49`	`return Option.of(annotation.value());`
`50`	`50`	`}`
`51`	`51`
	`52`	`+ @Override`
	`53`	`+ public boolean canHandle(Class<?> type, Parameter parameter) {`
	`54`	`+ return true;`
	`55`	`+ }`
	`56`	`+`
	`57`	`+ @Override`
	`58`	`+ public boolean canHandleAssignableFrom(Class<?> type, Parameter parameter) {`
	`59`	`+ return true;`
	`60`	`+ }`
	`61`	`+`
`52`	`62`	`}`
Original file line number	Diff line number	Diff line change
`@@ -87,7 +87,7 @@ public boolean canHandle(Class<?> type, Parameter parameter) {`
`87`	`87`	`@Override`
`88`	`88`	`public boolean canHandleAssignableFrom(Class<?> type, Parameter parameter) {`
`89`	`89`	`return OptionUtils.extractOptionType(parameter)`
`90`		`- .map(type::isAssignableFrom)`
	`90`	`+ .map(paramType -> paramType.isAssignableFrom(type))`
`91`	`91`	`.orElseGet(false);`
`92`	`92`	`}`
`93`	`93`
Original file line number	Diff line number	Diff line change
`@@ -81,7 +81,7 @@ private CommandState createState(Object instance) {`
`81`	`81`
`82`	`82`	`for (Annotation annotation : sectionClass.getAnnotations()) {`
`83`	`83`	`for (FactoryAnnotationResolver<? extends Annotation> resolver : annotationResolvers) {`
`84`		`- if (!annotation.annotationType().isAssignableFrom(resolver.getAnnotationClass())) {`
	`84`	`+ if (!annotation.annotationType().equals(resolver.getAnnotationClass())) {`
`85`	`85`	`continue;`
`86`	`86`	`}`
`87`	`87`
`@@ -100,7 +100,7 @@ private CommandState createState(Object instance) {`
`100`	`100`
`101`	`101`	`for (Annotation annotation : method.getAnnotations()) {`
`102`	`102`	`for (FactoryAnnotationResolver<? extends Annotation> resolver : annotationResolvers) {`
`103`		`- if (!annotation.annotationType().isAssignableFrom(resolver.getAnnotationClass())) {`
	`103`	`+ if (!annotation.annotationType().equals(resolver.getAnnotationClass())) {`
`104`	`104`	`continue;`
`105`	`105`	`}`
`106`	`106`