Update to v8.0.0 (#23)

* Remove deprecated parts of the code

* Fix argument identification in autocompletes

* Handle limitations of options

* Limit concatenation to InputArguments

* Add action listener to SubArgument

* Update example

Author: S3nS3IW00

src/main/java/me/s3ns3iw00/jcommands/Command.java

@@ -20,6 +20,7 @@
 
 import me.s3ns3iw00.jcommands.argument.Argument;
 import me.s3ns3iw00.jcommands.argument.InputArgument;
+import me.s3ns3iw00.jcommands.argument.SubArgument;
 import me.s3ns3iw00.jcommands.argument.concatenation.Concatenator;
 import me.s3ns3iw00.jcommands.event.listener.ArgumentMismatchEventListener;
 import me.s3ns3iw00.jcommands.event.listener.CommandActionEventListener;
@@ -39,15 +40,14 @@ public class Command {
      */
     private final String name, description;
     private final LinkedList<Argument> arguments = new LinkedList<>();
-    private final Map<Concatenator, LinkedList<Argument>> concatenators = new LinkedHashMap<>();
+    private final Map<Concatenator, LinkedList<InputArgument>> concatenators = new LinkedHashMap<>();
 
     private final Set<PermissionType> defaultPermissions = new HashSet<>();
 
     private boolean onlyForAdministrators = false;
     private boolean nsfw = false;
 
     private CommandActionEventListener actionListener;
-    private ArgumentMismatchEventListener argumentMismatchListener;
 
     /**
      * Default constructor
@@ -69,7 +69,7 @@ public Command(String name, String description) {
             throw new IllegalArgumentException("Command's name is invalid, it should contain only word characters, '-' and '_' character, and its length must between 1 and 32");
         }
 
-        if (description.length() < 1 || description.length() > 100) {
+        if (description.isEmpty() || description.length() > 100) {
             throw new IllegalArgumentException("Description's length must between 1 and 100");
         }
     }
@@ -80,11 +80,25 @@ public Command(String name, String description) {
      * @param argument the argument
      */
     public void addArgument(Argument argument) {
-        if (arguments.size() > 0 &&
-                (arguments.getLast() instanceof InputArgument) &&
-                ((InputArgument) arguments.getLast()).isOptional() &&
-                !((InputArgument) argument).isOptional()) {
-            throw new IllegalStateException("Cannot add non-optional argument after an optional argument!");
+        if (!arguments.isEmpty()) {
+            // Unique name checking
+            if (arguments.stream().anyMatch(arg -> arg.getName().equals(argument.getName()))) {
+                throw new IllegalStateException("Arguments must have unique name in the same scope!");
+            }
+
+            // SubArgument and InputArgument mix checking
+            if ((argument instanceof SubArgument && arguments.stream().anyMatch(arg -> arg instanceof InputArgument)) ||
+                    (argument instanceof InputArgument && arguments.stream().anyMatch(arg -> arg instanceof SubArgument))) {
+                throw new IllegalStateException("SubArguments and InputArguments cannot be mixed in the same scope!");
+            }
+
+            // Optional and non-optional argument order checking
+            if (argument instanceof InputArgument &&
+                    !((InputArgument) argument).isOptional() &&
+                    arguments.getLast() instanceof InputArgument &&
+                    ((InputArgument) arguments.getLast()).isOptional()) {
+                throw new IllegalStateException("Cannot add non-optional argument after an optional argument!");
+            }
         }
 
         this.arguments.add(argument);
@@ -106,7 +120,7 @@ public void addArgument(Argument... arguments) {
      * @param concatenator the concatenator
      * @param arguments    the list of arguments
      */
-    public void addConcatenator(Concatenator concatenator, Argument... arguments) {
+    public void addConcatenator(Concatenator concatenator, InputArgument... arguments) {
         if (!concatenators.containsKey(concatenator)) {
             concatenators.put(concatenator, new LinkedList<>());
         }
@@ -171,7 +185,7 @@ public List<Argument> getArguments() {
     /**
      * @return the map of concatenators
      */
-    public Map<Concatenator, LinkedList<Argument>> getConcatenators() {
+    public Map<Concatenator, LinkedList<InputArgument>> getConcatenators() {
         return concatenators;
     }
 

src/main/java/me/s3ns3iw00/jcommands/CommandHandler.java

@@ -39,6 +39,7 @@
 import org.javacord.api.interaction.*;
 
 import java.util.*;
+import java.util.concurrent.atomic.AtomicInteger;
 import java.util.function.Predicate;
 import java.util.stream.Collectors;
 
@@ -150,6 +151,15 @@ private static void handleCommand(SlashCommandInteraction interaction) {
                     }
                 }
 
+                AtomicInteger i = new AtomicInteger(0);
+                resultOptional.get().keySet().forEach(argument -> {
+                    if (argument instanceof SubArgument) {
+                        List<ArgumentResult> subResults = results.subList(i.incrementAndGet(), results.size());
+
+                        ((SubArgument<?, ?>) argument).getActionListener().ifPresent(listener -> listener.onAction(new CommandActionEvent(command, sender,
+                                new CommandResponder(interaction), channel.orElse(null), subResults.toArray(new ArgumentResult[0]))));
+                    }
+                });
                 command.getActionListener().ifPresent(listener -> listener.onAction(new CommandActionEvent(command, sender,
                         new CommandResponder(interaction), channel.orElse(null), results.toArray(new ArgumentResult[0]))));
             }
@@ -171,44 +181,62 @@ private static void handleAutocomplete(AutocompleteInteraction interaction) {
 
             User sender = interaction.getUser();
             Optional<TextChannel> channel = interaction.getChannel();
-            List<Argument> allArguments = collectArguments(command.getArguments());
-            Optional<Argument> argumentOptional = allArguments.stream()
-                    .filter(arg -> arg.getName().equalsIgnoreCase(option.getName()))
-                    .findFirst();
-            argumentOptional.ifPresent(argument -> {
-                if (argument instanceof AutocompletableInputArgument) {
-                    AutocompletableInputArgument<?, ?> autocompletable = (AutocompletableInputArgument) argument;
-                    AutocompleteState autocompleteState = new AutocompleteState(
-                            command,
-                            channel.orElse(null),
-                            sender,
-                            argument,
-                            getOptionValue(option, argument.getType()),
-                            interaction.getArguments().stream()
-                                    .collect(Collectors.toMap(
-                                            key -> allArguments.stream()
-                                                    .filter(arg -> arg.getName().equalsIgnoreCase(key.getName()))
-                                                    .findFirst().orElse(null),
-                                            value -> value
-                                    ))
-                                    .entrySet().stream()
-                                    .collect(Collectors.toMap(
-                                            Map.Entry::getKey,
-                                            value -> getOptionValue(value.getValue(), value.getKey().getType())
-                                    )));
-
-                    /* Collect results from autocompletes and construct the list */
-                    List<Choice> choices = autocompletable.getAutocompletes().stream()
-                            .map(autocomplete -> autocomplete.getResult(autocompleteState))
-                            .filter(Objects::nonNull)
-                            .flatMap(List::stream)
-                            .collect(Collectors.toList());
-
-                    if (choices.size() > 0) {
-                        interaction.respondWithChoices(choices.stream().map(Choice::getChoice).collect(Collectors.toList()));
-                    }
+
+            // Going through options and arguments to identify the proper subcommand that contains the argument
+            List<Argument> arguments = command.getArguments();
+            List<SlashCommandInteractionOption> options = interaction.getOptions();
+            Map<Argument, Optional<?>> argumentValues = new HashMap<>();
+            while (!options.get(0).getOptions().isEmpty()) {
+                SlashCommandInteractionOption firstOption = options.get(0);
+                SubArgument subArgument = (SubArgument) arguments.stream()
+                        .filter(argument -> argument.getName().equals(firstOption.getName()))
+                        .findFirst()
+                        .orElse(null);
+
+                argumentValues.put(subArgument, Optional.of(subArgument.getName()));
+
+                arguments = subArgument.getArguments();
+                options = options.get(0).getOptions();
+            }
+
+            // Identifying argument and collecting specified values
+            Argument argument = null;
+            for (Argument arg : arguments) {
+                if (arg.getName().equals(option.getName())) {
+                    argument = arg;
                 }
-            });
+                argumentValues.put(
+                        arg,
+                        getOptionValue(
+                                options.stream()
+                                        .filter(opt -> opt.getName().equals(arg.getName()))
+                                        .findFirst()
+                                        .orElse(null),
+                                arg.getType()
+                        )
+                );
+            }
+
+            AutocompletableInputArgument<?, ?> autocompletable = (AutocompletableInputArgument) argument;
+            AutocompleteState autocompleteState = new AutocompleteState(
+                    command,
+                    channel.orElse(null),
+                    sender,
+                    argument,
+                    getOptionValue(option, argument.getType()),
+                    argumentValues
+            );
+
+            /* Collect results from autocompletes and construct the list */
+            List<Choice> choices = autocompletable.getAutocompletes().stream()
+                    .map(autocomplete -> autocomplete.getResult(autocompleteState))
+                    .filter(Objects::nonNull)
+                    .flatMap(List::stream)
+                    .collect(Collectors.toList());
+
+            if (choices.size() > 0) {
+                interaction.respondWithChoices(choices.stream().map(Choice::getChoice).collect(Collectors.toList()));
+            }
         });
     }
 
@@ -317,20 +345,6 @@ private static Optional<?> getOptionValue(SlashCommandInteractionOption option,
         }
     }
 
-    /**
-     * Returns the {@link Argument} of {@link Command} by {@link SlashCommandInteractionOption}
-     *
-     * @param command the command
-     * @param option  the option
-     * @return an {@link Optional} with the {@link Argument} in it if found,
-     * otherwise an empty {@link Optional}
-     */
-    private static Optional<Argument> getArgumentByOption(Command command, SlashCommandInteractionOption option) {
-        return collectArguments(command.getArguments()).stream()
-                .filter(arg -> arg.getName().equalsIgnoreCase(option.getName()))
-                .findFirst();
-    }
-
     /**
      * Collects all arguments of a list of arguments in one list
      * For collecting a command's all arguments {@link Command#getArguments()} need to be passed as parameter
@@ -521,17 +535,6 @@ public static boolean isCommandExist(Server server, String cmd) {
         return false;
     }
 
-    /**
-     * Registers a converter for the given type
-     *
-     * @param clazz     the class of the type
-     * @param converter the converter
-     *
-     * @deprecated use {@link InputArgument#convertResult(ArgumentResultConverter)}
-     */
-    @Deprecated
-    public static void registerArgumentConverter(Class<?> clazz, ArgumentResultConverter converter) {}
-
     /**
      * @return the discord api
      */

src/main/java/me/s3ns3iw00/jcommands/argument/Argument.java

@@ -18,12 +18,9 @@
  */
 package me.s3ns3iw00.jcommands.argument;
 
-import me.s3ns3iw00.jcommands.event.listener.ArgumentMismatchEventListener;
 import org.javacord.api.interaction.SlashCommandOption;
 import org.javacord.api.interaction.SlashCommandOptionType;
 
-import java.util.Optional;
-
 /**
  * Represents an argument
  *
@@ -54,10 +51,10 @@ public Argument(String name, String description, SlashCommandOptionType type) {
         this.type = type;
 
         if (!name.matches("^[-_\\p{L}\\p{N}\\p{sc=Deva}\\p{sc=Thai}]{1,32}$")) {
-            throw new IllegalArgumentException("Command's name is invalid, it should contain only word characters, '-' and '_' character, and its length must between 1 and 32");
+            throw new IllegalArgumentException("Argument's name is invalid, it should contain only word characters, '-' and '_' character, and its length must between 1 and 32");
         }
 
-        if (description.length() < 1 || description.length() > 100) {
+        if (description.isEmpty() || description.length() > 100) {
             throw new IllegalArgumentException("Description's length must between 1 and 100");
         }
     }
@@ -93,26 +90,4 @@ public SlashCommandOptionType getType() {
      */
     public abstract SlashCommandOption getCommandOption();
 
-    /**
-     * Sets the argument mismatch listener
-     *
-     * @param listener the listener
-     */
-    @Deprecated
-    public void setOnMismatch(ArgumentMismatchEventListener listener) {
-        //this.mismatchListener = listener;
-    }
-
-    /**
-     * Gets the argument mismatch listener
-     *
-     * @return {@link Optional#empty()} when argument mismatch listener is not specified,
-     * otherwise {@link Optional#of(Object)} with the listener
-     */
-    @Deprecated
-    public Optional<ArgumentMismatchEventListener> getMismatchListener() {
-        //return Optional.ofNullable(mismatchListener);
-        return Optional.empty();
-    }
-
 }

src/main/java/me/s3ns3iw00/jcommands/argument/SubArgument.java

@@ -18,9 +18,11 @@
  */
 package me.s3ns3iw00.jcommands.argument;
 
+import me.s3ns3iw00.jcommands.event.listener.CommandActionEventListener;
 import org.javacord.api.interaction.SlashCommandOptionType;
 
 import java.util.LinkedList;
+import java.util.Optional;
 
 /**
  * Represents a sub argument
@@ -32,6 +34,8 @@ public abstract class SubArgument<T extends Argument, R> extends Argument<R> {
 
     private final LinkedList<T> arguments = new LinkedList<>();
 
+    private CommandActionEventListener actionListener;
+
     /**
      * Constructs the argument with the default requirements
      *
@@ -53,4 +57,24 @@ public LinkedList<T> getArguments() {
      * @param argument the argument
      */
     public abstract void addArgument(T argument);
+
+    /**
+     * Gets the action listener
+     *
+     * @return {@link Optional#empty()} when action listener is not specified,
+     * otherwise {@link Optional#ofNullable(Object)} with the listener
+     */
+    public Optional<CommandActionEventListener> getActionListener() {
+        return Optional.ofNullable(actionListener);
+    }
+
+    /**
+     * Sets the action listener
+     *
+     * @param listener the listener
+     */
+    public void setOnAction(CommandActionEventListener listener) {
+        this.actionListener = listener;
+    }
+
 }

src/main/java/me/s3ns3iw00/jcommands/argument/type/ConstantArgument.java

@@ -54,11 +54,17 @@ public SlashCommandOption getCommandOption() {
      * @param argument the argument
      */
     public void addArgument(InputArgument argument) {
-        if (getArguments().size() > 0 &&
-                (getArguments().getLast() != null) &&
-                getArguments().getLast().isOptional() &&
-                !argument.isOptional()) {
-            throw new IllegalStateException("Cannot add non-optional argument after an optional argument!");
+        if (!getArguments().isEmpty()) {
+            // Unique name checking
+            if (getArguments().stream().anyMatch(arg -> arg.getName().equals(argument.getName()))) {
+                throw new IllegalStateException("Arguments must have unique name in the same scope!");
+            }
+
+            // Optional and non-optional argument order checking
+            if (!argument.isOptional() &&
+                    getArguments().getLast().isOptional()) {
+                throw new IllegalStateException("Cannot add non-optional argument after an optional argument!");
+            }
         }
 
         getArguments().add(argument);