Add command proxies

cloud-annotations/src/main/java/com/intellectualsites/commands/annotations/AnnotationParser.java

@@ -211,7 +211,16 @@ public final class AnnotationParser<C> {
             } catch (final Exception e) {
                 throw new RuntimeException("Failed to construct command execution handler", e);
             }
-            commands.add(builder.build());
+            final Command<C> builtCommand = builder.build();
+            commands.add(builtCommand);
+            /* Check if we need to construct a proxy */
+            if (method.isAnnotationPresent(ProxiedBy.class)) {
+                final String proxy = method.getAnnotation(ProxiedBy.class).value();
+                if (proxy.contains(" ")) {
+                    throw new IllegalArgumentException("@ProxiedBy proxies may only contain single literals");
+                }
+                manager.command(manager.commandBuilder(proxy, builtCommand.getCommandMeta()).proxies(builtCommand).build());
+            }
         }
         return commands;
     }

cloud-annotations/src/main/java/com/intellectualsites/commands/annotations/ProxiedBy.java

@@ -0,0 +1,47 @@
+//
+// MIT License
+//
+// Copyright (c) 2020 Alexander Söderberg
+//
+// 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 com.intellectualsites.commands.annotations;
+
+import javax.annotation.Nonnull;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * Creates a command proxy for the command. This is similar to
+ * {@link com.intellectualsites.commands.Command.Builder#proxies(com.intellectualsites.commands.Command)}.
+ */
+@Target(ElementType.METHOD)
+@Retention(RetentionPolicy.RUNTIME)
+public @interface ProxiedBy {
+
+    /**
+     * Syntax of the proxying command
+     *
+     * @return Proxy syntax
+     */
+    @Nonnull String value();
+
+}

cloud-annotations/src/test/java/com/intellectualsites/commands/annotations/AnnotationParserTest.java

@@ -54,13 +54,15 @@ class AnnotationParserTest {
     void testMethodConstruction() {
         final Collection<Command<TestCommandSender>> commands = annotationParser.parse(this);
         Assertions.assertFalse(commands.isEmpty());
-        manager.executeCommand(new TestCommandSender(), "test 10").join();
+        manager.executeCommand(new TestCommandSender(), "test literal 10").join();
-        manager.executeCommand(new TestCommandSender(), "t 10 o").join();
+        manager.executeCommand(new TestCommandSender(), "t literal 10 o").join();
+        manager.executeCommand(new TestCommandSender(), "proxycommand 10").join();
         Assertions.assertThrows(CompletionException.class, () ->
                 manager.executeCommand(new TestCommandSender(), "test 101").join());
     }
 
-    @CommandMethod("test|t <int> [string]")
+    @ProxiedBy("proxycommand")
+    @CommandMethod("test|t literal <int> [string]")
     public void testCommand(@Nonnull final TestCommandSender sender,
                             @Argument("int") @Range(max = "100") final int argument,
                             @Nonnull @Argument(value = "string", defaultValue = "potato", parserName = "potato")

cloud-core/src/main/java/com/intellectualsites/commands/Command.java

@@ -410,6 +410,33 @@ public class Command<C> {
                                  this.commandExecutionHandler, Permission.of(permission));
         }
 
+        /**
+         * Make the current command be a proxy of the supplied command. This means that
+         * all of the proxied commands variable command arguments will be inserted into this
+         * builder instance, in the order they are declared in the proxied command. Furthermore,
+         * the proxied commands command handler will be showed by the command that is currently
+         * being built. If the current command builder does not have a permission node set, this
+         * too will be copied.
+         *
+         * @param command Command to proxy
+         * @return New builder that proxies the given command
+         */
+        @Nonnull
+        public Builder<C> proxies(@Nonnull final Command<C> command) {
+            Builder<C> builder = this;
+            for (final CommandArgument<C, ?> argument : command.getArguments()) {
+                if (argument instanceof StaticArgument) {
+                    continue;
+                }
+                final CommandArgument<C, ?> builtArgument = argument.copy();
+                builder = builder.argument(builtArgument, Description.of(command.getArgumentDescription(argument)));
+            }
+            if (this.commandPermission.toString().isEmpty()) {
+                builder = builder.withPermission(command.getCommandPermission());
+            }
+            return builder.handler(command.commandExecutionHandler);
+        }
+
         /**
          * Build a command using the builder instance
          *

cloud-core/src/main/java/com/intellectualsites/commands/arguments/CommandArgument.java

@@ -281,6 +281,27 @@ public class CommandArgument<C, T> implements Comparable<CommandArgument<?, ?>>
         return this.valueType;
     }
 
+    /**
+     * Create a copy of the command argument
+     *
+     * @return Copied argument
+     */
+    @Nonnull
+    public CommandArgument<C, T> copy() {
+        CommandArgument.Builder<C, T> builder = ofType(this.valueType, this.name);
+        builder = builder.withSuggestionsProvider(this.suggestionsProvider);
+        builder = builder.withParser(this.parser);
+        if (this.isRequired()) {
+            builder = builder.asRequired();
+        } else if (this.defaultValue.isEmpty()) {
+            builder = builder.asOptional();
+        } else {
+            builder = builder.asOptionalWithDefault(this.defaultValue);
+        }
+        return builder.build();
+    }
+
+
     /**
      * Mutable builder for {@link CommandArgument} instances
      *

cloud-core/src/test/java/com/intellectualsites/commands/CommandTreeTest.java

@@ -24,6 +24,7 @@
 package com.intellectualsites.commands;
 
 import com.intellectualsites.commands.arguments.standard.IntegerArgument;
+import com.intellectualsites.commands.arguments.standard.StringArgument;
 import com.intellectualsites.commands.context.CommandContext;
 import com.intellectualsites.commands.exceptions.NoPermissionException;
 import com.intellectualsites.commands.meta.SimpleCommandMeta;
@@ -56,6 +57,15 @@ class CommandTreeTest {
                                                  .optional("num", EXPECTED_INPUT_NUMBER))
                                .build())
                .command(manager.commandBuilder("req").withSenderType(SpecificCommandSender.class).build());
+        final Command<TestCommandSender> toProxy = manager.commandBuilder("test")
+                                                          .literal("unproxied")
+                                                          .argument(StringArgument.required("string"))
+                                                          .argument(IntegerArgument.required("int"))
+                                                          .literal("anotherliteral")
+                                                          .handler(c -> {})
+                                                          .build();
+        manager.command(toProxy);
+        manager.command(manager.commandBuilder("proxy").proxies(toProxy).build());
     }
 
     @Test
@@ -120,6 +130,12 @@ class CommandTreeTest {
                 .executeCommand(new TestCommandSender(), "invalid test").join());
     }
 
+    @Test
+    void testProxy() {
+        manager.executeCommand(new TestCommandSender(),"test unproxied foo 10 anotherliteral").join();
+        manager.executeCommand(new TestCommandSender(), "proxy foo 10").join();
+    }
+
 
     public static final class SpecificCommandSender extends TestCommandSender {
     }