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

WIP: add Message-Components handling/registry #21

Draft
tueem wants to merge 13 commits from feat/message-components into dev
pull from: feat/message-components
merge into: tueem:dev
Conversation 0 Commits 13 Files Changed 43 +855 -300
43 changed files with 855 additions and 300 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
build.gradle.kts
View File

@ -8,7 +8,11 @@ allprojects {
group = "net.tomatentum.Marinara"
version = "1.0.0-RC1" + (if (!project.hasProperty("release")) ("-" + getGitHash()) else "")
description = "A simple but powerful, library-agnostic Discord Interaction Wrapper."
plugins.withType<JavaPlugin> {
tasks.withType<Jar>().configureEach {
archiveBaseName.set("marinara-" + archiveBaseName.get())
}
}
}
subprojects {

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

@ -2,39 +2,64 @@ package net.tomatentum.marinara;
import org.slf4j.Logger;
import net.tomatentum.marinara.interaction.InteractionType;
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.wrapper.IdentifierProvider;
import net.tomatentum.marinara.wrapper.LibraryWrapper;
public class Marinara {
private Logger logger = LoggerUtil.getLogger(getClass());
public static <T extends LibraryWrapper> Marinara load(LibraryWrapper wrapper) {
public static Marinara load(LibraryWrapper wrapper) {
return new Marinara(wrapper);
}
private LibraryWrapper wrapper;
private ReflectedMethodFactory reflectedMethodFactory;
private InteractionRegistry registry;
private InteractionCheckRegistry checkRegistry;
private LibraryWrapper wrapper;
private MethodExecutor interactionExecutor;
private Marinara(LibraryWrapper wrapper) {
this.wrapper = wrapper;
this.reflectedMethodFactory = new ReflectedMethodFactoryImpl(this);
this.registry = new InteractionRegistry(this);
this.checkRegistry = new InteractionCheckRegistry();
IdentifierProvider provider = wrapper.createIdentifierProvider();
this.interactionExecutor = (MethodExecutor) new ProcessorMethodExecutor()
.addProcessor(new DirectInteractionProcessor(getRegistry(), provider, InteractionType.COMMAND, InteractionType.BUTTON))
.addProcessor(new AutocompleteInteractionProcessor(this, provider));
wrapper.subscribeInteractions(this.interactionExecutor::handle);
logger.info("Marinara loaded successfully!");
}
public LibraryWrapper getWrapper() {
return this.wrapper;
}
public InteractionRegistry getRegistry() {
return registry;
return this.registry;
}
public InteractionCheckRegistry getCheckRegistry() {
return checkRegistry;
return this.checkRegistry;
}
public LibraryWrapper getWrapper() {
return wrapper;
public ReflectedMethodFactory getReflectedMethodFactory() {
return this.reflectedMethodFactory;
}
public MethodExecutor getInteractionExecutor() {
return interactionExecutor;
}
}

2
lib/src/main/java/net/tomatentum/marinara/interaction/annotation/AutoComplete.java
View File

@ -8,5 +8,5 @@ import java.lang.annotation.Target;
@Target({ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
public @interface AutoComplete {
public String value();
}

5
lib/src/main/java/net/tomatentum/marinara/interaction/commands/annotation/SlashCommandOption.java
View File

@ -5,6 +5,7 @@ import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import net.tomatentum.marinara.interaction.annotation.AutoComplete;
import net.tomatentum.marinara.interaction.commands.option.SlashCommandOptionType;
@Target({ElementType.ANNOTATION_TYPE})
@ -14,11 +15,11 @@ public @interface SlashCommandOption {
public String description() default "";
public SlashCommandOptionType type() default SlashCommandOptionType.STRING;
public boolean required() default false;
public boolean autocomplete() default false;
public AutoComplete[] autocompletes() default {};
public Range range() default @Range;
public CommandChoices choices() default @CommandChoices;
public static enum PlaceHolderEnum {
public enum PlaceHolderEnum {
}
}

16
lib/src/main/java/net/tomatentum/marinara/interaction/commands/option/AutocompleteOptionData.java Normal file
View File

@ -0,0 +1,16 @@
package net.tomatentum.marinara.interaction.commands.option;
import java.util.Arrays;
import net.tomatentum.marinara.interaction.commands.annotation.SlashCommandOption;
public record AutocompleteOptionData(String name, Object input) {
public String[] getAutocompleteRefs(SlashCommandOption[] options) {
return Arrays.stream(options)
.filter(o -> o.name().equals(this.name()))
.flatMap(o -> Arrays.stream(o.autocompletes()))
.map(a -> a.value())
.toArray(String[]::new);
}
}

64
lib/src/main/java/net/tomatentum/marinara/interaction/components/methods/ButtonInteractionMethod.java Normal file
View File

@ -0,0 +1,64 @@
package net.tomatentum.marinara.interaction.components.methods;
import java.lang.reflect.Method;
import java.util.List;
import java.util.Optional;
import net.tomatentum.marinara.Marinara;
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;
public class ButtonInteractionMethod extends InteractionMethod {
private String customId;
private ButtonInteractionMethod(Method method, InteractionHandler handler, Marinara marinara) {
super(method, handler, marinara);
}
@Override
public Object getParameter(Object context, int index) {
Class<?> type = method().getParameterTypes()[index+1];
return marinara.getWrapper().getContextObjectProvider().getComponentContextObject(context, type);
}
@Override
public InteractionIdentifier identifier() {
return InteractionIdentifier.builder()
.name(customId)
.description("Button")
.type(InteractionType.BUTTON)
.build();
}
public static class Factory extends InteractionMethod.Factory {
@Override
public Optional<ReflectedMethod> produce(Marinara marinara, Method method, Object containingObject) {
ReflectedMethod rMethod = null;
if (method.isAnnotationPresent(Button.class) &&
(containingObject instanceof InteractionHandler iHandler)
)
rMethod = new ButtonInteractionMethod(method, iHandler, marinara);
return Optional.ofNullable(rMethod);
}
@Override
public void addParser(ReflectedMethod method, List<AnnotationParser> parser) {
super.addParser(method, parser);
parser.add(
new ButtonParser(method.method(), x -> ((ButtonInteractionMethod) method).customId = x)
);
}
}
}

9
lib/src/main/java/net/tomatentum/marinara/interaction/ident/InteractionIdentifier.java
View File

@ -80,14 +80,19 @@ public class InteractionIdentifier {
return false;
if (!name().equals(ident.name()))
return false;
return Objects.equals(ident, obj);
return Objects.equals(parent(), ident.parent());
}
@Override
public int hashCode() {
return Objects.hash(type(), name(), parent());
}
@Override
public String toString() {
if (parent() == null)
return name();
return "{}.{}".formatted(name(), parent().toString());
return "%s.%s".formatted(name(), parent().toString());
}
public static class Builder {

15
lib/src/main/java/net/tomatentum/marinara/interaction/ident/RootCommandIdentifier.java
View File

@ -28,7 +28,7 @@ public class RootCommandIdentifier extends SlashCommandIdentifier {
private String description;
private SlashCommandOption[] options;
private long[] serverIds;
private String[] autocompleteRef;
public InteractionIdentifier parent() {
return parent;
@ -75,12 +75,21 @@ public class RootCommandIdentifier extends SlashCommandIdentifier {
return this;
}
public SlashCommandIdentifier build(boolean autocomplete) {
public String[] autocompleteRef() {
return this.autocompleteRef;
}
public Builder autocompleteRef(String[] autocompleteRef) {
this.autocompleteRef = autocompleteRef;
return this;
}
public SlashCommandIdentifier build() {
return new RootCommandIdentifier(
parent,
name,
description,
autocomplete ? InteractionType.AUTOCOMPLETE : InteractionType.COMMAND,
InteractionType.COMMAND,
options,
serverIds);
}

17
lib/src/main/java/net/tomatentum/marinara/interaction/ident/SlashCommandIdentifier.java
View File

@ -12,8 +12,7 @@ public class SlashCommandIdentifier extends InteractionIdentifier {
String name,
String description,
InteractionType type,
SlashCommandOption[] options
) {
SlashCommandOption[] options) {
super(parent, name, description, type);
this.options = options;
}
@ -27,6 +26,7 @@ public class SlashCommandIdentifier extends InteractionIdentifier {
private String name;
private String description;
private SlashCommandOption[] options;
private String[] autocompleteRef;
public InteractionIdentifier parent() {
return parent;
@ -64,12 +64,21 @@ public class SlashCommandIdentifier extends InteractionIdentifier {
return this;
}
public SlashCommandIdentifier build(boolean autocomplete) {
public String[] autocompleteRef() {
return this.autocompleteRef;
}
public Builder autocompleteRef(String[] autocompleteRef) {
this.autocompleteRef = autocompleteRef;
return this;
}
public SlashCommandIdentifier build() {
return new SlashCommandIdentifier(
parent,
name,
description,
autocomplete ? InteractionType.AUTOCOMPLETE : InteractionType.COMMAND,
InteractionType.COMMAND,
options);
}

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

@ -1,44 +1,77 @@
package net.tomatentum.marinara.interaction.methods;
import java.lang.reflect.Method;
import java.util.List;
import java.util.Optional;
import net.tomatentum.marinara.Marinara;
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.SlashCommandParser;
import net.tomatentum.marinara.parser.AutocompleteParser;
import net.tomatentum.marinara.reflection.ReflectedMethod;
public class AutoCompleteInteractionMethod extends InteractionMethod {
private InteractionIdentifier interactionIdentifier;
private String autocompleteRef;
public AutoCompleteInteractionMethod(Method method,
private AutoCompleteInteractionMethod(Method method,
InteractionHandler handler,
Marinara marinara
) {
super(method, handler, marinara);
}
@Override
public AnnotationParser[] parsers() {
return new AnnotationParser[] {
new SlashCommandParser(method, true, (x) -> { this.interactionIdentifier = x; } )
};
}
@Override
public Object getParameter(Object context, int index) {
Class<?> type = method().getParameterTypes()[index+1];
Object autocompleteOptionValue = marinara.getWrapper().getContextObjectProvider().getAutocompleteFocusedOption(context);
if (autocompleteOptionValue != null)
Object contextObject = marinara.getWrapper().getContextObjectProvider().getInteractionContextObject(context, type);
if (contextObject != null)
return contextObject;
Object autocompleteOptionValue = marinara.getWrapper().getContextObjectProvider().getAutocompleteFocusedOption(context).input();
if (type.isInstance(autocompleteOptionValue))
return autocompleteOptionValue;
return marinara.getWrapper().getContextObjectProvider().getInteractionContextObject(context, type);
return null;
}
@Override
public InteractionIdentifier identifier() {
return interactionIdentifier;
return InteractionIdentifier.builder()
.type(InteractionType.AUTOCOMPLETE)
.name(autocompleteRef)
.description("AUTOCOMPLETE")
.build();
}
public static class Factory extends InteractionMethod.Factory {
@Override
public Optional<ReflectedMethod> produce(Marinara marinara, Method method, Object containingObject) {
ReflectedMethod 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);
return Optional.ofNullable(rMethod);
}
@Override
public void addParser(ReflectedMethod method, List<AnnotationParser> parser) {
super.addParser(method, parser);
parser.add(
new AutocompleteParser(method.method(), x -> ((AutoCompleteInteractionMethod) method).autocompleteRef = x[0])
);
}
}
}

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

@ -1,42 +0,0 @@
package net.tomatentum.marinara.interaction.methods;
import java.lang.reflect.Method;
import net.tomatentum.marinara.Marinara;
import net.tomatentum.marinara.interaction.InteractionHandler;
import net.tomatentum.marinara.interaction.InteractionType;
import net.tomatentum.marinara.interaction.ident.InteractionIdentifier;
import net.tomatentum.marinara.parser.AnnotationParser;
import net.tomatentum.marinara.parser.ButtonParser;
public class ButtonInteractionMethod extends InteractionMethod {
private String customId;
ButtonInteractionMethod(Method method, InteractionHandler handler, Marinara marinara) {
super(method, handler, marinara);
}
@Override
public AnnotationParser[] parsers() {
return new AnnotationParser[] {
new ButtonParser(method, (x) -> { this.customId = x; } )
};
}
@Override
public Object getParameter(Object context, int index) {
Class<?> type = method().getParameterTypes()[index+1];
return marinara.getWrapper().getContextObjectProvider().getComponentContextObject(context, type);
}
@Override
public InteractionIdentifier identifier() {
return InteractionIdentifier.builder()
.name(customId)
.description("Button")
.type(InteractionType.BUTTON)
.build();
}
}

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

@ -1,105 +1,66 @@
package net.tomatentum.marinara.interaction.methods;
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.Marinara;
import net.tomatentum.marinara.checks.AppliedCheck;
import net.tomatentum.marinara.interaction.InteractionHandler;
import net.tomatentum.marinara.interaction.annotation.AutoComplete;
import net.tomatentum.marinara.interaction.annotation.Button;
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.InteractionCheckParser;
import net.tomatentum.marinara.util.LoggerUtil;
import net.tomatentum.marinara.util.ReflectionUtil;
import net.tomatentum.marinara.reflection.ReflectedMethod;
import net.tomatentum.marinara.reflection.ReflectedMethodFactory;
public abstract class InteractionMethod {
public abstract class InteractionMethod extends ReflectedMethod {
public static InteractionMethod create(Method method, InteractionHandler handler, Marinara marinara) {
if (method.isAnnotationPresent(AutoComplete.class))
return new AutoCompleteInteractionMethod(method, handler, marinara);
if (method.isAnnotationPresent(SlashCommand.class) || method.isAnnotationPresent(SubCommand.class))
return new SlashCommandInteractionMethod(method, handler, marinara);
if (method.isAnnotationPresent(Button.class))
return new ButtonInteractionMethod(method, handler, marinara);
return null;
}
protected Method method;
protected InteractionHandler handler;
protected Marinara marinara;
protected List<AnnotationParser> parsers;
protected List<AppliedCheck> appliedChecks;
private Logger logger = LoggerUtil.getLogger(getClass());
protected InteractionMethod(
Method method,
InteractionHandler handler,
Marinara marinara
) {
if (!Arrays.asList(handler.getClass().getMethods()).contains(method))
throw new InvalidParameterException("Method does not apply to specified handler");
this.method = method;
this.handler = handler;
super(method, handler);
this.marinara = marinara;
this.parsers = new ArrayList<>(Arrays.asList(parsers()));
this.appliedChecks = new ArrayList<>();
parsers.add(new InteractionCheckParser(method, appliedChecks::add, marinara.getCheckRegistry()));
parsers.stream().forEach(AnnotationParser::parse);
}
public void run(Object context) {
@Override
public Object run(Object context) {
Object result = null;
if (this.appliedChecks.stream().filter(x -> !x.pre(context)).count() > 0)
return;
return null;
method.setAccessible(true);
try {
method.invoke(handler, getParameters(context));
}catch (IllegalAccessException | InvocationTargetException ex) {
logger.error("InteractionMethod failed to run", ex);
}
result = super.run(context);
this.appliedChecks.forEach(x -> x.post(context));
return result;
}
public abstract AnnotationParser[] parsers();
public abstract Object getParameter(Object context, int index);
public abstract InteractionIdentifier identifier();
public Method method() {
return method;
public Marinara marinara() {
return this.marinara;
}
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);
public List<AppliedCheck> appliedChecks() {
return this.appliedChecks;
}
logger.trace("Found parameter {}={} for method {}", parameter != null ? parameter.getClass().toString() : " ", parameter, ReflectionUtil.getFullMethodName(method));
parameters.add(parameter);
public abstract static class Factory implements ReflectedMethodFactory.Factory {
@Override
public void addParser(ReflectedMethod method, List<AnnotationParser> parser) {
InteractionMethod imethod = (InteractionMethod) method;
parser.add(
new InteractionCheckParser(method.method(), imethod.appliedChecks::add, imethod.marinara().getCheckRegistry())
);
}
return parameters.toArray();
}
}

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

@ -1,29 +1,27 @@
package net.tomatentum.marinara.interaction.methods;
import java.lang.reflect.Method;
import java.util.List;
import java.util.Optional;
import net.tomatentum.marinara.Marinara;
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;
public class SlashCommandInteractionMethod extends InteractionMethod {
private SlashCommandIdentifier interactionIdentifier;
SlashCommandInteractionMethod(Method method, InteractionHandler handler, Marinara marinara) {
private SlashCommandInteractionMethod(Method method, InteractionHandler handler, Marinara marinara) {
super(method, handler, marinara);
}
@Override
public AnnotationParser[] parsers() {
return new AnnotationParser[] {
new SlashCommandParser(method, false, (x) -> { this.interactionIdentifier = x; } )
};
}
@Override
public Object getParameter(Object context, int index) {
return marinara.getWrapper().getContextObjectProvider().convertCommandOption(context, interactionIdentifier.options()[index].name());
@ -34,4 +32,27 @@ public class SlashCommandInteractionMethod extends InteractionMethod {
return interactionIdentifier;
}
public static class Factory extends InteractionMethod.Factory {
@Override
public Optional<ReflectedMethod> produce(Marinara marinara, Method method, Object containingObject) {
ReflectedMethod rMethod = null;
if ((containingObject instanceof InteractionHandler iHandler) &&
(method.isAnnotationPresent(SlashCommand.class) ||
method.isAnnotationPresent(SubCommand.class)))
rMethod = new SlashCommandInteractionMethod(method, iHandler, marinara);
return Optional.ofNullable(rMethod);
}
@Override
public void addParser(ReflectedMethod method, List<AnnotationParser> parser) {
super.addParser(method, parser);
parser.add(
new SlashCommandParser(method.method(), x -> ((SlashCommandInteractionMethod) method).interactionIdentifier = x)
);
}
}
}

53
lib/src/main/java/net/tomatentum/marinara/interaction/processor/AutocompleteInteractionProcessor.java Normal file
View File

@ -0,0 +1,53 @@
package net.tomatentum.marinara.interaction.processor;
import java.util.Arrays;
import java.util.List;
import java.util.Objects;
import java.util.Optional;
import java.util.Set;
import net.tomatentum.marinara.Marinara;
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;
public class AutocompleteInteractionProcessor extends InteractionMethodProcessor {
private Marinara marinara;
public AutocompleteInteractionProcessor(Marinara marinara, IdentifierProvider provider) {
super(provider, Set.of(InteractionType.AUTOCOMPLETE));
this.marinara = marinara;
}
@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()
.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)
.filter(Objects::nonNull)
.toList();
if (!results.isEmpty())
marinara.getWrapper().respondAutocomplete(context, results);
}
}
private InteractionIdentifier convertToCommandIdentifier(InteractionIdentifier identifier) {
if (Objects.isNull(identifier))
return null;
return InteractionIdentifier.builder()
.type(InteractionType.COMMAND)
.name(identifier.name())
.parent(convertToCommandIdentifier(identifier.parent()))
.build();
}
}

27
lib/src/main/java/net/tomatentum/marinara/interaction/processor/DirectInteractionProcessor.java Normal file
View File

@ -0,0 +1,27 @@
package net.tomatentum.marinara.interaction.processor;
import java.util.Set;
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) {
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));
}
}

35
lib/src/main/java/net/tomatentum/marinara/interaction/processor/InteractionMethodProcessor.java Normal file
View File

@ -0,0 +1,35 @@
package net.tomatentum.marinara.interaction.processor;
import java.util.Set;
import org.slf4j.Logger;
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 {
private Logger logger = LoggerUtil.getLogger(getClass());
private IdentifierProvider provider;
private Set<InteractionType> types;
protected InteractionMethodProcessor(IdentifierProvider provider, Set<InteractionType> types) {
this.provider = provider;
this.types = types;
}
@Override
public void process(Object context) {
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);
}
protected abstract void processInteraction(Object context, InteractionIdentifier identifier);
}

33
lib/src/main/java/net/tomatentum/marinara/parser/AutocompleteParser.java Normal file
View File

@ -0,0 +1,33 @@
package net.tomatentum.marinara.parser;
import java.lang.reflect.Method;
import java.util.Arrays;
import java.util.function.Consumer;
import net.tomatentum.marinara.interaction.annotation.AutoComplete;
public class AutocompleteParser implements AnnotationParser {
private Method method;
private Consumer<String[]> consumer;
public AutocompleteParser(Method method, Consumer<String[]> consumer) {
this.method = method;
this.consumer = consumer;
}
@Override
public void parse() {
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;
}
}

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

@ -17,14 +17,12 @@ import net.tomatentum.marinara.util.ReflectionUtil;
public class SlashCommandParser implements AnnotationParser {
private Method method;
private boolean isAutoComplete;
private Consumer<SlashCommandIdentifier> consumer;
private Logger logger = LoggerUtil.getLogger(getClass());
public SlashCommandParser(Method method, boolean isAutoComplete, Consumer<SlashCommandIdentifier> consumer) {
public SlashCommandParser(Method method, Consumer<SlashCommandIdentifier> consumer) {
this.method = method;
this.isAutoComplete = isAutoComplete;
this.consumer = consumer;
}
@ -38,14 +36,14 @@ public class SlashCommandParser implements AnnotationParser {
.description(cmd.description())
.options(cmd.options())
.serverIds(cmd.serverIds())
.build(isAutoComplete);
.build();
if (ReflectionUtil.isAnnotationPresent(method, SubCommandGroup.class)) {
SubCommandGroup cmdGroup = ReflectionUtil.getAnnotation(method, SubCommandGroup.class);
lastIdentifier = InteractionIdentifier.builder()
.name(cmdGroup.name())
.description(cmdGroup.description())
.type(isAutoComplete ? InteractionType.AUTOCOMPLETE : InteractionType.COMMAND)
.type(InteractionType.COMMAND)
.parent(lastIdentifier)
.build();
}
@ -56,7 +54,7 @@ public class SlashCommandParser implements AnnotationParser {
.name(subCmd.name())
.description(subCmd.description())
.options(subCmd.options())
.build(isAutoComplete);
.build();
}
logger.trace("Parsed using SlashCommandParser for method {} with the result: {}", ReflectionUtil.getFullMethodName(method), lastIdentifier.toString());

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

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

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

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

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

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

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

@ -0,0 +1,32 @@
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 Normal file
View File

@ -0,0 +1,66 @@
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 Normal file
View File

@ -0,0 +1,20 @@
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 Normal file
View File

@ -0,0 +1,62 @@
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;
}
}

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

@ -1,7 +1,10 @@
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;
@ -11,6 +14,17 @@ 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;
@ -22,19 +36,25 @@ public class InteractionEntry {
}
public InteractionEntry addMethod(InteractionMethod method) {
if (!method.identifier().equals(this.identifier))
throw new IllegalArgumentException("Method's identifier did not match the entry's identifier");
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(identifier, method.identifier());
InteractionIdentifier.tryAddDescriptions(midentifier, midentifier);
logger.debug("Added method {} to entry {}", method.method().getName(), this.identifier);
return this;
}
public void runAll(Object context) {
this.methods.stream().forEach(x -> {
logger.debug("Running Method {} from {} with context {}", x.toString(), this.toString(), context.toString());
x.run(context);
});
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
@ -45,6 +65,11 @@ public class InteractionEntry {
return other.identifier().equals(identifier());
}
@Override
public int hashCode() {
return this.identifier().hashCode();
}
@Override
public String toString() {
return "InteractionEntry(%s)".formatted(identifier().toString());

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

@ -13,41 +13,41 @@ 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.wrapper.IdentifierProvider;
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;
private IdentifierProvider identifierProvider;
public InteractionRegistry(Marinara marinara) {
this.interactions = new HashSet<>();
this.marinara = marinara;
this.identifierProvider = marinara.getWrapper().createIdentifierProvider();
marinara.getWrapper().subscribeInteractions(this::handle);
marinara.getReflectedMethodFactory()
.addFactory(new AutoCompleteInteractionMethod.Factory())
.addFactory(new SlashCommandInteractionMethod.Factory())
.addFactory(new ButtonInteractionMethod.Factory());
}
/*
* TODO: Maybe relocate InteractionEntry checking to another class with description merging.
*/
public void addInteractions(InteractionHandler interactionHandler) {
for (Method method : interactionHandler.getClass().getMethods()) {
InteractionMethod iMethod = InteractionMethod.create(method, interactionHandler, marinara);
if (iMethod != null) {
Optional<InteractionEntry> oentry = this.interactions.stream()
.filter(i -> i.identifier().equals(iMethod.identifier()))
.findFirst();
InteractionEntry entry = oentry.orElse(new InteractionEntry(iMethod.identifier())).addMethod(iMethod);
if (oentry.isEmpty()) this.interactions.add(entry);
logger.debug("Added {} method from {}", iMethod.method().getName(), interactionHandler.getClass().getSimpleName());
}
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());
}
@ -68,13 +68,13 @@ public class InteractionRegistry {
marinara.getWrapper().getRegisterer().register(defs);
}
public void handle(Object context) {
logger.debug("Received {} interaction ", context);
interactions.forEach((e) -> {
if (this.identifierProvider.provide(context).equals(e.identifier())) {
logger.info("Running {} interaction using {}\ncontext: {}", e.type(), e.toString(), context.toString());
e.runAll(context);
}
});
public Optional<InteractionEntry> findFor(InteractionIdentifier identifier) {
return this.interactions.stream()
.filter(x -> x.identifier().equals(identifier))
.findFirst();
}
public Set<InteractionEntry> interactions() {
return this.interactions;
}
}

4
lib/src/main/java/net/tomatentum/marinara/wrapper/ContextObjectProvider.java
View File

@ -1,5 +1,7 @@
package net.tomatentum.marinara.wrapper;
import net.tomatentum.marinara.interaction.commands.option.AutocompleteOptionData;
public interface ContextObjectProvider {
public Object convertCommandOption(Object context, String optionName);
@ -7,5 +9,5 @@ public interface ContextObjectProvider {
public Object getComponentContextObject(Object context, Class<?> type);
public Object getInteractionContextObject(Object context, Class<?> type);
public Object getAutocompleteFocusedOption(Object context);
public AutocompleteOptionData getAutocompleteFocusedOption(Object context);
}

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

@ -29,7 +29,7 @@ public class IdentifierProvider {
if (conv.getClass().getName().contains("$$Lambda"))
throw new IllegalArgumentException("Lambdas cannot be used for IdentifierConverter because of Type erasure.");
Type type = GenericTypeReflector.getExactSuperType(conv.getClass(), Converter.class);
Type parameterType = (Class<?>) ((ParameterizedType) type).getActualTypeArguments()[0];
Type parameterType = ((ParameterizedType) type).getActualTypeArguments()[0];
if (!(parameterType instanceof Class))
throw new IllegalArgumentException("Only full Class types are supported by IdentiferConverters");
this.converter.put((Class<?>) parameterType, conv);
@ -42,7 +42,7 @@ public class IdentifierProvider {
context.getClass());
if (type == null)
logger.debug("No Identifier converter found for context {}", context.getClass().toString());
logger.debug("No Identifier converter found for context {}", context.getClass());
@SuppressWarnings("unchecked")
Converter<Object> conv = (Converter<Object>) converter.get(type);

3
lib/src/main/java/net/tomatentum/marinara/wrapper/LibraryWrapper.java
View File

@ -12,7 +12,7 @@ public abstract class LibraryWrapper {
}
public void handleInteraction(Object context) {
interactionSubscriber.forEach((o) -> o.accept(context));
interactionSubscriber.forEach(o -> o.accept(context));
}
public void subscribeInteractions(Consumer<Object> consumer) {
@ -25,5 +25,6 @@ public abstract class LibraryWrapper {
public abstract CommandRegisterer<?> getRegisterer();
public abstract IdentifierProvider createIdentifierProvider();
public abstract ContextObjectProvider getContextObjectProvider();
public abstract void respondAutocomplete(Object context, List<Object> options);
}

21
wrapper/discord4j/src/main/java/net/tomatentum/marinara/wrapper/discord4j/Discord4JContextObjectProvider.java
View File

@ -5,7 +5,9 @@ import java.util.List;
import discord4j.core.event.domain.interaction.ChatInputAutoCompleteEvent;
import discord4j.core.event.domain.interaction.ChatInputInteractionEvent;
import discord4j.core.event.domain.interaction.ComponentInteractionEvent;
import discord4j.core.event.domain.interaction.InteractionCreateEvent;
import discord4j.core.object.command.ApplicationCommandInteractionOption;
import net.tomatentum.marinara.interaction.commands.option.AutocompleteOptionData;
import net.tomatentum.marinara.interaction.commands.option.SlashCommandOptionType;
import net.tomatentum.marinara.wrapper.ContextObjectProvider;
@ -79,24 +81,25 @@ public class Discord4JContextObjectProvider implements ContextObjectProvider {
@Override
public Object getInteractionContextObject(Object context, Class<?> type) {
ComponentInteractionEvent componentInteractionEvent = (ComponentInteractionEvent) context;
InteractionCreateEvent interactionEvent = (InteractionCreateEvent) context;
switch (type.getName()) {
case "discord4j.core.object.entity.channel.MessageChannel":
return componentInteractionEvent.getInteraction().getChannel().block();
return interactionEvent.getInteraction().getChannel().block();
case "discord4j.core.object.entity.Guild":
return componentInteractionEvent.getInteraction().getGuild().block();
return interactionEvent.getInteraction().getGuild().block();
case "discord4j.core.object.entity.Member":
return componentInteractionEvent.getInteraction().getMember().orElse(null);
return interactionEvent.getInteraction().getMember().orElse(null);
case "discord4j.core.object.entity.User":
return componentInteractionEvent.getInteraction().getUser();
return interactionEvent.getInteraction().getUser();
default:
return null;
}
return null;
}
@Override
public Object getAutocompleteFocusedOption(Object context) {
ChatInputAutoCompleteEvent interaction = (ChatInputAutoCompleteEvent) context;
return getOptionValue(interaction.getFocusedOption());
public AutocompleteOptionData getAutocompleteFocusedOption(Object context) {
ApplicationCommandInteractionOption option = ((ChatInputAutoCompleteEvent) context).getFocusedOption();
return new AutocompleteOptionData(option.getName(), getOptionValue(option));
}
}

6
wrapper/discord4j/src/main/java/net/tomatentum/marinara/wrapper/discord4j/Discord4JConverterSpec.java
View File

@ -55,10 +55,10 @@ public class Discord4JConverterSpec implements CommandConverter.Spec<Application
.name(option.name())
.description(option.description())
.required(option.required())
.autocomplete(option.autocomplete())
.minLength(Double.valueOf(option.range().min()).intValue())
.autocomplete(option.autocompletes().length > 0)
.minLength((int) option.range().min())
.minValue(option.range().min())
.maxLength(Double.valueOf(option.range().max()).intValue())
.maxLength((int)option.range().max())
.maxValue(option.range().max())
.choices(choices)
.build();

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

@ -1,14 +1,16 @@
package net.tomatentum.marinara.wrapper.discord4j;
import java.util.List;
import java.util.function.Function;
import java.util.function.UnaryOperator;
import org.slf4j.Logger;
import discord4j.core.GatewayDiscordClient;
import discord4j.core.event.domain.interaction.ChatInputAutoCompleteEvent;
import discord4j.core.event.domain.interaction.InteractionCreateEvent;
import discord4j.core.object.command.ApplicationCommandInteractionOption;
import discord4j.core.object.command.ApplicationCommandOption.Type;
import discord4j.discordjson.json.ApplicationCommandOptionChoiceData;
import discord4j.discordjson.json.ApplicationCommandRequest;
import net.tomatentum.marinara.util.LoggerUtil;
@ -22,13 +24,12 @@ import net.tomatentum.marinara.wrapper.discord4j.identifierconverter.ButtonIdent
import net.tomatentum.marinara.wrapper.discord4j.identifierconverter.SlashCommandIdentifierConverter;
public class Discord4JWrapper extends LibraryWrapper {
public static final Function<List<ApplicationCommandInteractionOption>, List<ApplicationCommandInteractionOption>> SUB_FILTER = (i) ->
public static final UnaryOperator<List<ApplicationCommandInteractionOption>> SUB_FILTER = i ->
i.stream()
.filter(o -> o.getType().equals(Type.SUB_COMMAND) || o.getType().equals(Type.SUB_COMMAND_GROUP))
.toList();
public static final Function<List<ApplicationCommandInteractionOption>, List<ApplicationCommandInteractionOption>> ARG_FILTER = (i) ->
public static final UnaryOperator<List<ApplicationCommandInteractionOption>> ARG_FILTER = i ->
i.stream()
.filter(o -> !o.getType().equals(Type.SUB_COMMAND) && !o.getType().equals(Type.SUB_COMMAND_GROUP))
.toList();
@ -71,4 +72,15 @@ public class Discord4JWrapper extends LibraryWrapper {
return this.contextObjectProvider;
}
@Override
public void respondAutocomplete(Object context, List<Object> options) {
if (context instanceof ChatInputAutoCompleteEvent event) {
List<ApplicationCommandOptionChoiceData> choices = options.stream()
.filter(ApplicationCommandOptionChoiceData.class::isInstance)
.map(o -> (ApplicationCommandOptionChoiceData)o)
.toList();
event.respondWithSuggestions(choices);
}
}
}

38
wrapper/discord4j/src/main/java/net/tomatentum/marinara/wrapper/discord4j/identifierconverter/AutocompleteIdentifierConverter.java
View File

@ -13,26 +13,28 @@ public class AutocompleteIdentifierConverter implements IdentifierProvider.Conve
@Override
public InteractionIdentifier convert(ChatInputAutoCompleteEvent context) {
List<ApplicationCommandInteractionOption> options = Discord4JWrapper.SUB_FILTER.apply(context.getOptions());
String commandName = context.getCommandName();
InteractionIdentifier last = InteractionIdentifier.builder()
.type(InteractionType.AUTOCOMPLETE)
.name(context.getCommandName())
.build();
List<ApplicationCommandInteractionOption> options = Discord4JWrapper.SUB_FILTER.apply(context.getOptions());
if (!options.isEmpty()) {
List<ApplicationCommandInteractionOption> sub_options = Discord4JWrapper.SUB_FILTER.apply(options.getFirst().getOptions());
if (!sub_options.isEmpty())
return InteractionIdentifier.createHierarchy(
InteractionType.AUTOCOMPLETE,
commandName,
options.getFirst().getName(),
sub_options.getFirst().getName());
else
return InteractionIdentifier.createHierarchy(
InteractionType.AUTOCOMPLETE,
commandName,
options.getFirst().getName());
}else
return InteractionIdentifier.createHierarchy(
InteractionType.AUTOCOMPLETE,
commandName);
last = InteractionIdentifier.builder()
.type(InteractionType.AUTOCOMPLETE)
.name(options.getFirst().getName())
.parent(last)
.build();
List<ApplicationCommandInteractionOption> subOptions = Discord4JWrapper.SUB_FILTER.apply(options.getFirst().getOptions());
if (!subOptions.isEmpty())
last = InteractionIdentifier.builder()
.type(InteractionType.AUTOCOMPLETE)
.name(subOptions.getFirst().getName())
.parent(last)
.build();
}
return last;
}
}

37
wrapper/discord4j/src/main/java/net/tomatentum/marinara/wrapper/discord4j/identifierconverter/SlashCommandIdentifierConverter.java
View File

@ -13,27 +13,28 @@ public class SlashCommandIdentifierConverter implements IdentifierProvider.Conve
@Override
public InteractionIdentifier convert(ChatInputInteractionEvent context) {
InteractionIdentifier last = InteractionIdentifier.builder()
.type(InteractionType.COMMAND)
.name(context.getCommandName())
.build();
List<ApplicationCommandInteractionOption> options = Discord4JWrapper.SUB_FILTER.apply(context.getOptions());
String commandName = context.getCommandName();
if (!options.isEmpty()) {
List<ApplicationCommandInteractionOption> sub_options = Discord4JWrapper.SUB_FILTER.apply(options.getFirst().getOptions());
if (!sub_options.isEmpty())
return InteractionIdentifier.createHierarchy(
InteractionType.COMMAND,
commandName,
options.getFirst().getName(),
sub_options.getFirst().getName());
else
return InteractionIdentifier.createHierarchy(
InteractionType.COMMAND,
commandName,
options.getFirst().getName());
}else
return InteractionIdentifier.createHierarchy(
InteractionType.COMMAND,
commandName);
last = InteractionIdentifier.builder()
.type(InteractionType.COMMAND)
.name(options.getFirst().getName())
.parent(last)
.build();
List<ApplicationCommandInteractionOption> subOptions = Discord4JWrapper.SUB_FILTER.apply(options.getFirst().getOptions());
if (!subOptions.isEmpty())
last = InteractionIdentifier.builder()
.type(InteractionType.COMMAND)
.name(subOptions.getFirst().getName())
.parent(last)
.build();
}
return last;
}
}

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

@ -18,10 +18,10 @@ import net.tomatentum.marinara.Marinara;
import net.tomatentum.marinara.wrapper.LibraryWrapper;
import net.tomatentum.marinara.wrapper.discord4j.Discord4JWrapper;
public class AutoCompleteTest {
class AutoCompleteTest {
@Test
public void testAutocomplete() {
void testAutocomplete() {
ApplicationCommandInteractionOption optionMock = mock();
ChatInputAutoCompleteEvent autoCompleteEventMock = mock();

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

@ -5,18 +5,36 @@ 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;
import net.tomatentum.marinara.interaction.InteractionHandler;
import net.tomatentum.marinara.interaction.annotation.AutoComplete;
import net.tomatentum.marinara.interaction.commands.annotation.SlashCommand;
import net.tomatentum.marinara.interaction.commands.annotation.SlashCommandOption;
import net.tomatentum.marinara.interaction.commands.option.SlashCommandOptionType;
public class TestAutocomplete implements InteractionHandler {
@SlashCommand(
name = "test",
options = @SlashCommandOption(
name = "foo",
type = SlashCommandOptionType.STRING,
autocompletes = @AutoComplete("testAuto")
)
)
@AutoComplete("testAuto")
public void exec(ChatInputInteractionEvent context) {
}
@SlashCommand(name = "test")
@AutoComplete
public void autocomplete(ChatInputAutoCompleteEvent context, String value) {
@AutoComplete("testAuto")
public ApplicationCommandOptionChoiceData[] autocomplete(ChatInputAutoCompleteEvent context, String value) {
System.out.println("Success!");
assertEquals(value, "test");
context.respondWithSuggestions(Collections.emptyList());
assertEquals("test", value);
return new ApplicationCommandOptionChoiceData[]{
ApplicationCommandOptionChoiceData.builder().name("TestValue").value("test").build()
};
}
}

14
wrapper/javacord/src/main/java/net/tomatentum/marinara/wrapper/javacord/JavacordContextObjectProvider.java
View File

@ -2,10 +2,12 @@ package net.tomatentum.marinara.wrapper.javacord;
import org.javacord.api.interaction.AutocompleteInteraction;
import org.javacord.api.interaction.ButtonInteraction;
import org.javacord.api.interaction.InteractionBase;
import org.javacord.api.interaction.SlashCommandInteraction;
import org.javacord.api.interaction.SlashCommandInteractionOption;
import org.javacord.api.interaction.SlashCommandOptionType;
import net.tomatentum.marinara.interaction.commands.option.AutocompleteOptionData;
import net.tomatentum.marinara.wrapper.ContextObjectProvider;
public class JavacordContextObjectProvider implements ContextObjectProvider {
@ -16,14 +18,14 @@ public class JavacordContextObjectProvider implements ContextObjectProvider {
return null;
SlashCommandInteraction interaction = (SlashCommandInteraction) context;
if (!interaction.getArguments().isEmpty())
return getOptionValue(interaction.getOptionByName(optionName).get());
return getOptionValue(interaction.getOptionByName(optionName).orElse(null));
SlashCommandInteractionOption subCommandOption = interaction.getOptions().getFirst();
if (!subCommandOption.getOptions().isEmpty())
subCommandOption = subCommandOption.getOptions().getFirst();
return getOptionValue(subCommandOption.getOptionByName(optionName).get());
return getOptionValue(subCommandOption.getOptionByName(optionName).orElse(null));
}
private Object getOptionValue(SlashCommandInteractionOption option) {
@ -89,7 +91,7 @@ public class JavacordContextObjectProvider implements ContextObjectProvider {
@Override
public Object getInteractionContextObject(Object context, Class<?> type) {
ButtonInteraction button = (ButtonInteraction) context;
InteractionBase button = (InteractionBase) context;
switch (type.getName()) {
case "org.javacord.api.entity.channel.TextChannel":
return button.getChannel().orElse(null);
@ -102,9 +104,9 @@ public class JavacordContextObjectProvider implements ContextObjectProvider {
}
@Override
public Object getAutocompleteFocusedOption(Object context) {
AutocompleteInteraction interaction = (AutocompleteInteraction) context;
return getOptionValue(interaction.getFocusedOption());
public AutocompleteOptionData getAutocompleteFocusedOption(Object context) {
SlashCommandInteractionOption option = ((AutocompleteInteraction) context).getFocusedOption();
return new AutocompleteOptionData(option.getName(), getOptionValue(option));
}
}

6
wrapper/javacord/src/main/java/net/tomatentum/marinara/wrapper/javacord/JavacordConverterSpec.java
View File

@ -50,10 +50,10 @@ public class JavacordConverterSpec implements CommandConverter.Spec<SlashCommand
.setName(option.name())
.setDescription(option.description())
.setRequired(option.required())
.setAutocompletable(option.autocomplete())
.setMinLength(Double.valueOf(option.range().min()).longValue())
.setAutocompletable(option.autocompletes().length > 0)
.setMinLength((long) option.range().min())
.setDecimalMinValue(option.range().min())
.setMaxLength(Double.valueOf(option.range().max()).longValue())
.setMaxLength((long) option.range().max())
.setDecimalMaxValue(option.range().max())
.setChoices(choices)
.build();

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

@ -1,7 +1,11 @@
package net.tomatentum.marinara.wrapper.javacord;
import java.util.List;
import org.javacord.api.DiscordApi;
import org.javacord.api.interaction.AutocompleteInteraction;
import org.javacord.api.interaction.SlashCommandBuilder;
import org.javacord.api.interaction.SlashCommandOptionChoice;
import org.slf4j.Logger;
import net.tomatentum.marinara.wrapper.CommandConverter;
@ -27,7 +31,7 @@ public class JavacordWrapper extends LibraryWrapper {
if (api != null) {
this.commandRegisterer = CommandRegisterer.of(new JavacordRegistererStrategy(api), converter);
api.addInteractionCreateListener((e) -> handleInteraction(e.getInteraction()));
api.addInteractionCreateListener(e -> handleInteraction(e.getInteraction()));
}else
logger.warn("DiscordApi was null so no Events were subscribed to.");
logger.info("Javacord wrapper loaded!");
@ -52,4 +56,15 @@ public class JavacordWrapper extends LibraryWrapper {
return contextObjectProvider;
}
@Override
public void respondAutocomplete(Object context, List<Object> options) {
if (context instanceof AutocompleteInteraction interaction) {
List<SlashCommandOptionChoice> choices = options.stream()
.filter(SlashCommandOptionChoice.class::isInstance)
.map(o -> (SlashCommandOptionChoice)o)
.toList();
interaction.respondWithChoices(choices);
}
}
}

37
wrapper/javacord/src/main/java/net/tomatentum/marinara/wrapper/javacord/identifierconverter/AutocompleteIdentifierConverter.java
View File

@ -13,25 +13,28 @@ public class AutocompleteIdentifierConverter implements IdentifierProvider.Conve
@Override
public InteractionIdentifier convert(AutocompleteInteraction context) {
InteractionIdentifier last = InteractionIdentifier.builder()
.type(InteractionType.AUTOCOMPLETE)
.name(context.getCommandName())
.build();
List<SlashCommandInteractionOption> options = context.getOptions();
String commandName = context.getCommandName();
if (!options.isEmpty()) {
List<SlashCommandInteractionOption> sub_options = context.getOptions().getFirst().getOptions();
if (!sub_options.isEmpty())
return InteractionIdentifier.createHierarchy(
InteractionType.AUTOCOMPLETE,
commandName,
options.getFirst().getName(),
sub_options.getFirst().getName());
else
return InteractionIdentifier.createHierarchy(
InteractionType.AUTOCOMPLETE,
commandName,
options.getFirst().getName());
}else
return InteractionIdentifier.createHierarchy(
InteractionType.AUTOCOMPLETE,
commandName);
last = InteractionIdentifier.builder()
.type(InteractionType.AUTOCOMPLETE)
.name(options.getFirst().getName())
.parent(last)
.build();
List<SlashCommandInteractionOption> subOptions = context.getOptions().getFirst().getOptions();
if (!subOptions.isEmpty())
last = InteractionIdentifier.builder()
.type(InteractionType.AUTOCOMPLETE)
.name(subOptions.getFirst().getName())
.parent(last)
.build();
}
return last;
}
}

40
wrapper/javacord/src/main/java/net/tomatentum/marinara/wrapper/javacord/identifierconverter/SlashCommandIdentifierConverter.java
View File

@ -13,26 +13,28 @@ public class SlashCommandIdentifierConverter implements IdentifierProvider.Conve
@Override
public InteractionIdentifier convert(SlashCommandInteraction context) {
List<SlashCommandInteractionOption> options = context.getOptions();
String commandName = context.getCommandName();
if (!options.isEmpty()) {
List<SlashCommandInteractionOption> sub_options = context.getOptions().getFirst().getOptions();
if (!sub_options.isEmpty())
return InteractionIdentifier.createHierarchy(
InteractionType.COMMAND,
commandName,
options.getFirst().getName(),
sub_options.getFirst().getName());
else
return InteractionIdentifier.createHierarchy(
InteractionType.COMMAND,
commandName,
options.getFirst().getName());
}else
return InteractionIdentifier.createHierarchy(
InteractionType.COMMAND,
commandName);
InteractionIdentifier last = InteractionIdentifier.builder()
.type(InteractionType.COMMAND)
.name(context.getCommandName())
.build();
List<SlashCommandInteractionOption> options = context.getOptions();
if (!options.isEmpty()) {
last = InteractionIdentifier.builder()
.type(InteractionType.COMMAND)
.name(options.getFirst().getName())
.parent(last)
.build();
List<SlashCommandInteractionOption> subOptions = context.getOptions().getFirst().getOptions();
if (!subOptions.isEmpty())
last = InteractionIdentifier.builder()
.type(InteractionType.COMMAND)
.name(subOptions.getFirst().getName())
.parent(last)
.build();
}
return last;
}
}

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

@ -4,16 +4,32 @@ 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;
import net.tomatentum.marinara.interaction.InteractionHandler;
import net.tomatentum.marinara.interaction.annotation.AutoComplete;
import net.tomatentum.marinara.interaction.commands.annotation.SlashCommand;
import net.tomatentum.marinara.interaction.commands.annotation.SlashCommandOption;
import net.tomatentum.marinara.interaction.commands.option.SlashCommandOptionType;
public class TestAutocomplete implements InteractionHandler {
@SlashCommand(name = "test")
@AutoComplete
@SlashCommand(
name = "test",
options = @SlashCommandOption(
name = "foo",
type = SlashCommandOptionType.STRING,
autocompletes = @AutoComplete("testAuto")
)
)
@AutoComplete("testAuto")
public void exec(SlashCommandInteraction context) {
}
@AutoComplete("testAuto")
public void autocomplete(AutocompleteInteraction context, String value) {
System.out.println("Success!");
assertEquals(value, "test");