Merge pull request #15 from S3nS3IW00/dev

Update to v4.2.0

Author: S3nS3IW00

README.md

@@ -1,8 +1,8 @@
-# JCommands [![](https://img.shields.io/badge/Version-4.1.1-blue)](https://github.com/S3nS3IW00/JCommands) [![](https://img.shields.io/badge/Javadoc-Latest-green)](https://s3ns3iw00.github.io/JCommands/javadoc/) [![](https://img.shields.io/badge/Javacord-3.4.0-red)](https://github.com/Javacord/Javacord)
+# JCommands [![](https://img.shields.io/badge/Version-4.2.0-blue)](https://github.com/S3nS3IW00/JCommands) [![](https://img.shields.io/badge/Javadoc-Latest-green)](https://s3ns3iw00.github.io/JCommands/javadoc/) [![](https://img.shields.io/badge/Javacord-3.4.0-red)](https://github.com/Javacord/Javacord)
 
 With this Javacord extension you can create Slash commands within 1 minute with built-in validating, converting,
-concatenating and extended permission checking for channels and categories. There are so many useful pre-written
-argument types that can be used while creating a command.
+concatenating, argument autocompleting and extended permission checking for channels and categories. There are so many
+useful pre-written argument types that can be used while creating a command.
 
 ### Example command
 
@@ -41,5 +41,10 @@ bots with it.
    ```java  
    CommandHandler.setApi(DiscordApi);  
    ```  
-3. Create an error listener and as many command as you want.
-4. Enjoy!
+3. Give a star if you like it and enjoy!
+
+## Contact
+
+If you found a bug, or you just want a new feature in the next version, don't hesitate to report it on
+the [issues](https://github.com/S3nS3IW00/JCommands/issues) page. You can contact me through
+discord: [🆂🅴🅽🆂🅴🆈#0054](https://discord.com/users/249674530077802496)

build.gradle

@@ -3,7 +3,7 @@ plugins {
 }
 
 group 'me.s3ns3iw00'
-version '4.1.1'
+version '4.2.0'
 
 repositories {
     mavenCentral()

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

@@ -23,7 +23,6 @@
 import me.s3ns3iw00.jcommands.argument.concatenation.Concatenator;
 import me.s3ns3iw00.jcommands.event.listener.ArgumentMismatchEventListener;
 import me.s3ns3iw00.jcommands.event.listener.CommandActionEventListener;
-import me.s3ns3iw00.jcommands.listener.CommandActionListener;
 
 import java.util.*;
 
@@ -108,17 +107,6 @@ public void addConcatenator(Concatenator concatenator, Argument... arguments) {
         concatenators.get(concatenator).addAll(Arrays.asList(arguments));
     }
 
-    /**
-     * Sets the action listener of the command
-     *
-     * @param action is the listener object
-     * @deprecated because of the new event system
-     * use {@link Command#setOnAction(CommandActionEventListener)} instead
-     */
-    @Deprecated
-    public void setAction(CommandActionListener action) {
-    }
-
     /**
      * Sets the action listener
      *
@@ -156,15 +144,6 @@ public Map<Concatenator, LinkedList<Argument>> getConcatenators() {
         return concatenators;
     }
 
-    /**
-     * @return the command action instance
-     * @deprecated because of the new event system
-     */
-    @Deprecated
-    Optional<CommandActionEventListener> getAction() {
-        return Optional.empty();
-    }
-
     /**
      * Gets the action listener
      *

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

@@ -22,13 +22,14 @@
 import me.s3ns3iw00.jcommands.argument.ArgumentResult;
 import me.s3ns3iw00.jcommands.argument.InputArgument;
 import me.s3ns3iw00.jcommands.argument.SubArgument;
+import me.s3ns3iw00.jcommands.argument.ability.Autocompletable;
+import me.s3ns3iw00.jcommands.argument.autocomplete.AutocompleteState;
 import me.s3ns3iw00.jcommands.argument.concatenation.Concatenator;
 import me.s3ns3iw00.jcommands.argument.converter.ArgumentResultConverter;
 import me.s3ns3iw00.jcommands.argument.converter.type.URLConverter;
+import me.s3ns3iw00.jcommands.argument.type.ComboArgument;
+import me.s3ns3iw00.jcommands.argument.util.Choice;
 import me.s3ns3iw00.jcommands.builder.CommandBuilder;
-import me.s3ns3iw00.jcommands.event.listener.ArgumentMismatchEventListener;
-import me.s3ns3iw00.jcommands.event.listener.BadCategoryEventListener;
-import me.s3ns3iw00.jcommands.event.listener.BadChannelEventListener;
 import me.s3ns3iw00.jcommands.event.type.ArgumentMismatchEvent;
 import me.s3ns3iw00.jcommands.event.type.BadCategoryEvent;
 import me.s3ns3iw00.jcommands.event.type.BadChannelEvent;
@@ -38,7 +39,6 @@
 import me.s3ns3iw00.jcommands.limitation.type.ChannelLimitable;
 import me.s3ns3iw00.jcommands.limitation.type.RoleLimitable;
 import me.s3ns3iw00.jcommands.limitation.type.UserLimitable;
-import me.s3ns3iw00.jcommands.listener.CommandErrorListener;
 import org.javacord.api.DiscordApi;
 import org.javacord.api.entity.channel.ChannelCategory;
 import org.javacord.api.entity.channel.ChannelType;
@@ -81,6 +81,7 @@ public class CommandHandler {
     public static void setApi(DiscordApi api) {
         CommandHandler.api = api;
         api.addSlashCommandCreateListener(event -> handleCommand(event.getSlashCommandInteraction()));
+        api.addAutocompleteCreateListener(event -> handleAutocomplete(event.getAutocompleteInteraction()));
     }
 
     /**
@@ -186,6 +187,62 @@ private static void handleCommand(SlashCommandInteraction interaction) {
         });
     }
 
+    /**
+     * Handles autocomplete requests for arguments
+     *
+     * @param interaction the interaction
+     */
+    private static void handleAutocomplete(AutocompleteInteraction interaction) {
+        Optional<Command> commandOptional = commands.stream()
+                .filter(c -> c.getName().equalsIgnoreCase(interaction.getCommandName()))
+                .findFirst();
+
+        commandOptional.ifPresent(command -> {
+            SlashCommandInteractionOption option = interaction.getFocusedOption();
+
+            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 Autocompletable) {
+                    Autocompletable autocompletable = (Autocompletable) 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()));
+                    }
+                }
+            });
+        });
+    }
+
     /**
      * Processes arguments and every argument of the arguments recursively:
      * - Adjusts values to the arguments
@@ -221,6 +278,14 @@ private static Optional<Map<Argument, ArgumentResult>> processArguments(SlashCom
                     } else {
                         return Optional.empty();
                     }
+                } else if (argument instanceof ComboArgument) {
+                    /* Choose the value that the user picked
+                       Checking is unnecessary since the user only can pick a valid value
+                     */
+                    ComboArgument ca = (ComboArgument) argument;
+
+                    ca.choose(value);
+                    results.put(argument, new ArgumentResult(ca));
                 } else if (argument instanceof InputArgument) {
                     /* Adjusts the value to the argument and checks that the value is null
                        If it is not then it will be added to the list,
@@ -273,6 +338,9 @@ private static Object getOptionValue(SlashCommandInteractionOption option, Slash
             case LONG:
                 value = option.getLongValue().orElse(null);
                 break;
+            case DECIMAL:
+                value = option.getDecimalValue().orElse(null);
+                break;
             case BOOLEAN:
                 value = option.getBooleanValue().orElse(null);
                 break;
@@ -282,6 +350,40 @@ private static Object getOptionValue(SlashCommandInteractionOption option, Slash
         return value;
     }
 
+    /**
+     * 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
+     *
+     * @param arguments a list of argument
+     * @return the collection
+     */
+    private static List<Argument> collectArguments(List<Argument> arguments) {
+        List<Argument> allArguments = new ArrayList<>();
+        for (Argument argument : arguments) {
+            if (argument instanceof SubArgument) {
+                allArguments.addAll(collectArguments(((SubArgument) argument).getArguments()));
+            } else {
+                allArguments.add(argument);
+            }
+        }
+
+        return allArguments;
+    }
+
     /**
      * Registers the command for the listener on the specified servers
      * and sets up permissions with discord's default permission system
@@ -420,19 +522,6 @@ public static void registerCommand(CommandBuilder<?> builder) {
         registerCommand(builder.getCommand());
     }
 
-    /**
-     * Registers an error listener where the errors will be managed
-     *
-     * @param error the listener interface
-     * @deprecated because of the new event system
-     * use {@link CategoryLimitable#setOnBadCategory(BadCategoryEventListener)},
-     * {@link ChannelLimitable#setOnBadChannel(BadChannelEventListener)} and
-     * {@link Argument#setOnMismatch(ArgumentMismatchEventListener)} instead
-     */
-    @Deprecated
-    public static void setOnError(CommandErrorListener error) {
-    }
-
     /**
      * @return the list of the commands
      */

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

@@ -18,22 +18,31 @@
  */
 package me.s3ns3iw00.jcommands.argument;
 
+import me.s3ns3iw00.jcommands.argument.ability.Autocompletable;
+import me.s3ns3iw00.jcommands.argument.ability.Optionality;
+import me.s3ns3iw00.jcommands.argument.autocomplete.Autocomplete;
 import org.javacord.api.entity.channel.TextChannel;
 import org.javacord.api.entity.permission.Role;
 import org.javacord.api.entity.user.User;
 import org.javacord.api.interaction.SlashCommandOption;
+import org.javacord.api.interaction.SlashCommandOptionBuilder;
 import org.javacord.api.interaction.SlashCommandOptionType;
 
+import java.util.ArrayList;
+import java.util.List;
+
 /**
  * Represents argument that can have multiple value depends on the user input and the restrictions of the argument
  * These arguments can be optional
  */
-public abstract class InputArgument extends Argument {
+public abstract class InputArgument extends Argument implements Optionality, Autocompletable {
 
     private Object input;
     private final Class<?> resultType;
     private boolean optional = false;
 
+    private final List<Autocomplete> autocompletes = new ArrayList<>();
+
     /**
      * Constructs the argument with the default requirements
      *
@@ -83,9 +92,16 @@ public InputArgument(String name, String description, SlashCommandOptionType typ
 
     @Override
     public SlashCommandOption getCommandOption() {
-        return SlashCommandOption.create(getType(), getName(), getDescription(), !optional);
+        return new SlashCommandOptionBuilder()
+                .setName(getName())
+                .setDescription(getDescription())
+                .setType(getType())
+                .setRequired(!isOptional())
+                .setAutocompletable(autocompletes.size() > 0)
+                .build();
     }
 
+    @Override
     public boolean isOptional() {
         return optional;
     }
@@ -98,6 +114,10 @@ public void setOptional() {
         optional = true;
     }
 
+    public List<Autocomplete> getAutocompletes() {
+        return autocompletes;
+    }
+
     /**
      * Sets the input
      *

src/main/java/me/s3ns3iw00/jcommands/CommandErrorType.java renamed to src/main/java/me/s3ns3iw00/jcommands/argument/ability/Autocompletable.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2021 S3nS3IW00
+ * Copyright (C) 2022 S3nS3IW00
  *
  * This file is part of JCommands.
  *
@@ -16,30 +16,21 @@
  * You should have received a copy of the GNU Lesser General Public
  * License along with this program; if not, see <http://www.gnu.org/licenses/>.
  */
-package me.s3ns3iw00.jcommands;
+package me.s3ns3iw00.jcommands.argument.ability;
+
+import me.s3ns3iw00.jcommands.argument.autocomplete.Autocomplete;
+
+import java.util.List;
 
 /**
- * Enum with error type constants
- *
- * @author S3nS3IW00
- * @deprecated see {@link me.s3ns3iw00.jcommands.listener.CommandErrorListener} for more information
+ * Identifies whether an argument is autocompletable
  */
-@Deprecated
-public enum CommandErrorType {
-
-    /**
-     * Occurs when one or more of the arguments are missing or not matching the pattern.
-     */
-    BAD_ARGUMENTS,
+public interface Autocompletable {
 
-    /**
-     * Occurs when the sender wants to use the command in a category where it is not allowed.
-     */
-    BAD_CATEGORY,
+    List<Autocomplete> getAutocompletes();
 
-    /**
-     * Occurs when the sender wants to use the command in a channel where it is not allowed.
-     */
-    BAD_CHANNEL
+    default void addAutocomplete(Autocomplete autocomplete) {
+        getAutocompletes().add(autocomplete);
+    }
 
 }

src/main/java/me/s3ns3iw00/jcommands/argument/ability/Optionality.java

@@ -0,0 +1,28 @@
+/*
+ * Copyright (C) 2022 S3nS3IW00
+ *
+ * This file is part of JCommands.
+ *
+ * JCommands is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser general Public License as
+ * published by the Free Software Foundation; either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * JCommands is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this program; if not, see <http://www.gnu.org/licenses/>.
+ */
+package me.s3ns3iw00.jcommands.argument.ability;
+
+/**
+ * Identifies whether an argument can be optional or not
+ */
+public interface Optionality {
+
+    boolean isOptional();
+
+}