Merge pull request CommandAPI#560 from JorelAli/dev/example/paper-command-registration

Delegate Bukkit command registering logic to `CommandRegistrationStrategy`

Author: DerEchtePilz

commandapi-platforms/commandapi-bukkit/commandapi-bukkit-core/src/main/java/dev/jorel/commandapi/CommandAPIBukkit.java

@@ -0,0 +1,86 @@
+package dev.jorel.commandapi;
+
+import com.mojang.brigadier.CommandDispatcher;
+import com.mojang.brigadier.builder.LiteralArgumentBuilder;
+import com.mojang.brigadier.tree.CommandNode;
+import com.mojang.brigadier.tree.LiteralCommandNode;
+import com.mojang.brigadier.tree.RootCommandNode;
+import dev.jorel.commandapi.preprocessor.RequireField;
+
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.function.Predicate;
+
+@RequireField(in = CommandNode.class, name = "children", ofType = Map.class)
+@RequireField(in = CommandNode.class, name = "literals", ofType = Map.class)
+@RequireField(in = CommandNode.class, name = "arguments", ofType = Map.class)
+public abstract class CommandRegistrationStrategy<Source> {
+	// Reflection
+	// I'd like to make the Maps here `Map<String, CommandNode<Source>>`, but these static fields cannot use the type
+	//  parameter Source. We still need to cast to that signature for map, so Map is raw.
+	static final SafeVarHandle<CommandNode<?>, Map> commandNodeChildren;
+	private static final SafeVarHandle<CommandNode<?>, Map> commandNodeLiterals;
+	private static final SafeVarHandle<CommandNode<?>, Map> commandNodeArguments;
+
+	// Compute all var handles all in one go so we don't do this during main server runtime
+	static {
+		commandNodeChildren = SafeVarHandle.ofOrNull(CommandNode.class, "children", "children", Map.class);
+		commandNodeLiterals = SafeVarHandle.ofOrNull(CommandNode.class, "literals", "literals", Map.class);
+		commandNodeArguments = SafeVarHandle.ofOrNull(CommandNode.class, "arguments", "arguments", Map.class);
+	}
+
+	// Utility methods
+	protected void removeBrigadierCommands(RootCommandNode<Source> root, String commandName,
+										   boolean unregisterNamespaces, Predicate<CommandNode<Source>> extraCheck) {
+		Map<String, CommandNode<Source>> children = (Map<String, CommandNode<Source>>) commandNodeChildren.get(root);
+		Map<String, CommandNode<Source>> literals = (Map<String, CommandNode<Source>>) commandNodeLiterals.get(root);
+		Map<String, CommandNode<Source>> arguments = (Map<String, CommandNode<Source>>) commandNodeArguments.get(root);
+
+		removeCommandFromMapIfCheckPasses(children, commandName, extraCheck);
+		removeCommandFromMapIfCheckPasses(literals, commandName, extraCheck);
+		// Commands should really only be represented as literals, but it is technically possible
+		// to put an ArgumentCommandNode in the root, so we'll check
+		removeCommandFromMapIfCheckPasses(arguments, commandName, extraCheck);
+
+		if (unregisterNamespaces) {
+			removeCommandNamespace(children, commandName, extraCheck);
+			removeCommandNamespace(literals, commandName, extraCheck);
+			removeCommandNamespace(arguments, commandName, extraCheck);
+		}
+	}
+
+	protected static <T> void removeCommandNamespace(Map<String, T> map, String commandName, Predicate<T> extraCheck) {
+		for (String key : new HashSet<>(map.keySet())) {
+			if (!isThisTheCommandButNamespaced(commandName, key)) continue;
+
+			removeCommandFromMapIfCheckPasses(map, key, extraCheck);
+		}
+	}
+
+	protected static <T> void removeCommandFromMapIfCheckPasses(Map<String, T> map, String key, Predicate<T> extraCheck) {
+		T element = map.get(key);
+		if (element == null) return;
+		if (extraCheck.test(element)) map.remove(key);
+	}
+
+	protected static boolean isThisTheCommandButNamespaced(String commandName, String key) {
+		if (!key.contains(":")) return false;
+		String[] split = key.split(":");
+		if (split.length < 2) return false;
+		return split[1].equalsIgnoreCase(commandName);
+	}
+
+	// Behavior methods
+	public abstract CommandDispatcher<Source> getBrigadierDispatcher();
+
+	public abstract void runTasksAfterServerStart();
+
+	public abstract void postCommandRegistration(RegisteredCommand registeredCommand, LiteralCommandNode<Source> resultantNode, List<LiteralCommandNode<Source>> aliasNodes);
+
+	public abstract LiteralCommandNode<Source> registerCommandNode(LiteralArgumentBuilder<Source> node, String namespace);
+
+	public abstract void unregister(String commandName, boolean unregisterNamespaces, boolean unregisterBukkit);
+
+	public abstract void preReloadDataPacks();
+}

commandapi-platforms/commandapi-bukkit/commandapi-bukkit-core/src/main/java/dev/jorel/commandapi/CommandRegistrationStrategy.java

@@ -0,0 +1,97 @@
+package dev.jorel.commandapi;
+
+import com.mojang.brigadier.CommandDispatcher;
+import com.mojang.brigadier.builder.LiteralArgumentBuilder;
+import com.mojang.brigadier.tree.CommandNode;
+import com.mojang.brigadier.tree.LiteralCommandNode;
+import com.mojang.brigadier.tree.RootCommandNode;
+
+import java.util.List;
+import java.util.function.Predicate;
+import java.util.function.Supplier;
+
+/**
+ * Handles logic for registering commands after Paper build 65, where <a href="https://github.com/PaperMC/Paper/pull/8235">https://github.com/PaperMC/Paper/pull/8235</a>
+ * changed a bunch of the behind-the-scenes logic.
+ */
+public class PaperCommandRegistration<Source> extends CommandRegistrationStrategy<Source> {
+	// References to necessary methods
+	private final Supplier<CommandDispatcher<Source>> getBrigadierDispatcher;
+	private final Predicate<CommandNode<Source>> isBukkitCommand;
+
+	// Store registered commands nodes for eventual reloads
+	private final RootCommandNode<Source> registeredNodes = new RootCommandNode<>();
+
+	public PaperCommandRegistration(Supplier<CommandDispatcher<Source>> getBrigadierDispatcher, Predicate<CommandNode<Source>> isBukkitCommand) {
+		this.getBrigadierDispatcher = getBrigadierDispatcher;
+		this.isBukkitCommand = isBukkitCommand;
+	}
+
+	// Provide access to internal functions that may be useful to developers
+	/**
+	 * Checks if a Brigadier command node came from wrapping a Bukkit command
+	 *
+	 * @param node The CommandNode to check
+	 * @return true if the CommandNode is being handled by Paper's BukkitCommandNode
+	 */
+	public boolean isBukkitCommand(CommandNode<Source> node) {
+		return isBukkitCommand.test(node);
+	}
+
+	// Implement CommandRegistrationStrategy methods
+	@Override
+	public CommandDispatcher<Source> getBrigadierDispatcher() {
+		return getBrigadierDispatcher.get();
+	}
+
+	@Override
+	public void runTasksAfterServerStart() {
+		// Nothing to do
+	}
+
+	@Override
+	public void postCommandRegistration(RegisteredCommand registeredCommand, LiteralCommandNode<Source> resultantNode, List<LiteralCommandNode<Source>> aliasNodes) {
+		// Nothing to do
+	}
+
+	@Override
+	public LiteralCommandNode<Source> registerCommandNode(LiteralArgumentBuilder<Source> node, String namespace) {
+		LiteralCommandNode<Source> commandNode = getBrigadierDispatcher.get().register(node);
+		LiteralCommandNode<Source> namespacedCommandNode = CommandAPIHandler.getInstance().namespaceNode(commandNode, namespace);
+
+		// Add to registered command nodes
+		registeredNodes.addChild(commandNode);
+		registeredNodes.addChild(namespacedCommandNode);
+
+		// Namespace is not empty on Bukkit forks
+		getBrigadierDispatcher.get().getRoot().addChild(namespacedCommandNode);
+
+		return commandNode;
+	}
+
+	@Override
+	public void unregister(String commandName, boolean unregisterNamespaces, boolean unregisterBukkit) {
+		// Remove nodes from the  dispatcher
+		removeBrigadierCommands(getBrigadierDispatcher.get().getRoot(), commandName, unregisterNamespaces,
+			// If we are unregistering a Bukkit command, ONLY unregister BukkitCommandNodes
+			// If we are unregistering a Vanilla command, DO NOT unregister BukkitCommandNodes
+			c -> !unregisterBukkit ^ isBukkitCommand.test(c));
+
+		// CommandAPI commands count as non-Bukkit
+		if (!unregisterBukkit) {
+			// Don't add nodes back after a reload
+			removeBrigadierCommands(registeredNodes, commandName, unregisterNamespaces, c -> true);
+		}
+
+		// Update the dispatcher file
+		CommandAPIHandler.getInstance().writeDispatcherToFile();
+	}
+
+	@Override
+	public void preReloadDataPacks() {
+		RootCommandNode<Source> root = getBrigadierDispatcher.get().getRoot();
+		for (CommandNode<Source> commandNode : registeredNodes.getChildren()) {
+			root.addChild(commandNode);
+		}
+	}
+}

commandapi-platforms/commandapi-bukkit/commandapi-bukkit-core/src/main/java/dev/jorel/commandapi/PaperCommandRegistration.java

@@ -58,6 +58,9 @@ public void registerReloadHandler(Plugin plugin) {
 
 				@EventHandler
 				public void onServerReloadResources(ServerResourcesReloadedEvent event) {
+					// This event is called after Paper is done with everything command related
+					// which means we can put commands back
+					CommandAPIBukkit.get().getCommandRegistrationStrategy().preReloadDataPacks();
 					CommandAPI.logNormal("/minecraft:reload detected. Reloading CommandAPI commands!");
 					nmsInstance.reloadDataPacks();
 				}