Sponge 11 implementation

cloud-sponge/build.gradle.kts

@@ -0,0 +1,20 @@
+plugins {
+    id("conventions.base")
+    id("conventions.publishing")
+    id("net.neoforged.moddev")
+}
+
+dependencies {
+    api(libs.cloud.core)
+    implementation(libs.cloud.brigadier)
+    offlineLinkedJavadoc(project(":cloud-minecraft-modded-common"))
+    implementation(project(":cloud-minecraft-modded-common"))
+    compileOnly("org.spongepowered:spongeapi:19.0.0-SNAPSHOT")
+    compileOnly("org.spongepowered:sponge:26.1.2-19.0.0-SNAPSHOT")
+}
+
+neoForge {
+    enable {
+        neoFormVersion = "26.1.2-1"
+    }
+}

cloud-sponge/src/main/java/org/incendo/cloud/sponge/CloudInjectionModule.java

@@ -0,0 +1,95 @@
+//
+// MIT License
+//
+// Copyright (c) 2024 Incendo
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+//
+package org.incendo.cloud.sponge;
+
+import com.google.inject.AbstractModule;
+import com.google.inject.Key;
+import com.google.inject.util.Types;
+import java.lang.reflect.Type;
+import org.checkerframework.checker.nullness.qual.NonNull;
+import org.incendo.cloud.SenderMapper;
+import org.incendo.cloud.execution.ExecutionCoordinator;
+import org.spongepowered.api.command.CommandCause;
+
+/**
+ * Injection module that allows for {@link SpongeCommandManager} to be injectable.
+ *
+ * @param <C> Command sender type
+ */
+public final class CloudInjectionModule<C> extends AbstractModule {
+
+    private final Class<C> commandSenderType;
+    private final ExecutionCoordinator<C> executionCoordinator;
+    private final SenderMapper<@NonNull CommandCause, @NonNull C> senderMapper;
+
+    /**
+     * Create a new injection module.
+     *
+     * @param commandSenderType    Your command sender type
+     * @param executionCoordinator Command execution coordinator
+     * @param senderMapper         Function mapping the custom command sender type to a Sponge CommandCause
+     */
+    public CloudInjectionModule(
+        final @NonNull Class<C> commandSenderType,
+        final @NonNull ExecutionCoordinator<C> executionCoordinator,
+        final @NonNull SenderMapper<@NonNull CommandCause, @NonNull C> senderMapper
+    ) {
+        this.commandSenderType = commandSenderType;
+        this.executionCoordinator = executionCoordinator;
+        this.senderMapper = senderMapper;
+    }
+
+    /**
+     * Create a new injection module using Sponge's {@link CommandCause} as the sender type.
+     *
+     * @param executionCoordinator Command execution coordinator
+     * @return new injection module
+     */
+    public static @NonNull CloudInjectionModule<@NonNull CommandCause> createNative(
+        final @NonNull ExecutionCoordinator<CommandCause> executionCoordinator
+    ) {
+        return new CloudInjectionModule<>(
+            CommandCause.class,
+            executionCoordinator,
+            SenderMapper.identity()
+        );
+    }
+
+    @SuppressWarnings({"unchecked", "rawtypes"})
+    @Override
+    protected void configure() {
+        final Type commandExecutionCoordinatorType = Types.newParameterizedType(
+            ExecutionCoordinator.class, this.commandSenderType
+        );
+        final Key coordinatorKey = Key.get(commandExecutionCoordinatorType);
+        this.bind(coordinatorKey).toInstance(this.executionCoordinator);
+
+        final Type commandSenderMapperFunction = Types.newParameterizedType(
+            SenderMapper.class, CommandCause.class, this.commandSenderType
+        );
+        final Key senderMapperKey = Key.get(commandSenderMapperFunction);
+        this.bind(senderMapperKey).toInstance(this.senderMapper);
+    }
+
+}

cloud-sponge/src/main/java/org/incendo/cloud/sponge/CloudSpongeCommand.java

@@ -0,0 +1,228 @@
+//
+// MIT License
+//
+// Copyright (c) 2024 Incendo
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+//
+package org.incendo.cloud.sponge;
+
+import io.leangen.geantyref.GenericTypeReflector;
+import java.lang.reflect.Type;
+import java.util.ArrayDeque;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import java.util.stream.Collectors;
+import net.kyori.adventure.text.Component;
+import org.checkerframework.checker.nullness.qual.NonNull;
+import org.incendo.cloud.component.CommandComponent;
+import org.incendo.cloud.internal.CommandNode;
+import org.incendo.cloud.parser.aggregate.AggregateParser;
+import org.incendo.cloud.parser.standard.LiteralParser;
+import org.incendo.cloud.permission.Permission;
+import org.incendo.cloud.type.tuple.Pair;
+import org.spongepowered.api.command.Command;
+import org.spongepowered.api.command.CommandCause;
+import org.spongepowered.api.command.CommandCompletion;
+import org.spongepowered.api.command.CommandResult;
+import org.spongepowered.api.command.parameter.ArgumentReader;
+import org.spongepowered.api.command.registrar.tree.CommandTreeNode;
+import org.spongepowered.api.registry.RegistryHolder;
+
+import static net.kyori.adventure.text.Component.text;
+
+final class CloudSpongeCommand<C> implements Command.Raw {
+
+    private final SpongeCommandManager<C> commandManager;
+    private final String label;
+
+    CloudSpongeCommand(
+        final @NonNull String label,
+        final @NonNull SpongeCommandManager<C> commandManager
+    ) {
+        this.label = label;
+        this.commandManager = commandManager;
+    }
+
+    @Override
+    public CommandResult process(final @NonNull CommandCause cause, final ArgumentReader.@NonNull Mutable arguments) {
+        final C cloudSender = this.commandManager.senderMapper().map(cause);
+        final String input = this.formatCommandForParsing(arguments.input());
+        this.commandManager.commandExecutor().executeCommand(cloudSender, input);
+        return CommandResult.success();
+    }
+
+    @Override
+    public List<CommandCompletion> complete(
+        final @NonNull CommandCause cause,
+        final ArgumentReader.@NonNull Mutable arguments
+    ) {
+        return this.commandManager.suggestionFactory()
+            .suggestImmediately(this.commandManager.senderMapper().map(cause),
+                this.formatCommandForSuggestions(arguments.input()))
+            .list()
+            .stream()
+            .map(s -> CommandCompletion.of(s.suggestion(), s.tooltip()))
+            .collect(Collectors.toList());
+    }
+
+    @Override
+    public boolean canExecute(final @NonNull CommandCause cause) {
+        return this.checkAccess(
+            cause,
+            this.namedNode().nodeMeta()
+                .getOrDefault(CommandNode.META_KEY_ACCESS, Collections.emptyMap())
+        );
+    }
+
+    @Override
+    public Optional<Component> shortDescription(final CommandCause cause) {
+        return Optional.of(this.usage(cause));
+    }
+
+    @Override
+    public Optional<Component> extendedDescription(final CommandCause cause) {
+        return Optional.of(this.usage(cause));
+    }
+
+    @Override
+    public Optional<Component> help(final @NonNull CommandCause cause) {
+        return Optional.of(this.usage(cause));
+    }
+
+    @Override
+    public Component usage(final CommandCause cause) {
+        return text(this.commandManager.commandSyntaxFormatter()
+            .apply(this.commandManager.senderMapper().map(cause), Collections.emptyList(), this.namedNode()));
+    }
+
+    private CommandNode<C> namedNode() {
+        return this.commandManager.commandTree().getNamedNode(this.label);
+    }
+
+    @Override
+    public CommandTreeNode.Root commandTree(final RegistryHolder holder) {
+        final CommandTreeNode<CommandTreeNode.Root> root = CommandTreeNode.root();
+
+        final CommandNode<C> cloud = this.namedNode();
+
+        if (canExecute(cloud)) {
+            root.executable();
+        }
+
+        this.addRequirement(cloud, root);
+
+        this.addChildren(root, cloud, holder);
+        return (CommandTreeNode.Root) root;
+    }
+
+    private void addChildren(final CommandTreeNode<?> node, final CommandNode<C> cloud, final RegistryHolder holder) {
+        for (final CommandNode<C> child : cloud.children()) {
+            final CommandComponent<C> value = child.component();
+            final CommandTreeNode.Argument<? extends CommandTreeNode.Argument<?>> treeNode;
+            if (value.parser() instanceof LiteralParser) {
+                treeNode = (CommandTreeNode.Argument<? extends CommandTreeNode.Argument<?>>) CommandTreeNode.literal();
+            } else if (value.parser() instanceof AggregateParser<C, ?> aggregate) {
+                this.handleAggregate(node, child, aggregate, holder);
+                continue;
+            } else {
+                treeNode = this.commandManager.parserMapper().mapComponent(value, holder);
+            }
+            this.addRequirement(child, treeNode);
+            if (canExecute(child)) {
+                treeNode.executable();
+            }
+            this.addChildren(treeNode, child, holder);
+            node.child(value.name(), treeNode);
+        }
+    }
+
+    private void handleAggregate(
+        final CommandTreeNode<?> node,
+        final CommandNode<C> child,
+        final AggregateParser<C, ?> compound,
+        final RegistryHolder holder
+    ) {
+        final CommandTreeNode.Argument<? extends CommandTreeNode.Argument<?>> treeNode;
+        final ArrayDeque<Pair<String, CommandTreeNode.Argument<? extends CommandTreeNode.Argument<?>>>> nodes = new ArrayDeque<>();
+        for (final CommandComponent<C> component : compound.components()) {
+            final String name = component.name();
+            nodes.add(Pair.of(name, this.commandManager.parserMapper().mapParser(component.parser(), holder)));
+        }
+        Pair<String, CommandTreeNode.Argument<? extends CommandTreeNode.Argument<?>>> argument = null;
+        while (!nodes.isEmpty()) {
+            final Pair<String, CommandTreeNode.Argument<? extends CommandTreeNode.Argument<?>>> prev = argument;
+            argument = nodes.removeLast();
+            if (prev != null) {
+                argument.second().child(prev.first(), prev.second());
+            } else {
+                // last node
+                if (canExecute(child)) {
+                    argument.second().executable();
+                }
+            }
+            this.addRequirement(child, argument.second());
+        }
+        treeNode = argument.second();
+        this.addChildren(treeNode, child, holder);
+        node.child(compound.components().get(0).toString(), treeNode);
+    }
+
+    private static <C> boolean canExecute(final @NonNull CommandNode<C> node) {
+        return node.isLeaf()
+            || !node.component().required()
+            || node.command() != null
+            || node.children().stream().noneMatch(c -> c.component().required());
+    }
+
+    private void addRequirement(
+        final @NonNull CommandNode<C> cloud,
+        final @NonNull CommandTreeNode<? extends CommandTreeNode<?>> node
+    ) {
+        final Map<Type, Permission> accessMap =
+            cloud.nodeMeta().getOrDefault(CommandNode.META_KEY_ACCESS, Collections.emptyMap());
+        node.requires(cause -> this.checkAccess(cause, accessMap));
+    }
+
+    private boolean checkAccess(final CommandCause cause, final Map<Type, Permission> accessMap) {
+        final C cloudSender = this.commandManager.senderMapper().map(cause);
+        for (final Map.Entry<Type, Permission> entry : accessMap.entrySet()) {
+            if (GenericTypeReflector.isSuperType(entry.getKey(), cloudSender.getClass())) {
+                if (this.commandManager.testPermission(cloudSender, entry.getValue()).allowed()) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+
+    private String formatCommandForParsing(final @NonNull String arguments) {
+        if (arguments.isEmpty()) {
+            return this.label;
+        }
+        return this.label + " " + arguments;
+    }
+
+    private String formatCommandForSuggestions(final @NonNull String arguments) {
+        return this.label + " " + arguments;
+    }
+
+}

cloud-sponge/src/main/java/org/incendo/cloud/sponge/NodeSource.java

@@ -0,0 +1,43 @@
+//
+// MIT License
+//
+// Copyright (c) 2024 Incendo
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+//
+package org.incendo.cloud.sponge;
+
+import org.checkerframework.checker.nullness.qual.NonNull;
+import org.spongepowered.api.command.registrar.tree.CommandTreeNode;
+import org.spongepowered.api.registry.RegistryHolder;
+
+/**
+ * Implemented by {@link org.incendo.cloud.parser.ArgumentParser} which also supply a special {@link CommandTreeNode.Argument}.
+ */
+public interface NodeSource {
+
+    /**
+     * Get the node for this parser.
+     *
+     * @param registryHolder registry holder
+     * @return argument node
+     */
+    CommandTreeNode.@NonNull Argument<? extends CommandTreeNode.Argument<?>> node(RegistryHolder registryHolder);
+
+}