v1.1.0 - Brigadier, etc.

Author: Manered

build.gradle

@@ -2,7 +2,7 @@ apply plugin: 'java'
 apply plugin: 'maven-publish'
 
 group = 'dev.manere'
-version = '1.0.6'
+version = '1.1.0'
 
 repositories {
     mavenCentral()
@@ -30,15 +30,6 @@ tasks.withType(JavaCompile).configureEach {
     }
 }
 
-processResources {
-    def props = [version: version]
-    inputs.properties props
-    filteringCharset 'UTF-8'
-    filesMatching('plugin.yml') {
-        expand props
-    }
-}
-
 publishing {
     publications {
         maven(MavenPublication) {

src/main/java/dev/manere/commands/BasicCommandNode.java

@@ -1,152 +1,39 @@
 package dev.manere.commands;
 
-import com.google.common.collect.ImmutableList;
-import dev.manere.commands.api.APIHolder;
-import dev.manere.commands.api.CommandManager;
-import dev.manere.commands.api.CommandsAPI;
 import dev.manere.commands.argument.CommandArgument;
-import dev.manere.commands.ctx.CommandContext;
-import dev.manere.commands.handler.CommandRequirement;
-import dev.manere.commands.handler.ExecutionHandler;
-import dev.manere.commands.handler.RequirementResult;
-import dev.manere.commands.info.CommandInfo;
-import org.bukkit.plugin.java.JavaPlugin;
+import org.bukkit.command.CommandSender;
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
 import org.jetbrains.annotations.Unmodifiable;
 
-import java.lang.reflect.InvocationTargetException;
+import java.util.Collection;
 import java.util.List;
+import java.util.Optional;
 
-/**
- * Represents a command node in a command tree structure.
- * A basic command node may contain information about the command, its children,
- * and the command's literal and arguments.
- * This interface also extends {@link ExecutionHandler}, allowing for command execution handling.
- *
- * @see CommandManager
- * @see CommandsAPI
- * @see CommandNode
- */
-public interface BasicCommandNode extends ExecutionHandler, CommandRequirement {
-    /**
-     * Registers a command node with the provided {@link CommandsAPI}.
-     *
-     * @param api  The CommandsAPI instance used to manage command nodes.
-     * @param root The root command node to register.
-     */
-    static void register(final @NotNull CommandsAPI api, final @NotNull BasicCommandNode root) {
-        api.manager().register(root);
-    }
-
-    /**
-     * Registers a command node by its class type with the provided {@link CommandsAPI}.
-     * <p>
-     * If the root class does not have an empty constructor, this method attempts to find
-     * a constructor that accepts a {@link JavaPlugin} instance and registers using it.
-     * </p>
-     *
-     * @param api  The CommandsAPI instance used to manage command nodes.
-     * @param root The class type of the root command node to register.
-     * @throws RuntimeException If no suitable constructor is found.
-     */
-    static void register(final @NotNull CommandsAPI api, final @NotNull Class<? extends BasicCommandNode> root) {
-        try {
-            register(api, root.getDeclaredConstructor().newInstance());
-        } catch (InstantiationException | IllegalAccessException | InvocationTargetException | NoSuchMethodException e) {
-            api.plugin().getLogger().severe("Attempted to register a basic command node. Couldn't find a empty constructor, attempting to provide a plugin inside the parameters.");
-
-            try {
-                register(api, root.getDeclaredConstructor(api.plugin().getClass()).newInstance(api.plugin()));
-            } catch (InstantiationException | IllegalAccessException | InvocationTargetException | NoSuchMethodException ex) {
-                api.plugin().getLogger().severe("Attempted to register a basic command node. Couldn't find a empty constructor, attempting to provide a plugin inside the parameters.");
-                throw new RuntimeException("Attempted to register a basic command node, couldn't find empty constructor and constructor of parameters JavaPlugin/Plugin/" + api.plugin().getClass().getSimpleName());
-            }
-
-            throw new RuntimeException(e);
-        }
-    }
-
-    /**
-     * Registers a command node using the default {@link CommandsAPI} instance.
-     *
-     * @param root The root command node to register.
-     */
-    static void register(final @NotNull BasicCommandNode root) {
-        register(APIHolder.api(), root);
-    }
-
-    /**
-     * Registers a command node by its class type using the default {@link CommandsAPI} instance.
-     *
-     * @param root The class type of the root command node to register.
-     */
-    static void register(final @NotNull Class<? extends BasicCommandNode> root) {
-        register(APIHolder.api(), root);
-    }
-
-    /**
-     * Registers this command node using the default {@link CommandsAPI} instance.
-     */
-    default void register() {
-        register(this);
-    }
+public interface BasicCommandNode {
+    @NotNull
+    String getLiteral();
 
-    /**
-     * Registers this command node with the provided {@link CommandsAPI} instance.
-     *
-     * @param api The CommandsAPI instance used to manage command nodes.
-     */
-    default void register(final @NotNull CommandsAPI api) {
-        register(api, this);
+    @NotNull
+    default Optional<String> getPermission() {
+        return Optional.empty();
     }
 
-    /**
-     * Gets the command information associated with this command node.
-     *
-     * @return the {@link CommandInfo} object containing the command's metadata,
-     *         or {@code null} if no information is associated with this command node.
-     */
-    @Nullable
-    CommandInfo info();
-
-    /**
-     * Gets the literal string representing this command node.
-     * The literal is typically the name or identifier of the command.
-     *
-     * @return a non-null string representing the literal of this command node.
-     */
     @NotNull
-    String literal();
+    default Collection<String> getAliases() {
+        return List.of();
+    }
 
-    /**
-     * Gets an unmodifiable list of arguments that this command node accepts.
-     * This method returns an empty list by default, which can be overridden by implementing classes.
-     *
-     * @return a non-null unmodifiable list of {@link CommandArgument} objects.
-     */
     @NotNull
     @Unmodifiable
-    default List<CommandArgument<?>> arguments() {
-        return ImmutableList.of();
+    default Collection<? extends CommandArgument> getArguments() {
+        return List.of();
     }
 
-    /**
-     * Gets an unmodifiable list of child command nodes for this command node.
-     * Child nodes represent sub-commands or additional layers in the command hierarchy.
-     * This method returns an empty list by default, which can be overridden by implementing classes.
-     *
-     * @return a non-null unmodifiable list of {@link BasicCommandNode} objects representing the child nodes.
-     */
     @NotNull
     @Unmodifiable
-    default List<BasicCommandNode> children() {
-        return ImmutableList.of();
+    default Collection<?> getChildren() {
+        return List.of();
     }
 
-    @NotNull
-    @Override
-    default RequirementResult require(final @NotNull CommandContext context) {
-        return RequirementResult.passed();
-    }
+    void execute(final @NotNull CommandContext<? extends CommandSender> context);
 }

src/main/java/dev/manere/commands/CommandContext.java

@@ -0,0 +1,86 @@
+package dev.manere.commands;
+
+import com.mojang.brigadier.context.ParsedArgument;
+import dev.manere.commands.argument.Argument;
+import dev.manere.commands.argument.CommandArgument;
+import dev.manere.commands.argument.SingleCommandArgument;
+import io.papermc.paper.command.brigadier.CommandSourceStack;
+import org.bukkit.command.CommandSender;
+import org.jetbrains.annotations.ApiStatus;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.lang.reflect.Field;
+import java.util.Map;
+import java.util.Optional;
+
+@SuppressWarnings("UnstableApiUsage")
+public class CommandContext<S extends CommandSender> {
+    private final S source;
+    private final CommandNode node;
+
+    private final String input;
+
+    private final com.mojang.brigadier.context.CommandContext<CommandSourceStack> stack;
+
+    public CommandContext(final @NotNull S source, final @NotNull CommandNode node, final @NotNull com.mojang.brigadier.context.CommandContext<CommandSourceStack> stack, final @NotNull String input) {
+        this.source = source;
+        this.node = node;
+        this.input = input;
+        this.stack = stack;
+    }
+
+    @NotNull
+    public S getSource() {
+        return source;
+    }
+
+    @NotNull
+    public <T> Optional<T> getArgument(final @NotNull Class<T> type, final @NotNull String key) {
+        try {
+            final Field field = stack.getClass().getDeclaredField("arguments");
+            field.setAccessible(true);
+            final Map<String, ParsedArgument<S, ?>> object = (Map<String, ParsedArgument<S, ?>>) field.get(stack);
+
+            final var argument = (SingleCommandArgument<? extends Argument<Object, Object>>) getArgument(key);
+            if (argument == null) return Optional.empty();
+
+            final ParsedArgument<S, ?> parsed = object.get(key);
+            if (parsed == null) return Optional.empty();
+
+            final Object result = parsed.getResult();
+
+            final Argument<Object, Object> converter = argument.getArgument().get();
+            return Optional.ofNullable(type.cast(converter.convert(stack.getSource(), result)));
+        } catch (final Exception e) {
+            return Optional.empty();
+        }
+    }
+
+    @Nullable
+    @ApiStatus.Internal
+    private SingleCommandArgument<? extends Argument<?, ?>> getArgument(final @NotNull String key) {
+        for (final CommandArgument argument : node.arguments()) {
+            if (argument instanceof SingleCommandArgument<?> single) {
+                if (single.getKey().equals(key)) return single;
+            }
+        }
+
+        return null;
+    }
+
+    @NotNull
+    public CommandNode getNode() {
+        return node;
+    }
+
+    @NotNull
+    public String getInput() {
+        return input;
+    }
+
+    @Override
+    public String toString() {
+        return "CommandContext[source = " + source + ", node = " + node + ", input = " + input + "]";
+    }
+}