diff --git a/gradle/libs.versions.toml b/gradle/libs.versions.toml index 5963d01..fb7c6f0 100644 --- a/gradle/libs.versions.toml +++ b/gradle/libs.versions.toml @@ -8,7 +8,7 @@ javacord = "3.8.0" discord4j = "3.2.7" geantyref = "2.0.0" mockito = "5.15.2" -cutin = "0.1.0" +cutin = "0.1.1-cad019e" [libraries] junit-jupiter = { module = "org.junit.jupiter:junit-jupiter", version.ref = "junit-jupiter" } @@ -17,4 +17,4 @@ javacord = { module = "org.javacord:javacord", version.ref = "javacord"} discord4j = { module = "com.discord4j:discord4j-core", version.ref = "discord4j"} geantyref = { module = "io.leangen.geantyref:geantyref", version.ref = "geantyref"} mockito = {module = "org.mockito:mockito-core", version.ref = "mockito"} -cutin = {module = "net.tomatentum.cutin:lib", version.ref = "cutin"} +cutin = {module = "net.tomatentum.cutin:lib-dev", version.ref = "cutin"} diff --git a/lib/build.gradle.kts b/lib/build.gradle.kts index 25b66fd..5144454 100644 --- a/lib/build.gradle.kts +++ b/lib/build.gradle.kts @@ -17,7 +17,7 @@ dependencies { testRuntimeOnly("org.junit.platform:junit-platform-launcher") implementation(libs.slf4j) implementation(libs.geantyref) - implementation(libs.cutin) + api(libs.cutin) } // Apply a specific Java toolchain to ease working on different environments. diff --git a/lib/src/main/java/net/tomatentum/marinara/Marinara.java b/lib/src/main/java/net/tomatentum/marinara/Marinara.java index 77c57d7..643271c 100644 --- a/lib/src/main/java/net/tomatentum/marinara/Marinara.java +++ b/lib/src/main/java/net/tomatentum/marinara/Marinara.java @@ -1,17 +1,25 @@ package net.tomatentum.marinara; +import java.util.Arrays; +import java.util.List; + import org.slf4j.Logger; +import net.tomatentum.cutin.MethodExecutor; +import net.tomatentum.cutin.ProcessorMethodExecutor; +import net.tomatentum.cutin.container.MethodContainer; +import net.tomatentum.marinara.checks.CheckExecutionContext; +import net.tomatentum.marinara.checks.CheckMethodIdentifier; +import net.tomatentum.marinara.container.InteractionCheckContainer; +import net.tomatentum.marinara.container.InteractionMethodContainer; import net.tomatentum.marinara.interaction.InteractionType; +import net.tomatentum.marinara.interaction.commands.SlashCommandDefinition; +import net.tomatentum.marinara.interaction.ident.InteractionIdentifier; +import net.tomatentum.marinara.interaction.ident.RootCommandIdentifier; import net.tomatentum.marinara.interaction.processor.AutocompleteInteractionProcessor; import net.tomatentum.marinara.interaction.processor.DirectInteractionProcessor; -import net.tomatentum.marinara.reflection.MethodExecutor; -import net.tomatentum.marinara.reflection.ProcessorMethodExecutor; -import net.tomatentum.marinara.reflection.ReflectedMethodFactory; -import net.tomatentum.marinara.reflection.ReflectedMethodFactoryImpl; -import net.tomatentum.marinara.registry.InteractionCheckRegistry; -import net.tomatentum.marinara.registry.InteractionRegistry; import net.tomatentum.marinara.util.LoggerUtil; +import net.tomatentum.marinara.util.ObjectAggregator; import net.tomatentum.marinara.wrapper.IdentifierProvider; import net.tomatentum.marinara.wrapper.LibraryWrapper; @@ -24,41 +32,53 @@ public class Marinara { } private LibraryWrapper wrapper; - private ReflectedMethodFactory reflectedMethodFactory; - private InteractionRegistry registry; - private InteractionCheckRegistry checkRegistry; - private MethodExecutor interactionExecutor; + private MethodContainer checkContainer; + private MethodContainer interactionContainer; + private MethodExecutor interactionExecutor; private Marinara(LibraryWrapper wrapper) { this.wrapper = wrapper; - this.reflectedMethodFactory = new ReflectedMethodFactoryImpl(this); - this.registry = new InteractionRegistry(this); - this.checkRegistry = new InteractionCheckRegistry(); + this.checkContainer = new InteractionCheckContainer(); + this.interactionContainer = new InteractionMethodContainer(getCheckContainer(), getWrapper().getContextObjectProvider()); IdentifierProvider provider = wrapper.createIdentifierProvider(); - this.interactionExecutor = (MethodExecutor) new ProcessorMethodExecutor() - .addProcessor(new DirectInteractionProcessor(getRegistry(), provider, InteractionType.COMMAND, InteractionType.BUTTON)) - .addProcessor(new AutocompleteInteractionProcessor(this, provider)); + ProcessorMethodExecutor exec = new ProcessorMethodExecutor<>(getInteractionContainer()); + exec + .addProcessor(new DirectInteractionProcessor(provider, InteractionType.COMMAND, InteractionType.BUTTON)) + .addProcessor(new AutocompleteInteractionProcessor(getWrapper(), provider)); + this.interactionExecutor = exec; wrapper.subscribeInteractions(this.interactionExecutor::handle); logger.info("Marinara loaded successfully!"); } + //TODO move to future interactionstructure module + public void registerCommands() { + List slashIdentifiers = getInteractionContainer().identifiers().stream() + .filter(i -> i.type().equals(InteractionType.COMMAND)) + .toList(); + + SlashCommandDefinition[] defs = new ObjectAggregator( + i -> Arrays.asList((RootCommandIdentifier)i.rootNode()), + SlashCommandDefinition::addIdentifier, + SlashCommandDefinition::new) + .aggregate(slashIdentifiers) + .toArray(SlashCommandDefinition[]::new); + + wrapper.getRegisterer().register(defs); + } + public LibraryWrapper getWrapper() { return this.wrapper; } - public InteractionRegistry getRegistry() { - return this.registry; + public MethodContainer getInteractionContainer() { + return this.interactionContainer; } - public InteractionCheckRegistry getCheckRegistry() { - return this.checkRegistry; + public MethodContainer getCheckContainer() { + return this.checkContainer; } - public ReflectedMethodFactory getReflectedMethodFactory() { - return this.reflectedMethodFactory; - } - - public MethodExecutor getInteractionExecutor() { + public MethodExecutor getInteractionExecutor() { return interactionExecutor; } diff --git a/lib/src/main/java/net/tomatentum/marinara/checks/AppliedCheck.java b/lib/src/main/java/net/tomatentum/marinara/checks/AppliedCheck.java index c20cf5a..50431ce 100644 --- a/lib/src/main/java/net/tomatentum/marinara/checks/AppliedCheck.java +++ b/lib/src/main/java/net/tomatentum/marinara/checks/AppliedCheck.java @@ -1,50 +1,28 @@ package net.tomatentum.marinara.checks; import java.lang.annotation.Annotation; -import java.lang.reflect.InvocationTargetException; -import java.lang.reflect.Method; -import java.util.Arrays; import org.slf4j.Logger; +import net.tomatentum.cutin.method.ReflectedMethod; import net.tomatentum.marinara.util.LoggerUtil; -import net.tomatentum.marinara.util.ReflectionUtil; -public record AppliedCheck(InteractionCheck check, Annotation annotation) { +public record AppliedCheck( + Annotation annotation, + ReflectedMethod preExec, + ReflectedMethod postExec + ) { + + private static Logger logger = LoggerUtil.getLogger(AppliedCheck.class); - private static Logger logger = LoggerUtil.getLogger(AppliedCheck.class); - public boolean pre(Object context) { - Method[] methods = Arrays.stream(check.getClass().getMethods()) - .filter(x -> x.getName().equals("preExec")) - .filter(x -> !x.isBridge()) - .toArray(s -> new Method[s]); - Method method = ReflectionUtil.getMostSpecificMethod(methods, context.getClass(), annotation.annotationType()); - method.setAccessible(true); - try { - logger.debug("Executing pre check {} with context {}", check.getClass().getName(), context.toString()); - boolean result = (boolean) method.invoke(check, context, annotation); - logger.debug("Pre Check {} {} with context {}", check.getClass().getName(), result ? "succeeded" : "failed", context.toString()); - return result; - } catch (IllegalAccessException | InvocationTargetException | SecurityException e) { - logger.error("Failed executing pre-check", e); - return false; - } + logger.debug("Running InteractionCheck preExec {} with annotation {}", preExec(), annotation()); + return (boolean) preExec().run(new CheckExecutionContext(annotation, context)); } public void post(Object context) { - Method[] methods = Arrays.stream(check.getClass().getMethods()) - .filter(x -> x.getName().equals("postExec")) - .filter(x -> !x.isBridge()) - .toArray(s -> new Method[s]); - Method method = ReflectionUtil.getMostSpecificMethod(methods, context.getClass(), annotation.annotationType()); - method.setAccessible(true); - try { - logger.debug("Executing post check {} with context {}", check.getClass().getName(), context.toString()); - method.invoke(check, context, annotation); - } catch (IllegalAccessException | InvocationTargetException | SecurityException e) { - logger.error("Failed executing post-check", e); - } + logger.debug("Running InteractionCheck postExec {} with annotation {}", postExec(), annotation()); + postExec().run(new CheckExecutionContext(annotation, context)); } } diff --git a/lib/src/main/java/net/tomatentum/marinara/checks/CheckExecutionContext.java b/lib/src/main/java/net/tomatentum/marinara/checks/CheckExecutionContext.java new file mode 100644 index 0000000..4dfbdac --- /dev/null +++ b/lib/src/main/java/net/tomatentum/marinara/checks/CheckExecutionContext.java @@ -0,0 +1,7 @@ +package net.tomatentum.marinara.checks; + +import java.lang.annotation.Annotation; + +public record CheckExecutionContext(Annotation annotation, Object originalContext) { + +} diff --git a/lib/src/main/java/net/tomatentum/marinara/checks/CheckMethodIdentifier.java b/lib/src/main/java/net/tomatentum/marinara/checks/CheckMethodIdentifier.java new file mode 100644 index 0000000..af3ca01 --- /dev/null +++ b/lib/src/main/java/net/tomatentum/marinara/checks/CheckMethodIdentifier.java @@ -0,0 +1,27 @@ +package net.tomatentum.marinara.checks; + +import java.lang.reflect.Type; + +public record CheckMethodIdentifier(Type annotationType, CheckMethodType type) { + + public enum CheckMethodType { + PRE("preExec"), + POST("postExec"); + + private String methodName; + + private CheckMethodType(String methodName) { + this.methodName = methodName; + } + + public String methodName() { + return this.methodName; + } + } + + @Override + public final String toString() { + return "InteractionCheck(%s, %s)".formatted(annotationType, type); + } + +} diff --git a/lib/src/main/java/net/tomatentum/marinara/checks/InteractionCheckMethod.java b/lib/src/main/java/net/tomatentum/marinara/checks/InteractionCheckMethod.java new file mode 100644 index 0000000..0774f26 --- /dev/null +++ b/lib/src/main/java/net/tomatentum/marinara/checks/InteractionCheckMethod.java @@ -0,0 +1,66 @@ +package net.tomatentum.marinara.checks; + +import java.util.List; +import java.util.Optional; + +import net.tomatentum.cutin.MethodParser; +import net.tomatentum.cutin.container.MethodContainer; +import net.tomatentum.cutin.method.BestCandidateMethod; +import net.tomatentum.cutin.method.ReflectedMethod; +import net.tomatentum.marinara.checks.CheckMethodIdentifier.CheckMethodType; +import net.tomatentum.marinara.parser.InteractionCheckClassParser; + +public class InteractionCheckMethod extends BestCandidateMethod { + + private CheckMethodIdentifier identifier; + + public InteractionCheckMethod(String methodName, Object containingObject) { + super(methodName, containingObject); + } + + @Override + public Object getParameter(CheckExecutionContext context, int index) { + switch (index) { + case 0: + return context.originalContext(); + case 1: + return context.annotation(); + default: + return null; + } + } + + @Override + public CheckMethodIdentifier identifier() { + return this.identifier; + } + + public static class InteractionCheckMethodFactory extends BestCandidateMethod.Factory { + + private CheckMethodType type; + + public InteractionCheckMethodFactory(MethodContainer methodContainer, CheckMethodType type) { + super(methodContainer, type.methodName()); + this.type = type; + } + + @SuppressWarnings("unchecked") + @Override + public void addParser(ReflectedMethod method, List parsers) { + parsers.add( + new InteractionCheckClassParser((Class>) method.containingObject().getClass(), + a -> ((InteractionCheckMethod) method).identifier = new CheckMethodIdentifier(a, type)) + ); + } + + @Override + protected Optional> bcProduce(String methodName, + Object containingObject) { + if (!(containingObject instanceof InteractionCheck)) + return Optional.empty(); + return Optional.of(new InteractionCheckMethod(methodName, containingObject)); + } + + } + +} diff --git a/lib/src/main/java/net/tomatentum/marinara/container/InteractionCheckContainer.java b/lib/src/main/java/net/tomatentum/marinara/container/InteractionCheckContainer.java new file mode 100644 index 0000000..11f8271 --- /dev/null +++ b/lib/src/main/java/net/tomatentum/marinara/container/InteractionCheckContainer.java @@ -0,0 +1,19 @@ +package net.tomatentum.marinara.container; + +import net.tomatentum.cutin.ReflectedMethodFactoryImpl; +import net.tomatentum.cutin.container.LoneMethodContainer; +import net.tomatentum.marinara.checks.CheckExecutionContext; +import net.tomatentum.marinara.checks.CheckMethodIdentifier; +import net.tomatentum.marinara.checks.CheckMethodIdentifier.CheckMethodType; +import net.tomatentum.marinara.checks.InteractionCheckMethod.InteractionCheckMethodFactory; + +public class InteractionCheckContainer extends LoneMethodContainer { + + public InteractionCheckContainer() { + super(new ReflectedMethodFactoryImpl<>()); + super.factory() + .addFactory(new InteractionCheckMethodFactory(this, CheckMethodType.PRE)) + .addFactory(new InteractionCheckMethodFactory(this, CheckMethodType.POST)); + } + +} diff --git a/lib/src/main/java/net/tomatentum/marinara/container/InteractionMethodContainer.java b/lib/src/main/java/net/tomatentum/marinara/container/InteractionMethodContainer.java new file mode 100644 index 0000000..0223c95 --- /dev/null +++ b/lib/src/main/java/net/tomatentum/marinara/container/InteractionMethodContainer.java @@ -0,0 +1,38 @@ +package net.tomatentum.marinara.container; + +import net.tomatentum.cutin.ReflectedMethodFactory; +import net.tomatentum.cutin.ReflectedMethodFactoryImpl; +import net.tomatentum.cutin.container.MethodContainer; +import net.tomatentum.cutin.container.MultiMethodContainer; +import net.tomatentum.cutin.method.ReflectedMethod; +import net.tomatentum.marinara.checks.CheckExecutionContext; +import net.tomatentum.marinara.checks.CheckMethodIdentifier; +import net.tomatentum.marinara.interaction.components.methods.ButtonInteractionMethod; +import net.tomatentum.marinara.interaction.ident.InteractionIdentifier; +import net.tomatentum.marinara.wrapper.ContextObjectProvider; +import net.tomatentum.marinara.interaction.methods.AutoCompleteInteractionMethod; +import net.tomatentum.marinara.interaction.methods.SlashCommandInteractionMethod; + +public class InteractionMethodContainer extends MultiMethodContainer { + + + private static ReflectedMethodFactory createFactory(MethodContainer checkRegistry, ContextObjectProvider cop) { + return new ReflectedMethodFactoryImpl() + .addFactory(new AutoCompleteInteractionMethod.Factory(checkRegistry, cop)) + .addFactory(new SlashCommandInteractionMethod.Factory(checkRegistry, cop)) + .addFactory(new ButtonInteractionMethod.Factory(checkRegistry, cop)); + } + + public InteractionMethodContainer(MethodContainer checkRegistry, ContextObjectProvider cop) { + super(createFactory(checkRegistry, cop)); + } + + @Override + public MethodContainer addMethod(ReflectedMethod method) { + super.identifiers().stream() + .filter(method.identifier()::equals) + .forEach(i -> InteractionIdentifier.tryAddDescriptions(i, method.identifier())); + return super.addMethod(method); + } + +} diff --git a/lib/src/main/java/net/tomatentum/marinara/interaction/components/methods/ButtonInteractionMethod.java b/lib/src/main/java/net/tomatentum/marinara/interaction/components/methods/ButtonInteractionMethod.java index 7fd45a5..ffb4c0d 100644 --- a/lib/src/main/java/net/tomatentum/marinara/interaction/components/methods/ButtonInteractionMethod.java +++ b/lib/src/main/java/net/tomatentum/marinara/interaction/components/methods/ButtonInteractionMethod.java @@ -4,28 +4,37 @@ import java.lang.reflect.Method; import java.util.List; import java.util.Optional; -import net.tomatentum.marinara.Marinara; +import net.tomatentum.cutin.MethodParser; +import net.tomatentum.cutin.container.MethodContainer; +import net.tomatentum.cutin.method.ReflectedMethod; +import net.tomatentum.marinara.checks.CheckExecutionContext; +import net.tomatentum.marinara.checks.CheckMethodIdentifier; import net.tomatentum.marinara.interaction.InteractionHandler; import net.tomatentum.marinara.interaction.InteractionType; import net.tomatentum.marinara.interaction.annotation.Button; import net.tomatentum.marinara.interaction.ident.InteractionIdentifier; import net.tomatentum.marinara.interaction.methods.InteractionMethod; -import net.tomatentum.marinara.parser.AnnotationParser; import net.tomatentum.marinara.parser.ButtonParser; -import net.tomatentum.marinara.reflection.ReflectedMethod; +import net.tomatentum.marinara.wrapper.ContextObjectProvider; public class ButtonInteractionMethod extends InteractionMethod { private String customId; + private ContextObjectProvider cop; - private ButtonInteractionMethod(Method method, InteractionHandler handler, Marinara marinara) { - super(method, handler, marinara); + private ButtonInteractionMethod(Method method, InteractionHandler handler, ContextObjectProvider cop) { + super(method, handler); + this.cop = cop; } @Override public Object getParameter(Object context, int index) { - Class type = method().getParameterTypes()[index+1]; - return marinara.getWrapper().getContextObjectProvider().getComponentContextObject(context, type); + Class type = method().getParameterTypes()[index]; + Object superResult = super.getParameter(context, index); + if (superResult == null) + return this.cop.getComponentContextObject(context, type); + else + return superResult; } @Override @@ -39,19 +48,26 @@ public class ButtonInteractionMethod extends InteractionMethod { public static class Factory extends InteractionMethod.Factory { + private ContextObjectProvider cop; + + public Factory(MethodContainer checkContainer, ContextObjectProvider cop) { + super(checkContainer); + this.cop = cop; + } + @Override - public Optional produce(Marinara marinara, Method method, Object containingObject) { - ReflectedMethod rMethod = null; + public Optional> produce(Method method, Object containingObject) { + ButtonInteractionMethod rMethod = null; if (method.isAnnotationPresent(Button.class) && (containingObject instanceof InteractionHandler iHandler) ) - rMethod = new ButtonInteractionMethod(method, iHandler, marinara); + rMethod = new ButtonInteractionMethod(method, iHandler, this.cop); return Optional.ofNullable(rMethod); } @Override - public void addParser(ReflectedMethod method, List parser) { + public void addParser(ReflectedMethod method, List parser) { super.addParser(method, parser); parser.add( diff --git a/lib/src/main/java/net/tomatentum/marinara/interaction/methods/AutoCompleteInteractionMethod.java b/lib/src/main/java/net/tomatentum/marinara/interaction/methods/AutoCompleteInteractionMethod.java index af100e5..a00c008 100644 --- a/lib/src/main/java/net/tomatentum/marinara/interaction/methods/AutoCompleteInteractionMethod.java +++ b/lib/src/main/java/net/tomatentum/marinara/interaction/methods/AutoCompleteInteractionMethod.java @@ -4,40 +4,45 @@ import java.lang.reflect.Method; import java.util.List; import java.util.Optional; -import net.tomatentum.marinara.Marinara; +import net.tomatentum.cutin.MethodParser; +import net.tomatentum.cutin.container.MethodContainer; +import net.tomatentum.cutin.method.ReflectedMethod; +import net.tomatentum.marinara.checks.CheckExecutionContext; +import net.tomatentum.marinara.checks.CheckMethodIdentifier; import net.tomatentum.marinara.interaction.InteractionHandler; import net.tomatentum.marinara.interaction.InteractionType; import net.tomatentum.marinara.interaction.annotation.AutoComplete; import net.tomatentum.marinara.interaction.commands.annotation.SlashCommand; import net.tomatentum.marinara.interaction.commands.annotation.SubCommand; import net.tomatentum.marinara.interaction.ident.InteractionIdentifier; -import net.tomatentum.marinara.parser.AnnotationParser; import net.tomatentum.marinara.parser.AutocompleteParser; -import net.tomatentum.marinara.reflection.ReflectedMethod; +import net.tomatentum.marinara.wrapper.ContextObjectProvider; public class AutoCompleteInteractionMethod extends InteractionMethod { private String autocompleteRef; + private ContextObjectProvider cop; private AutoCompleteInteractionMethod(Method method, InteractionHandler handler, - Marinara marinara + ContextObjectProvider cop ) { - super(method, handler, marinara); + super(method, handler); + this.cop = cop; } @Override public Object getParameter(Object context, int index) { - Class type = method().getParameterTypes()[index+1]; - Object contextObject = marinara.getWrapper().getContextObjectProvider().getInteractionContextObject(context, type); + Class type = method().getParameterTypes()[index]; + Object contextObject = this.cop.getInteractionContextObject(context, type); if (contextObject != null) return contextObject; - Object autocompleteOptionValue = marinara.getWrapper().getContextObjectProvider().getAutocompleteFocusedOption(context).input(); + Object autocompleteOptionValue = this.cop.getAutocompleteFocusedOption(context).input(); if (type.isInstance(autocompleteOptionValue)) return autocompleteOptionValue; - return null; + return super.getParameter(context, index); } @Override @@ -51,20 +56,27 @@ public class AutoCompleteInteractionMethod extends InteractionMethod { public static class Factory extends InteractionMethod.Factory { + private ContextObjectProvider cop; + + public Factory(MethodContainer checkContainer, ContextObjectProvider cop) { + super(checkContainer); + this.cop = cop; + } + @Override - public Optional produce(Marinara marinara, Method method, Object containingObject) { - ReflectedMethod rMethod = null; + public Optional> produce(Method method, Object containingObject) { + AutoCompleteInteractionMethod rMethod = null; if ((containingObject instanceof InteractionHandler iHandler) && method.isAnnotationPresent(AutoComplete.class) && !(method.isAnnotationPresent(SlashCommand.class) || method.isAnnotationPresent(SubCommand.class))) - rMethod = new AutoCompleteInteractionMethod(method, iHandler, marinara); + rMethod = new AutoCompleteInteractionMethod(method, iHandler, cop); return Optional.ofNullable(rMethod); } @Override - public void addParser(ReflectedMethod method, List parser) { + public void addParser(ReflectedMethod method, List parser) { super.addParser(method, parser); parser.add( diff --git a/lib/src/main/java/net/tomatentum/marinara/interaction/methods/InteractionMethod.java b/lib/src/main/java/net/tomatentum/marinara/interaction/methods/InteractionMethod.java index caaa884..7dd316f 100644 --- a/lib/src/main/java/net/tomatentum/marinara/interaction/methods/InteractionMethod.java +++ b/lib/src/main/java/net/tomatentum/marinara/interaction/methods/InteractionMethod.java @@ -4,29 +4,35 @@ import java.lang.reflect.Method; import java.util.ArrayList; import java.util.List; -import net.tomatentum.marinara.Marinara; +import net.tomatentum.cutin.MethodParser; +import net.tomatentum.cutin.ReflectedMethodFactory; +import net.tomatentum.cutin.container.MethodContainer; +import net.tomatentum.cutin.method.ReflectedMethod; import net.tomatentum.marinara.checks.AppliedCheck; +import net.tomatentum.marinara.checks.CheckExecutionContext; +import net.tomatentum.marinara.checks.CheckMethodIdentifier; import net.tomatentum.marinara.interaction.InteractionHandler; import net.tomatentum.marinara.interaction.ident.InteractionIdentifier; -import net.tomatentum.marinara.parser.AnnotationParser; import net.tomatentum.marinara.parser.InteractionCheckParser; -import net.tomatentum.marinara.reflection.ReflectedMethod; -import net.tomatentum.marinara.reflection.ReflectedMethodFactory; -public abstract class InteractionMethod extends ReflectedMethod { +public abstract class InteractionMethod extends ReflectedMethod { - protected Marinara marinara; protected List appliedChecks; protected InteractionMethod( Method method, - InteractionHandler handler, - Marinara marinara + InteractionHandler handler ) { super(method, handler); - this.marinara = marinara; this.appliedChecks = new ArrayList<>(); } + + @Override + public Object getParameter(Object context, int index) { + if (index == 0) + return context; + return null; + } @Override public Object run(Object context) { @@ -41,23 +47,23 @@ public abstract class InteractionMethod extends ReflectedMethod { return result; } - public abstract InteractionIdentifier identifier(); - - public Marinara marinara() { - return this.marinara; - } - public List appliedChecks() { return this.appliedChecks; } - public abstract static class Factory implements ReflectedMethodFactory.Factory { + public abstract static class Factory implements ReflectedMethodFactory.Factory { + + private MethodContainer checkContainer; + + protected Factory(MethodContainer checkContainer) { + this.checkContainer = checkContainer; + } @Override - public void addParser(ReflectedMethod method, List parser) { + public void addParser(ReflectedMethod method, List parser) { InteractionMethod imethod = (InteractionMethod) method; parser.add( - new InteractionCheckParser(method.method(), imethod.appliedChecks::add, imethod.marinara().getCheckRegistry()) + new InteractionCheckParser(method.method(), imethod.appliedChecks::add, this.checkContainer) ); } diff --git a/lib/src/main/java/net/tomatentum/marinara/interaction/methods/SlashCommandInteractionMethod.java b/lib/src/main/java/net/tomatentum/marinara/interaction/methods/SlashCommandInteractionMethod.java index a6bd130..8afa595 100644 --- a/lib/src/main/java/net/tomatentum/marinara/interaction/methods/SlashCommandInteractionMethod.java +++ b/lib/src/main/java/net/tomatentum/marinara/interaction/methods/SlashCommandInteractionMethod.java @@ -4,27 +4,36 @@ import java.lang.reflect.Method; import java.util.List; import java.util.Optional; -import net.tomatentum.marinara.Marinara; +import net.tomatentum.cutin.MethodParser; +import net.tomatentum.cutin.container.MethodContainer; +import net.tomatentum.cutin.method.ReflectedMethod; +import net.tomatentum.marinara.checks.CheckExecutionContext; +import net.tomatentum.marinara.checks.CheckMethodIdentifier; import net.tomatentum.marinara.interaction.InteractionHandler; import net.tomatentum.marinara.interaction.commands.annotation.SlashCommand; import net.tomatentum.marinara.interaction.commands.annotation.SubCommand; import net.tomatentum.marinara.interaction.ident.InteractionIdentifier; import net.tomatentum.marinara.interaction.ident.SlashCommandIdentifier; -import net.tomatentum.marinara.parser.AnnotationParser; import net.tomatentum.marinara.parser.SlashCommandParser; -import net.tomatentum.marinara.reflection.ReflectedMethod; +import net.tomatentum.marinara.wrapper.ContextObjectProvider; public class SlashCommandInteractionMethod extends InteractionMethod { private SlashCommandIdentifier interactionIdentifier; + private ContextObjectProvider cop; - private SlashCommandInteractionMethod(Method method, InteractionHandler handler, Marinara marinara) { - super(method, handler, marinara); + private SlashCommandInteractionMethod(Method method, InteractionHandler handler, ContextObjectProvider cop) { + super(method, handler); + this.cop = cop; } @Override public Object getParameter(Object context, int index) { - return marinara.getWrapper().getContextObjectProvider().convertCommandOption(context, interactionIdentifier.options()[index].name()); + Object superResult = super.getParameter(context, index); + if (superResult == null) + return this.cop.convertCommandOption(context, interactionIdentifier.options()[index-1].name()); + else + return superResult; } @Override @@ -34,18 +43,25 @@ public class SlashCommandInteractionMethod extends InteractionMethod { public static class Factory extends InteractionMethod.Factory { + private ContextObjectProvider cop; + + public Factory(MethodContainer checkContainer, ContextObjectProvider cop) { + super(checkContainer); + this.cop = cop; + } + @Override - public Optional produce(Marinara marinara, Method method, Object containingObject) { - ReflectedMethod rMethod = null; + public Optional> produce(Method method, Object containingObject) { + SlashCommandInteractionMethod rMethod = null; if ((containingObject instanceof InteractionHandler iHandler) && (method.isAnnotationPresent(SlashCommand.class) || method.isAnnotationPresent(SubCommand.class))) - rMethod = new SlashCommandInteractionMethod(method, iHandler, marinara); + rMethod = new SlashCommandInteractionMethod(method, iHandler, cop); return Optional.ofNullable(rMethod); } @Override - public void addParser(ReflectedMethod method, List parser) { + public void addParser(ReflectedMethod method, List parser) { super.addParser(method, parser); parser.add( diff --git a/lib/src/main/java/net/tomatentum/marinara/interaction/processor/AutocompleteInteractionProcessor.java b/lib/src/main/java/net/tomatentum/marinara/interaction/processor/AutocompleteInteractionProcessor.java index b194946..1d02b92 100644 --- a/lib/src/main/java/net/tomatentum/marinara/interaction/processor/AutocompleteInteractionProcessor.java +++ b/lib/src/main/java/net/tomatentum/marinara/interaction/processor/AutocompleteInteractionProcessor.java @@ -6,37 +6,38 @@ import java.util.Objects; import java.util.Optional; import java.util.Set; -import net.tomatentum.marinara.Marinara; +import net.tomatentum.cutin.container.MethodContainer; import net.tomatentum.marinara.interaction.InteractionType; import net.tomatentum.marinara.interaction.ident.InteractionIdentifier; import net.tomatentum.marinara.interaction.ident.SlashCommandIdentifier; -import net.tomatentum.marinara.registry.InteractionEntry; import net.tomatentum.marinara.wrapper.IdentifierProvider; +import net.tomatentum.marinara.wrapper.LibraryWrapper; public class AutocompleteInteractionProcessor extends InteractionMethodProcessor { - private Marinara marinara; + private LibraryWrapper wrapper; - public AutocompleteInteractionProcessor(Marinara marinara, IdentifierProvider provider) { + public AutocompleteInteractionProcessor(LibraryWrapper wrapper, IdentifierProvider provider) { super(provider, Set.of(InteractionType.AUTOCOMPLETE)); - this.marinara = marinara; + this.wrapper = wrapper; } @Override - public void processInteraction(Object context, InteractionIdentifier identifier) { - Optional entry = this.marinara.getRegistry().findFor(convertToCommandIdentifier(identifier)); - if (entry.isPresent() && entry.get().identifier() instanceof SlashCommandIdentifier sIdent) { - List autocompleteRefs = Arrays.asList(this.marinara.getWrapper().getContextObjectProvider() + public void processInteraction(Object context, MethodContainer container, InteractionIdentifier identifier) { + Optional oIdent = container.identifiers().stream() + .filter(i -> convertToCommandIdentifier(identifier).equals(i)) + .findFirst(); + if (oIdent.isPresent() && oIdent.get() instanceof SlashCommandIdentifier sIdent) { + List autocompleteRefs = Arrays.asList(this.wrapper.getContextObjectProvider() .getAutocompleteFocusedOption(context).getAutocompleteRefs(sIdent.options())); - List results = this.marinara.getRegistry().interactions().stream() - .filter(e -> e.type().equals(InteractionType.AUTOCOMPLETE)) - .filter(e -> autocompleteRefs.contains(e.identifier().name())) - .map(e -> e.runAll(context)) - .flatMap(Arrays::stream) + List results = container.methods().stream() + .filter(m -> m.identifier().type().equals(InteractionType.AUTOCOMPLETE)) + .filter(m -> autocompleteRefs.contains(m.identifier().name())) + .map(m -> m.run(context)) .filter(Objects::nonNull) .toList(); if (!results.isEmpty()) - marinara.getWrapper().respondAutocomplete(context, results); + this.wrapper.respondAutocomplete(context, results); } } diff --git a/lib/src/main/java/net/tomatentum/marinara/interaction/processor/DirectInteractionProcessor.java b/lib/src/main/java/net/tomatentum/marinara/interaction/processor/DirectInteractionProcessor.java index 3d1cf7a..6856d2f 100644 --- a/lib/src/main/java/net/tomatentum/marinara/interaction/processor/DirectInteractionProcessor.java +++ b/lib/src/main/java/net/tomatentum/marinara/interaction/processor/DirectInteractionProcessor.java @@ -2,26 +2,21 @@ package net.tomatentum.marinara.interaction.processor; import java.util.Set; +import net.tomatentum.cutin.container.MethodContainer; import net.tomatentum.marinara.interaction.InteractionType; import net.tomatentum.marinara.interaction.ident.InteractionIdentifier; -import net.tomatentum.marinara.registry.InteractionRegistry; import net.tomatentum.marinara.wrapper.IdentifierProvider; public class DirectInteractionProcessor extends InteractionMethodProcessor { - private InteractionRegistry registry; - public DirectInteractionProcessor(InteractionRegistry registry, IdentifierProvider provider, InteractionType... types) { + public DirectInteractionProcessor(IdentifierProvider provider, InteractionType... types) { super(provider, Set.of(types)); - this.registry = registry; } @Override - protected void processInteraction(Object context, InteractionIdentifier identifier) { - this.registry.interactions().stream() - .filter(e -> e.identifier().equals(identifier)) - .findFirst() - .ifPresent(e -> e.runAll(context)); + protected void processInteraction(Object context, MethodContainer container, InteractionIdentifier identifier) { + container.findFor(identifier).forEach(m -> m.run(context)); } } diff --git a/lib/src/main/java/net/tomatentum/marinara/interaction/processor/InteractionMethodProcessor.java b/lib/src/main/java/net/tomatentum/marinara/interaction/processor/InteractionMethodProcessor.java index 38a2742..9424c75 100644 --- a/lib/src/main/java/net/tomatentum/marinara/interaction/processor/InteractionMethodProcessor.java +++ b/lib/src/main/java/net/tomatentum/marinara/interaction/processor/InteractionMethodProcessor.java @@ -4,13 +4,14 @@ import java.util.Set; import org.slf4j.Logger; +import net.tomatentum.cutin.MethodProcessor; +import net.tomatentum.cutin.container.MethodContainer; import net.tomatentum.marinara.interaction.InteractionType; import net.tomatentum.marinara.interaction.ident.InteractionIdentifier; -import net.tomatentum.marinara.reflection.MethodProcessor; import net.tomatentum.marinara.util.LoggerUtil; import net.tomatentum.marinara.wrapper.IdentifierProvider; -public abstract class InteractionMethodProcessor implements MethodProcessor { +public abstract class InteractionMethodProcessor implements MethodProcessor { private Logger logger = LoggerUtil.getLogger(getClass()); @@ -23,13 +24,16 @@ public abstract class InteractionMethodProcessor implements MethodProcessor { } @Override - public void process(Object context) { + public void process(Object context, MethodContainer container) { InteractionIdentifier identifier = this.provider.provide(context); if (!this.types.contains(identifier.type())) return; logger.debug("Processing {} : {} with context {}", identifier, identifier.type(), context); - this.processInteraction(context, identifier); + this.processInteraction(context, container, identifier); } - protected abstract void processInteraction(Object context, InteractionIdentifier identifier); + protected abstract void processInteraction( + Object context, + MethodContainer container, + InteractionIdentifier identifier); } diff --git a/lib/src/main/java/net/tomatentum/marinara/parser/AnnotationParser.java b/lib/src/main/java/net/tomatentum/marinara/parser/AnnotationParser.java deleted file mode 100644 index 187a4a4..0000000 --- a/lib/src/main/java/net/tomatentum/marinara/parser/AnnotationParser.java +++ /dev/null @@ -1,8 +0,0 @@ -package net.tomatentum.marinara.parser; - -import java.lang.reflect.Method; - -public interface AnnotationParser { - void parse(); - Method getMethod(); -} diff --git a/lib/src/main/java/net/tomatentum/marinara/parser/AutocompleteParser.java b/lib/src/main/java/net/tomatentum/marinara/parser/AutocompleteParser.java index 37ab8c8..96a0eda 100644 --- a/lib/src/main/java/net/tomatentum/marinara/parser/AutocompleteParser.java +++ b/lib/src/main/java/net/tomatentum/marinara/parser/AutocompleteParser.java @@ -4,9 +4,16 @@ import java.lang.reflect.Method; import java.util.Arrays; import java.util.function.Consumer; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import net.tomatentum.cutin.MethodParser; +import net.tomatentum.cutin.util.ReflectionUtil; import net.tomatentum.marinara.interaction.annotation.AutoComplete; -public class AutocompleteParser implements AnnotationParser { +public class AutocompleteParser implements MethodParser { + + private Logger logger = LoggerFactory.getLogger(getClass()); private Method method; private Consumer consumer; @@ -21,13 +28,8 @@ public class AutocompleteParser implements AnnotationParser { String[] autocompletes = Arrays.stream(this.method.getAnnotationsByType(AutoComplete.class)) .map(AutoComplete::value) .toArray(String[]::new); - this.consumer.accept(autocompletes); - - } - - @Override - public Method getMethod() { - return this.method; + logger.trace("Parsed AutoComplete annotation {} for method {}", autocompletes, ReflectionUtil.getFullMethodName(method)); + this.consumer.accept(autocompletes); } } diff --git a/lib/src/main/java/net/tomatentum/marinara/parser/ButtonParser.java b/lib/src/main/java/net/tomatentum/marinara/parser/ButtonParser.java index ee8ab37..a2d533e 100644 --- a/lib/src/main/java/net/tomatentum/marinara/parser/ButtonParser.java +++ b/lib/src/main/java/net/tomatentum/marinara/parser/ButtonParser.java @@ -5,11 +5,12 @@ import java.util.function.Consumer; import org.slf4j.Logger; +import net.tomatentum.cutin.MethodParser; +import net.tomatentum.cutin.util.ReflectionUtil; import net.tomatentum.marinara.interaction.annotation.Button; import net.tomatentum.marinara.util.LoggerUtil; -import net.tomatentum.marinara.util.ReflectionUtil; -public class ButtonParser implements AnnotationParser { +public class ButtonParser implements MethodParser { private Method method; private Consumer consumer; @@ -23,14 +24,9 @@ public class ButtonParser implements AnnotationParser { @Override public void parse() { - Button button = getMethod().getAnnotation(Button.class); - logger.trace("Parsed Button annotation {} for method {}", button.toString(), ReflectionUtil.getFullMethodName(method)); + Button button = this.method.getAnnotation(Button.class); + logger.trace("Parsed Button annotation {} for method {}", button, ReflectionUtil.getFullMethodName(method)); this.consumer.accept(button.value()); } - - @Override - public Method getMethod() { - return this.method; - } } diff --git a/lib/src/main/java/net/tomatentum/marinara/parser/InteractionCheckClassParser.java b/lib/src/main/java/net/tomatentum/marinara/parser/InteractionCheckClassParser.java new file mode 100644 index 0000000..0023e3f --- /dev/null +++ b/lib/src/main/java/net/tomatentum/marinara/parser/InteractionCheckClassParser.java @@ -0,0 +1,28 @@ +package net.tomatentum.marinara.parser; + +import java.lang.reflect.ParameterizedType; +import java.lang.reflect.Type; +import java.util.function.Consumer; + +import io.leangen.geantyref.GenericTypeReflector; +import net.tomatentum.cutin.MethodParser; +import net.tomatentum.marinara.checks.InteractionCheck; + +public class InteractionCheckClassParser implements MethodParser { + + private Class> interactionCheckType; + private Consumer annotationTypeConsumer; + + public InteractionCheckClassParser(Class> interactionCheckType, Consumer annotationTypeConsumer) { + this.interactionCheckType = interactionCheckType; + this.annotationTypeConsumer = annotationTypeConsumer; + } + + @Override + public void parse() { + ParameterizedType type = (ParameterizedType) GenericTypeReflector.getExactSuperType(interactionCheckType, InteractionCheck.class); + Type typeParam = type.getActualTypeArguments()[0]; + this.annotationTypeConsumer.accept(typeParam); + } + +} diff --git a/lib/src/main/java/net/tomatentum/marinara/parser/InteractionCheckParser.java b/lib/src/main/java/net/tomatentum/marinara/parser/InteractionCheckParser.java index 7379141..4e3a36c 100644 --- a/lib/src/main/java/net/tomatentum/marinara/parser/InteractionCheckParser.java +++ b/lib/src/main/java/net/tomatentum/marinara/parser/InteractionCheckParser.java @@ -3,27 +3,29 @@ package net.tomatentum.marinara.parser; import java.lang.annotation.Annotation; import java.lang.reflect.Method; import java.util.Arrays; -import java.util.Optional; import java.util.function.Consumer; import org.slf4j.Logger; +import net.tomatentum.cutin.MethodParser; +import net.tomatentum.cutin.container.MethodContainer; +import net.tomatentum.cutin.util.ReflectionUtil; import net.tomatentum.marinara.checks.AppliedCheck; -import net.tomatentum.marinara.checks.InteractionCheck; -import net.tomatentum.marinara.registry.InteractionCheckRegistry; +import net.tomatentum.marinara.checks.CheckExecutionContext; +import net.tomatentum.marinara.checks.CheckMethodIdentifier; +import net.tomatentum.marinara.checks.CheckMethodIdentifier.CheckMethodType; import net.tomatentum.marinara.util.LoggerUtil; -import net.tomatentum.marinara.util.ReflectionUtil; -public class InteractionCheckParser implements AnnotationParser { +public class InteractionCheckParser implements MethodParser { - private InteractionCheckRegistry checkRegistry; + private MethodContainer checkContainer; private Method method; private Consumer consumer; private Logger logger = LoggerUtil.getLogger(getClass()); - public InteractionCheckParser(Method method, Consumer consumer, InteractionCheckRegistry checkRegistry) { - this.checkRegistry = checkRegistry; + public InteractionCheckParser(Method method, Consumer consumer, MethodContainer checkContainer) { + this.checkContainer = checkContainer; this.method = method; this.consumer = consumer; } @@ -35,17 +37,13 @@ public class InteractionCheckParser implements AnnotationParser { } private void convertAnnotation(Annotation annotation) { - Optional> check = this.checkRegistry.getCheckFromAnnotation(annotation.annotationType()); - if (check.isPresent()) { - AppliedCheck appliedCheck = new AppliedCheck(check.get(), annotation); - logger.trace("Parsed InteractionCheck {} for annotation {} for method {}", check.getClass().getName(), annotation.toString(), ReflectionUtil.getFullMethodName(method)); + var preExec = this.checkContainer.findFirstFor(new CheckMethodIdentifier(annotation.annotationType(), CheckMethodType.PRE)); + var postExec = this.checkContainer.findFirstFor(new CheckMethodIdentifier(annotation.annotationType(), CheckMethodType.POST)); + if (preExec.isPresent() && postExec.isPresent()) { + AppliedCheck appliedCheck = new AppliedCheck(annotation, preExec.get(), postExec.get()); + logger.trace("Parsed InteractionCheck {} for annotation {} for method {}", preExec.get().containingObject(), annotation, ReflectionUtil.getFullMethodName(method)); consumer.accept(appliedCheck); } } - - @Override - public Method getMethod() { - return this.method; - } } diff --git a/lib/src/main/java/net/tomatentum/marinara/parser/SlashCommandParser.java b/lib/src/main/java/net/tomatentum/marinara/parser/SlashCommandParser.java index b13efa1..c6ca43b 100644 --- a/lib/src/main/java/net/tomatentum/marinara/parser/SlashCommandParser.java +++ b/lib/src/main/java/net/tomatentum/marinara/parser/SlashCommandParser.java @@ -5,6 +5,8 @@ import java.util.function.Consumer; import org.slf4j.Logger; +import net.tomatentum.cutin.MethodParser; +import net.tomatentum.cutin.util.ReflectionUtil; import net.tomatentum.marinara.interaction.InteractionType; import net.tomatentum.marinara.interaction.commands.annotation.SlashCommand; import net.tomatentum.marinara.interaction.commands.annotation.SubCommand; @@ -12,9 +14,8 @@ import net.tomatentum.marinara.interaction.commands.annotation.SubCommandGroup; import net.tomatentum.marinara.interaction.ident.InteractionIdentifier; import net.tomatentum.marinara.interaction.ident.SlashCommandIdentifier; import net.tomatentum.marinara.util.LoggerUtil; -import net.tomatentum.marinara.util.ReflectionUtil; -public class SlashCommandParser implements AnnotationParser { +public class SlashCommandParser implements MethodParser { private Method method; private Consumer consumer; @@ -57,15 +58,10 @@ public class SlashCommandParser implements AnnotationParser { .build(); } - logger.trace("Parsed using SlashCommandParser for method {} with the result: {}", ReflectionUtil.getFullMethodName(method), lastIdentifier.toString()); + logger.trace("Parsed using SlashCommandParser for method {} with the result: {}", ReflectionUtil.getFullMethodName(method), lastIdentifier); consumer.accept((SlashCommandIdentifier) lastIdentifier); } - @Override - public Method getMethod() { - return this.method; - } - private void checkValidCommandMethod(Method method) { if (method.isAnnotationPresent(SlashCommand.class) && method.getDeclaringClass().isAnnotationPresent(SlashCommand.class)) { diff --git a/lib/src/main/java/net/tomatentum/marinara/reflection/MethodExecutor.java b/lib/src/main/java/net/tomatentum/marinara/reflection/MethodExecutor.java deleted file mode 100644 index a16c48f..0000000 --- a/lib/src/main/java/net/tomatentum/marinara/reflection/MethodExecutor.java +++ /dev/null @@ -1,7 +0,0 @@ -package net.tomatentum.marinara.reflection; - -public interface MethodExecutor { - - void handle(Object context); - -} diff --git a/lib/src/main/java/net/tomatentum/marinara/reflection/MethodProcessor.java b/lib/src/main/java/net/tomatentum/marinara/reflection/MethodProcessor.java deleted file mode 100644 index 7cc4ce8..0000000 --- a/lib/src/main/java/net/tomatentum/marinara/reflection/MethodProcessor.java +++ /dev/null @@ -1,7 +0,0 @@ -package net.tomatentum.marinara.reflection; - -public interface MethodProcessor { - - void process(Object context); - -} diff --git a/lib/src/main/java/net/tomatentum/marinara/reflection/ProcessorContainer.java b/lib/src/main/java/net/tomatentum/marinara/reflection/ProcessorContainer.java deleted file mode 100644 index 0e33fe7..0000000 --- a/lib/src/main/java/net/tomatentum/marinara/reflection/ProcessorContainer.java +++ /dev/null @@ -1,7 +0,0 @@ -package net.tomatentum.marinara.reflection; - -public interface ProcessorContainer { - - ProcessorContainer addProcessor(MethodProcessor processor); - -} diff --git a/lib/src/main/java/net/tomatentum/marinara/reflection/ProcessorMethodExecutor.java b/lib/src/main/java/net/tomatentum/marinara/reflection/ProcessorMethodExecutor.java deleted file mode 100644 index 373ef93..0000000 --- a/lib/src/main/java/net/tomatentum/marinara/reflection/ProcessorMethodExecutor.java +++ /dev/null @@ -1,32 +0,0 @@ -package net.tomatentum.marinara.reflection; - -import java.util.HashSet; -import java.util.Set; - -import org.slf4j.Logger; - -import net.tomatentum.marinara.util.LoggerUtil; - -public class ProcessorMethodExecutor implements MethodExecutor, ProcessorContainer { - - private Logger logger = LoggerUtil.getLogger(getClass()); - - private Set processors; - - public ProcessorMethodExecutor() { - this.processors = new HashSet<>(); - } - - @Override - public ProcessorContainer addProcessor(MethodProcessor processor) { - processors.add(processor); - return this; - } - - @Override - public void handle(Object context) { - logger.debug("Received {} interaction ", context); - processors.forEach(x -> x.process(context)); - } - -} diff --git a/lib/src/main/java/net/tomatentum/marinara/reflection/ReflectedMethod.java b/lib/src/main/java/net/tomatentum/marinara/reflection/ReflectedMethod.java deleted file mode 100644 index fa0a1fd..0000000 --- a/lib/src/main/java/net/tomatentum/marinara/reflection/ReflectedMethod.java +++ /dev/null @@ -1,66 +0,0 @@ -package net.tomatentum.marinara.reflection; - -import java.lang.reflect.InvocationTargetException; -import java.lang.reflect.Method; -import java.security.InvalidParameterException; -import java.util.ArrayList; -import java.util.Arrays; -import java.util.List; - -import org.slf4j.Logger; - -import net.tomatentum.marinara.util.LoggerUtil; -import net.tomatentum.marinara.util.ReflectionUtil; - -public abstract class ReflectedMethod { - - private Logger logger = LoggerUtil.getLogger(getClass()); - - private Method method; - private Object containingObject; - - public ReflectedMethod(Method method, Object containingObject) { - if (!Arrays.asList(containingObject.getClass().getMethods()).contains(method)) - throw new InvalidParameterException("Method does not apply to specified handler"); - this.method = method; - this.containingObject = containingObject; - } - - public abstract Object getParameter(Object context, int index); - - public Object run(Object context) { - method.setAccessible(true); - try { - return method.invoke(containingObject, getParameters(context)); - }catch (IllegalAccessException | InvocationTargetException ex) { - logger.error("ReflectedMethod failed to run", ex); - return null; - } - } - - public Method method() { - return this.method; - } - - public Object containingObject() { - return this.containingObject; - } - - private Object[] getParameters(Object context) { - int parameterCount = method.getParameterCount(); - List parameters = new ArrayList<>(); - - for (int i = 0; i < parameterCount; i++) { - Object parameter; - if (i == 0) { - parameter = context; - }else - parameter = getParameter(context, i-1); - - logger.trace("Found parameter {}={} for method {}", parameter != null ? parameter.getClass().toString() : " ", parameter, ReflectionUtil.getFullMethodName(method)); - parameters.add(parameter); - } - return parameters.toArray(); - } - -} diff --git a/lib/src/main/java/net/tomatentum/marinara/reflection/ReflectedMethodFactory.java b/lib/src/main/java/net/tomatentum/marinara/reflection/ReflectedMethodFactory.java deleted file mode 100644 index e36da12..0000000 --- a/lib/src/main/java/net/tomatentum/marinara/reflection/ReflectedMethodFactory.java +++ /dev/null @@ -1,20 +0,0 @@ -package net.tomatentum.marinara.reflection; - -import java.lang.reflect.Method; -import java.util.List; -import java.util.Optional; - -import net.tomatentum.marinara.Marinara; -import net.tomatentum.marinara.parser.AnnotationParser; - -public interface ReflectedMethodFactory { - Optional produce(Method method, Object containingClass); - ReflectedMethodFactory addFactory(Factory factory); - - public interface Factory { - - Optional produce(Marinara marinara, Method method, Object containingObject); - void addParser(ReflectedMethod method, List parser); - - } -} \ No newline at end of file diff --git a/lib/src/main/java/net/tomatentum/marinara/reflection/ReflectedMethodFactoryImpl.java b/lib/src/main/java/net/tomatentum/marinara/reflection/ReflectedMethodFactoryImpl.java deleted file mode 100644 index 485ea0c..0000000 --- a/lib/src/main/java/net/tomatentum/marinara/reflection/ReflectedMethodFactoryImpl.java +++ /dev/null @@ -1,62 +0,0 @@ -package net.tomatentum.marinara.reflection; - -import java.lang.reflect.Method; -import java.util.ArrayList; -import java.util.List; -import java.util.Optional; - -import org.slf4j.Logger; - -import net.tomatentum.marinara.Marinara; -import net.tomatentum.marinara.parser.AnnotationParser; -import net.tomatentum.marinara.util.LoggerUtil; -import net.tomatentum.marinara.util.ReflectionUtil; - -public class ReflectedMethodFactoryImpl implements ReflectedMethodFactory { - - private Logger logger = LoggerUtil.getLogger(getClass()); - - private Marinara marinara; - private List factories; - - public ReflectedMethodFactoryImpl(Marinara marinara) { - this(marinara, new ArrayList<>()); - } - - public ReflectedMethodFactoryImpl(Marinara marinara, List factories) { - this.marinara = marinara; - this.factories = factories; - } - - @Override - public Optional produce(Method method, Object containingClass) { - Optional imethod = this.factories.stream() - .map(f -> factoryProduce(f, method, containingClass)) - .filter(Optional::isPresent) - .map(Optional::get) - .findFirst(); - - if (imethod.isEmpty()) { - logger.debug("Could not produce a ReflectedMethod for Method {}", ReflectionUtil.getFullMethodName(method)); - } - - return imethod; - } - - @Override - public ReflectedMethodFactory addFactory(Factory factory) { - this.factories.add(factory); - return this; - } - - private Optional factoryProduce(Factory factory, Method method, Object containingClass) { - List parser = new ArrayList<>(); - Optional m = factory.produce(this.marinara, method, containingClass); - m.ifPresent(x -> { - factory.addParser(x, parser); - parser.forEach(AnnotationParser::parse); - }); - return m; - } - -} diff --git a/lib/src/main/java/net/tomatentum/marinara/registry/InteractionCheckRegistry.java b/lib/src/main/java/net/tomatentum/marinara/registry/InteractionCheckRegistry.java deleted file mode 100644 index 1093adf..0000000 --- a/lib/src/main/java/net/tomatentum/marinara/registry/InteractionCheckRegistry.java +++ /dev/null @@ -1,40 +0,0 @@ -package net.tomatentum.marinara.registry; - -import java.lang.reflect.ParameterizedType; -import java.lang.reflect.Type; -import java.util.ArrayList; -import java.util.List; -import java.util.Optional; - -import org.slf4j.Logger; - -import io.leangen.geantyref.GenericTypeReflector; -import net.tomatentum.marinara.checks.InteractionCheck; -import net.tomatentum.marinara.util.LoggerUtil; - -public class InteractionCheckRegistry { - - private List> checks; - - private Logger logger = LoggerUtil.getLogger(getClass()); - - public InteractionCheckRegistry() { - this.checks = new ArrayList<>(); - } - - public void addCheck(InteractionCheck check) { - checks.add(check); - logger.info("Registered Check {}", check.getClass().getName()); - } - - public Optional> getCheckFromAnnotation(Type annotation) { - for (InteractionCheck interactionCheck : checks) { - ParameterizedType type = (ParameterizedType) GenericTypeReflector.getExactSuperType(interactionCheck.getClass(), InteractionCheck.class); - Type typeParam = type.getActualTypeArguments()[0]; - if (typeParam.equals(annotation)) - return Optional.of(interactionCheck); - } - return Optional.empty(); - } - -} diff --git a/lib/src/main/java/net/tomatentum/marinara/registry/InteractionEntry.java b/lib/src/main/java/net/tomatentum/marinara/registry/InteractionEntry.java deleted file mode 100644 index 5f0828e..0000000 --- a/lib/src/main/java/net/tomatentum/marinara/registry/InteractionEntry.java +++ /dev/null @@ -1,90 +0,0 @@ -package net.tomatentum.marinara.registry; - -import java.util.Arrays; -import java.util.HashSet; -import java.util.Optional; -import java.util.Set; -import java.util.stream.Stream; - -import org.slf4j.Logger; - -import net.tomatentum.marinara.interaction.InteractionType; -import net.tomatentum.marinara.interaction.ident.InteractionIdentifier; -import net.tomatentum.marinara.interaction.methods.InteractionMethod; -import net.tomatentum.marinara.util.LoggerUtil; - -public class InteractionEntry { - - public static InteractionEntry findEntry(Set entries, InteractionIdentifier identifier) { - Optional oentry = entries.stream() - .filter(i -> i.identifier().equals(identifier)) - .findFirst(); - - InteractionEntry entry = oentry.orElse(new InteractionEntry(identifier)); - if (oentry.isEmpty()) entries.add(entry); - return entry; - } - - private InteractionIdentifier identifier; - private Set methods; - - private Logger logger = LoggerUtil.getLogger(getClass()); - - public InteractionEntry(InteractionIdentifier identifier) { - this.identifier = identifier; - this.methods = new HashSet<>(); - } - - public InteractionEntry addMethod(InteractionMethod method) { - InteractionIdentifier midentifier = method.identifier(); - - if (!this.identifier().equals(midentifier)) - throw new IllegalArgumentException("Method's identifier did not equal the entry's identifier"); - - this.methods.add(method); - InteractionIdentifier.tryAddDescriptions(midentifier, midentifier); - logger.debug("Added method {} to entry {}", method.method().getName(), this.identifier); - return this; - } - - public Object[] runAll(Object context) { - return this.methods.stream() - .map(x -> { - logger.debug("Running Method {} from {} with context {}", x, this, context); - return x.run(context); - }) - .flatMap(o -> o instanceof Object[] oArray ? Arrays.stream(oArray) : Stream.of(o)) - .toArray(); - } - - @Override - public boolean equals(Object obj) { - if (!(obj instanceof InteractionEntry)) - return false; - InteractionEntry other = (InteractionEntry) obj; - return other.identifier().equals(identifier()); - } - - @Override - public int hashCode() { - return this.identifier().hashCode(); - } - - @Override - public String toString() { - return "InteractionEntry(%s)".formatted(identifier().toString()); - } - - public InteractionType type() { - return identifier().type(); - } - - public InteractionIdentifier identifier() { - return identifier; - } - - public Set methods() { - return methods; - } - -} diff --git a/lib/src/main/java/net/tomatentum/marinara/registry/InteractionRegistry.java b/lib/src/main/java/net/tomatentum/marinara/registry/InteractionRegistry.java deleted file mode 100644 index 0c7b244..0000000 --- a/lib/src/main/java/net/tomatentum/marinara/registry/InteractionRegistry.java +++ /dev/null @@ -1,80 +0,0 @@ -package net.tomatentum.marinara.registry; - -import java.lang.reflect.Method; -import java.util.Arrays; -import java.util.HashSet; -import java.util.List; -import java.util.Optional; -import java.util.Set; - -import org.slf4j.Logger; - -import net.tomatentum.marinara.Marinara; -import net.tomatentum.marinara.interaction.InteractionHandler; -import net.tomatentum.marinara.interaction.InteractionType; -import net.tomatentum.marinara.interaction.commands.SlashCommandDefinition; -import net.tomatentum.marinara.interaction.components.methods.ButtonInteractionMethod; -import net.tomatentum.marinara.interaction.ident.InteractionIdentifier; -import net.tomatentum.marinara.interaction.ident.RootCommandIdentifier; -import net.tomatentum.marinara.util.LoggerUtil; -import net.tomatentum.marinara.util.ObjectAggregator; -import net.tomatentum.marinara.interaction.methods.AutoCompleteInteractionMethod; -import net.tomatentum.marinara.interaction.methods.InteractionMethod; -import net.tomatentum.marinara.interaction.methods.SlashCommandInteractionMethod; -import net.tomatentum.marinara.reflection.ReflectedMethod; - -public class InteractionRegistry { - private Logger logger = LoggerUtil.getLogger(getClass()); - private Set interactions; - private Marinara marinara; - - public InteractionRegistry(Marinara marinara) { - this.interactions = new HashSet<>(); - this.marinara = marinara; - marinara.getReflectedMethodFactory() - .addFactory(new AutoCompleteInteractionMethod.Factory()) - .addFactory(new SlashCommandInteractionMethod.Factory()) - .addFactory(new ButtonInteractionMethod.Factory()); - - } - - public void addInteractions(InteractionHandler interactionHandler) { - for (Method method : interactionHandler.getClass().getDeclaredMethods()) { - Optional rMethod = this.marinara.getReflectedMethodFactory().produce(method, interactionHandler); - rMethod.ifPresent(x -> { - if (x instanceof InteractionMethod) { - InteractionMethod iMethod = (InteractionMethod) x; - InteractionEntry.findEntry(interactions, iMethod.identifier()).addMethod(iMethod); - logger.debug("Added {} method from {}", iMethod.method().getName(), interactionHandler.getClass().getSimpleName()); - } - }); - } - logger.info("Added all Interactions from {}", interactionHandler.getClass().getSimpleName()); - } - - public void registerCommands() { - List slashIdentifiers = interactions.stream() - .filter((x) -> x.type().equals(InteractionType.COMMAND)) - .map((x) -> x.identifier()) - .toList(); - - SlashCommandDefinition[] defs = new ObjectAggregator( - i -> Arrays.asList((RootCommandIdentifier)i.rootNode()), - SlashCommandDefinition::addIdentifier, - SlashCommandDefinition::new) - .aggregate(slashIdentifiers) - .toArray(SlashCommandDefinition[]::new); - - marinara.getWrapper().getRegisterer().register(defs); - } - - public Optional findFor(InteractionIdentifier identifier) { - return this.interactions.stream() - .filter(x -> x.identifier().equals(identifier)) - .findFirst(); - } - - public Set interactions() { - return this.interactions; - } -} diff --git a/lib/src/main/java/net/tomatentum/marinara/util/ReflectionUtil.java b/lib/src/main/java/net/tomatentum/marinara/util/ReflectionUtil.java deleted file mode 100644 index 5bda90f..0000000 --- a/lib/src/main/java/net/tomatentum/marinara/util/ReflectionUtil.java +++ /dev/null @@ -1,107 +0,0 @@ -package net.tomatentum.marinara.util; - -import java.lang.annotation.Annotation; -import java.lang.reflect.Method; -import java.util.ArrayList; -import java.util.Arrays; -import java.util.List; -import java.util.Objects; - -public final class ReflectionUtil { - - public static boolean isAnnotationPresent(Method method, Class annotationClass) { - if (method.isAnnotationPresent(annotationClass) || method.getDeclaringClass().isAnnotationPresent(annotationClass)) - return true; - - return false; - } - - public static T getAnnotation(Method method, Class annotationClass) { - return method.isAnnotationPresent(annotationClass) ? - method.getAnnotation(annotationClass) : - method.getDeclaringClass().getAnnotation(annotationClass); - } - - public static int getCastDepth(Class child, Class parent) { - - if (parent.equals(Object.class)) - return Integer.MAX_VALUE; - - if (!parent.isAssignableFrom(child)) { - throw new IllegalArgumentException("The specified class is not a child class of the specified parent."); - } - - int depth = 0; - Class curr = child; - List> parents = new ArrayList<>(); - - while (!curr.equals(parent)) { - depth++; - parents.add(curr.getSuperclass()); - parents.addAll(Arrays.asList(curr.getInterfaces())); - - for (Class currParent : parents) { - if (currParent != null && parent.isAssignableFrom(currParent)) { - curr = currParent; - break; - } - } - parents.clear(); - } - - return depth; - } - - public static Method getMostSpecificMethod(Method[] methods, Class... parameters) { - List compatibleMethods = Arrays.stream(methods) - .filter(x -> isMethodCallable(x, parameters)) - .toList(); - - if (compatibleMethods.size() == 0) - throw new IllegalArgumentException("There are no compatible Methods provided"); - - for (int i = 0; i < parameters.length; i++) { - final int currI = i; - Class[] parameterTypes = compatibleMethods.stream() - .map(x -> x.getParameterTypes()[currI]) - .toArray(x -> new Class[x]); - - Class mostSpecific = getMostSpecificClass(parameterTypes, parameters[i]); - - compatibleMethods = compatibleMethods.stream() - .filter(x -> Objects.equals(x.getParameterTypes()[currI], mostSpecific)) - .toList(); - } - - return compatibleMethods.getFirst(); - } - - public static Class getMostSpecificClass(Class[] classes, Class base) { - int min = Integer.MAX_VALUE; - Class currMostSpecific = null; - for (Class currClass : classes) { - int currCastDepth = getCastDepth(base, currClass); - if (currCastDepth <= min) { - min = currCastDepth; - currMostSpecific = currClass; - } - } - return currMostSpecific; - } - - public static boolean isMethodCallable(Method method, Class... parameters) { - if (!Objects.equals(method.getParameterCount(), parameters.length)) - return false; - - Class[] methodParams = method.getParameterTypes(); - for (int i = 0; i < parameters.length; i++) { - if (!methodParams[i].isAssignableFrom(parameters[i])) - return false; - } - return true; - } - - public static String getFullMethodName(Method method) { - return method.getDeclaringClass().getName() + "." + method.getName(); - } -} diff --git a/lib/src/main/java/net/tomatentum/marinara/wrapper/IdentifierProvider.java b/lib/src/main/java/net/tomatentum/marinara/wrapper/IdentifierProvider.java index 0adbee9..d96d6f2 100644 --- a/lib/src/main/java/net/tomatentum/marinara/wrapper/IdentifierProvider.java +++ b/lib/src/main/java/net/tomatentum/marinara/wrapper/IdentifierProvider.java @@ -10,9 +10,9 @@ import java.util.Map; import org.slf4j.Logger; import io.leangen.geantyref.GenericTypeReflector; +import net.tomatentum.cutin.util.ReflectionUtil; import net.tomatentum.marinara.interaction.ident.InteractionIdentifier; import net.tomatentum.marinara.util.LoggerUtil; -import net.tomatentum.marinara.util.ReflectionUtil; public class IdentifierProvider { diff --git a/wrapper/discord4j/src/test/java/net/tomatentum/marinara/test/discord4j/AutoCompleteTest.java b/wrapper/discord4j/src/test/java/net/tomatentum/marinara/test/discord4j/AutoCompleteTest.java index 2c20695..3f15b52 100644 --- a/wrapper/discord4j/src/test/java/net/tomatentum/marinara/test/discord4j/AutoCompleteTest.java +++ b/wrapper/discord4j/src/test/java/net/tomatentum/marinara/test/discord4j/AutoCompleteTest.java @@ -38,7 +38,7 @@ class AutoCompleteTest { LibraryWrapper wrapper = new Discord4JWrapper(null); //null okay as we don't use the discord API in this test. Marinara marinara = Marinara.load(wrapper); - marinara.getRegistry().addInteractions(new TestAutocomplete()); + marinara.getInteractionContainer().addAllMethods(new TestAutocomplete()); wrapper.handleInteraction(autoCompleteEventMock); verify(autoCompleteEventMock).respondWithSuggestions(any()); } diff --git a/wrapper/discord4j/src/test/java/net/tomatentum/marinara/test/discord4j/ButtonTest.java b/wrapper/discord4j/src/test/java/net/tomatentum/marinara/test/discord4j/ButtonTest.java index bb0c70b..4e8ff2b 100644 --- a/wrapper/discord4j/src/test/java/net/tomatentum/marinara/test/discord4j/ButtonTest.java +++ b/wrapper/discord4j/src/test/java/net/tomatentum/marinara/test/discord4j/ButtonTest.java @@ -13,15 +13,15 @@ import net.tomatentum.marinara.wrapper.LibraryWrapper; import net.tomatentum.marinara.wrapper.discord4j.Discord4JWrapper; @TestInstance(Lifecycle.PER_CLASS) -public class ButtonTest { +class ButtonTest { @Test - public void testButtonExecution() { + void testButtonExecution() { ButtonInteractionEvent buttonEventMock = CommonMocks.getButtonEventMock("test"); LibraryWrapper wrapper = new Discord4JWrapper(null); //null okay as we don't use the discord API in this test. Marinara marinara = Marinara.load(wrapper); - marinara.getRegistry().addInteractions(new TestButton()); + marinara.getInteractionContainer().addAllMethods(new TestButton()); wrapper.handleInteraction(buttonEventMock); assertTrue(TestButton.didRun); } diff --git a/wrapper/discord4j/src/test/java/net/tomatentum/marinara/test/discord4j/InteractionCheckTest.java b/wrapper/discord4j/src/test/java/net/tomatentum/marinara/test/discord4j/InteractionCheckTest.java index 0e7874c..8e0a9b7 100644 --- a/wrapper/discord4j/src/test/java/net/tomatentum/marinara/test/discord4j/InteractionCheckTest.java +++ b/wrapper/discord4j/src/test/java/net/tomatentum/marinara/test/discord4j/InteractionCheckTest.java @@ -24,16 +24,16 @@ import net.tomatentum.marinara.wrapper.discord4j.checks.PermissionCheck; import reactor.core.publisher.Mono; @TestInstance(Lifecycle.PER_CLASS) -public class InteractionCheckTest { +class InteractionCheckTest { @Test - public void testInteractionCheck() { + void testInteractionCheck() { ButtonInteractionEvent buttonEventMock = CommonMocks.getButtonEventMock("test"); LibraryWrapper wrapper = new Discord4JWrapper(null); Marinara marinara = Marinara.load(wrapper); - marinara.getCheckRegistry().addCheck(new TestInteractionCheck()); - marinara.getRegistry().addInteractions(new TestButton()); + marinara.getCheckContainer().addAllMethods(new TestInteractionCheck()); + marinara.getInteractionContainer().addAllMethods(new TestButton()); wrapper.handleInteraction(buttonEventMock); assertTrue(TestInteractionCheck.preExecuted); @@ -42,7 +42,7 @@ public class InteractionCheckTest { } @Test - public void testPermissionCheck() { + void testPermissionCheck() { Member memberMock = mock(); Interaction interactionMock = mock(); @@ -54,8 +54,8 @@ public class InteractionCheckTest { LibraryWrapper wrapper = new Discord4JWrapper(null); Marinara marinara = Marinara.load(wrapper); - marinara.getCheckRegistry().addCheck(new PermissionCheck()); - marinara.getRegistry().addInteractions(new TestButton()); + marinara.getCheckContainer().addAllMethods(new PermissionCheck()); + marinara.getInteractionContainer().addAllMethods(new TestButton()); wrapper.handleInteraction(buttonEventMock); assertFalse(TestButton.didPermRun); diff --git a/wrapper/discord4j/src/test/java/net/tomatentum/marinara/test/discord4j/SlashCommandTest.java b/wrapper/discord4j/src/test/java/net/tomatentum/marinara/test/discord4j/SlashCommandTest.java index 377f123..54ff156 100644 --- a/wrapper/discord4j/src/test/java/net/tomatentum/marinara/test/discord4j/SlashCommandTest.java +++ b/wrapper/discord4j/src/test/java/net/tomatentum/marinara/test/discord4j/SlashCommandTest.java @@ -22,9 +22,9 @@ import net.tomatentum.marinara.Marinara; import net.tomatentum.marinara.wrapper.LibraryWrapper; import net.tomatentum.marinara.wrapper.discord4j.Discord4JWrapper; @TestInstance(Lifecycle.PER_CLASS) -public class SlashCommandTest { +class SlashCommandTest { - String DISCORD_TOKEN = System.getenv("DISCORD_TEST_TOKEN"); + private static String DISCORD_TOKEN = System.getenv("DISCORD_TEST_TOKEN"); GatewayDiscordClient client; @BeforeAll @@ -41,8 +41,8 @@ public class SlashCommandTest { @Test void testSlashCommand() { Marinara marinara = Marinara.load(new Discord4JWrapper(client)); - marinara.getRegistry().addInteractions(new TestCommand()); - marinara.getRegistry().registerCommands(); + marinara.getInteractionContainer().addAllMethods(new TestCommand()); + marinara.registerCommands(); System.out.println("Success!"); } @@ -64,7 +64,7 @@ public class SlashCommandTest { LibraryWrapper wrapper = new Discord4JWrapper(client); Marinara marinara = Marinara.load(wrapper); - marinara.getRegistry().addInteractions(new TestCommand()); + marinara.getInteractionContainer().addAllMethods(new TestCommand()); wrapper.handleInteraction(eventMock); } diff --git a/wrapper/discord4j/src/test/java/net/tomatentum/marinara/test/discord4j/TestAutocomplete.java b/wrapper/discord4j/src/test/java/net/tomatentum/marinara/test/discord4j/TestAutocomplete.java index 18c0965..1c4517a 100644 --- a/wrapper/discord4j/src/test/java/net/tomatentum/marinara/test/discord4j/TestAutocomplete.java +++ b/wrapper/discord4j/src/test/java/net/tomatentum/marinara/test/discord4j/TestAutocomplete.java @@ -2,8 +2,6 @@ package net.tomatentum.marinara.test.discord4j; import static org.junit.jupiter.api.Assertions.assertEquals; -import java.util.Collections; - import discord4j.core.event.domain.interaction.ChatInputAutoCompleteEvent; import discord4j.core.event.domain.interaction.ChatInputInteractionEvent; import discord4j.discordjson.json.ApplicationCommandOptionChoiceData; @@ -23,9 +21,8 @@ public class TestAutocomplete implements InteractionHandler { autocompletes = @AutoComplete("testAuto") ) ) - @AutoComplete("testAuto") public void exec(ChatInputInteractionEvent context) { - + // Not executed just there for autocomplete to work } @AutoComplete("testAuto") diff --git a/wrapper/discord4j/src/test/java/net/tomatentum/marinara/test/discord4j/TestCommand.java b/wrapper/discord4j/src/test/java/net/tomatentum/marinara/test/discord4j/TestCommand.java index 9482748..3430155 100644 --- a/wrapper/discord4j/src/test/java/net/tomatentum/marinara/test/discord4j/TestCommand.java +++ b/wrapper/discord4j/src/test/java/net/tomatentum/marinara/test/discord4j/TestCommand.java @@ -26,7 +26,7 @@ public class TestCommand implements InteractionHandler { } ) public void exec(ChatInputInteractionEvent event, String test) { - assertEquals(test, "test"); + assertEquals("test", test); System.out.println("Success!"); } } diff --git a/wrapper/javacord/src/test/java/net/tomatentum/marinara/test/javacord/AutoCompleteTest.java b/wrapper/javacord/src/test/java/net/tomatentum/marinara/test/javacord/AutoCompleteTest.java index e10d19c..8724326 100644 --- a/wrapper/javacord/src/test/java/net/tomatentum/marinara/test/javacord/AutoCompleteTest.java +++ b/wrapper/javacord/src/test/java/net/tomatentum/marinara/test/javacord/AutoCompleteTest.java @@ -16,10 +16,10 @@ import net.tomatentum.marinara.Marinara; import net.tomatentum.marinara.wrapper.LibraryWrapper; import net.tomatentum.marinara.wrapper.javacord.JavacordWrapper; -public class AutoCompleteTest { +class AutoCompleteTest { @Test - public void testAutocomplete() { + void testAutocomplete() { SlashCommandInteractionOption optionMock = mock(); AutocompleteInteraction autocompleteInteractionMock = mock(); @@ -33,7 +33,7 @@ public class AutoCompleteTest { LibraryWrapper wrapper = new JavacordWrapper(null); //null okay as we don't use the discord API in this test. Marinara marinara = Marinara.load(wrapper); - marinara.getRegistry().addInteractions(new TestAutocomplete()); + marinara.getInteractionContainer().addAllMethods(new TestAutocomplete()); wrapper.handleInteraction(autocompleteInteractionMock); verify(autocompleteInteractionMock).respondWithChoices(any()); } diff --git a/wrapper/javacord/src/test/java/net/tomatentum/marinara/test/javacord/ButtonTest.java b/wrapper/javacord/src/test/java/net/tomatentum/marinara/test/javacord/ButtonTest.java index dc85d36..5e8a9b4 100644 --- a/wrapper/javacord/src/test/java/net/tomatentum/marinara/test/javacord/ButtonTest.java +++ b/wrapper/javacord/src/test/java/net/tomatentum/marinara/test/javacord/ButtonTest.java @@ -12,13 +12,13 @@ import net.tomatentum.marinara.wrapper.LibraryWrapper; import net.tomatentum.marinara.wrapper.javacord.JavacordWrapper; @TestInstance(Lifecycle.PER_CLASS) -public class ButtonTest { +class ButtonTest { @Test - public void testButtonExecution() { + void testButtonExecution() { LibraryWrapper wrapper = new JavacordWrapper(null); //null okay as we don't use the discord API in this test. Marinara marinara = Marinara.load(wrapper); - marinara.getRegistry().addInteractions(new TestButton()); + marinara.getInteractionContainer().addAllMethods(new TestButton()); wrapper.handleInteraction(CommonMocks.getButtonInteractionMock("test")); assertTrue(TestButton.didRun); } diff --git a/wrapper/javacord/src/test/java/net/tomatentum/marinara/test/javacord/InteractionCheckTest.java b/wrapper/javacord/src/test/java/net/tomatentum/marinara/test/javacord/InteractionCheckTest.java index 950c314..a522a27 100644 --- a/wrapper/javacord/src/test/java/net/tomatentum/marinara/test/javacord/InteractionCheckTest.java +++ b/wrapper/javacord/src/test/java/net/tomatentum/marinara/test/javacord/InteractionCheckTest.java @@ -19,25 +19,25 @@ import net.tomatentum.marinara.wrapper.javacord.JavacordWrapper; import net.tomatentum.marinara.wrapper.javacord.checks.PermissionCheck; @TestInstance(Lifecycle.PER_CLASS) -public class InteractionCheckTest { +class InteractionCheckTest { @Test - public void testInteractionCheck() { + void testInteractionCheck() { LibraryWrapper wrapper = new JavacordWrapper(null); Marinara marinara = Marinara.load(wrapper); - marinara.getCheckRegistry().addCheck(new TestInteractionCheck()); - marinara.getRegistry().addInteractions(new TestButton()); + marinara.getCheckContainer().addAllMethods(new TestInteractionCheck()); + marinara.getInteractionContainer().addAllMethods(new TestButton()); wrapper.handleInteraction(CommonMocks.getButtonInteractionMock("test")); assertTrue(TestInteractionCheck.preExecuted); assertTrue(TestInteractionCheck.postExecuted); } @Test - public void testPermissionCheck() { + void testPermissionCheck() { LibraryWrapper wrapper = new JavacordWrapper(null); Marinara marinara = Marinara.load(wrapper); - marinara.getCheckRegistry().addCheck(new PermissionCheck()); - marinara.getRegistry().addInteractions(new TestButton()); + marinara.getCheckContainer().addAllMethods(new PermissionCheck()); + marinara.getInteractionContainer().addAllMethods(new TestButton()); Server serverMock = mock(); ButtonInteraction buttonInteractionMock = CommonMocks.getButtonInteractionMock("permissionCheck", serverMock); diff --git a/wrapper/javacord/src/test/java/net/tomatentum/marinara/test/javacord/SlashCommandTest.java b/wrapper/javacord/src/test/java/net/tomatentum/marinara/test/javacord/SlashCommandTest.java index 8fd80d0..ce645a8 100644 --- a/wrapper/javacord/src/test/java/net/tomatentum/marinara/test/javacord/SlashCommandTest.java +++ b/wrapper/javacord/src/test/java/net/tomatentum/marinara/test/javacord/SlashCommandTest.java @@ -20,7 +20,7 @@ import net.tomatentum.marinara.Marinara; import net.tomatentum.marinara.wrapper.LibraryWrapper; import net.tomatentum.marinara.wrapper.javacord.JavacordWrapper; @TestInstance(Lifecycle.PER_CLASS) -public class SlashCommandTest { +class SlashCommandTest { String DISCORD_TOKEN = System.getenv("DISCORD_TEST_TOKEN"); DiscordApi api; @@ -41,8 +41,8 @@ public class SlashCommandTest { @Test void testSlashCommand() { Marinara marinara = Marinara.load(new JavacordWrapper(api)); - marinara.getRegistry().addInteractions(new TestCommand()); - marinara.getRegistry().registerCommands(); + marinara.getInteractionContainer().addAllMethods(new TestCommand()); + marinara.registerCommands(); System.out.println("Success!"); } @@ -50,7 +50,7 @@ public class SlashCommandTest { void testSlashCommandExecution() { LibraryWrapper wrapper = new JavacordWrapper(api); Marinara marinara = Marinara.load(wrapper); - marinara.getRegistry().addInteractions(new TestCommand()); + marinara.getInteractionContainer().addAllMethods(new TestCommand()); SlashCommandInteractionOption optionMock = mock(); SlashCommandInteraction interactionMock = mock(); diff --git a/wrapper/javacord/src/test/java/net/tomatentum/marinara/test/javacord/TestAutocomplete.java b/wrapper/javacord/src/test/java/net/tomatentum/marinara/test/javacord/TestAutocomplete.java index da37684..0285cff 100644 --- a/wrapper/javacord/src/test/java/net/tomatentum/marinara/test/javacord/TestAutocomplete.java +++ b/wrapper/javacord/src/test/java/net/tomatentum/marinara/test/javacord/TestAutocomplete.java @@ -4,7 +4,6 @@ import static org.junit.jupiter.api.Assertions.assertEquals; import java.util.Collections; -import org.javacord.api.event.interaction.SlashCommandCreateEvent; import org.javacord.api.interaction.AutocompleteInteraction; import org.javacord.api.interaction.SlashCommandInteraction; @@ -24,15 +23,14 @@ public class TestAutocomplete implements InteractionHandler { autocompletes = @AutoComplete("testAuto") ) ) - @AutoComplete("testAuto") public void exec(SlashCommandInteraction context) { - + //only here for command definition } @AutoComplete("testAuto") public void autocomplete(AutocompleteInteraction context, String value) { System.out.println("Success!"); - assertEquals(value, "test"); + assertEquals("test", value); context.respondWithChoices(Collections.emptyList()); } diff --git a/wrapper/javacord/src/test/java/net/tomatentum/marinara/test/javacord/TestButton.java b/wrapper/javacord/src/test/java/net/tomatentum/marinara/test/javacord/TestButton.java index f838e5e..e1e65ac 100644 --- a/wrapper/javacord/src/test/java/net/tomatentum/marinara/test/javacord/TestButton.java +++ b/wrapper/javacord/src/test/java/net/tomatentum/marinara/test/javacord/TestButton.java @@ -16,8 +16,8 @@ import net.tomatentum.marinara.wrapper.javacord.checks.PermissionCheck.HasPermis public class TestButton implements InteractionHandler { - public static boolean didRun = false; + @Button("test") @TestCheck public void exec(ButtonInteraction interaction, TextChannel channel, Message message, User member, Server server) { diff --git a/wrapper/javacord/src/test/java/net/tomatentum/marinara/test/javacord/TestCommand.java b/wrapper/javacord/src/test/java/net/tomatentum/marinara/test/javacord/TestCommand.java index d6f371c..2a95ba7 100644 --- a/wrapper/javacord/src/test/java/net/tomatentum/marinara/test/javacord/TestCommand.java +++ b/wrapper/javacord/src/test/java/net/tomatentum/marinara/test/javacord/TestCommand.java @@ -11,6 +11,7 @@ import net.tomatentum.marinara.interaction.commands.annotation.SlashCommandOptio import net.tomatentum.marinara.interaction.commands.option.SlashCommandOptionType; public class TestCommand implements InteractionHandler { + @SlashCommand( name = "test", description = "testingen", @@ -27,7 +28,8 @@ public class TestCommand implements InteractionHandler { } ) public void exec(SlashCommandInteraction interaction, String test) { - assertEquals(test, "test"); + assertEquals("test", test); System.out.println("Success!"); } + }