Upgrades

Patchwork/src/main/java/me/totalfreedom/command/BukkitDelegator.java

@@ -0,0 +1,120 @@
+package me.totalfreedom.command;
+
+import jdk.jshell.MethodSnippet;
+import me.totalfreedom.api.Context;
+import me.totalfreedom.command.annotation.Subcommand;
+import me.totalfreedom.provider.ContextProvider;
+import me.totalfreedom.utils.FreedomLogger;
+import net.kyori.adventure.text.Component;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.command.ConsoleCommandSender;
+import org.bukkit.command.PluginIdentifiableCommand;
+import org.bukkit.plugin.Plugin;
+import org.bukkit.plugin.java.JavaPlugin;
+import org.jetbrains.annotations.NotNull;
+
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Set;
+
+public class BukkitDelegator extends Command implements PluginIdentifiableCommand
+{
+    private final JavaPlugin plugin;
+    private final CommandBase command;
+    private final boolean noConsole;
+
+    BukkitDelegator(final JavaPlugin plugin, final CommandBase command)
+    {
+        super(command.getInfo().name());
+        this.plugin = plugin;
+        this.command = command;
+        this.setDescription(command.getInfo().description());
+        this.setUsage(command.getInfo().usage());
+        this.setPermission(command.getPerms().perm());
+        this.setAliases(Arrays.asList(command.getInfo().aliases()));
+        this.permissionMessage(Component.text(command.getPerms().noPerms()));
+        this.noConsole = command.getPerms().onlyPlayers();
+    }
+
+    @Override
+    public boolean execute(@NotNull CommandSender sender, @NotNull String commandLabel, @NotNull String[] args)
+    {
+        if (commandLabel.isEmpty() || !commandLabel.equalsIgnoreCase(getName()))
+            return false;
+
+        if (sender instanceof ConsoleCommandSender && noConsole)
+        {
+            sender.sendMessage(Component.text("This command can only be run by players."));
+            return true;
+        }
+
+        if (getPermission() != null && !sender.hasPermission(getPermission()))
+        {
+            Component permissionMessage = permissionMessage();
+            if (permissionMessage == null)
+                permissionMessage = Component.text("You do not have permission to use this command.");
+            sender.sendMessage(permissionMessage);
+            return true;
+        }
+
+        if (args.length > 0)
+        {
+            ContextProvider provider = new ContextProvider();
+            Set<Subcommand> nodes = command.getSubcommands().keySet();
+            for (Subcommand node : nodes) {
+                Class<?>[] argTypes = node.args();
+                if (argTypes.length != args.length)
+                    continue;
+
+                Object[] objects = new Object[0];
+
+                for (int i = 0; i < argTypes.length; i++) {
+                    Class<?> argType = argTypes[i];
+                    String arg = args[i];
+                    if (argType == String.class)
+                        continue;
+
+                    Context<?> context = () -> provider.fromString(arg);
+                    if (!argType.isInstance(context.get())) {
+                        throw new IllegalStateException();
+                    }
+                    objects = Arrays.copyOf(objects, objects.length + 1);
+                    objects[objects.length - 1] = context.get();
+                }
+                try
+                {
+                    command.getSubcommands().get(node).invoke(command, objects);
+                } catch (Exception ex)
+                {
+                    FreedomLogger.getLogger("Patchwork")
+                            .error(ex);
+                }
+            }
+
+            return false;
+        }
+
+        if (command.getBaseMethodPair() != null) {
+            try
+            {
+                command.getBaseMethodPair().getValue().invoke(command, sender);
+            } catch (Exception ex)
+            {
+                FreedomLogger.getLogger("Patchwork")
+                        .error(ex);
+            }
+        }
+
+        return true;
+    }
+
+    @Override
+    public @NotNull Plugin getPlugin()
+    {
+        return this.plugin;
+    }
+}

Patchwork/src/main/java/me/totalfreedom/command/CommandBase.java

@@ -0,0 +1,72 @@
+package me.totalfreedom.command;
+
+import me.totalfreedom.command.annotation.Base;
+import me.totalfreedom.command.annotation.Info;
+import me.totalfreedom.command.annotation.Permissive;
+import me.totalfreedom.command.annotation.Subcommand;
+import me.totalfreedom.utils.Pair;
+import org.bukkit.plugin.java.JavaPlugin;
+
+import java.lang.reflect.Method;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.stream.Stream;
+
+public abstract class CommandBase
+{
+    private final JavaPlugin plugin;
+    private final Info info;
+    private final Permissive perms;
+    private final Map<Subcommand, Method> subcommands;
+    private final Pair<Base, Method> baseMethodPair;
+
+    protected CommandBase(final JavaPlugin plugin)
+    {
+        this.info = this.getClass().getDeclaredAnnotation(Info.class);
+        this.perms = this.getClass().getDeclaredAnnotation(Permissive.class);
+        this.plugin = plugin;
+        this.subcommands = new HashMap<>();
+
+        if (this.getClass().isAnnotationPresent(Base.class))
+        {
+            Method method = Stream.of(this.getClass().getDeclaredMethods())
+                    .filter(m -> m.isAnnotationPresent(Base.class))
+                    .findFirst()
+                    .orElseThrow(() -> new RuntimeException("Base annotation present but no method found."));
+
+            this.baseMethodPair = new Pair<>(method.getDeclaredAnnotation(Base.class), method);
+        } else
+        {
+            this.baseMethodPair = null;
+        }
+
+        Stream.of(this.getClass().getDeclaredMethods())
+                .filter(method -> method.isAnnotationPresent(Subcommand.class))
+                .forEach(method -> this.subcommands.put(method.getDeclaredAnnotation(Subcommand.class), method));
+    }
+
+    public Pair<Base, Method> getBaseMethodPair()
+    {
+        return baseMethodPair;
+    }
+
+    Info getInfo()
+    {
+        return this.info;
+    }
+
+    Permissive getPerms()
+    {
+        return this.perms;
+    }
+
+    public JavaPlugin getPlugin()
+    {
+        return this.plugin;
+    }
+
+    Map<Subcommand, Method> getSubcommands()
+    {
+        return this.subcommands;
+    }
+}

Patchwork/src/main/java/me/totalfreedom/command/CommandHandler.java

@@ -0,0 +1,25 @@
+package me.totalfreedom.command;
+
+import org.bukkit.Bukkit;
+import org.bukkit.command.PluginCommand;
+import org.bukkit.plugin.java.JavaPlugin;
+
+public class CommandHandler
+{
+    private final JavaPlugin plugin;
+
+    public CommandHandler(JavaPlugin plugin)
+    {
+        this.plugin = plugin;
+    }
+
+    // TODO: Figure out how to use CommandExecutor and TabCompleter.
+    //       We need to find a way to resolve PluginCommands so we can
+    //       set the executor and tab completer as necessary.
+    //       OR we need to find an alternative way to process tab completions.
+    public <T extends CommandBase> void registerCommand(T command) {
+        BukkitDelegator delegate = new BukkitDelegator(plugin, command);
+
+        Bukkit.getCommandMap().register(plugin.getName(), delegate);
+    }
+}

Patchwork/src/main/java/me/totalfreedom/command/annotation/Base.java

@@ -0,0 +1,13 @@
+package me.totalfreedom.command.annotation;
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+
+/**
+ * This annotation is used to mark a method as the command's default method.
+ * This is the method that will be run to execute the command when a user inputs /{command}
+ */
+@Retention(RetentionPolicy.RUNTIME)
+public @interface Base
+{
+}

Patchwork/src/main/java/me/totalfreedom/command/annotation/Info.java

@@ -0,0 +1,16 @@
+package me.totalfreedom.command.annotation;
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+
+@Retention(RetentionPolicy.RUNTIME)
+public @interface Info
+{
+    String name();
+
+    String description() default "This is the default command description.";
+
+    String usage() default "/<command>";
+
+    String[] aliases() default {};
+}

Patchwork/src/main/java/me/totalfreedom/command/annotation/Permissive.java

@@ -0,0 +1,14 @@
+package me.totalfreedom.command.annotation;
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+
+@Retention(RetentionPolicy.RUNTIME)
+public @interface Permissive
+{
+    String perm();
+
+    boolean onlyPlayers() default false;
+
+    String noPerms() default "You do not have permission to use this command.";
+}

Patchwork/src/main/java/me/totalfreedom/command/annotation/Subcommand.java

@@ -0,0 +1,14 @@
+package me.totalfreedom.command.annotation;
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+
+@Retention(RetentionPolicy.RUNTIME)
+public @interface Subcommand
+{
+    String name() default "";
+
+    String permission();
+
+    Class<?>[] args() default {};
+}