Allow required arguments after optional arguments (Linking Edition)

commandapi-core/src/main/java/dev/jorel/commandapi/AbstractCommandAPICommand.java

@@ -22,6 +22,7 @@
 
 import java.util.ArrayList;
 import java.util.Arrays;
+import java.util.Iterator;
 import java.util.List;
 import java.util.function.Predicate;
 
@@ -33,8 +34,9 @@
 
 /**
  * A builder used to create commands to be registered by the CommandAPI.
- * @param <Impl> The class extending this class, used as the return type for chain calls
- * @param <Argument> The implementation of AbstractArgument used by the class extending this class
+ *
+ * @param <Impl> The class extending this class, used as the return type for chain calls
+ * @param <Argument> The implementation of AbstractArgument used by the class extending this class
  * @param <CommandSender> The CommandSender class used by the class extending this class
  */
 public abstract class AbstractCommandAPICommand<Impl extends AbstractCommandAPICommand<Impl, Argument, CommandSender>,
@@ -90,7 +92,7 @@ public final Impl withArguments(Argument... args) {
 
  /**
  * Appends the optional arguments to the current command builder.
- *
+ * <p>
  * This also calls {@link AbstractArgument#setOptional(boolean)} on each argument to make sure they are optional
  *
  * @param args A <code>List</code> that represents the arguments that this
@@ -107,7 +109,7 @@ public Impl withOptionalArguments(List<Argument> args) {
 
  /**
  * Appends the optional arguments to the current command builder.
- *
+ * <p>
  * This also calls {@link AbstractArgument#setOptional(boolean)} on each argument to make sure they are optional
  *
  * @param args Arguments that this command can accept
@@ -325,42 +327,46 @@ public Impl copy() {
 
  private List<Argument[]> getArgumentsToRegister(Argument[] argumentsArray) {
  List<Argument[]> argumentsToRegister = new ArrayList<>();
+ List<Argument> currentCommand = new ArrayList<>();
 
- // Check optional argument constraints
- // They can only be at the end, no required argument can follow an optional argument
- int firstOptionalArgumentIndex = -1;
- boolean seenOptionalArgument = false;
- for (int i = 0; i < argumentsArray.length; i++) {
- if (argumentsArray[i].isOptional()) {
- if (firstOptionalArgumentIndex == -1) {
- firstOptionalArgumentIndex = i;
- }
- seenOptionalArgument = true;
- } else if (seenOptionalArgument) {
- // Argument is not optional
- throw new OptionalArgumentException(meta.commandName);
+ Iterator<Argument> argumentIterator = List.of(argumentsArray).iterator();
+
+ // Collect all required arguments, adding them as a command once finding the first optional
+ while(argumentIterator.hasNext()) {
+ Argument next = argumentIterator.next();
+ if(next.isOptional()) {
+ argumentsToRegister.add((Argument[]) currentCommand.toArray(new AbstractArgument[0]));
+ currentCommand.addAll(unpackCombinedArguments(next));
+ break;
  }
+ currentCommand.addAll(unpackCombinedArguments(next));
  }
 
- // Create a List of arrays that hold arguments to register optional arguments
- // if optional arguments have been found
- if (firstOptionalArgumentIndex != -1) {
- for (int i = 0; i <= argumentsArray.length; i++) {
- if (i >= firstOptionalArgumentIndex) {
- @SuppressWarnings("unchecked")
- Argument[] optionalArguments = (Argument[]) new AbstractArgument[i];
- System.arraycopy(argumentsArray, 0, optionalArguments, 0, i);
- argumentsToRegister.add(optionalArguments);
- }
+ // Collect the optional arguments, adding each one as a valid command
+ while (argumentIterator.hasNext()) {
+ Argument next = argumentIterator.next();
+ if(!next.isOptional()) {
+ throw new OptionalArgumentException(meta.commandName); // non-optional argument after optional
  }
- }
-
- // If there were no optional arguments, let's just return the array of
- // arguments we were going to register normally.
- if(argumentsToRegister.isEmpty()) {
- argumentsToRegister.add(argumentsArray);
+ argumentsToRegister.add((Argument[]) currentCommand.toArray(new AbstractArgument[0]));
+ currentCommand.addAll(unpackCombinedArguments(next));
  }
 
+ // All the arguments expanded, also handles when there are no optional arguments
+ argumentsToRegister.add((Argument[]) currentCommand.toArray(new AbstractArgument[0]));
  return argumentsToRegister;
  }
+
+ private List<Argument> unpackCombinedArguments(Argument argument) {
+ if (!argument.hasCombinedArguments()) {
+ return List.of(argument);
+ }
+ List<Argument> combinedArguments = new ArrayList<>();
+ combinedArguments.add(argument);
+ for (Argument subArgument : argument.getCombinedArguments()) {
+ subArgument.copyPermissionsAndRequirements(argument);
+ combinedArguments.addAll(unpackCombinedArguments(subArgument));
+ }
+ return combinedArguments;
+ }
 }

commandapi-core/src/main/java/dev/jorel/commandapi/arguments/AbstractArgument.java

@@ -20,19 +20,19 @@
  *******************************************************************************/
 package dev.jorel.commandapi.arguments;
 
-import java.util.Collections;
-import java.util.List;
-import java.util.Optional;
-import java.util.function.Predicate;
-
 import com.mojang.brigadier.arguments.ArgumentType;
 import com.mojang.brigadier.context.CommandContext;
 import com.mojang.brigadier.exceptions.CommandSyntaxException;
-
 import dev.jorel.commandapi.AbstractArgumentTree;
 import dev.jorel.commandapi.CommandPermission;
 import dev.jorel.commandapi.executors.CommandArguments;
 
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.Optional;
+import java.util.function.Predicate;
+
 /**
  * The core abstract class for Command API arguments
  * 
@@ -227,6 +227,13 @@ public final Impl withRequirement(Predicate<CommandSender> requirement) {
  return instance();
  }
 
+ /**
+ * Resets the requirements for this command
+ */
+ void resetRequirements() {
+ this.requirements = s -> true;
+ }
+
  /////////////////
  // Listability //
  /////////////////
@@ -258,6 +265,7 @@ public Impl setListed(boolean listed) {
  /////////////////
 
  private boolean isOptional = false;
+ private final List<Argument> combinedArguments = new ArrayList<>();
 
  /**
  * Returns true if this argument will be optional when executing the command this argument is included in
@@ -279,6 +287,42 @@ public Impl setOptional(boolean optional) {
  return instance();
  }
 
+ /**
+ * Returns a list of arguments linked to this argument.
+ *
+ * @return A list of arguments linked to this argument
+ */
+ public List<Argument> getCombinedArguments() {
+ return combinedArguments;
+ }
+
+ /**
+ * Returns true if this argument has linked arguments.
+ *
+ * @return true if this argument has linked arguments
+ */
+ public boolean hasCombinedArguments() {
+ return !combinedArguments.isEmpty();
+ }
+
+ /**
+ * Adds combined arguments to this argument. Combined arguments are used to have required arguments after optional arguments
+ * by ignoring they exist until they are added to the arguments array for registration.
+ *
+ * This method also causes permissions and requirements from this argument to be copied over to the arguments you want to combine
+ * this argument with. Their permissions and requirements will be ignored.
+ *
+ * @param combinedArguments The arguments to combine to this argument
+ * @return this current argument
+ */
+ @SafeVarargs
+ public final Impl combineWith(Argument... combinedArguments) {
+ for (Argument argument : combinedArguments) {
+ this.combinedArguments.add(argument);
+ }
+ return instance();
+ }
+
  ///////////
  // Other //
  ///////////
@@ -297,6 +341,18 @@ public List<String> getEntityNames(Object argument) {
  return Collections.singletonList(null);
  }
 
+ /**
+ * Copies permissions and requirements from the provided argument to this argument
+ * This also resets additional permissions and requirements.
+ *
+ * @param argument The argument to copy permissions and requirements from
+ */
+ public void copyPermissionsAndRequirements(Argument argument) {
+ this.resetRequirements();
+ this.withRequirement(argument.getRequirements());
+ this.withPermission(argument.getArgumentPermission());
+ }
+
  @Override
  public String toString() {
  return this.getNodeName() + "<" + this.getClass().getSimpleName() + ">";

commandapi-core/src/main/java/dev/jorel/commandapi/exceptions/OptionalArgumentException.java

@@ -4,7 +4,7 @@
 public class OptionalArgumentException extends RuntimeException {
 
  public OptionalArgumentException(String commandName) {
- super("Failed to register command /" + commandName + " because a required argument cannot follow an optional argument!");
+ super("Failed to register command /" + commandName + " because an unlinked required argument cannot follow an optional argument!");
  }
 
 }

commandapi-documentation-code/src/main/java/dev/jorel/commandapi/examples/java/Examples.java

@@ -1583,6 +1583,32 @@ void optionalArguments() {
  })
  .register();
 /* ANCHOR_END: optionalArguments2 */
+
+/* ANCHOR: optionalArguments3 */
+new CommandAPICommand("rate")
+ .withOptionalArguments(new StringArgument("topic").combineWith(new IntegerArgument("rating", 0, 10)))
+ .withOptionalArguments(new PlayerArgument("target"))
+ .executes((sender, args) -> {
+ String topic = (String) args.get("topic");
+ if(topic == null) {
+ sender.sendMessage(
+ "Usage: /rate <topic> <rating> <player>(optional)",
+ "Select a topic to rate, then give a rating between 0 and 10",
+ "You can optionally add a player at the end to give the rating to"
+ );
+ return;
+ }
+
+ // We know this is not null because rating is required if topic is given
+ int rating = (int) args.get("rating");
+
+ // The target player is optional, so give it a default here
+ CommandSender target = (CommandSender) args.getOrDefault("target", sender);
+
+ target.sendMessage("Your " + topic + " was rated: " + rating + "/10");
+ })
+ .register();
+/* ANCHOR_END: optionalArguments3 */
 }
 
 void permissions() {

commandapi-documentation-code/src/main/kotlin/dev/jorel/commandapi/examples/kotlin/Examples.kt

@@ -1496,6 +1496,32 @@ CommandAPICommand("sayhi")
  })
  .register()
 /* ANCHOR_END: optionalArguments2 */
+
+/* ANCHOR: optionalArguments3 */
+CommandAPICommand("rate")
+ .withOptionalArguments(StringArgument("topic").combineWith(IntegerArgument("rating", 0, 10)))
+ .withOptionalArguments(PlayerArgument("target"))
+ .executes(CommandExecutor { sender, args ->
+ val topic: String? = args["topic"] as String?
+ if (topic == null) {
+ sender.sendMessage(
+ "Usage: /rate <topic> <rating> <player>(optional)",
+ "Select a topic to rate, then give a rating between 0 and 10",
+ "You can optionally add a player at the end to give the rating to"
+ )
+ return@CommandExecutor
+ }
+
+ // We know this is not null because rating is required if topic is given
+ val rating = args["rating"] as Int
+
+ // The target player is optional, so give it a default here
+ val target: CommandSender = args.getOrDefault("target", sender) as CommandSender
+
+ target.sendMessage("Your $topic was rated: $rating/10")
+ })
+ .register()
+/* ANCHOR_END: optionalArguments3 */
 }
 
 fun permissions() {

commandapi-documentation-code/src/main/kotlin/dev/jorel/commandapi/examples/kotlin/ExamplesKotlinDSL.kt

@@ -1053,6 +1053,32 @@ commandAPICommand("sayhi") {
  }
 }
 /* ANCHOR_END: optionalArguments2 */
+
+/* ANCHOR: optionalArguments3 */
+commandAPICommand("rate") {
+ argument(StringArgument("topic").setOptional(true).combineWith(IntegerArgument("rating", 0, 10)))
+ playerArgument("target", optional = true)
+ anyExecutor { sender, args ->
+ val topic: String? = args["topic"] as String?
+ if (topic == null) {
+ sender.sendMessage(
+ "Usage: /rate <topic> <rating> <player>(optional)",
+ "Select a topic to rate, then give a rating between 0 and 10",
+ "You can optionally add a player at the end to give the rating to"
+ )
+ return@anyExecutor
+ }
+
+ // We know this is not null because rating is required if topic is given
+ val rating = args["rating"] as Int
+
+ // The target player is optional, so give it a default here
+ val target: CommandSender = args.getOrDefault("target", sender) as CommandSender
+
+ target.sendMessage("Your $topic was rated: $rating/10")
+ }
+}
+/* ANCHOR_END: optionalArguments3 */
 }
 
 fun proxysender() {