zdm/envoy
zdm
/
envoy
Archived
3
Fork 0
Code Issues 22 Pull Requests Releases 1 Wiki Activity

Add Customizability to SystemCommandMap #84

Merged
delvh merged 2 commits from f/enhanced-system-commands into develop 2020-10-07 22:12:58 +02:00
Conversation 5 Commits 2 Files Changed 3 +124 -69
3 changed files with 124 additions and 69 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

188
client/src/main/java/envoy/client/data/commands/SystemCommandMap.java
View File

@ -1,27 +1,53 @@
package envoy.client.data.commands;
import java.util.*;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.function.Consumer;
import java.util.logging.*;
import java.util.regex.Pattern;
import java.util.stream.Collectors;
import javafx.application.Platform;
import javafx.scene.control.Alert;
import javafx.scene.control.Alert.AlertType;
import envoy.util.EnvoyLog;
/**
* This class stores all {@link SystemCommand}s used.
* Stores all {@link SystemCommand}s used.
* SystemCommands can be called using an activator char and the text that needs
* to be present behind the activator.
* Additionally offers the option to request recommendations for a partial input
* String.
*
* @author Leon Hofmeister
* @since Envoy Client v0.2-beta
*/
public final class SystemCommandMap {
private final Map<String, SystemCommand> systemCommands = new HashMap<>();
private final Pattern commandPattern = Pattern.compile("^[a-zA-Z0-9_:!\\(\\)\\?\\.\\,\\;\\-]+$");
private final Character activator;
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(SystemCommandMap.class);
/**
* Creates a new {@code SystemCommandMap} with the given char as activator.
* If this Character is null, any text used as input will be treated as a system
* command.
*
* @param activator the char to use as activator for commands
* @since Envoy Client v0.3-beta
*/
public SystemCommandMap(Character activator) { this.activator = activator; }
/**
* Creates a new {@code SystemCommandMap} with '/' as activator.
*
* @since Envoy Client v0.3-beta
*/
public SystemCommandMap() { activator = '/'; }
/**
* Adds a new command to the map if the command name is valid.
*
@ -39,19 +65,16 @@ public final class SystemCommandMap {
/**
* 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 SystemCommandMap systemCommands = new SystemCommandMap();}<br>
* {@code Button button = new Button();}
* {@code systemCommands.add("example", text -> button.setText(text.get(0), 1);}<br>
* {@code SystemCommandMap systemCommands = new SystemCommandMap('*');}<br>
* {@code systemCommands.add("example", new SystemCommand(text -> {}, 1, null,
* ""));}<br>
* {@code ....}<br>
* user input: {@code "/example xyz ..."}<br>
* user input: {@code "*example xyz ..."}<br>
* {@code systemCommands.get("example xyz ...")} or
* {@code systemCommands.get("/example xyz ...")}
* result: {@code Optional<SystemCommand>}
* {@code systemCommands.get("*example xyz ...")}
* result: {@code Optional<SystemCommand>.get() != null}
*
* @param input the input string given by the user
* @return the wrapped system command, if present
@ -60,33 +83,36 @@ public final class SystemCommandMap {
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>
* This method ensures that the activator of a {@link SystemCommand} is
* stripped.<br>
* It only checks the word beginning from the first non-blank position in the
* input.
* 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.
* Activators in the middle of the word will be disregarded.
mpk commented 2020-10-07 21:24:58 +02:00
Outdated
Review
Copy Link

there is a typo

there is a typo
*
* @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.
* whatever is entered after the activator is not a system command.
* Only exception: for recommendation purposes.
*/
public String getCommand(String raw) {
final var trimmed = raw.stripLeading();
// Entering only a slash should not throw an error
if (trimmed.length() == 1 && trimmed.charAt(0) == '/') return "";
// Entering only the activator should not throw an error
if (trimmed.length() == 1 && activator != null && activator.equals(trimmed.charAt(0))) return "";
else {
final var index = trimmed.indexOf(' ');
return trimmed.substring(trimmed.charAt(0) == '/' ? 1 : 0, index < 1 ? trimmed.length() : index);
return trimmed.substring(activator != null && activator.equals(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>)
* (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
@ -100,59 +126,86 @@ public final class SystemCommandMap {
final var 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 "
+ "\" is not valid. As it might cause problems when executed, 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>
* Takes a 'raw' string (the whole input) and checks if the activator is the
* first visible character and then checks if a command is present after that
* activator. If that is the case, it will be executed.
*
* @param raw the raw input string
* @return whether a command could be found
* @return whether a command could be found and successfully executed
* @since Envoy Client v0.2-beta
*/
public boolean executeIfAnyPresent(String raw) {
public boolean executeIfPresent(String raw) {
// possibly a command was detected and could be executed
final var raw2 = raw.stripLeading();
final var commandFound = raw2.startsWith("/") ? executeIfPresent(raw2) : false;
final var commandFound = activator == null || raw2.startsWith(activator.toString()) ? executeAvailableCommand(raw2) : false;
// the command was executed successfully - no further checking needed
if (commandFound) logger.log(Level.FINE, "executed system command " + getCommand(raw2));
return commandFound;
}
/**
* 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 activator is at its beginning or not.<br>
* If recommendations are present, the given function will be executed on the
* recommendations.<br>
* Otherwise nothing will be done.<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);
}
/**
* 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 SystemCommandMap systemCommands = new SystemCommandMap();}<br>
* {@code SystemCommandMap systemCommands = new SystemCommandMap('*');}<br>
* {@code Button button = new Button();}<br>
* {@code systemCommands.add("example", (words)-> button.setText(words.get(0), 1);}<br>
* {@code systemCommands.add("example", new SystemCommand(text ->
* {button.setText(text.get(0))}, 1, null,
* ""));}<br>
* {@code ....}<br>
* user input: {@code "/example xyz ..."}<br>
* {@code systemCommands.executeIfPresent("example xyz ...")}
* user input: {@code "*example xyz ..."}<br>
* {@code systemCommands.executeIfPresent("example xyz ...")} or
* {@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
* @return whether a command could be found and successfully executed
* @since Envoy Client v0.2-beta
*/
public boolean executeIfPresent(String input) {
final var command = getCommand(input);
final var value = get(command);
private boolean executeAvailableCommand(String input) {
final var command = getCommand(input);
final var value = get(command);
final var commandExecuted = new AtomicBoolean(value.isPresent());
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.call(arguments);
@ -161,11 +214,23 @@ public final class SystemCommandMap {
String.format(
"System command %s could not be performed correctly because the user is a dumbass and could not write a parseable number.",
command));
Platform.runLater(() -> {
final var alert = new Alert(AlertType.ERROR);
alert.setContentText("Please enter a readable number as argument.");
alert.showAndWait();
});
commandExecuted.set(false);
} catch (final Exception e) {
logger.log(Level.WARNING, "System command " + command + " threw an exception: ", e);
Platform.runLater(() -> {
final var alert = new Alert(AlertType.ERROR);
alert.setContentText("Could not execute system command: Internal error. Please insult the responsible programmer.");
alert.showAndWait();
});
commandExecuted.set(false);
}
});
return value.isPresent();
return commandExecuted.get();
}
/**
@ -177,12 +242,15 @@ public final class SystemCommandMap {
* @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;
@ -190,37 +258,17 @@ public final class SystemCommandMap {
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.
* In the current implementation, all that gets checked 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()
@ -231,11 +279,8 @@ public final class SystemCommandMap {
}
/**
*
* 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
@ -253,6 +298,7 @@ public final class SystemCommandMap {
if (toEvaluate.getNumberOfArguments() > 0) for (var 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.
@ -266,4 +312,10 @@ public final class SystemCommandMap {
* @since Envoy Client v0.2-beta
*/
public Map<String, SystemCommand> getSystemCommands() { return systemCommands; }
/**
* @return the activator of any command in this map. Can be null.
* @since Envoy Client v0.3-beta
*/
public Character getActivator() { return activator; }
}

3
client/src/main/java/envoy/client/ui/chatscene/ChatSceneCommands.java
View File

@ -40,6 +40,9 @@ public final class ChatSceneCommands {
public ChatSceneCommands(ListView<Message> messageList, ChatScene chatScene) {
this.messageList = messageList;
// Error message initialization
builder.setAction(text -> { throw new RuntimeException(); }).setDescription("Shows an error message.").buildNoArg("error");
// Do A Barrel roll initialization
final var random = new Random();
builder.setAction(text -> chatScene.doABarrelRoll(Integer.parseInt(text.get(0)), Double.parseDouble(text.get(1))))

2
client/src/main/java/envoy/client/ui/controller/ChatScene.java
View File

@ -625,7 +625,7 @@ public final class ChatScene implements EventListener, Restorable {
return;
}
final var text = messageTextArea.getText().strip();
if (!commands.getChatSceneCommands().executeIfAnyPresent(text)) {
if (!commands.getChatSceneCommands().executeIfPresent(text)) {
// Creating the message and its metadata
final var builder = new MessageBuilder(localDB.getUser().getID(), currentChat.getRecipient().getID(), localDB.getIDGenerator())
.setText(text);