scrow/KenCommandAPI
2
0
Fork 0
Code Issues Pull requests Projects Releases Packages 3 Wiki Activity Actions

.

Browse source
This commit is contained in:
kento2 2026-04-16 14:52:10 +02:00
parent c8b7049f1d
commit 124e65a472
26 changed files with 123 additions and 116 deletions
Download patch file Download diff file Expand all files Collapse all files

2
kencommandapi-core/build.gradle.kts
View file

@ -8,7 +8,7 @@ plugins {
}
group = "de.kentoj"
version = "1.3.0"
version = "2.0.1"
repositories {
mavenCentral()

23
kencommandapi-core/src/main/java/de/kentoj/kencommandapi/Main.java
View file

@ -1,6 +1,5 @@
package de.kentoj.kencommandapi;
import de.kentoj.kencommandapi.api.processing.CommandContext;
import de.kentoj.kencommandapi.api.processing.ParsedArgument;
import de.kentoj.kencommandapi.api.structure.argument.types.IntegerArgumentType;
import de.kentoj.kencommandapi.impl.AbstractKenCommandApi;
@ -11,11 +10,23 @@ import java.util.Map;
public class Main {
private static class BasicCommandContext extends CommandContextImpl<PrintStream, BasicCommandContext> {
public BasicCommandContext(PrintStream sender, Map<String, ParsedArgument<PrintStream, BasicCommandContext, ?>> parsedArguments) {
super(sender, parsedArguments);
}
public void respond(String msg) {
getSender().println("|==================|");
getSender().println(msg);
getSender().println("|==================|");
}
}
public static void main(String[] args) {
var api = new AbstractKenCommandApi<PrintStream, CommandContext<PrintStream>>() {
var api = new AbstractKenCommandApi<PrintStream, BasicCommandContext>() {
@Override
public CommandContextImpl<PrintStream> createContext(PrintStream sender, Map<String, ParsedArgument<CommandContext<PrintStream>, ?>> parsedArguments) {
return new CommandContextImpl<>(sender, parsedArguments);
public BasicCommandContext createContext(PrintStream sender, Map<String, ParsedArgument<PrintStream, BasicCommandContext, ?>> parsedArguments) {
return new BasicCommandContext(sender, parsedArguments);
}
};
@ -25,10 +36,10 @@ public class Main {
addNode.setExecutor(ctx -> {
int amount = ctx.getArg("amount");
ctx.getSender().println("adding " + amount + "$ to your balance");
ctx.respond("adding " + amount + "$ to your balance");
});
addNode.addArgument(api.createArgument("amount", IntegerArgumentType.getInstance()));
addNode.addArgument(api.createArgument("amount", new IntegerArgumentType<>()));
root.addLiteral(addNode);
api.invoke(root, System.out, new String[]{"add", "100"});
}

8
kencommandapi-core/src/main/java/de/kentoj/kencommandapi/api/KenCommandApi.java
View file

@ -5,11 +5,11 @@ import de.kentoj.kencommandapi.api.structure.argument.ArgumentType;
import de.kentoj.kencommandapi.api.structure.argument.CommandArgument;
import de.kentoj.kencommandapi.api.structure.node.CommandNode;
public interface KenCommandApi<T, S extends CommandContext<T>> {
public interface KenCommandApi<T, S extends CommandContext<T, ?>> {
CommandNode<S> createNode(String... name);
CommandNode<T, S> createNode(String... name);
<V> CommandArgument<S, V> createArgument(String id, ArgumentType<V> type);
<V> CommandArgument<T, S, V> createArgument(String id, ArgumentType<T, S, V> type);
void invoke(CommandNode<S> node, T sender, String[] args);
void invoke(CommandNode<T, S> node, T sender, String[] args);
}

8
kencommandapi-core/src/main/java/de/kentoj/kencommandapi/api/processing/CommandContext.java
View file

@ -2,7 +2,7 @@ package de.kentoj.kencommandapi.api.processing;
import de.kentoj.kencommandapi.api.structure.argument.CommandArgument;
public interface CommandContext<T> {
public interface CommandContext<T, S extends CommandContext<T, ?>> {
T getSender();
@ -10,18 +10,18 @@ public interface CommandContext<T> {
* @return Object that is parsed from the raw argument
* @throws RuntimeException if no value given and no default value supplied
*/
<V> ParsedArgument<CommandContext<T>, V> getParsedArgument(String name);
<V> ParsedArgument<T, S, V> getParsedArgument(String name);
@SuppressWarnings("unchecked")
default <V> V getArg(String name) {
return (V) getParsedArgument(name).getValue();
}
default <V> V getArg(CommandArgument<CommandContext<T>, V> arg) {
default <V> V getArg(CommandArgument<T, S, V> arg) {
return getArg(arg.getId());
}
default <V> ParsedArgument<CommandContext<T>, V> getParsedArgument(CommandArgument<CommandContext<T>, V> arg) {
default <V> ParsedArgument<T, S, V> getParsedArgument(CommandArgument<T, S, V> arg) {
return getParsedArgument(arg.getId());
}
}

2
kencommandapi-core/src/main/java/de/kentoj/kencommandapi/api/processing/CommandExecutor.java
View file

@ -1,6 +1,6 @@
package de.kentoj.kencommandapi.api.processing;
public interface CommandExecutor<S extends CommandContext<?>> {
public interface CommandExecutor<T, S extends CommandContext<T, ?>> {
void execute(S ctx);
}

4
kencommandapi-core/src/main/java/de/kentoj/kencommandapi/api/processing/ParsedArgument.java
View file

@ -2,9 +2,9 @@ package de.kentoj.kencommandapi.api.processing;
import de.kentoj.kencommandapi.api.structure.argument.CommandArgument;
public interface ParsedArgument<S extends CommandContext<?>, V> {
public interface ParsedArgument<T, S extends CommandContext<T, ?>, V> {
V getValue();
CommandArgument<S, V> getArgument();
CommandArgument<T, S, V> getArgument();
}

6
kencommandapi-core/src/main/java/de/kentoj/kencommandapi/api/structure/argument/ArgumentType.java
View file

@ -1,8 +1,10 @@
package de.kentoj.kencommandapi.api.structure.argument;
public interface ArgumentType<V> {
import de.kentoj.kencommandapi.api.processing.CommandContext;
public interface ArgumentType<T, S extends CommandContext<T, ?>, V> {
V parseInput(String string);
SuggestionProvider<?> defaultSuggestionProvider();
SuggestionProvider<T, S> defaultSuggestionProvider();
}

8
kencommandapi-core/src/main/java/de/kentoj/kencommandapi/api/structure/argument/CommandArgument.java
View file

@ -4,20 +4,20 @@ import de.kentoj.kencommandapi.api.processing.CommandContext;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
public interface CommandArgument<S extends CommandContext<?>, V> {
public interface CommandArgument<T, S extends CommandContext<T, ?>, V> {
String getId();
ArgumentType<V> getType();
ArgumentType<T, S, V> getType();
void setDefaultValue(@Nullable V defaultValue);
@Nullable V getDefaultValue();
void setSuggestionProvider(@Nullable SuggestionProvider<S> suggestionProvider);
void setSuggestionProvider(@Nullable SuggestionProvider<T, S> suggestionProvider);
/**
* @return the explicitly set SuggestionProvider or the default suggestions for the type if unset/null
*/
@NotNull SuggestionProvider<S> getSuggestionProvider();
@NotNull SuggestionProvider<T, S> getSuggestionProvider();
}

2
kencommandapi-core/src/main/java/de/kentoj/kencommandapi/api/structure/argument/SuggestionProvider.java
View file

@ -4,7 +4,7 @@ import de.kentoj.kencommandapi.api.processing.CommandContext;
import java.util.Set;
public interface SuggestionProvider<S extends CommandContext<?>> {
public interface SuggestionProvider<T, S extends CommandContext<T, ?>> {
Set<String> suggest(S context);
}

15
kencommandapi-core/src/main/java/de/kentoj/kencommandapi/api/structure/argument/suggestion/NoSuggestionProvider.java
View file

@ -2,24 +2,13 @@ package de.kentoj.kencommandapi.api.structure.argument.suggestion;
import de.kentoj.kencommandapi.api.processing.CommandContext;
import de.kentoj.kencommandapi.api.structure.argument.SuggestionProvider;
import lombok.AccessLevel;
import lombok.Getter;
import lombok.NoArgsConstructor;
import java.util.Set;
@NoArgsConstructor(access = AccessLevel.NONE)
public class NoSuggestionProvider implements SuggestionProvider<CommandContext<Object>> {
@Getter(value = AccessLevel.PRIVATE, lazy = true)
private static final SuggestionProvider<?> instance = new NoSuggestionProvider();
public static SuggestionProvider<?> create() {
return getInstance();
}
public class NoSuggestionProvider<T, S extends CommandContext<T, ?>> implements SuggestionProvider<T, S> {
@Override
public Set<String> suggest(CommandContext<Object> context) {
public Set<String> suggest(S context) {
return Set.of();
}
}

14
kencommandapi-core/src/main/java/de/kentoj/kencommandapi/api/structure/argument/types/IntegerArgumentType.java
View file

@ -1,17 +1,11 @@
package de.kentoj.kencommandapi.api.structure.argument.types;
import de.kentoj.kencommandapi.api.processing.CommandContext;
import de.kentoj.kencommandapi.api.structure.argument.ArgumentType;
import de.kentoj.kencommandapi.api.structure.argument.SuggestionProvider;
import de.kentoj.kencommandapi.api.structure.argument.suggestion.NoSuggestionProvider;
import lombok.AccessLevel;
import lombok.Getter;
import lombok.NoArgsConstructor;
@NoArgsConstructor(access = AccessLevel.PRIVATE)
public class IntegerArgumentType implements ArgumentType<Integer> {
@Getter(lazy = true)
private static final IntegerArgumentType instance = new IntegerArgumentType();
public class IntegerArgumentType<T, S extends CommandContext<T, ?>> implements ArgumentType<T, S, Integer> {
@Override
public Integer parseInput(String string) {
@ -19,7 +13,7 @@ public class IntegerArgumentType implements ArgumentType<Integer> {
}
@Override
public SuggestionProvider<?> defaultSuggestionProvider() {
return NoSuggestionProvider.create();
public SuggestionProvider<T, S> defaultSuggestionProvider() {
return new NoSuggestionProvider<>();
}
}

6
kencommandapi-core/src/main/java/de/kentoj/kencommandapi/api/structure/node/ArgumentNode.java
View file

@ -5,9 +5,9 @@ import de.kentoj.kencommandapi.api.structure.argument.CommandArgument;
import java.util.Set;
public interface ArgumentNode<S extends CommandContext<?>> {
public interface ArgumentNode<T, S extends CommandContext<T, ?>> {
<V> void addArgument(CommandArgument<S, V> argument);
<V> void addArgument(CommandArgument<T, S, V> argument);
Set<CommandArgument<S, ?>> getArguments();
Set<CommandArgument<T, S, ?>> getArguments();
}

6
kencommandapi-core/src/main/java/de/kentoj/kencommandapi/api/structure/node/CommandNode.java
View file

@ -8,13 +8,13 @@ import org.jetbrains.annotations.Nullable;
/**
* @param <S> type of command context
*/
public interface CommandNode<S extends CommandContext<?>> extends ArgumentNode<S>, LiteralNode<S> {
public interface CommandNode<T, S extends CommandContext<T, ?>> extends ArgumentNode<T, S>, LiteralNode<T, S> {
@NotNull String[] getNames();
void setExecutor(@Nullable CommandExecutor<S> executor);
void setExecutor(@Nullable CommandExecutor<T, S> executor);
@Nullable CommandExecutor<S> getExecutor();
@Nullable CommandExecutor<T, S> getExecutor();
void setDescription(@Nullable String description);

8
kencommandapi-core/src/main/java/de/kentoj/kencommandapi/api/structure/node/LiteralNode.java
View file

@ -6,11 +6,11 @@ import org.jetbrains.annotations.Nullable;
import java.util.Set;
public interface LiteralNode<S extends CommandContext<?>> {
public interface LiteralNode<T, S extends CommandContext<T, ?>> {
void addLiteral(@NotNull CommandNode<S> commandNode);
void addLiteral(@NotNull CommandNode<T, S> commandNode);
@Nullable CommandNode<S> getLiteral(@NotNull String name);
@Nullable CommandNode<T, S> getLiteral(@NotNull String name);
@NotNull Set<CommandNode<S>> getLiterals();
@NotNull Set<CommandNode<T, S>> getLiterals();
}

19
kencommandapi-core/src/main/java/de/kentoj/kencommandapi/impl/AbstractKenCommandApi.java
View file

@ -17,30 +17,31 @@ import java.util.Iterator;
import java.util.Map;
@RequiredArgsConstructor
public abstract class AbstractKenCommandApi<T, S extends CommandContext<T>> implements KenCommandApi<T, S> {
public abstract class AbstractKenCommandApi<T, S extends CommandContext<T, ?>> implements KenCommandApi<T, S> {
public abstract S createContext(T sender, Map<String, ParsedArgument<S, ?>> parsedArguments);
public abstract S createContext(T sender, Map<String, ParsedArgument<T, S, ?>> parsedArguments);
@Override
public CommandNode<S> createNode(String... name) {
public CommandNode<T, S> createNode(String... name) {
return new CommandNodeImpl<>(name);
}
@Override
public <V> CommandArgument<S, V> createArgument(String id, ArgumentType<V> type) {
public <V> CommandArgument<T, S, V> createArgument(String id, ArgumentType<T, S, V> type) {
return new CommandArgumentImpl<>(id, type);
}
@Override
public void invoke(CommandNode<S> node, T sender, String[] args) {
public void invoke(CommandNode<T, S> node, T sender, String[] args) {
var iter = Arrays.stream(args).iterator();
var executableLiteral = processLiterals(node, iter);
var parsedArguments = parseArguments(executableLiteral, iter);
assert executableLiteral.getExecutor() != null;
executableLiteral.getExecutor().execute(createContext(sender, parsedArguments));
}
private CommandNode<S> processLiterals(CommandNode<S> commandNode, Iterator<String> iter) {
private CommandNode<T, S> processLiterals(CommandNode<T, S> commandNode, Iterator<String> iter) {
if (!iter.hasNext()) {
// literals/arguments are optional if the node itself is executable
if (commandNode.getExecutor() == null) throw new RuntimeException("no literal given but required");
@ -59,11 +60,11 @@ public abstract class AbstractKenCommandApi<T, S extends CommandContext<T>> impl
return processLiterals(literal, iter);
}
private Map<String, ParsedArgument<S, ?>> parseArguments(CommandNode<S> commandNode, Iterator<String> iter) {
Map<String, ParsedArgument<S, ?>> parsedArguments = new HashMap<>();
private Map<String, ParsedArgument<T, S, ?>> parseArguments(CommandNode<T, S> commandNode, Iterator<String> iter) {
Map<String, ParsedArgument<T, S, ?>> parsedArguments = new HashMap<>();
for (var argument : commandNode.getArguments()) {
@SuppressWarnings("unchecked")
var arg = ((CommandArgument<S, Object>) argument);
var arg = ((CommandArgument<T, S, Object>) argument);
if (!iter.hasNext()) {
var defaultValue = arg.getDefaultValue();

8
kencommandapi-core/src/main/java/de/kentoj/kencommandapi/impl/processing/CommandContextImpl.java
View file

@ -8,17 +8,17 @@ import lombok.RequiredArgsConstructor;
import java.util.Map;
@RequiredArgsConstructor
public class CommandContextImpl<T> implements CommandContext<T> {
public class CommandContextImpl<T, S extends CommandContext<T, ?>> implements CommandContext<T, S> {
@Getter
private final T sender;
@Getter
private final Map<String, ParsedArgument<CommandContext<T>, ?>> parsedArguments;
private final Map<String, ParsedArgument<T, S, ?>> parsedArguments;
@Override
public <V> ParsedArgument<CommandContext<T>, V> getParsedArgument(String name) {
public <V> ParsedArgument<T, S, V> getParsedArgument(String name) {
try {
//noinspection unchecked
return (ParsedArgument<CommandContext<T>, V>) parsedArguments.get(name);
return (ParsedArgument<T, S, V>) parsedArguments.get(name);
} catch (ClassCastException e) {
throw new RuntimeException("requested argument with wrong type", e);
}

10
kencommandapi-core/src/main/java/de/kentoj/kencommandapi/impl/processing/ParsedArgumentImpl.java
View file

@ -3,10 +3,10 @@ package de.kentoj.kencommandapi.impl.processing;
import de.kentoj.kencommandapi.api.processing.CommandContext;
import de.kentoj.kencommandapi.api.processing.ParsedArgument;
import de.kentoj.kencommandapi.api.structure.argument.CommandArgument;
import lombok.Data;
import lombok.Value;
@Data
public class ParsedArgumentImpl<S extends CommandContext<?>, V> implements ParsedArgument<S, V> {
final V value;
final CommandArgument<S, V> argument;
@Value
public class ParsedArgumentImpl<T, S extends CommandContext<T, ?>, V> implements ParsedArgument<T, S, V> {
V value;
CommandArgument<T, S, V> argument;
}

6
kencommandapi-core/src/main/java/de/kentoj/kencommandapi/impl/structure/argument/CommandArgumentImpl.java
View file

@ -10,12 +10,12 @@ import lombok.Setter;
import org.jetbrains.annotations.Nullable;
@RequiredArgsConstructor
public class CommandArgumentImpl<S extends CommandContext<?>, V> implements CommandArgument<S, V> {
public class CommandArgumentImpl<T, S extends CommandContext<T, ?>, V> implements CommandArgument<T, S, V> {
@Getter
private final String id;
@Getter
private final ArgumentType<V> type;
private final ArgumentType<T, S, V> type;
@Getter
@Setter
@ -23,5 +23,5 @@ public class CommandArgumentImpl<S extends CommandContext<?>, V> implements Comm
@Getter
@Setter
private @Nullable SuggestionProvider<S> suggestionProvider;
private @Nullable SuggestionProvider<T, S> suggestionProvider;
}

33
kencommandapi-core/src/main/java/de/kentoj/kencommandapi/impl/structure/node/CommandNodeImpl.java
View file

@ -12,31 +12,30 @@ import org.jetbrains.annotations.Nullable;
import java.util.HashSet;
import java.util.Set;
public class CommandNodeImpl<S extends CommandContext<?>> implements CommandNode<S> {
public class CommandNodeImpl<T, S extends CommandContext<T, ?>> implements CommandNode<T, S> {
@Getter
private final String[] names;
@Getter
private final Set<CommandNode<T, S>> literals = new HashSet<>();
@Getter
private final Set<CommandArgument<T, S, ?>> arguments = new HashSet<>();
@Getter
@Setter
private @Nullable CommandExecutor<T, S> executor;
@Getter
@Setter
private String description;
public CommandNodeImpl(String[] names) {
if (names.length == 0) throw new IllegalArgumentException("at least one name is required");
this.names = names;
}
@Getter
private final Set<CommandNode<S>> literals = new HashSet<>();
@Getter
private final Set<CommandArgument<S, ?>> arguments = new HashSet<>();
@Getter
@Setter
private @Nullable CommandExecutor<S> executor;
@Getter
@Setter
private String description;
@Override
public void addLiteral(@NotNull CommandNode<S> commandNode) {
public void addLiteral(@NotNull CommandNode<T, S> commandNode) {
for (String name : commandNode.getNames()) {
if (getLiteral(name) != null) throw new IllegalArgumentException("literal with same name is already added");
}
@ -44,7 +43,7 @@ public class CommandNodeImpl<S extends CommandContext<?>> implements CommandNode
}
@Override
public CommandNode<S> getLiteral(@NotNull String name) {
public CommandNode<T, S> getLiteral(@NotNull String name) {
for (var literal : literals) {
for (String literalName : literal.getNames()) {
if (literalName.equalsIgnoreCase(name)) return literal;
@ -54,7 +53,7 @@ public class CommandNodeImpl<S extends CommandContext<?>> implements CommandNode
}
@Override
public <V> void addArgument(CommandArgument<S, V> argument) {
public <V> void addArgument(CommandArgument<T, S, V> argument) {
if (arguments.stream()
.anyMatch(arg -> arg.getId().equals(argument.getId()))
) {