265 lines
11 KiB
Java
265 lines
11 KiB
Java
package envoy.client.data.commands;
|
|
|
|
import java.util.*;
|
|
import java.util.function.Consumer;
|
|
import java.util.logging.*;
|
|
import java.util.regex.Pattern;
|
|
import java.util.stream.Collectors;
|
|
|
|
import envoy.util.EnvoyLog;
|
|
|
|
/**
|
|
* This class stores all {@link SystemCommand}s used.
|
|
* <p>
|
|
* Project: <strong>envoy-client</strong><br>
|
|
* File: <strong>SystemCommandsMap.java</strong><br>
|
|
* Created: <strong>17.07.2020</strong><br>
|
|
*
|
|
* @author Leon Hofmeister
|
|
* @since Envoy Client v0.2-beta
|
|
*/
|
|
public final class SystemCommandsMap {
|
|
|
|
private final Map<String, SystemCommand> systemCommands = new HashMap<>();
|
|
|
|
private final Pattern commandPattern = Pattern.compile("^[a-zA-Z0-9_:!\\(\\)\\?\\.\\,\\;\\-]+$");
|
|
|
|
private static final Logger logger = EnvoyLog.getLogger(SystemCommandsMap.class);
|
|
|
|
/**
|
|
* Adds a new command to the map if the command name is valid.
|
|
*
|
|
* @param command the input string to execute the
|
|
* given action
|
|
* @param systemCommand the command to add - can be built using
|
|
* {@link SystemCommandBuilder}
|
|
* @see SystemCommandsMap#isValidKey(String)
|
|
* @since Envoy Client v0.2-beta
|
|
*/
|
|
public void add(String command, SystemCommand systemCommand) {
|
|
if (isValidKey(command)) systemCommands.put(command.toLowerCase(), systemCommand);
|
|
}
|
|
|
|
/**
|
|
* This method checks if the input String is a key in the map and returns the
|
|
* wrapped System command if present.
|
|
* It will return an empty optional if the value after the slash is not a key in
|
|
* the map, which is a valid case (i.e. input="3/4" and "4" is not a key in the
|
|
* map).
|
|
* <p>
|
|
* Usage example:<br>
|
|
* {@code SystemCommandsMap systemCommands = new SystemCommandsMap();}<br>
|
|
* {@code Button button = new Button();}
|
|
* {@code systemCommands.add("example", text -> button.setText(text.get(0), 1);}<br>
|
|
* {@code ....}<br>
|
|
* user input: {@code "/example xyz ..."}<br>
|
|
* {@code systemCommands.get("example xyz ...")} or
|
|
* {@code systemCommands.get("/example xyz ...")}
|
|
* result: {@code Optional<SystemCommand>}
|
|
*
|
|
* @param input the input string given by the user
|
|
* @return the wrapped system command, if present
|
|
* @since Envoy Client v0.2-beta
|
|
*/
|
|
public Optional<SystemCommand> get(String input) { return Optional.ofNullable(systemCommands.get(getCommand(input.toLowerCase()))); }
|
|
|
|
/**
|
|
* This method ensures that the "/" of a {@link SystemCommand} is stripped.<br>
|
|
* It returns the command as (most likely) entered as key in the map for the
|
|
* first word of the text.<br>
|
|
* It should only be called on strings that contain a "/" at position 0/-1.
|
|
*
|
|
* @param raw the input
|
|
* @return the command as entered in the map
|
|
* @since Envoy Client v0.2-beta
|
|
* @apiNote this method will (most likely) not return anything useful if
|
|
* whatever is entered after the slash is not a system command. Only
|
|
* exception: for recommendation purposes.
|
|
*/
|
|
public String getCommand(String raw) {
|
|
final var trimmed = raw.stripLeading();
|
|
final var index = trimmed.indexOf(' ');
|
|
return trimmed.substring(trimmed.charAt(0) == '/' ? 1 : 0, index < 1 ? trimmed.length() : index);
|
|
}
|
|
|
|
/**
|
|
* Examines whether a key can be put in the map and logs it with
|
|
* {@code Level.WARNING} if that key violates API constrictions.<br>
|
|
* (allowed chars are <b>a-zA-Z0-9_:!()?.,;-</b>)
|
|
* <p>
|
|
* The approach to not throw an exception was taken so that an ugly try-catch
|
|
* block for every addition to the system commands map could be avoided, an
|
|
* error that should only occur during implementation and not in production.
|
|
*
|
|
* @param command the key to examine
|
|
* @return whether this key can be used in the map
|
|
* @since Envoy Client v0.2-beta
|
|
*/
|
|
public boolean isValidKey(String command) {
|
|
final boolean valid = commandPattern.matcher(command).matches();
|
|
if (!valid) logger.log(Level.WARNING,
|
|
"The command \"" + command
|
|
+ "\" is not valid. As it will cause problems in execution, it will not be entered into the map. Only the characters "
|
|
+ commandPattern + "are allowed");
|
|
return valid;
|
|
}
|
|
|
|
/**
|
|
* Takes a 'raw' string (the whole input) and checks if "/" is the first visible
|
|
* character and then checks if a command is present after that "/". If that is
|
|
* the case, it will be executed.
|
|
* <p>
|
|
*
|
|
* @param raw the raw input string
|
|
* @return whether a command could be found
|
|
* @since Envoy Client v0.2-beta
|
|
*/
|
|
public boolean executeIfAnyPresent(String raw) {
|
|
// possibly a command was detected and could be executed
|
|
final var raw2 = raw.stripLeading();
|
|
final var commandFound = raw2.startsWith("/") ? executeIfPresent(raw2) : false;
|
|
// the command was executed successfully - no further checking needed
|
|
if (commandFound) logger.log(Level.FINE, "executed system command " + getCommand(raw2));
|
|
return commandFound;
|
|
}
|
|
|
|
/**
|
|
* This method checks if the input String is a key in the map and executes the
|
|
* wrapped System command if present.
|
|
* Its intended usage is after a "/" has been detected in the input String.
|
|
* It will do nothing if the value after the slash is not a key in
|
|
* the map, which is a valid case (i.e. input="3/4" and "4" is not a key in the
|
|
* map).
|
|
* <p>
|
|
* Usage example:<br>
|
|
* {@code SystemCommandsMap systemCommands = new SystemCommandsMap();}<br>
|
|
* {@code Button button = new Button();}<br>
|
|
* {@code systemCommands.add("example", (words)-> button.setText(words.get(0), 1);}<br>
|
|
* {@code ....}<br>
|
|
* user input: {@code "/example xyz ..."}<br>
|
|
* {@code systemCommands.executeIfPresent("example xyz ...")}
|
|
* result: {@code button.getText()=="xyz"}
|
|
*
|
|
* @param input the input string given by the user
|
|
* @return whether a command could be found
|
|
* @since Envoy Client v0.2-beta
|
|
*/
|
|
public boolean executeIfPresent(String input) {
|
|
final var command = getCommand(input);
|
|
final var value = get(command);
|
|
value.ifPresent(systemCommand -> {
|
|
// Splitting the String so that the leading command including the first " " is
|
|
// removed and only as many following words as allowed by the system command
|
|
// persist
|
|
final var arguments = extractArguments(input, systemCommand);
|
|
// Executing the function
|
|
try {
|
|
systemCommand.getAction().accept(arguments);
|
|
systemCommand.onCall();
|
|
} catch (final Exception e) {
|
|
logger.log(Level.WARNING, "The system command " + command + " threw an exception: ", e);
|
|
}
|
|
});
|
|
return value.isPresent();
|
|
}
|
|
|
|
/**
|
|
* Supplies missing values with default values.
|
|
*
|
|
* @param input the input String
|
|
* @param systemCommand the command that is expected
|
|
* @return the list of arguments that can be used to parse the systemCommand
|
|
* @since Envoy Client v0.2-beta
|
|
*/
|
|
private List<String> extractArguments(String input, SystemCommand systemCommand) {
|
|
// no more arguments follow after the command (e.g. text = "/DABR")
|
|
final var indexOfSpace = input.indexOf(" ");
|
|
if (indexOfSpace < 0) return supplementDefaults(new String[] {}, systemCommand);
|
|
// the arguments behind a system command
|
|
final var remainingString = input.substring(indexOfSpace + 1);
|
|
final var numberOfArguments = systemCommand.getNumberOfArguments();
|
|
// splitting those arguments and supplying default values
|
|
final var textArguments = remainingString.split(" ", -1);
|
|
final var originalArguments = numberOfArguments >= 0 ? Arrays.copyOfRange(textArguments, 0, numberOfArguments) : textArguments;
|
|
final var arguments = supplementDefaults(originalArguments, systemCommand);
|
|
return arguments;
|
|
}
|
|
|
|
/**
|
|
* Retrieves the recommendations based on the current input entered.<br>
|
|
* The first word is used for the recommendations and
|
|
* it does not matter if the "/" is at its beginning or not.<br>
|
|
* If none are present, nothing will be done.<br>
|
|
* Otherwise the given function will be executed on the recommendations.<br>
|
|
*
|
|
* @param input the input string
|
|
* @param action the action that should be taken for the recommendations, if any
|
|
* are present
|
|
* @since Envoy Client v0.2-beta
|
|
*/
|
|
public void requestRecommendations(String input, Consumer<Set<String>> action) {
|
|
final var partialCommand = getCommand(input);
|
|
// Get the expected commands
|
|
final var recommendations = recommendCommands(partialCommand);
|
|
if (recommendations.isEmpty()) return;
|
|
// Execute the given action
|
|
else action.accept(recommendations);
|
|
}
|
|
|
|
/**
|
|
* Recommends commands based upon the currently entered input.<br>
|
|
* In the current implementation, all we check is whether a key contains this
|
|
* input. This might be updated later on.
|
|
*
|
|
* @param partialCommand the partially entered command
|
|
* @return a set of all commands that match this input
|
|
* @since Envoy Client v0.2-beta
|
|
*/
|
|
private Set<String> recommendCommands(String partialCommand) {
|
|
// current implementation only looks if input is contained within a command,
|
|
// might be updated
|
|
return systemCommands.keySet()
|
|
.stream()
|
|
.filter(command -> command.contains(partialCommand))
|
|
.sorted((command1, command2) -> Integer.compare(systemCommands.get(command1).getRelevance(), systemCommands.get(command2).getRelevance()))
|
|
.collect(Collectors.toSet());
|
|
}
|
|
|
|
/**
|
|
*
|
|
* Supplies the default values for arguments if none are present in the text for
|
|
* any argument. <br>
|
|
* Will only work for {@code SystemCommand}s whose argument counter is bigger
|
|
* than 1.
|
|
*
|
|
* @param textArguments the arguments that were parsed from the text
|
|
* @param toEvaluate the system command whose default values should be used
|
|
* @return the final argument list
|
|
* @since Envoy Client v0.2-beta
|
|
* @apiNote this method will insert an empty String if the size of the list
|
|
* given to the {@code SystemCommand} is smaller than its argument
|
|
* counter and no more text arguments could be found.
|
|
*/
|
|
private List<String> supplementDefaults(String[] textArguments, SystemCommand toEvaluate) {
|
|
final var defaults = toEvaluate.getDefaults();
|
|
final var numberOfArguments = toEvaluate.getNumberOfArguments();
|
|
final List<String> result = new ArrayList<>();
|
|
|
|
if (toEvaluate.getNumberOfArguments() > 0) for (int index = 0; index < numberOfArguments; index++) {
|
|
String textArg = null;
|
|
if (index < textArguments.length) textArg = textArguments[index];
|
|
// Set the argument at position index to the current argument of the text, if it
|
|
// is present. Otherwise the default for that argument will be taken if present.
|
|
// In the worst case, an empty String will be used.
|
|
result.add(!(textArg == null) && !textArg.isBlank() ? textArg : index < defaults.size() ? defaults.get(index) : "");
|
|
}
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* @return all {@link SystemCommand}s used with the underlying command as key
|
|
* @since Envoy Client v0.2-beta
|
|
*/
|
|
public Map<String, SystemCommand> getSystemCommands() { return systemCommands; }
|
|
}
|