refactor ig

bukkit/BUILD

@@ -0,0 +1,15 @@
+load("@rules_jvm_external//:defs.bzl", "artifact", "java_export")
+
+java_export(
+    name = "bukkit",
+    maven_coordinates = "de.kentoj.scrow:kencommandapi-bukkit:0.34-SNAPSHOT",
+    srcs = glob(["src/main/**/*.java"]),
+    deps = [
+        "//core",
+        artifact("org.jetbrains:annotations"),
+        artifact("io.papermc.paper:paper-api"),
+    ],
+    exports = [
+        "//core",
+    ],
+)

bukkit/src/main/java/de/kentoj/kencommandapi/BukkitKenCommand.java

@@ -0,0 +1,40 @@
+package de.kentoj.kencommandapi;
+
+import de.kentoj.kencommandapi.api.CommandHandler;
+import de.kentoj.kencommandapi.api.literal.RootLiteral;
+import de.kentoj.kencommandapi.api.platform.MessageStyle;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.Arrays;
+import java.util.stream.Stream;
+
+public class BukkitKenCommand<T extends CommandSender> extends Command {
+
+    private final RootLiteral<T> rootLiteral;
+    private final CommandHandler<T> commandHandler;
+    private final Class<T> senderType;
+
+    protected BukkitKenCommand(CommandHandler<T> commandHandler, RootLiteral<T> rootLiteral, Class<T> senderType) {
+        super(rootLiteral.names()[0]);
+        this.commandHandler = commandHandler;
+        this.rootLiteral = rootLiteral;
+        this.senderType = senderType;
+
+        this.setAliases(Arrays.asList(rootLiteral.names()));
+        this.setPermission(rootLiteral.permission());
+    }
+
+    @Override
+    public boolean execute(@NotNull CommandSender commandSender, @NotNull String commandLabel, @NotNull String[] args) {
+        if (!senderType.isInstance(commandSender)) {
+            commandSender.sendMessage(MessageStyle.PLAIN.err("You can't use that command"));
+            return true;
+        }
+        T sender = senderType.cast(commandSender);
+
+        commandHandler.invoke(rootLiteral, sender, Stream.of(args).filter(str -> !str.isEmpty()));
+        return true;
+    }
+}

bukkit/src/main/java/de/kentoj/kencommandapi/CommandAPI.java

@@ -0,0 +1,50 @@
+package de.kentoj.kencommandapi;
+
+import de.kentoj.kencommandapi.api.CommandHandler;
+import de.kentoj.kencommandapi.api.literal.RootLiteral;
+import org.bukkit.Bukkit;
+import org.bukkit.command.CommandSender;
+import org.bukkit.command.SimpleCommandMap;
+import org.bukkit.permissions.Permissible;
+import org.bukkit.plugin.Plugin;
+import org.jetbrains.annotations.Nullable;
+
+import java.lang.reflect.Field;
+import java.util.ArrayList;
+import java.util.List;
+
+public class CommandAPI<T extends CommandSender> {
+
+    private final CommandHandler<T> commandHandler;
+    private final List<RootLiteral<T>> registeredNodes = new ArrayList<>();
+    private final SimpleCommandMap commandMap;
+    private final Class<T> senderType;
+
+    public CommandAPI(Plugin plugin, Class<T> senderType) {
+        this.senderType = senderType;
+        this.commandHandler = new CommandHandler<>(CommandSender::sendMessage, Permissible::hasPermission);
+        Bukkit.getPluginManager().registerEvents(new TabCompleteListener<>(this, commandHandler, senderType), plugin);
+
+        try {
+            Field field = Bukkit.getPluginManager().getClass().getDeclaredField("commandMap");
+            field.setAccessible(true);
+            commandMap = (SimpleCommandMap) field.get(Bukkit.getPluginManager());
+        } catch (NoSuchFieldException | IllegalAccessException e) {
+            throw new IllegalStateException("failed getting command map", e);
+        }
+    }
+
+    @Nullable RootLiteral<T> getRegistered(String name) {
+        for (var node : registeredNodes) {
+            for (String nodeName : node.names()) {
+                if (nodeName.equals(name)) return node;
+            }
+        }
+        return null;
+    }
+
+    public void register(RootLiteral<T> rootNode) {
+        registeredNodes.add(rootNode);
+        commandMap.register(rootNode.names()[0], new BukkitKenCommand<>(commandHandler, rootNode, senderType));
+    }
+}

bukkit/src/main/java/de/kentoj/kencommandapi/TabCompleteListener.java

@@ -0,0 +1,46 @@
+package de.kentoj.kencommandapi;
+
+import com.destroystokyo.paper.event.server.AsyncTabCompleteEvent;
+import de.kentoj.kencommandapi.api.CommandHandler;
+import org.bukkit.command.CommandSender;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
+
+import java.util.Arrays;
+
+public class TabCompleteListener<T extends CommandSender> implements Listener {
+
+    private final CommandAPI<T> commandAPI;
+    private final CommandHandler<T> commandHandler;
+    private final Class<T> senderType;
+
+    public TabCompleteListener(CommandAPI<T> commandAPI, CommandHandler<T> commandHandler, Class<T> senderType) {
+        this.commandAPI = commandAPI;
+        this.commandHandler = commandHandler;
+        this.senderType = senderType;
+    }
+
+    @EventHandler(ignoreCancelled = true)
+    public void onAsyncTabComplete(AsyncTabCompleteEvent ev) {
+        if (!ev.isCommand()) return;
+        var args = ev.getBuffer().substring(1).split(" ");
+        if (args.length == 0) return;
+
+        var label = args[0];
+        {
+            // commands can be called with a '<plugin name>:' prefix. strip it.
+            int l = label.indexOf(':');
+            if (l >= 0)
+                label = label.substring(l + 1);
+        }
+        var literal = commandAPI.getRegistered(label);
+        if (literal == null) return;
+
+        if (!senderType.isInstance(ev.getSender()))
+            return;
+
+        T sender = senderType.cast(ev.getSender());
+        ev.setHandled(true);
+        ev.setCompletions(commandHandler.getSuggestions(literal, sender, Arrays.copyOfRange(args, 1, args.length), ev.getBuffer().endsWith(" ")));
+    }
+}

bukkit/src/main/java/de/kentoj/kencommandapi/suggestionprovider/PlayerSuggestionProvider.java

@@ -0,0 +1,16 @@
+package de.kentoj.kencommandapi.suggestionprovider;
+
+import de.kentoj.kencommandapi.api.suggestion.SuggestionProvider;
+import org.bukkit.Bukkit;
+import org.bukkit.entity.Player;
+
+import java.util.List;
+
+public final class PlayerSuggestionProvider<T> implements SuggestionProvider<T> {
+    @Override
+    public List<String> suggest(T __) {
+        return Bukkit.getOnlinePlayers().stream()
+                .map(Player::getName)
+                .toList();
+    }
+}

bukkit/src/main/java/de/kentoj/kencommandapi/type/OfflinePlayerArgumentType.java

@@ -0,0 +1,34 @@
+package de.kentoj.kencommandapi.type;
+
+import de.kentoj.kencommandapi.api.argument.ArgumentType;
+import de.kentoj.kencommandapi.api.suggestion.SuggestionProvider;
+import de.kentoj.kencommandapi.suggestionprovider.PlayerSuggestionProvider;
+import org.bukkit.Bukkit;
+import org.bukkit.OfflinePlayer;
+
+import java.util.UUID;
+
+public class OfflinePlayerArgumentType<T> implements ArgumentType<T, OfflinePlayer> {
+
+    @Override
+    public OfflinePlayer parseInputUnchecked(String string) {
+        // UUIDs are always 36 chars
+        if (string.length() == 36) {
+            try {
+                return Bukkit.getOfflinePlayer(UUID.fromString(string));
+            } catch (IllegalArgumentException ex) {
+                throw new IllegalArgumentException("Invalid UUID");
+            }
+        }
+
+        OfflinePlayer player = Bukkit.getPlayerExact(string);
+        if (player == null || (!player.hasPlayedBefore() && !player.isOnline()))
+            throw new IllegalArgumentException("Player not found");
+        return player;
+    }
+
+    @Override
+    public SuggestionProvider<T> getDefaultSuggestionProvider() {
+        return new PlayerSuggestionProvider<>();
+    }
+}

bukkit/src/main/java/de/kentoj/kencommandapi/type/PlayerArgumentType.java

@@ -0,0 +1,22 @@
+package de.kentoj.kencommandapi.type;
+
+import de.kentoj.kencommandapi.api.argument.ArgumentType;
+import de.kentoj.kencommandapi.api.suggestion.SuggestionProvider;
+import de.kentoj.kencommandapi.suggestionprovider.PlayerSuggestionProvider;
+import org.bukkit.Bukkit;
+import org.bukkit.entity.Player;
+
+public class PlayerArgumentType<T> implements ArgumentType<T, Player> {
+
+    @Override
+    public Player parseInputUnchecked(String string) {
+        var player = Bukkit.getPlayer(string);
+        if (player == null) throw new IllegalArgumentException("player not online");
+        return player;
+    }
+
+    @Override
+    public SuggestionProvider<T> getDefaultSuggestionProvider() {
+        return new PlayerSuggestionProvider<>();
+    }
+}