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

Compare commits

base: tueem:42a675dc967df727df24fa542fbd2c8f411b1c9a
Branches Tags
tueem:master
tueem:feat/message-components
tueem:dev
..
compare: tueem:83b446e6fb6ff64fd819085b19bf0fc817a99d27
Branches Tags
tueem:feat/message-components
tueem:dev
tueem:master

No commits in common. "42a675dc967df727df24fa542fbd2c8f411b1c9a" and "83b446e6fb6ff64fd819085b19bf0fc817a99d27" have entirely different histories.
42a675dc96 ... 83b446e6fb

14 changed files with 133 additions and 152 deletions
Show Stats 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.2.0"
cutin = "0.1.1-cad019e"
[libraries]
junit-jupiter = { module = "org.junit.jupiter:junit-jupiter", version.ref = "junit-jupiter" }
@ -18,4 +18,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"}

32
lib/src/main/java/net/tomatentum/marinara/checks/InteractionCheckMethod.java
View File

@ -1,12 +1,12 @@
package net.tomatentum.marinara.checks;
import java.util.List;
import java.util.Optional;
import java.util.Set;
import net.tomatentum.cutin.MethodParser;
import net.tomatentum.cutin.ReflectedMethodFactory.ParserResults;
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;
@ -14,13 +14,8 @@ public class InteractionCheckMethod extends BestCandidateMethod<CheckMethodIdent
private CheckMethodIdentifier identifier;
public InteractionCheckMethod(
String methodName,
Object containingObject,
CheckMethodIdentifier identifier
) {
public InteractionCheckMethod(String methodName, Object containingObject) {
super(methodName, containingObject);
this.identifier = identifier;
}
@Override
@ -49,24 +44,21 @@ public class InteractionCheckMethod extends BestCandidateMethod<CheckMethodIdent
this.type = type;
}
@SuppressWarnings("unchecked")
@Override
public void addParser(Set<MethodParser> parsers) {
public void addParser(ReflectedMethod<CheckMethodIdentifier, CheckExecutionContext> method, List<MethodParser> parsers) {
parsers.add(
new InteractionCheckClassParser()
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,
ParserResults parserResults
) {
CheckMethodIdentifier identifier = new CheckMethodIdentifier(parserResults.get(InteractionCheckClassParser.class), type);
if (identifier.annotationType() == null)
return null;
return Optional.of(new InteractionCheckMethod(methodName, containingObject, identifier));
protected Optional<BestCandidateMethod<CheckMethodIdentifier, CheckExecutionContext>> bcProduce(String methodName,
Object containingObject) {
if (!(containingObject instanceof InteractionCheck))
return Optional.empty();
return Optional.of(new InteractionCheckMethod(methodName, containingObject));
}
}

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

@ -3,21 +3,18 @@ package net.tomatentum.marinara.interaction.components.methods;
import java.lang.reflect.Method;
import java.util.List;
import java.util.Optional;
import java.util.Set;
import net.tomatentum.cutin.MethodParser;
import net.tomatentum.cutin.ReflectedMethodFactory.ParserResults;
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.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.ButtonParser;
import net.tomatentum.marinara.parser.InteractionCheckParser;
import net.tomatentum.marinara.wrapper.ContextObjectProvider;
public class ButtonInteractionMethod extends InteractionMethod {
@ -25,15 +22,8 @@ public class ButtonInteractionMethod extends InteractionMethod {
private String customId;
private ContextObjectProvider cop;
private ButtonInteractionMethod(
Method method,
InteractionHandler handler,
List<AppliedCheck> appliedChecks,
String customId,
ContextObjectProvider cop
) {
super(method, handler, appliedChecks);
this.customId = customId;
private ButtonInteractionMethod(Method method, InteractionHandler handler, ContextObjectProvider cop) {
super(method, handler);
this.cop = cop;
}
@ -66,25 +56,22 @@ public class ButtonInteractionMethod extends InteractionMethod {
}
@Override
public Optional<ReflectedMethod<InteractionIdentifier, Object>> produce(Method method, Object containingObject, ParserResults parserResults) {
if (!(containingObject instanceof InteractionHandler)) return Optional.empty();
String customId = parserResults.get(ButtonParser.class);
if (customId == null) return Optional.empty();
return Optional.of(new ButtonInteractionMethod(
method,
(InteractionHandler) containingObject,
parserResults.get(InteractionCheckParser.class),
customId,
this.cop
));
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, this.cop);
return Optional.ofNullable(rMethod);
}
@Override
public void addParser(Set<MethodParser> parser) {
super.addParser(parser);
public void addParser(ReflectedMethod<InteractionIdentifier, Object> method, List<MethodParser> parser) {
super.addParser(method, parser);
parser.add(
new ButtonParser()
new ButtonParser(method.method(), x -> ((ButtonInteractionMethod) method).customId = x)
);
}

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

@ -3,20 +3,19 @@ package net.tomatentum.marinara.interaction.methods;
import java.lang.reflect.Method;
import java.util.List;
import java.util.Optional;
import java.util.Set;
import net.tomatentum.cutin.MethodParser;
import net.tomatentum.cutin.ReflectedMethodFactory.ParserResults;
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.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.AutocompleteParser;
import net.tomatentum.marinara.parser.InteractionCheckParser;
import net.tomatentum.marinara.wrapper.ContextObjectProvider;
public class AutoCompleteInteractionMethod extends InteractionMethod {
@ -24,15 +23,11 @@ public class AutoCompleteInteractionMethod extends InteractionMethod {
private String autocompleteRef;
private ContextObjectProvider cop;
private AutoCompleteInteractionMethod(
Method method,
InteractionHandler handler,
List<AppliedCheck> appliedChecks,
String autocompleteRef,
ContextObjectProvider cop
private AutoCompleteInteractionMethod(Method method,
InteractionHandler handler,
ContextObjectProvider cop
) {
super(method, handler, appliedChecks);
this.autocompleteRef = autocompleteRef;
super(method, handler);
this.cop = cop;
}
@ -69,27 +64,23 @@ public class AutoCompleteInteractionMethod extends InteractionMethod {
}
@Override
public Optional<ReflectedMethod<InteractionIdentifier, Object>> produce(Method method, Object containingObject, ParserResults parserResults) {
if (!(containingObject instanceof InteractionHandler)) return Optional.empty();
String[] autocompletes = parserResults.get(AutocompleteParser.class);
if (autocompletes.length <= 0) return Optional.empty();
return Optional.of(new AutoCompleteInteractionMethod(
method,
(InteractionHandler) containingObject,
parserResults.get(InteractionCheckParser.class),
autocompletes[0],
cop
));
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, cop);
return Optional.ofNullable(rMethod);
}
@Override
public void addParser(Set<MethodParser> parser) {
super.addParser(parser);
public void addParser(ReflectedMethod<InteractionIdentifier, Object> method, List<MethodParser> parser) {
super.addParser(method, parser);
parser.add(
new AutocompleteParser()
new AutocompleteParser(method.method(), x -> ((AutoCompleteInteractionMethod) method).autocompleteRef = x[0])
);
}

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

@ -1,8 +1,8 @@
package net.tomatentum.marinara.interaction.methods;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.List;
import java.util.Set;
import net.tomatentum.cutin.MethodParser;
import net.tomatentum.cutin.ReflectedMethodFactory;
@ -21,11 +21,10 @@ public abstract class InteractionMethod extends ReflectedMethod<InteractionIdent
protected InteractionMethod(
Method method,
InteractionHandler handler,
List<AppliedCheck> appliedChecks
InteractionHandler handler
) {
super(method, handler);
this.appliedChecks = appliedChecks;
this.appliedChecks = new ArrayList<>();
}
@Override
@ -61,9 +60,10 @@ public abstract class InteractionMethod extends ReflectedMethod<InteractionIdent
}
@Override
public void addParser(Set<MethodParser> parser) {
public void addParser(ReflectedMethod<InteractionIdentifier, Object> method, List<MethodParser> parser) {
InteractionMethod imethod = (InteractionMethod) method;
parser.add(
new InteractionCheckParser(this.checkContainer)
new InteractionCheckParser(method.method(), imethod.appliedChecks::add, this.checkContainer)
);
}

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

@ -3,36 +3,27 @@ package net.tomatentum.marinara.interaction.methods;
import java.lang.reflect.Method;
import java.util.List;
import java.util.Optional;
import java.util.Set;
import net.tomatentum.cutin.MethodParser;
import net.tomatentum.cutin.ReflectedMethodFactory.ParserResults;
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.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.InteractionCheckParser;
import net.tomatentum.marinara.parser.SlashCommandParser;
import net.tomatentum.marinara.wrapper.ContextObjectProvider;
public class SlashCommandInteractionMethod extends InteractionMethod {
private SlashCommandIdentifier identifier;
private SlashCommandIdentifier interactionIdentifier;
private ContextObjectProvider cop;
private SlashCommandInteractionMethod(
Method method,
InteractionHandler handler,
List<AppliedCheck> appliedChecks,
SlashCommandIdentifier identifier,
ContextObjectProvider cop
) {
super(method, handler, appliedChecks);
this.identifier = identifier;
private SlashCommandInteractionMethod(Method method, InteractionHandler handler, ContextObjectProvider cop) {
super(method, handler);
this.cop = cop;
}
@ -40,14 +31,14 @@ public class SlashCommandInteractionMethod extends InteractionMethod {
public Object getParameter(Object context, int index) {
Object superResult = super.getParameter(context, index);
if (superResult == null)
return this.cop.convertCommandOption(context, identifier.options()[index-1].name());
return this.cop.convertCommandOption(context, interactionIdentifier.options()[index-1].name());
else
return superResult;
}
@Override
public InteractionIdentifier identifier() {
return identifier;
return interactionIdentifier;
}
public static class Factory extends InteractionMethod.Factory {
@ -60,25 +51,21 @@ public class SlashCommandInteractionMethod extends InteractionMethod {
}
@Override
public Optional<ReflectedMethod<InteractionIdentifier, Object>> produce(Method method, Object containingObject, ParserResults parserResults) {
if (!(containingObject instanceof InteractionHandler)) return Optional.empty();
SlashCommandIdentifier ident = parserResults.get(SlashCommandParser.class);
if (ident == null) return Optional.empty();
return Optional.of(new SlashCommandInteractionMethod(
method,
(InteractionHandler) containingObject,
parserResults.get(InteractionCheckParser.class),
ident,
cop
));
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, cop);
return Optional.ofNullable(rMethod);
}
@Override
public void addParser(Set<MethodParser> parser) {
super.addParser(parser);
public void addParser(ReflectedMethod<InteractionIdentifier, Object> method, List<MethodParser> parser) {
super.addParser(method, parser);
parser.add(
new SlashCommandParser()
new SlashCommandParser(method.method(), x -> ((SlashCommandInteractionMethod) method).interactionIdentifier = x)
);
}

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

@ -2,6 +2,7 @@ package net.tomatentum.marinara.parser;
import java.lang.reflect.Method;
import java.util.Arrays;
import java.util.function.Consumer;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
@ -14,14 +15,21 @@ public class AutocompleteParser implements MethodParser {
private Logger logger = LoggerFactory.getLogger(getClass());
private Method method;
private Consumer<String[]> consumer;
public AutocompleteParser(Method method, Consumer<String[]> consumer) {
this.method = method;
this.consumer = consumer;
}
@Override
public Object parse(Method method, Object containingObject) {
String[] autoCompletes = Arrays.stream(method.getAnnotationsByType(AutoComplete.class))
public void parse() {
String[] autocompletes = Arrays.stream(this.method.getAnnotationsByType(AutoComplete.class))
.map(AutoComplete::value)
.toArray(String[]::new);
if (autoCompletes.length > 0)
logger.trace("Parsed AutoComplete annotations {} for method {}", autoCompletes, ReflectionUtil.getFullMethodName(method));
return autoCompletes;
logger.trace("Parsed AutoComplete annotation {} for method {}", autocompletes, ReflectionUtil.getFullMethodName(method));
this.consumer.accept(autocompletes);
}
}

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

@ -1,6 +1,7 @@
package net.tomatentum.marinara.parser;
import java.lang.reflect.Method;
import java.util.function.Consumer;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
@ -11,17 +12,21 @@ import net.tomatentum.marinara.interaction.annotation.Button;
public class ButtonParser implements MethodParser {
private Method method;
private Consumer<String> consumer;
private Logger logger = LoggerFactory.getLogger(getClass());
public ButtonParser() {
public ButtonParser(Method method, Consumer<String> consumer) {
this.method = method;
this.consumer = consumer;
}
@Override
public Object parse(Method method, Object containingObject) {
Button button = method.getAnnotation(Button.class);
if (button == null) return null;
public void parse() {
Button button = this.method.getAnnotation(Button.class);
logger.trace("Parsed Button annotation {} for method {}", button, ReflectionUtil.getFullMethodName(method));
return button.value();
this.consumer.accept(button.value());
}
}

22
lib/src/main/java/net/tomatentum/marinara/parser/InteractionCheckClassParser.java
View File

@ -1,8 +1,8 @@
package net.tomatentum.marinara.parser;
import java.lang.reflect.Method;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.function.Consumer;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
@ -15,14 +15,20 @@ public class InteractionCheckClassParser implements MethodParser {
private Logger logger = LoggerFactory.getLogger(getClass());
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 Object parse(Method method, Object containingObject) {
ParameterizedType type = (ParameterizedType) GenericTypeReflector.getExactSuperType(containingObject.getClass(), InteractionCheck.class);
if (type == null) return null;
Type typeParam = type.getActualTypeArguments().length == 1 ? type.getActualTypeArguments()[0] : null;
if (typeParam != null)
logger.trace("Parsed InteractionCheck Annotation {}", typeParam);
return typeParam;
public void parse() {
ParameterizedType type = (ParameterizedType) GenericTypeReflector.getExactSuperType(interactionCheckType, InteractionCheck.class);
Type typeParam = type.getActualTypeArguments()[0];
logger.trace("Parsed InteractionCheck Annotation {}", typeParam);
this.annotationTypeConsumer.accept(typeParam);
}
}

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

@ -3,7 +3,7 @@ package net.tomatentum.marinara.parser;
import java.lang.annotation.Annotation;
import java.lang.reflect.Method;
import java.util.Arrays;
import java.util.Objects;
import java.util.function.Consumer;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
@ -19,31 +19,31 @@ import net.tomatentum.marinara.checks.CheckMethodIdentifier.CheckMethodType;
public class InteractionCheckParser implements MethodParser {
private MethodContainer<CheckMethodIdentifier, CheckExecutionContext> checkContainer;
private Method method;
private Consumer<AppliedCheck> consumer;
private Logger logger = LoggerFactory.getLogger(getClass());
public InteractionCheckParser(MethodContainer<CheckMethodIdentifier, CheckExecutionContext> checkContainer) {
public InteractionCheckParser(Method method, Consumer<AppliedCheck> consumer, MethodContainer<CheckMethodIdentifier, CheckExecutionContext> checkContainer) {
this.checkContainer = checkContainer;
this.method = method;
this.consumer = consumer;
}
@Override
public Object parse(Method method, Object containingObject) {
public void parse() {
Annotation[] annotations = method.getAnnotations();
return Arrays.stream(annotations)
.map(a -> convertAnnotation(a, method))
.filter(Objects::nonNull)
.toList();
Arrays.stream(annotations).forEach(this::convertAnnotation);
}
private AppliedCheck convertAnnotation(Annotation annotation, Method method) {
private void convertAnnotation(Annotation annotation) {
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));
return appliedCheck;
consumer.accept(appliedCheck);
}
return null;
}
}

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

@ -1,6 +1,7 @@
package net.tomatentum.marinara.parser;
import java.lang.reflect.Method;
import java.util.function.Consumer;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
@ -12,17 +13,22 @@ import net.tomatentum.marinara.interaction.commands.annotation.SlashCommand;
import net.tomatentum.marinara.interaction.commands.annotation.SubCommand;
import net.tomatentum.marinara.interaction.commands.annotation.SubCommandGroup;
import net.tomatentum.marinara.interaction.ident.InteractionIdentifier;
import net.tomatentum.marinara.interaction.ident.SlashCommandIdentifier;
public class SlashCommandParser implements MethodParser {
private Method method;
private Consumer<SlashCommandIdentifier> consumer;
private Logger logger = LoggerFactory.getLogger(getClass());
public SlashCommandParser() {
public SlashCommandParser(Method method, Consumer<SlashCommandIdentifier> consumer) {
this.method = method;
this.consumer = consumer;
}
@Override
public Object parse(Method method, Object containingObject) {
if (!method.isAnnotationPresent(SlashCommand.class) && !method.isAnnotationPresent(SubCommand.class)) return null;
public void parse() {
this.checkValidCommandMethod(method);
SlashCommand cmd = ReflectionUtil.getAnnotation(method, SlashCommand.class);
@ -53,21 +59,21 @@ public class SlashCommandParser implements MethodParser {
}
logger.trace("Parsed using SlashCommandParser for method {} with the result: {}", ReflectionUtil.getFullMethodName(method), lastIdentifier);
return lastIdentifier;
consumer.accept((SlashCommandIdentifier) lastIdentifier);
}
private void checkValidCommandMethod(Method method) {
if (method.isAnnotationPresent(SlashCommand.class) &&
method.getDeclaringClass().isAnnotationPresent(SlashCommand.class)) {
throw new RuntimeException(method.getName() + ": Can't have SlashCommand Annotation on Class and Method");
throw new RuntimeException(method.getName() + ": Can't have ApplicationCommand Annotation on Class and Method");
}
if (!ReflectionUtil.isAnnotationPresent(method, SlashCommand.class))
throw new RuntimeException(method.getName() + ": Missing SlashCommand Annotation on either Class or Method");
throw new RuntimeException(method.getName() + ": Missing ApplicationCommand Annotation on either Class or Method");
if ((method.isAnnotationPresent(SubCommand.class) &&
!ReflectionUtil.isAnnotationPresent(method, SlashCommand.class))) {
throw new RuntimeException(method.getName() + ": Missing SlashCommand Annotation on either Method or Class");
throw new RuntimeException(method.getName() + ": Missing ApplicationCommand Annotation on either Method or Class");
}
}

4
wrapper/discord4j/src/main/java/net/tomatentum/marinara/wrapper/discord4j/Discord4JWrapper.java
View File

@ -4,7 +4,6 @@ import java.util.List;
import java.util.function.UnaryOperator;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import discord4j.core.GatewayDiscordClient;
import discord4j.core.event.domain.interaction.ChatInputAutoCompleteEvent;
@ -14,6 +13,7 @@ import discord4j.core.object.command.ApplicationCommandOption.Type;
import discord4j.discordjson.json.ApplicationCommandOptionChoiceData;
import discord4j.discordjson.json.ApplicationCommandRequest;
import net.tomatentum.marinara.util.LoggerUtil;
import net.tomatentum.marinara.wrapper.CommandConverter;
import net.tomatentum.marinara.wrapper.CommandRegisterer;
import net.tomatentum.marinara.wrapper.ContextObjectProvider;
@ -37,7 +37,7 @@ public class Discord4JWrapper extends LibraryWrapper {
private Discord4JContextObjectProvider contextObjectProvider;
private CommandRegisterer<ApplicationCommandRequest> commandRegisterer;
private Logger logger = LoggerFactory.getLogger(getClass());
private Logger logger = LoggerUtil.getLogger(getClass());
public Discord4JWrapper(GatewayDiscordClient api) {
this.contextObjectProvider = new Discord4JContextObjectProvider();

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

@ -21,7 +21,6 @@ import discord4j.core.object.command.ApplicationCommandOption.Type;
import net.tomatentum.marinara.Marinara;
import net.tomatentum.marinara.wrapper.LibraryWrapper;
import net.tomatentum.marinara.wrapper.discord4j.Discord4JWrapper;
@TestInstance(Lifecycle.PER_CLASS)
class SlashCommandTest {

4
wrapper/javacord/src/main/java/net/tomatentum/marinara/wrapper/javacord/JavacordWrapper.java
View File

@ -7,12 +7,12 @@ import org.javacord.api.interaction.AutocompleteInteraction;
import org.javacord.api.interaction.SlashCommandBuilder;
import org.javacord.api.interaction.SlashCommandOptionChoice;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import net.tomatentum.marinara.wrapper.CommandConverter;
import net.tomatentum.marinara.wrapper.CommandRegisterer;
import net.tomatentum.marinara.wrapper.ContextObjectProvider;
import net.tomatentum.marinara.wrapper.IdentifierProvider;
import net.tomatentum.marinara.util.LoggerUtil;
import net.tomatentum.marinara.wrapper.LibraryWrapper;
import net.tomatentum.marinara.wrapper.javacord.identifierconverter.AutocompleteIdentifierConverter;
import net.tomatentum.marinara.wrapper.javacord.identifierconverter.ButtonIdentifierConverter;
@ -23,7 +23,7 @@ public class JavacordWrapper extends LibraryWrapper {
private JavacordContextObjectProvider contextObjectProvider;
private CommandRegisterer<SlashCommandBuilder> commandRegisterer;
private Logger logger = LoggerFactory.getLogger(getClass());
private Logger logger = LoggerUtil.getLogger(getClass());
public JavacordWrapper(DiscordApi api) {
this.contextObjectProvider = new JavacordContextObjectProvider();