tueem/Marinara
1
1
Fork 0
Code Issues 2 Pull Requests 1 Actions Packages Projects 1 Releases Wiki Activity

refactor(reflection): migrate to using cutin library
All checks were successful
github-mirror / push-github (push) Successful in 12s
Details
Build / Gradle-Build (push) Successful in 15s
Details
Test / Gradle-Test (push) Successful in 24s
Details

Browse Source
This commit is contained in:
tueem 2025-04-13 23:15:38 +02:00
parent ebf5600e29
commit ef9384336a
Signed by: tueem
GPG Key ID: 65C8667EC17A88FB
47 changed files with 452 additions and 756 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
gradle/libs.versions.toml
View File

@ -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"}

2
lib/build.gradle.kts
View File

@ -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.

70
lib/src/main/java/net/tomatentum/marinara/Marinara.java
View File

@ -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<CheckMethodIdentifier, CheckExecutionContext> checkContainer;
private MethodContainer<InteractionIdentifier, Object> interactionContainer;
private MethodExecutor<Object> 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<InteractionIdentifier, Object> 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<InteractionIdentifier> slashIdentifiers = getInteractionContainer().identifiers().stream()
.filter(i -> i.type().equals(InteractionType.COMMAND))
.toList();
SlashCommandDefinition[] defs = new ObjectAggregator<InteractionIdentifier, RootCommandIdentifier, SlashCommandDefinition>(
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<InteractionIdentifier, Object> getInteractionContainer() {
return this.interactionContainer;
}
public InteractionCheckRegistry getCheckRegistry() {
return this.checkRegistry;
public MethodContainer<CheckMethodIdentifier, CheckExecutionContext> getCheckContainer() {
return this.checkContainer;
}
public ReflectedMethodFactory getReflectedMethodFactory() {
return this.reflectedMethodFactory;
}
public MethodExecutor getInteractionExecutor() {
public MethodExecutor<Object> getInteractionExecutor() {
return interactionExecutor;
}

46
lib/src/main/java/net/tomatentum/marinara/checks/AppliedCheck.java
View File

@ -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<CheckMethodIdentifier, CheckExecutionContext> preExec,
ReflectedMethod<CheckMethodIdentifier, CheckExecutionContext> 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));
}
}

7
lib/src/main/java/net/tomatentum/marinara/checks/CheckExecutionContext.java Normal file
View File

@ -0,0 +1,7 @@
package net.tomatentum.marinara.checks;
import java.lang.annotation.Annotation;
public record CheckExecutionContext(Annotation annotation, Object originalContext) {
}

27
lib/src/main/java/net/tomatentum/marinara/checks/CheckMethodIdentifier.java Normal file
View File

@ -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);
}
}

66
lib/src/main/java/net/tomatentum/marinara/checks/InteractionCheckMethod.java Normal file
View File

@ -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<CheckMethodIdentifier, CheckExecutionContext> {
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<CheckMethodIdentifier, CheckExecutionContext> {
private CheckMethodType type;
public InteractionCheckMethodFactory(MethodContainer<CheckMethodIdentifier, CheckExecutionContext> methodContainer, CheckMethodType type) {
super(methodContainer, type.methodName());
this.type = type;
}
@SuppressWarnings("unchecked")
@Override
public void addParser(ReflectedMethod<CheckMethodIdentifier, CheckExecutionContext> method, List<MethodParser> parsers) {
parsers.add(
new InteractionCheckClassParser((Class<InteractionCheck<?>>) method.containingObject().getClass(),
a -> ((InteractionCheckMethod) method).identifier = new CheckMethodIdentifier(a, type))
);
}
@Override
protected Optional<BestCandidateMethod<CheckMethodIdentifier, CheckExecutionContext>> bcProduce(String methodName,
Object containingObject) {
if (!(containingObject instanceof InteractionCheck))
return Optional.empty();
return Optional.of(new InteractionCheckMethod(methodName, containingObject));
}
}
}

19
lib/src/main/java/net/tomatentum/marinara/container/InteractionCheckContainer.java Normal file
View File

@ -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<CheckMethodIdentifier, CheckExecutionContext> {
public InteractionCheckContainer() {
super(new ReflectedMethodFactoryImpl<>());
super.factory()
.addFactory(new InteractionCheckMethodFactory(this, CheckMethodType.PRE))
.addFactory(new InteractionCheckMethodFactory(this, CheckMethodType.POST));
}
}

38
lib/src/main/java/net/tomatentum/marinara/container/InteractionMethodContainer.java Normal file
View File

@ -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<InteractionIdentifier, Object> {
private static ReflectedMethodFactory<InteractionIdentifier, Object> createFactory(MethodContainer<CheckMethodIdentifier, CheckExecutionContext> checkRegistry, ContextObjectProvider cop) {
return new ReflectedMethodFactoryImpl<InteractionIdentifier, Object>()
.addFactory(new AutoCompleteInteractionMethod.Factory(checkRegistry, cop))
.addFactory(new SlashCommandInteractionMethod.Factory(checkRegistry, cop))
.addFactory(new ButtonInteractionMethod.Factory(checkRegistry, cop));
}
public InteractionMethodContainer(MethodContainer<CheckMethodIdentifier, CheckExecutionContext> checkRegistry, ContextObjectProvider cop) {
super(createFactory(checkRegistry, cop));
}
@Override
public MethodContainer<InteractionIdentifier, Object> addMethod(ReflectedMethod<InteractionIdentifier, Object> method) {
super.identifiers().stream()
.filter(method.identifier()::equals)
.forEach(i -> InteractionIdentifier.tryAddDescriptions(i, method.identifier()));
return super.addMethod(method);
}
}

38
lib/src/main/java/net/tomatentum/marinara/interaction/components/methods/ButtonInteractionMethod.java
View File

@ -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<CheckMethodIdentifier, CheckExecutionContext> checkContainer, ContextObjectProvider cop) {
super(checkContainer);
this.cop = cop;
}
@Override
public Optional<ReflectedMethod> produce(Marinara marinara, Method method, Object containingObject) {
ReflectedMethod rMethod = null;
public Optional<ReflectedMethod<InteractionIdentifier, Object>> 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<AnnotationParser> parser) {
public void addParser(ReflectedMethod<InteractionIdentifier, Object> method, List<MethodParser> parser) {
super.addParser(method, parser);
parser.add(

38
lib/src/main/java/net/tomatentum/marinara/interaction/methods/AutoCompleteInteractionMethod.java
View File

@ -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<CheckMethodIdentifier, CheckExecutionContext> checkContainer, ContextObjectProvider cop) {
super(checkContainer);
this.cop = cop;
}
@Override
public Optional<ReflectedMethod> produce(Marinara marinara, Method method, Object containingObject) {
ReflectedMethod rMethod = null;
public Optional<ReflectedMethod<InteractionIdentifier, Object>> 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<AnnotationParser> parser) {
public void addParser(ReflectedMethod<InteractionIdentifier, Object> method, List<MethodParser> parser) {
super.addParser(method, parser);
parser.add(

42
lib/src/main/java/net/tomatentum/marinara/interaction/methods/InteractionMethod.java
View File

@ -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<InteractionIdentifier, Object> {
protected Marinara marinara;
protected List<AppliedCheck> 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<AppliedCheck> appliedChecks() {
return this.appliedChecks;
}
public abstract static class Factory implements ReflectedMethodFactory.Factory {
public abstract static class Factory implements ReflectedMethodFactory.Factory<InteractionIdentifier, Object> {
private MethodContainer<CheckMethodIdentifier, CheckExecutionContext> checkContainer;
protected Factory(MethodContainer<CheckMethodIdentifier, CheckExecutionContext> checkContainer) {
this.checkContainer = checkContainer;
}
@Override
public void addParser(ReflectedMethod method, List<AnnotationParser> parser) {
public void addParser(ReflectedMethod<InteractionIdentifier, Object> method, List<MethodParser> 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)
);
}

36
lib/src/main/java/net/tomatentum/marinara/interaction/methods/SlashCommandInteractionMethod.java
View File

@ -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<CheckMethodIdentifier, CheckExecutionContext> checkContainer, ContextObjectProvider cop) {
super(checkContainer);
this.cop = cop;
}
@Override
public Optional<ReflectedMethod> produce(Marinara marinara, Method method, Object containingObject) {
ReflectedMethod rMethod = null;
public Optional<ReflectedMethod<InteractionIdentifier, Object>> 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<AnnotationParser> parser) {
public void addParser(ReflectedMethod<InteractionIdentifier, Object> method, List<MethodParser> parser) {
super.addParser(method, parser);
parser.add(

31
lib/src/main/java/net/tomatentum/marinara/interaction/processor/AutocompleteInteractionProcessor.java
View File

@ -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<InteractionEntry> entry = this.marinara.getRegistry().findFor(convertToCommandIdentifier(identifier));
if (entry.isPresent() && entry.get().identifier() instanceof SlashCommandIdentifier sIdent) {
List<String> autocompleteRefs = Arrays.asList(this.marinara.getWrapper().getContextObjectProvider()
public void processInteraction(Object context, MethodContainer<InteractionIdentifier, Object> container, InteractionIdentifier identifier) {
Optional<InteractionIdentifier> oIdent = container.identifiers().stream()
.filter(i -> convertToCommandIdentifier(identifier).equals(i))
.findFirst();
if (oIdent.isPresent() && oIdent.get() instanceof SlashCommandIdentifier sIdent) {
List<String> autocompleteRefs = Arrays.asList(this.wrapper.getContextObjectProvider()
.getAutocompleteFocusedOption(context).getAutocompleteRefs(sIdent.options()));
List<Object> 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<Object> 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);
}
}

13
lib/src/main/java/net/tomatentum/marinara/interaction/processor/DirectInteractionProcessor.java
View File

@ -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<InteractionIdentifier, Object> container, InteractionIdentifier identifier) {
container.findFor(identifier).forEach(m -> m.run(context));
}
}

14
lib/src/main/java/net/tomatentum/marinara/interaction/processor/InteractionMethodProcessor.java
View File

@ -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<InteractionIdentifier, Object> {
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<InteractionIdentifier, Object> 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<InteractionIdentifier, Object> container,
InteractionIdentifier identifier);
}

8
lib/src/main/java/net/tomatentum/marinara/parser/AnnotationParser.java
View File

@ -1,8 +0,0 @@
package net.tomatentum.marinara.parser;
import java.lang.reflect.Method;
public interface AnnotationParser {
void parse();
Method getMethod();
}

18
lib/src/main/java/net/tomatentum/marinara/parser/AutocompleteParser.java
View File

@ -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<String[]> 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);
}
}

14
lib/src/main/java/net/tomatentum/marinara/parser/ButtonParser.java
View File

@ -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<String> 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;
}
}

28
lib/src/main/java/net/tomatentum/marinara/parser/InteractionCheckClassParser.java Normal file
View File

@ -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<? extends InteractionCheck<?>> interactionCheckType;
private Consumer<Type> annotationTypeConsumer;
public InteractionCheckClassParser(Class<? extends InteractionCheck<?>> interactionCheckType, Consumer<Type> 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);
}
}

32
lib/src/main/java/net/tomatentum/marinara/parser/InteractionCheckParser.java
View File

@ -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<CheckMethodIdentifier, CheckExecutionContext> checkContainer;
private Method method;
private Consumer<AppliedCheck> consumer;
private Logger logger = LoggerUtil.getLogger(getClass());
public InteractionCheckParser(Method method, Consumer<AppliedCheck> consumer, InteractionCheckRegistry checkRegistry) {
this.checkRegistry = checkRegistry;
public InteractionCheckParser(Method method, Consumer<AppliedCheck> consumer, MethodContainer<CheckMethodIdentifier, CheckExecutionContext> 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<InteractionCheck<?>> 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;
}
}

12
lib/src/main/java/net/tomatentum/marinara/parser/SlashCommandParser.java
View File

@ -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<SlashCommandIdentifier> 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)) {

7
lib/src/main/java/net/tomatentum/marinara/reflection/MethodExecutor.java
View File

@ -1,7 +0,0 @@
package net.tomatentum.marinara.reflection;
public interface MethodExecutor {
void handle(Object context);
}

7
lib/src/main/java/net/tomatentum/marinara/reflection/MethodProcessor.java
View File

@ -1,7 +0,0 @@
package net.tomatentum.marinara.reflection;
public interface MethodProcessor {
void process(Object context);
}

7
lib/src/main/java/net/tomatentum/marinara/reflection/ProcessorContainer.java
View File

@ -1,7 +0,0 @@
package net.tomatentum.marinara.reflection;
public interface ProcessorContainer {
ProcessorContainer addProcessor(MethodProcessor processor);
}

32
lib/src/main/java/net/tomatentum/marinara/reflection/ProcessorMethodExecutor.java
View File

@ -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<MethodProcessor> 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));
}
}

66
lib/src/main/java/net/tomatentum/marinara/reflection/ReflectedMethod.java
View File

@ -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<Object> 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();
}
}

20
lib/src/main/java/net/tomatentum/marinara/reflection/ReflectedMethodFactory.java
View File

@ -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<ReflectedMethod> produce(Method method, Object containingClass);
ReflectedMethodFactory addFactory(Factory factory);
public interface Factory {
Optional<ReflectedMethod> produce(Marinara marinara, Method method, Object containingObject);
void addParser(ReflectedMethod method, List<AnnotationParser> parser);
}
}

62
lib/src/main/java/net/tomatentum/marinara/reflection/ReflectedMethodFactoryImpl.java
View File

@ -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<Factory> factories;
public ReflectedMethodFactoryImpl(Marinara marinara) {
this(marinara, new ArrayList<>());
}
public ReflectedMethodFactoryImpl(Marinara marinara, List<Factory> factories) {
this.marinara = marinara;
this.factories = factories;
}
@Override
public Optional<ReflectedMethod> produce(Method method, Object containingClass) {
Optional<ReflectedMethod> 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<ReflectedMethod> factoryProduce(Factory factory, Method method, Object containingClass) {
List<AnnotationParser> parser = new ArrayList<>();
Optional<ReflectedMethod> m = factory.produce(this.marinara, method, containingClass);
m.ifPresent(x -> {
factory.addParser(x, parser);
parser.forEach(AnnotationParser::parse);
});
return m;
}
}

40
lib/src/main/java/net/tomatentum/marinara/registry/InteractionCheckRegistry.java
View File

@ -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<InteractionCheck<?>> 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<InteractionCheck<?>> 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();
}
}

90
lib/src/main/java/net/tomatentum/marinara/registry/InteractionEntry.java
View File

@ -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<InteractionEntry> entries, InteractionIdentifier identifier) {
Optional<InteractionEntry> 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<InteractionMethod> 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.<Object>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<InteractionMethod> methods() {
return methods;
}
}

80
lib/src/main/java/net/tomatentum/marinara/registry/InteractionRegistry.java
View File

@ -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<InteractionEntry> 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<ReflectedMethod> 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<InteractionIdentifier> slashIdentifiers = interactions.stream()
.filter((x) -> x.type().equals(InteractionType.COMMAND))
.map((x) -> x.identifier())
.toList();
SlashCommandDefinition[] defs = new ObjectAggregator<InteractionIdentifier, RootCommandIdentifier, SlashCommandDefinition>(
i -> Arrays.asList((RootCommandIdentifier)i.rootNode()),
SlashCommandDefinition::addIdentifier,
SlashCommandDefinition::new)
.aggregate(slashIdentifiers)
.toArray(SlashCommandDefinition[]::new);
marinara.getWrapper().getRegisterer().register(defs);
}
public Optional<InteractionEntry> findFor(InteractionIdentifier identifier) {
return this.interactions.stream()
.filter(x -> x.identifier().equals(identifier))
.findFirst();
}
public Set<InteractionEntry> interactions() {
return this.interactions;
}
}

107
lib/src/main/java/net/tomatentum/marinara/util/ReflectionUtil.java
View File

@ -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 <T extends Annotation> boolean isAnnotationPresent(Method method, Class<T> annotationClass) {
if (method.isAnnotationPresent(annotationClass) || method.getDeclaringClass().isAnnotationPresent(annotationClass))
return true;
return false;
}
public static <T extends Annotation> T getAnnotation(Method method, Class<T> 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<Class<?>> 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<Method> 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();
}
}

2
lib/src/main/java/net/tomatentum/marinara/wrapper/IdentifierProvider.java
View File

@ -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 {

2
wrapper/discord4j/src/test/java/net/tomatentum/marinara/test/discord4j/AutoCompleteTest.java
View File

@ -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());
}

6
wrapper/discord4j/src/test/java/net/tomatentum/marinara/test/discord4j/ButtonTest.java
View File

@ -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);
}

14
wrapper/discord4j/src/test/java/net/tomatentum/marinara/test/discord4j/InteractionCheckTest.java
View File

@ -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);

10
wrapper/discord4j/src/test/java/net/tomatentum/marinara/test/discord4j/SlashCommandTest.java
View File

@ -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);
}

5
wrapper/discord4j/src/test/java/net/tomatentum/marinara/test/discord4j/TestAutocomplete.java
View File

@ -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")

2
wrapper/discord4j/src/test/java/net/tomatentum/marinara/test/discord4j/TestCommand.java
View File

@ -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!");
}
}

6
wrapper/javacord/src/test/java/net/tomatentum/marinara/test/javacord/AutoCompleteTest.java
View File

@ -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());
}

6
wrapper/javacord/src/test/java/net/tomatentum/marinara/test/javacord/ButtonTest.java
View File

@ -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);
}

14
wrapper/javacord/src/test/java/net/tomatentum/marinara/test/javacord/InteractionCheckTest.java
View File

@ -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);

8
wrapper/javacord/src/test/java/net/tomatentum/marinara/test/javacord/SlashCommandTest.java
View File

@ -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();

6
wrapper/javacord/src/test/java/net/tomatentum/marinara/test/javacord/TestAutocomplete.java
View File

@ -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());
}

2
wrapper/javacord/src/test/java/net/tomatentum/marinara/test/javacord/TestButton.java
View File

@ -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) {

4
wrapper/javacord/src/test/java/net/tomatentum/marinara/test/javacord/TestCommand.java
View File

@ -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!");
}
}