From 2b7edeec0c02c392e2b9a605357cfbac034a0a67 Mon Sep 17 00:00:00 2001 From: jojo Date: Sun, 27 Dec 2020 17:14:43 +0100 Subject: [PATCH 01/53] Add simple SWCommand Add SWCommandArgument Add SWCommandArgumentBuilder Add SWCommandExecutor --- .../src/de/steamwar/command/SWCommand.java | 111 ++++++++++++++++++ .../steamwar/command/SWCommandArgument.java | 45 +++++++ .../command/SWCommandArgumentBuilder.java | 80 +++++++++++++ .../steamwar/command/SWCommandExecutor.java | 31 +++++ 4 files changed, 267 insertions(+) create mode 100644 SpigotCore_Main/src/de/steamwar/command/SWCommand.java create mode 100644 SpigotCore_Main/src/de/steamwar/command/SWCommandArgument.java create mode 100644 SpigotCore_Main/src/de/steamwar/command/SWCommandArgumentBuilder.java create mode 100644 SpigotCore_Main/src/de/steamwar/command/SWCommandExecutor.java diff --git a/SpigotCore_Main/src/de/steamwar/command/SWCommand.java b/SpigotCore_Main/src/de/steamwar/command/SWCommand.java new file mode 100644 index 0000000..9893144 --- /dev/null +++ b/SpigotCore_Main/src/de/steamwar/command/SWCommand.java @@ -0,0 +1,111 @@ +/* + * + * This file is a part of the SteamWar software. + * + * Copyright (C) 2020 SteamWar.de-Serverteam + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Affero General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program 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 Affero General Public License for more details. + * + * You should have received a copy of the GNU Affero General Public License + * along with this program. If not, see . + * / + */ + +package de.steamwar.command; + +import org.bukkit.command.Command; +import org.bukkit.command.CommandSender; +import org.bukkit.entity.Player; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; +import java.util.function.Consumer; +import java.util.function.Predicate; + +public class SWCommand { + + private Predicate permissionCheck = (player) -> true; + private Consumer permissionMessage = (player) -> {}; + + private List swCommandArgumentList = new ArrayList<>(); + private SWCommandExecutor helpExecutor = (sender, command, label, args) -> false; + + public SWCommand() { + + } + + public SWCommand(SWCommandArgument... swCommandArguments) { + swCommandArgumentList = Arrays.asList(swCommandArguments); + } + + public SWCommand add(SWCommandArgument swCommandArgument) { + swCommandArgumentList.add(swCommandArgument); + return this; + } + + public SWCommand setPermissionCheck(Predicate permissionCheck, Consumer permissionMessage) { + if (permissionCheck == null || permissionMessage == null) { + throw new IllegalStateException(); + } + this.permissionCheck = permissionCheck; + this.permissionMessage = permissionMessage; + return this; + } + + public boolean help(Player sender, Command command, String label, String[] args) { + return helpExecutor.execute(sender, command, label, args); + } + + public boolean onCommand(CommandSender sender, Command command, String label, String[] args) { + if (!(sender instanceof Player)) { + return false; + } + Player player = (Player) sender; + + if (!permissionCheck.test(player)) { + permissionMessage.accept(player); + return false; + } + + for (SWCommandArgument swCommandArgument : swCommandArgumentList) { + if (swCommandArgument.commandPredicate.test(player, args)) { + return swCommandArgument.swCommandExecutor.execute(player, command, label, args); + } + } + help(player, command, label, args); + return false; + } + + public List onTabComplete(CommandSender sender, Command command, String label, String[] args) { + if (!(sender instanceof Player)) { + return new ArrayList<>(); + } + Player player = (Player) sender; + + List tabComplete = new ArrayList<>(); + for (SWCommandArgument swCommandArgument : swCommandArgumentList) { + if (swCommandArgument.tabCompletePredicate.test(player, args)) { + tabComplete.addAll(Arrays.asList(swCommandArgument.tabCompleteArguments)); + } + } + return manageList(tabComplete, args); + } + + private List manageList(List strings, String[] args) { + if (strings == null) return new ArrayList<>(); + for (int i = strings.size() - 1; i >= 0; i--) { + if (!strings.get(i).startsWith(args[args.length - 1])) strings.remove(i); + } + return strings; + } + +} diff --git a/SpigotCore_Main/src/de/steamwar/command/SWCommandArgument.java b/SpigotCore_Main/src/de/steamwar/command/SWCommandArgument.java new file mode 100644 index 0000000..2ae8122 --- /dev/null +++ b/SpigotCore_Main/src/de/steamwar/command/SWCommandArgument.java @@ -0,0 +1,45 @@ +/* + * + * This file is a part of the SteamWar software. + * + * Copyright (C) 2020 SteamWar.de-Serverteam + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Affero General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program 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 Affero General Public License for more details. + * + * You should have received a copy of the GNU Affero General Public License + * along with this program. If not, see . + * / + */ + +package de.steamwar.command; + +import org.bukkit.entity.Player; + +import java.util.function.BiPredicate; + +public class SWCommandArgument { + + final SWCommandExecutor swCommandExecutor; + final BiPredicate commandPredicate; + final String[] commandArguments; + + final BiPredicate tabCompletePredicate; + final String[] tabCompleteArguments; + + public SWCommandArgument(SWCommandExecutor swCommandExecutor, BiPredicate commandPredicate, String[] commandArguments, BiPredicate tabCompletePredicate, String[] tabCompleteArguments) { + this.swCommandExecutor = swCommandExecutor; + this.commandPredicate = commandPredicate; + this.commandArguments = commandArguments; + this.tabCompletePredicate = tabCompletePredicate; + this.tabCompleteArguments = tabCompleteArguments; + } + +} diff --git a/SpigotCore_Main/src/de/steamwar/command/SWCommandArgumentBuilder.java b/SpigotCore_Main/src/de/steamwar/command/SWCommandArgumentBuilder.java new file mode 100644 index 0000000..6784db4 --- /dev/null +++ b/SpigotCore_Main/src/de/steamwar/command/SWCommandArgumentBuilder.java @@ -0,0 +1,80 @@ +/* + * + * This file is a part of the SteamWar software. + * + * Copyright (C) 2020 SteamWar.de-Serverteam + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Affero General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program 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 Affero General Public License for more details. + * + * You should have received a copy of the GNU Affero General Public License + * along with this program. If not, see . + * / + */ + +package de.steamwar.command; + +import org.bukkit.entity.Player; + +import java.util.function.BiPredicate; + +public class SWCommandArgumentBuilder { + + private SWCommandExecutor swCommandExecutor = (sender, command, label, args) -> false; + private BiPredicate commandPredicate; + private String[] commandArguments; + + private BiPredicate tabCompletePredicate = (player, args) -> true; + private String[] tabCompleteArguments; + + public SWCommandArgument build() { + if (swCommandExecutor == null) { + throw new IllegalStateException(); + } + if (commandPredicate == null) { + throw new IllegalStateException(); + } + if (commandArguments == null) { + throw new IllegalStateException(); + } + if (tabCompletePredicate == null) { + throw new IllegalStateException(); + } + if (tabCompleteArguments == null) { + throw new IllegalStateException(); + } + return new SWCommandArgument(swCommandExecutor, commandPredicate, commandArguments, tabCompletePredicate, tabCompleteArguments); + } + + public SWCommandArgumentBuilder setSwCommandExecutor(SWCommandExecutor swCommandExecutor) { + this.swCommandExecutor = swCommandExecutor; + return this; + } + + public SWCommandArgumentBuilder setCommandPredicate(BiPredicate commandPredicate) { + this.commandPredicate = commandPredicate; + return this; + } + + public SWCommandArgumentBuilder setCommandArguments(String[] commandArguments) { + this.commandArguments = commandArguments; + return this; + } + + public SWCommandArgumentBuilder setTabCompletePredicate(BiPredicate tabCompletePredicate) { + this.tabCompletePredicate = tabCompletePredicate; + return this; + } + + public SWCommandArgumentBuilder setTabCompleteArguments(String[] tabCompleteArguments) { + this.tabCompleteArguments = tabCompleteArguments; + return this; + } +} diff --git a/SpigotCore_Main/src/de/steamwar/command/SWCommandExecutor.java b/SpigotCore_Main/src/de/steamwar/command/SWCommandExecutor.java new file mode 100644 index 0000000..22ac389 --- /dev/null +++ b/SpigotCore_Main/src/de/steamwar/command/SWCommandExecutor.java @@ -0,0 +1,31 @@ +/* + * + * This file is a part of the SteamWar software. + * + * Copyright (C) 2020 SteamWar.de-Serverteam + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Affero General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program 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 Affero General Public License for more details. + * + * You should have received a copy of the GNU Affero General Public License + * along with this program. If not, see . + * / + */ + +package de.steamwar.command; + +import org.bukkit.command.Command; +import org.bukkit.entity.Player; + +public interface SWCommandExecutor { + + boolean execute(Player sender, Command command, String label, String[] args); + +} -- 2.39.2 From 10934058cccd58fc2df96f56242252e8074bb5b0 Mon Sep 17 00:00:00 2001 From: jojo Date: Sun, 27 Dec 2020 17:31:14 +0100 Subject: [PATCH 02/53] Add SWCommand.registerCommand --- .../src/de/steamwar/command/SWCommand.java | 12 +++++++++++- 1 file changed, 11 insertions(+), 1 deletion(-) diff --git a/SpigotCore_Main/src/de/steamwar/command/SWCommand.java b/SpigotCore_Main/src/de/steamwar/command/SWCommand.java index 9893144..32449be 100644 --- a/SpigotCore_Main/src/de/steamwar/command/SWCommand.java +++ b/SpigotCore_Main/src/de/steamwar/command/SWCommand.java @@ -22,8 +22,11 @@ package de.steamwar.command; import org.bukkit.command.Command; +import org.bukkit.command.CommandExecutor; import org.bukkit.command.CommandSender; +import org.bukkit.command.TabCompleter; import org.bukkit.entity.Player; +import org.bukkit.plugin.java.JavaPlugin; import java.util.ArrayList; import java.util.Arrays; @@ -31,7 +34,7 @@ import java.util.List; import java.util.function.Consumer; import java.util.function.Predicate; -public class SWCommand { +public class SWCommand implements CommandExecutor, TabCompleter { private Predicate permissionCheck = (player) -> true; private Consumer permissionMessage = (player) -> {}; @@ -65,6 +68,7 @@ public class SWCommand { return helpExecutor.execute(sender, command, label, args); } + @Override public boolean onCommand(CommandSender sender, Command command, String label, String[] args) { if (!(sender instanceof Player)) { return false; @@ -85,6 +89,7 @@ public class SWCommand { return false; } + @Override public List onTabComplete(CommandSender sender, Command command, String label, String[] args) { if (!(sender instanceof Player)) { return new ArrayList<>(); @@ -108,4 +113,9 @@ public class SWCommand { return strings; } + public void registerCommand(JavaPlugin plugin, String command) { + plugin.getCommand(command).setExecutor(this); + plugin.getCommand(command).setTabCompleter(this); + } + } -- 2.39.2 From 67dc554f14d6ca8a9f6fa99ca300e207b4253fb2 Mon Sep 17 00:00:00 2001 From: jojo Date: Sun, 27 Dec 2020 21:30:50 +0100 Subject: [PATCH 03/53] Add Argument Add Executor --- .../src/de/steamwar/command/Argument.java | 62 +++++++++++ ...CommandArgument.java => ArgumentType.java} | 25 ++--- .../{SWCommandExecutor.java => Executor.java} | 8 +- .../src/de/steamwar/command/SWCommand.java | 100 ++++-------------- .../command/SWCommandArgumentBuilder.java | 80 -------------- 5 files changed, 94 insertions(+), 181 deletions(-) create mode 100644 SpigotCore_Main/src/de/steamwar/command/Argument.java rename SpigotCore_Main/src/de/steamwar/command/{SWCommandArgument.java => ArgumentType.java} (50%) rename SpigotCore_Main/src/de/steamwar/command/{SWCommandExecutor.java => Executor.java} (85%) delete mode 100644 SpigotCore_Main/src/de/steamwar/command/SWCommandArgumentBuilder.java diff --git a/SpigotCore_Main/src/de/steamwar/command/Argument.java b/SpigotCore_Main/src/de/steamwar/command/Argument.java new file mode 100644 index 0000000..3f26bc7 --- /dev/null +++ b/SpigotCore_Main/src/de/steamwar/command/Argument.java @@ -0,0 +1,62 @@ +/* + * + * This file is a part of the SteamWar software. + * + * Copyright (C) 2020 SteamWar.de-Serverteam + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Affero General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program 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 Affero General Public License for more details. + * + * You should have received a copy of the GNU Affero General Public License + * along with this program. If not, see . + * / + */ + +package de.steamwar.command; + +import org.bukkit.Bukkit; + +import java.util.Optional; +import java.util.function.Function; +import java.util.function.Predicate; + +public class Argument { + + public static final Argument PLAYER = new Argument<>(ArgumentType.STRING, string -> Bukkit.getPlayer(string) == null, Bukkit::getPlayer); + + private ArgumentType argumentType; + private Predicate constraint; + private Function valueMapper; + + public Argument(ArgumentType argumentType, Predicate constraint) { + this(argumentType, constraint, o -> o); + } + + public Argument(ArgumentType argumentType, Predicate constraint, Function valueMapper) { + this.argumentType = argumentType; + this.constraint = constraint; + this.valueMapper = valueMapper; + } + + public Optional valueSupplier(String s) { + try { + T argumentMapped = argumentType.mapper.apply(s); + if (constraint.test(argumentMapped)) { + return Optional.ofNullable(valueMapper.apply(argumentMapped)); + } + } catch (NumberFormatException e) { + return Optional.empty(); + } catch (Exception e) { + throw new SecurityException(e); + } + return Optional.empty(); + } + +} diff --git a/SpigotCore_Main/src/de/steamwar/command/SWCommandArgument.java b/SpigotCore_Main/src/de/steamwar/command/ArgumentType.java similarity index 50% rename from SpigotCore_Main/src/de/steamwar/command/SWCommandArgument.java rename to SpigotCore_Main/src/de/steamwar/command/ArgumentType.java index 2ae8122..f24cc1c 100644 --- a/SpigotCore_Main/src/de/steamwar/command/SWCommandArgument.java +++ b/SpigotCore_Main/src/de/steamwar/command/ArgumentType.java @@ -21,25 +21,20 @@ package de.steamwar.command; -import org.bukkit.entity.Player; +import java.util.function.Function; -import java.util.function.BiPredicate; +public class ArgumentType { -public class SWCommandArgument { + public static final ArgumentType INT = new ArgumentType<>(Integer::parseInt); + public static final ArgumentType LONG = new ArgumentType<>(Long::parseLong); + public static final ArgumentType FLOAT = new ArgumentType<>(Float::parseFloat); + public static final ArgumentType DOUBLE = new ArgumentType<>(Double::parseDouble); + public static final ArgumentType STRING = new ArgumentType<>((s) -> s); - final SWCommandExecutor swCommandExecutor; - final BiPredicate commandPredicate; - final String[] commandArguments; + Function mapper; - final BiPredicate tabCompletePredicate; - final String[] tabCompleteArguments; - - public SWCommandArgument(SWCommandExecutor swCommandExecutor, BiPredicate commandPredicate, String[] commandArguments, BiPredicate tabCompletePredicate, String[] tabCompleteArguments) { - this.swCommandExecutor = swCommandExecutor; - this.commandPredicate = commandPredicate; - this.commandArguments = commandArguments; - this.tabCompletePredicate = tabCompletePredicate; - this.tabCompleteArguments = tabCompleteArguments; + private ArgumentType(Function mapper) { + this.mapper = mapper; } } diff --git a/SpigotCore_Main/src/de/steamwar/command/SWCommandExecutor.java b/SpigotCore_Main/src/de/steamwar/command/Executor.java similarity index 85% rename from SpigotCore_Main/src/de/steamwar/command/SWCommandExecutor.java rename to SpigotCore_Main/src/de/steamwar/command/Executor.java index 22ac389..0b42f79 100644 --- a/SpigotCore_Main/src/de/steamwar/command/SWCommandExecutor.java +++ b/SpigotCore_Main/src/de/steamwar/command/Executor.java @@ -21,11 +21,9 @@ package de.steamwar.command; -import org.bukkit.command.Command; import org.bukkit.entity.Player; -public interface SWCommandExecutor { - - boolean execute(Player sender, Command command, String label, String[] args); - +@FunctionalInterface +public interface Executor { + boolean execute(Player player, Object[] args); } diff --git a/SpigotCore_Main/src/de/steamwar/command/SWCommand.java b/SpigotCore_Main/src/de/steamwar/command/SWCommand.java index 32449be..d17f4b3 100644 --- a/SpigotCore_Main/src/de/steamwar/command/SWCommand.java +++ b/SpigotCore_Main/src/de/steamwar/command/SWCommand.java @@ -21,101 +21,39 @@ package de.steamwar.command; -import org.bukkit.command.Command; -import org.bukkit.command.CommandExecutor; -import org.bukkit.command.CommandSender; -import org.bukkit.command.TabCompleter; import org.bukkit.entity.Player; -import org.bukkit.plugin.java.JavaPlugin; -import java.util.ArrayList; -import java.util.Arrays; -import java.util.List; -import java.util.function.Consumer; -import java.util.function.Predicate; +import java.util.Optional; -public class SWCommand implements CommandExecutor, TabCompleter { +public class SWCommand { - private Predicate permissionCheck = (player) -> true; - private Consumer permissionMessage = (player) -> {}; - - private List swCommandArgumentList = new ArrayList<>(); - private SWCommandExecutor helpExecutor = (sender, command, label, args) -> false; - - public SWCommand() { + private Argument[] arguments; + private Executor executor; + public SWCommand(Executor executor, Argument... arguments) { + this.arguments = arguments; } - public SWCommand(SWCommandArgument... swCommandArguments) { - swCommandArgumentList = Arrays.asList(swCommandArguments); - } - - public SWCommand add(SWCommandArgument swCommandArgument) { - swCommandArgumentList.add(swCommandArgument); - return this; - } - - public SWCommand setPermissionCheck(Predicate permissionCheck, Consumer permissionMessage) { - if (permissionCheck == null || permissionMessage == null) { - throw new IllegalStateException(); - } - this.permissionCheck = permissionCheck; - this.permissionMessage = permissionMessage; - return this; - } - - public boolean help(Player sender, Command command, String label, String[] args) { - return helpExecutor.execute(sender, command, label, args); - } - - @Override - public boolean onCommand(CommandSender sender, Command command, String label, String[] args) { - if (!(sender instanceof Player)) { + public boolean checkValidity(String[] args) { + if (args.length != arguments.length) { return false; } - Player player = (Player) sender; - - if (!permissionCheck.test(player)) { - permissionMessage.accept(player); - return false; + for (int i = 0; i < args.length; i++) { + Optional optional = arguments[i].valueSupplier(args[i]); + if (optional.isEmpty()) return false; } - - for (SWCommandArgument swCommandArgument : swCommandArgumentList) { - if (swCommandArgument.commandPredicate.test(player, args)) { - return swCommandArgument.swCommandExecutor.execute(player, command, label, args); - } - } - help(player, command, label, args); - return false; + return true; } - @Override - public List onTabComplete(CommandSender sender, Command command, String label, String[] args) { - if (!(sender instanceof Player)) { - return new ArrayList<>(); + public Optional execute(Player player, String[] args) { + if (!checkValidity(args)) { + return Optional.empty(); } - Player player = (Player) sender; - - List tabComplete = new ArrayList<>(); - for (SWCommandArgument swCommandArgument : swCommandArgumentList) { - if (swCommandArgument.tabCompletePredicate.test(player, args)) { - tabComplete.addAll(Arrays.asList(swCommandArgument.tabCompleteArguments)); - } + Object[] objects = new Object[args.length]; + for (int i = 0; i < args.length; i++) { + objects[i] = arguments[i].valueSupplier(args[i]).orElseThrow(); } - return manageList(tabComplete, args); - } - - private List manageList(List strings, String[] args) { - if (strings == null) return new ArrayList<>(); - for (int i = strings.size() - 1; i >= 0; i--) { - if (!strings.get(i).startsWith(args[args.length - 1])) strings.remove(i); - } - return strings; - } - - public void registerCommand(JavaPlugin plugin, String command) { - plugin.getCommand(command).setExecutor(this); - plugin.getCommand(command).setTabCompleter(this); + return Optional.of(executor.execute(player, objects)); } } diff --git a/SpigotCore_Main/src/de/steamwar/command/SWCommandArgumentBuilder.java b/SpigotCore_Main/src/de/steamwar/command/SWCommandArgumentBuilder.java deleted file mode 100644 index 6784db4..0000000 --- a/SpigotCore_Main/src/de/steamwar/command/SWCommandArgumentBuilder.java +++ /dev/null @@ -1,80 +0,0 @@ -/* - * - * This file is a part of the SteamWar software. - * - * Copyright (C) 2020 SteamWar.de-Serverteam - * - * This program is free software: you can redistribute it and/or modify - * it under the terms of the GNU Affero General Public License as published by - * the Free Software Foundation, either version 3 of the License, or - * (at your option) any later version. - * - * This program 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 Affero General Public License for more details. - * - * You should have received a copy of the GNU Affero General Public License - * along with this program. If not, see . - * / - */ - -package de.steamwar.command; - -import org.bukkit.entity.Player; - -import java.util.function.BiPredicate; - -public class SWCommandArgumentBuilder { - - private SWCommandExecutor swCommandExecutor = (sender, command, label, args) -> false; - private BiPredicate commandPredicate; - private String[] commandArguments; - - private BiPredicate tabCompletePredicate = (player, args) -> true; - private String[] tabCompleteArguments; - - public SWCommandArgument build() { - if (swCommandExecutor == null) { - throw new IllegalStateException(); - } - if (commandPredicate == null) { - throw new IllegalStateException(); - } - if (commandArguments == null) { - throw new IllegalStateException(); - } - if (tabCompletePredicate == null) { - throw new IllegalStateException(); - } - if (tabCompleteArguments == null) { - throw new IllegalStateException(); - } - return new SWCommandArgument(swCommandExecutor, commandPredicate, commandArguments, tabCompletePredicate, tabCompleteArguments); - } - - public SWCommandArgumentBuilder setSwCommandExecutor(SWCommandExecutor swCommandExecutor) { - this.swCommandExecutor = swCommandExecutor; - return this; - } - - public SWCommandArgumentBuilder setCommandPredicate(BiPredicate commandPredicate) { - this.commandPredicate = commandPredicate; - return this; - } - - public SWCommandArgumentBuilder setCommandArguments(String[] commandArguments) { - this.commandArguments = commandArguments; - return this; - } - - public SWCommandArgumentBuilder setTabCompletePredicate(BiPredicate tabCompletePredicate) { - this.tabCompletePredicate = tabCompletePredicate; - return this; - } - - public SWCommandArgumentBuilder setTabCompleteArguments(String[] tabCompleteArguments) { - this.tabCompleteArguments = tabCompleteArguments; - return this; - } -} -- 2.39.2 From 47025962fda36809e29621de2a7e0176d0ce018d Mon Sep 17 00:00:00 2001 From: jojo Date: Sun, 27 Dec 2020 21:41:44 +0100 Subject: [PATCH 04/53] Add Argument.INT Add Argument.LONG Add Argument.FLOAT Add Argument.DOUBLE --- SpigotCore_Main/src/de/steamwar/command/Argument.java | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/SpigotCore_Main/src/de/steamwar/command/Argument.java b/SpigotCore_Main/src/de/steamwar/command/Argument.java index 3f26bc7..df5b5b4 100644 --- a/SpigotCore_Main/src/de/steamwar/command/Argument.java +++ b/SpigotCore_Main/src/de/steamwar/command/Argument.java @@ -29,6 +29,10 @@ import java.util.function.Predicate; public class Argument { + public static final Argument INT = new Argument<>(ArgumentType.INT, integer -> true); + public static final Argument LONG = new Argument<>(ArgumentType.LONG, l -> true); + public static final Argument FLOAT = new Argument<>(ArgumentType.FLOAT, integer -> true); + public static final Argument DOUBLE = new Argument<>(ArgumentType.DOUBLE, integer -> true); public static final Argument PLAYER = new Argument<>(ArgumentType.STRING, string -> Bukkit.getPlayer(string) == null, Bukkit::getPlayer); private ArgumentType argumentType; -- 2.39.2 From fbc13c75f0b56496186e5e1bc4694cede6ab4975 Mon Sep 17 00:00:00 2001 From: jojo Date: Sun, 27 Dec 2020 22:12:42 +0100 Subject: [PATCH 05/53] Simplify Argument for common use cases Add Executor to SWCommand --- SpigotCore_Main/src/de/steamwar/command/Argument.java | 1 + SpigotCore_Main/src/de/steamwar/command/SWCommand.java | 7 +++++-- 2 files changed, 6 insertions(+), 2 deletions(-) diff --git a/SpigotCore_Main/src/de/steamwar/command/Argument.java b/SpigotCore_Main/src/de/steamwar/command/Argument.java index df5b5b4..c7d3edb 100644 --- a/SpigotCore_Main/src/de/steamwar/command/Argument.java +++ b/SpigotCore_Main/src/de/steamwar/command/Argument.java @@ -33,6 +33,7 @@ public class Argument { public static final Argument LONG = new Argument<>(ArgumentType.LONG, l -> true); public static final Argument FLOAT = new Argument<>(ArgumentType.FLOAT, integer -> true); public static final Argument DOUBLE = new Argument<>(ArgumentType.DOUBLE, integer -> true); + public static final Argument STRING = new Argument<>(ArgumentType.STRING, string -> true); public static final Argument PLAYER = new Argument<>(ArgumentType.STRING, string -> Bukkit.getPlayer(string) == null, Bukkit::getPlayer); private ArgumentType argumentType; diff --git a/SpigotCore_Main/src/de/steamwar/command/SWCommand.java b/SpigotCore_Main/src/de/steamwar/command/SWCommand.java index d17f4b3..ed7b939 100644 --- a/SpigotCore_Main/src/de/steamwar/command/SWCommand.java +++ b/SpigotCore_Main/src/de/steamwar/command/SWCommand.java @@ -32,6 +32,7 @@ public class SWCommand { public SWCommand(Executor executor, Argument... arguments) { this.arguments = arguments; + this.executor = executor; } public boolean checkValidity(String[] args) { @@ -40,7 +41,7 @@ public class SWCommand { } for (int i = 0; i < args.length; i++) { Optional optional = arguments[i].valueSupplier(args[i]); - if (optional.isEmpty()) return false; + if (!optional.isPresent()) return false; } return true; } @@ -51,7 +52,9 @@ public class SWCommand { } Object[] objects = new Object[args.length]; for (int i = 0; i < args.length; i++) { - objects[i] = arguments[i].valueSupplier(args[i]).orElseThrow(); + Optional optional = arguments[i].valueSupplier(args[i]); + if (!optional.isPresent()) throw new IllegalStateException(); + objects[i] = optional.get(); } return Optional.of(executor.execute(player, objects)); } -- 2.39.2 From f20283dc3787d4aef8f2d85cfa1f343bfe76f2d6 Mon Sep 17 00:00:00 2001 From: jojo Date: Sun, 27 Dec 2020 22:56:14 +0100 Subject: [PATCH 06/53] Add SWCommandBundle --- .../de/steamwar/command/SWCommandBundle.java | 54 +++++++++++++++++++ 1 file changed, 54 insertions(+) create mode 100644 SpigotCore_Main/src/de/steamwar/command/SWCommandBundle.java diff --git a/SpigotCore_Main/src/de/steamwar/command/SWCommandBundle.java b/SpigotCore_Main/src/de/steamwar/command/SWCommandBundle.java new file mode 100644 index 0000000..e3954ca --- /dev/null +++ b/SpigotCore_Main/src/de/steamwar/command/SWCommandBundle.java @@ -0,0 +1,54 @@ +/* + * + * This file is a part of the SteamWar software. + * + * Copyright (C) 2020 SteamWar.de-Serverteam + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Affero General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program 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 Affero General Public License for more details. + * + * You should have received a copy of the GNU Affero General Public License + * along with this program. If not, see . + * / + */ + +package de.steamwar.command; + +import org.bukkit.entity.Player; + +import java.util.ArrayList; +import java.util.List; +import java.util.Optional; + +public class SWCommandBundle { + + private List swCommandList = new ArrayList<>(); + + public SWCommandBundle add(SWCommand swCommand) { + if (swCommand == null) return this; + swCommandList.add(swCommand); + return this; + } + + public SWCommandBundle add(SWCommandBundle swCommandBundle) { + if (swCommandBundle == null) return this; + swCommandList.addAll(swCommandBundle.swCommandList); + return this; + } + + public Optional execute(Player player, String[] args) { + for (SWCommand swCommand : swCommandList) { + Optional optionalBoolean = swCommand.execute(player, args); + if (optionalBoolean.isPresent()) return optionalBoolean; + } + return Optional.empty(); + } + +} -- 2.39.2 From 96eb3e52ae7cbed412e813b3489fdf5542e38924 Mon Sep 17 00:00:00 2001 From: jojo Date: Sun, 27 Dec 2020 23:03:15 +0100 Subject: [PATCH 07/53] Add ArgumentMap for easy argument use Add Argument.of Add Argument.ofIgnoreCase --- .../src/de/steamwar/command/Argument.java | 12 +++- .../src/de/steamwar/command/ArgumentMap.java | 56 +++++++++++++++++++ .../src/de/steamwar/command/Executor.java | 2 +- .../src/de/steamwar/command/SWCommand.java | 2 +- 4 files changed, 68 insertions(+), 4 deletions(-) create mode 100644 SpigotCore_Main/src/de/steamwar/command/ArgumentMap.java diff --git a/SpigotCore_Main/src/de/steamwar/command/Argument.java b/SpigotCore_Main/src/de/steamwar/command/Argument.java index c7d3edb..8d3876e 100644 --- a/SpigotCore_Main/src/de/steamwar/command/Argument.java +++ b/SpigotCore_Main/src/de/steamwar/command/Argument.java @@ -31,8 +31,8 @@ public class Argument { public static final Argument INT = new Argument<>(ArgumentType.INT, integer -> true); public static final Argument LONG = new Argument<>(ArgumentType.LONG, l -> true); - public static final Argument FLOAT = new Argument<>(ArgumentType.FLOAT, integer -> true); - public static final Argument DOUBLE = new Argument<>(ArgumentType.DOUBLE, integer -> true); + public static final Argument FLOAT = new Argument<>(ArgumentType.FLOAT, f -> true); + public static final Argument DOUBLE = new Argument<>(ArgumentType.DOUBLE, d -> true); public static final Argument STRING = new Argument<>(ArgumentType.STRING, string -> true); public static final Argument PLAYER = new Argument<>(ArgumentType.STRING, string -> Bukkit.getPlayer(string) == null, Bukkit::getPlayer); @@ -50,6 +50,14 @@ public class Argument { this.valueMapper = valueMapper; } + public static Argument of(String argument) { + return new Argument<>(ArgumentType.STRING, string -> string.equals(argument)); + } + + public static Argument ofIgnoreCase(String argument) { + return new Argument<>(ArgumentType.STRING, string -> string.equalsIgnoreCase(argument)); + } + public Optional valueSupplier(String s) { try { T argumentMapped = argumentType.mapper.apply(s); diff --git a/SpigotCore_Main/src/de/steamwar/command/ArgumentMap.java b/SpigotCore_Main/src/de/steamwar/command/ArgumentMap.java new file mode 100644 index 0000000..f4266a6 --- /dev/null +++ b/SpigotCore_Main/src/de/steamwar/command/ArgumentMap.java @@ -0,0 +1,56 @@ +/* + * + * This file is a part of the SteamWar software. + * + * Copyright (C) 2020 SteamWar.de-Serverteam + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Affero General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program 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 Affero General Public License for more details. + * + * You should have received a copy of the GNU Affero General Public License + * along with this program. If not, see . + * / + */ + +package de.steamwar.command; + +import java.util.Arrays; + +public class ArgumentMap { + + private Object[] objects; + + public ArgumentMap(Object[] objects) { + this.objects = objects; + } + + public int length() { + return objects.length; + } + + public T get(int index) { + return (T)objects[index]; + } + + @Override + public String toString() { + StringBuilder st = new StringBuilder(); + st.append("ArgumentMap{"); + boolean b = false; + for (Object o : objects) { + if (b) st.append(", "); + b = true; + + st.append(o.getClass().getSimpleName()).append("=").append(o); + } + st.append("}"); + return st.toString(); + } +} diff --git a/SpigotCore_Main/src/de/steamwar/command/Executor.java b/SpigotCore_Main/src/de/steamwar/command/Executor.java index 0b42f79..f752951 100644 --- a/SpigotCore_Main/src/de/steamwar/command/Executor.java +++ b/SpigotCore_Main/src/de/steamwar/command/Executor.java @@ -25,5 +25,5 @@ import org.bukkit.entity.Player; @FunctionalInterface public interface Executor { - boolean execute(Player player, Object[] args); + boolean execute(Player player, ArgumentMap argumentMap); } diff --git a/SpigotCore_Main/src/de/steamwar/command/SWCommand.java b/SpigotCore_Main/src/de/steamwar/command/SWCommand.java index ed7b939..13bd061 100644 --- a/SpigotCore_Main/src/de/steamwar/command/SWCommand.java +++ b/SpigotCore_Main/src/de/steamwar/command/SWCommand.java @@ -56,7 +56,7 @@ public class SWCommand { if (!optional.isPresent()) throw new IllegalStateException(); objects[i] = optional.get(); } - return Optional.of(executor.execute(player, objects)); + return Optional.of(executor.execute(player, new ArgumentMap(objects))); } } -- 2.39.2 From 96c15aba714774a128e63f0491a855b74b21e561 Mon Sep 17 00:00:00 2001 From: jojo Date: Sun, 27 Dec 2020 23:08:03 +0100 Subject: [PATCH 08/53] Simplify Argument for Numbers with static constructor --- .../src/de/steamwar/command/Argument.java | 48 +++++++++++++++++++ 1 file changed, 48 insertions(+) diff --git a/SpigotCore_Main/src/de/steamwar/command/Argument.java b/SpigotCore_Main/src/de/steamwar/command/Argument.java index 8d3876e..236fcca 100644 --- a/SpigotCore_Main/src/de/steamwar/command/Argument.java +++ b/SpigotCore_Main/src/de/steamwar/command/Argument.java @@ -58,6 +58,54 @@ public class Argument { return new Argument<>(ArgumentType.STRING, string -> string.equalsIgnoreCase(argument)); } + public static Argument above(int minValue) { + return between(minValue, Integer.MAX_VALUE); + } + + public static Argument below(int maxValue) { + return between(Integer.MIN_VALUE, maxValue); + } + + public static Argument between(int minValue, int maxValue) { + return new Argument<>(ArgumentType.INT, i -> i >= minValue && i <= maxValue); + } + + public static Argument above(long minValue) { + return between(minValue, Long.MAX_VALUE); + } + + public static Argument below(long maxValue) { + return between(Long.MIN_VALUE, maxValue); + } + + public static Argument between(long minValue, long maxValue) { + return new Argument<>(ArgumentType.LONG, l -> l >= minValue && l <= maxValue); + } + + public static Argument above(float minValue) { + return between(minValue, Float.MAX_VALUE); + } + + public static Argument below(float maxValue) { + return between(Float.MIN_VALUE, maxValue); + } + + public static Argument between(float minValue, float maxValue) { + return new Argument<>(ArgumentType.FLOAT, f -> f >= minValue && f <= maxValue); + } + + public static Argument above(double minValue) { + return between(minValue, Double.MAX_VALUE); + } + + public static Argument below(double maxValue) { + return between(Double.MIN_VALUE, maxValue); + } + + public static Argument between(double minValue, double maxValue) { + return new Argument<>(ArgumentType.DOUBLE, d -> d >= minValue && d <= maxValue); + } + public Optional valueSupplier(String s) { try { T argumentMapped = argumentType.mapper.apply(s); -- 2.39.2 From 54a472e33e095df653524ee5721bda102b685a49 Mon Sep 17 00:00:00 2001 From: jojo Date: Mon, 28 Dec 2020 10:59:14 +0100 Subject: [PATCH 09/53] Add ArgumentUtils Add initial basic TabComplete Simplify SWCommand.execute --- .../src/de/steamwar/command/Argument.java | 64 +-------- .../src/de/steamwar/command/ArgumentMap.java | 16 +++ .../de/steamwar/command/ArgumentUtils.java | 131 ++++++++++++++++++ .../src/de/steamwar/command/SWCommand.java | 4 +- 4 files changed, 154 insertions(+), 61 deletions(-) create mode 100644 SpigotCore_Main/src/de/steamwar/command/ArgumentUtils.java diff --git a/SpigotCore_Main/src/de/steamwar/command/Argument.java b/SpigotCore_Main/src/de/steamwar/command/Argument.java index 236fcca..e231b8c 100644 --- a/SpigotCore_Main/src/de/steamwar/command/Argument.java +++ b/SpigotCore_Main/src/de/steamwar/command/Argument.java @@ -38,72 +38,18 @@ public class Argument { private ArgumentType argumentType; private Predicate constraint; + private String[] tabCompletes; private Function valueMapper; - public Argument(ArgumentType argumentType, Predicate constraint) { - this(argumentType, constraint, o -> o); + public Argument(ArgumentType argumentType, Predicate constraint, String... tabCompletes) { + this(argumentType, constraint, o -> o, tabCompletes); } - public Argument(ArgumentType argumentType, Predicate constraint, Function valueMapper) { + public Argument(ArgumentType argumentType, Predicate constraint, Function valueMapper, String... tabCompletes) { this.argumentType = argumentType; this.constraint = constraint; this.valueMapper = valueMapper; - } - - public static Argument of(String argument) { - return new Argument<>(ArgumentType.STRING, string -> string.equals(argument)); - } - - public static Argument ofIgnoreCase(String argument) { - return new Argument<>(ArgumentType.STRING, string -> string.equalsIgnoreCase(argument)); - } - - public static Argument above(int minValue) { - return between(minValue, Integer.MAX_VALUE); - } - - public static Argument below(int maxValue) { - return between(Integer.MIN_VALUE, maxValue); - } - - public static Argument between(int minValue, int maxValue) { - return new Argument<>(ArgumentType.INT, i -> i >= minValue && i <= maxValue); - } - - public static Argument above(long minValue) { - return between(minValue, Long.MAX_VALUE); - } - - public static Argument below(long maxValue) { - return between(Long.MIN_VALUE, maxValue); - } - - public static Argument between(long minValue, long maxValue) { - return new Argument<>(ArgumentType.LONG, l -> l >= minValue && l <= maxValue); - } - - public static Argument above(float minValue) { - return between(minValue, Float.MAX_VALUE); - } - - public static Argument below(float maxValue) { - return between(Float.MIN_VALUE, maxValue); - } - - public static Argument between(float minValue, float maxValue) { - return new Argument<>(ArgumentType.FLOAT, f -> f >= minValue && f <= maxValue); - } - - public static Argument above(double minValue) { - return between(minValue, Double.MAX_VALUE); - } - - public static Argument below(double maxValue) { - return between(Double.MIN_VALUE, maxValue); - } - - public static Argument between(double minValue, double maxValue) { - return new Argument<>(ArgumentType.DOUBLE, d -> d >= minValue && d <= maxValue); + this.tabCompletes = tabCompletes; } public Optional valueSupplier(String s) { diff --git a/SpigotCore_Main/src/de/steamwar/command/ArgumentMap.java b/SpigotCore_Main/src/de/steamwar/command/ArgumentMap.java index f4266a6..5ced8bc 100644 --- a/SpigotCore_Main/src/de/steamwar/command/ArgumentMap.java +++ b/SpigotCore_Main/src/de/steamwar/command/ArgumentMap.java @@ -35,10 +35,26 @@ public class ArgumentMap { return objects.length; } + public Class getType(int index) { + return objects[index].getClass(); + } + public T get(int index) { return (T)objects[index]; } + public T get(int index, T t) { + return get(index); + } + + public T get(int index, Class clazz) { + return get(index); + } + + public Class[] typeArray() { + return Arrays.stream(objects).map(Object::getClass).toArray(Class[]::new); + } + @Override public String toString() { StringBuilder st = new StringBuilder(); diff --git a/SpigotCore_Main/src/de/steamwar/command/ArgumentUtils.java b/SpigotCore_Main/src/de/steamwar/command/ArgumentUtils.java new file mode 100644 index 0000000..1ebfb78 --- /dev/null +++ b/SpigotCore_Main/src/de/steamwar/command/ArgumentUtils.java @@ -0,0 +1,131 @@ +/* + * + * This file is a part of the SteamWar software. + * + * Copyright (C) 2020 SteamWar.de-Serverteam + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Affero General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program 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 Affero General Public License for more details. + * + * You should have received a copy of the GNU Affero General Public License + * along with this program. If not, see . + * / + */ + +package de.steamwar.command; + +import java.util.Arrays; +import java.util.function.Predicate; + +public class ArgumentUtils { + + public static Argument of(String argument) { + return new Argument<>(ArgumentType.STRING, string -> string.equals(argument), argument); + } + + public static Argument of(String... arguments) { + return new Argument<>(ArgumentType.STRING, string -> { + for (String arg : arguments) { + if (string.equals(arg)) return true; + } + return false; + }, arguments); + } + + public static Argument ofIgnoreCase(String argument) { + return new Argument<>(ArgumentType.STRING, string -> string.equalsIgnoreCase(argument), argument); + } + + public static Argument ofIgnoreCase(String... arguments) { + return new Argument<>(ArgumentType.STRING, string -> { + for (String arg : arguments) { + if (string.equalsIgnoreCase(arg)) return true; + } + return false; + }, arguments); + } + + public static Argument above(int minValue, int... tabValues) { + return between(minValue, Integer.MAX_VALUE, tabValues); + } + + public static Argument below(int maxValue, int... tabValues) { + return between(Integer.MIN_VALUE, maxValue, tabValues); + } + + public static Argument between(int minValue, int maxValue, int... tabValues) { + Predicate predicate = i -> i >= minValue && i <= maxValue; + for (int tabValue : tabValues) { + if (!predicate.test(tabValue)) throw new IllegalArgumentException(); + } + return new Argument<>(ArgumentType.INT, predicate, Arrays.stream(tabValues).mapToObj(i -> i + "").toArray(String[]::new)); + } + + public static Argument above(long minValue, long... tabValues) { + return between(minValue, Long.MAX_VALUE, tabValues); + } + + public static Argument below(long maxValue, long... tabValues) { + return between(Long.MIN_VALUE, maxValue, tabValues); + } + + public static Argument between(long minValue, long maxValue, long... tabValues) { + Predicate predicate = l -> l >= minValue && l <= maxValue; + for (long tabValue : tabValues) { + if (!predicate.test(tabValue)) throw new IllegalArgumentException(); + } + return new Argument<>(ArgumentType.LONG, predicate, Arrays.stream(tabValues).mapToObj(l -> l + "").toArray(String[]::new)); + } + + public static Argument above(float minValue, float... tabValues) { + return between(minValue, Float.MAX_VALUE, tabValues); + } + + public static Argument below(float maxValue, float... tabValues) { + return between(Float.MIN_VALUE, maxValue, tabValues); + } + + public static Argument between(float minValue, float maxValue, float... tabValues) { + Predicate predicate = f -> f >= minValue && f <= maxValue; + for (float tabValue : tabValues) { + if (!predicate.test(tabValue)) throw new IllegalArgumentException(); + } + String[] strings = new String[tabValues.length]; + for (int i = 0; i < tabValues.length; i++) { + strings[i] = tabValues[i] + ""; + } + return new Argument<>(ArgumentType.FLOAT, predicate, strings); + } + + public static Argument above(double minValue, double... tabValues) { + return between(minValue, Double.MAX_VALUE, tabValues); + } + + public static Argument below(double maxValue, double... tabValues) { + return between(Double.MIN_VALUE, maxValue, tabValues); + } + + public static Argument between(double minValue, double maxValue, double... tabValues) { + Predicate predicate = d -> d >= minValue && d <= maxValue; + for (double tabValue : tabValues) { + if (!predicate.test(tabValue)) throw new IllegalArgumentException(); + } + return new Argument<>(ArgumentType.DOUBLE, predicate, Arrays.stream(tabValues).mapToObj(d -> d + "").toArray(String[]::new)); + } + + private static String[] toStringArray(Object[] objects) { + String[] strings = new String[objects.length]; + for (int i = 0; i < objects.length; i++) { + strings[i] = objects[i].toString(); + } + return strings; + } + +} diff --git a/SpigotCore_Main/src/de/steamwar/command/SWCommand.java b/SpigotCore_Main/src/de/steamwar/command/SWCommand.java index 13bd061..2a727ec 100644 --- a/SpigotCore_Main/src/de/steamwar/command/SWCommand.java +++ b/SpigotCore_Main/src/de/steamwar/command/SWCommand.java @@ -47,13 +47,13 @@ public class SWCommand { } public Optional execute(Player player, String[] args) { - if (!checkValidity(args)) { + if (args.length != arguments.length) { return Optional.empty(); } Object[] objects = new Object[args.length]; for (int i = 0; i < args.length; i++) { Optional optional = arguments[i].valueSupplier(args[i]); - if (!optional.isPresent()) throw new IllegalStateException(); + if (!optional.isPresent()) return Optional.empty(); objects[i] = optional.get(); } return Optional.of(executor.execute(player, new ArgumentMap(objects))); -- 2.39.2 From b6e4147af4cdebba77f3597cc8e72bbd454314dc Mon Sep 17 00:00:00 2001 From: jojo Date: Mon, 28 Dec 2020 11:25:41 +0100 Subject: [PATCH 10/53] Add Basic TabCompleting --- .../src/de/steamwar/command/Argument.java | 17 +++++++++++++++++ .../src/de/steamwar/command/SWCommand.java | 14 ++++++++++++++ 2 files changed, 31 insertions(+) diff --git a/SpigotCore_Main/src/de/steamwar/command/Argument.java b/SpigotCore_Main/src/de/steamwar/command/Argument.java index e231b8c..591cc38 100644 --- a/SpigotCore_Main/src/de/steamwar/command/Argument.java +++ b/SpigotCore_Main/src/de/steamwar/command/Argument.java @@ -23,9 +23,12 @@ package de.steamwar.command; import org.bukkit.Bukkit; +import java.util.Arrays; +import java.util.List; import java.util.Optional; import java.util.function.Function; import java.util.function.Predicate; +import java.util.stream.Collectors; public class Argument { @@ -66,4 +69,18 @@ public class Argument { return Optional.empty(); } + public Optional> tabCompleteSupplier(String s) { + try { + // Check if mappable + if (!s.isEmpty()) argumentType.mapper.apply(s); + List strings = Arrays.stream(tabCompletes).filter(t -> t.startsWith(s)).collect(Collectors.toList()); + if (strings.isEmpty()) strings.add(s); + return Optional.of(strings); + } catch (NumberFormatException e) { + return Optional.empty(); + } catch (Exception e) { + throw new SecurityException(e); + } + } + } diff --git a/SpigotCore_Main/src/de/steamwar/command/SWCommand.java b/SpigotCore_Main/src/de/steamwar/command/SWCommand.java index 2a727ec..001605a 100644 --- a/SpigotCore_Main/src/de/steamwar/command/SWCommand.java +++ b/SpigotCore_Main/src/de/steamwar/command/SWCommand.java @@ -23,6 +23,8 @@ package de.steamwar.command; import org.bukkit.entity.Player; +import java.util.Arrays; +import java.util.List; import java.util.Optional; public class SWCommand { @@ -59,4 +61,16 @@ public class SWCommand { return Optional.of(executor.execute(player, new ArgumentMap(objects))); } + public Optional> tabComplete(String[] args) { + if (args.length > arguments.length) { + return Optional.empty(); + } + for (int i = 0; i < args.length - 1; i++) { + Optional optional = arguments[i].valueSupplier(args[i]); + if (!optional.isPresent()) return Optional.empty(); + } + int index = args.length - 1; + return arguments[index].tabCompleteSupplier(args[index]); + } + } -- 2.39.2 From b3fffe398ad2a9bb263d66306c527c6683abb046 Mon Sep 17 00:00:00 2001 From: jojo Date: Mon, 28 Dec 2020 11:34:43 +0100 Subject: [PATCH 11/53] Add number TabCompleting --- .../src/de/steamwar/command/Argument.java | 8 ++++++-- .../src/de/steamwar/command/ArgumentType.java | 14 ++++++++------ .../src/de/steamwar/command/SWCommandBundle.java | 11 ++++++++++- 3 files changed, 24 insertions(+), 9 deletions(-) diff --git a/SpigotCore_Main/src/de/steamwar/command/Argument.java b/SpigotCore_Main/src/de/steamwar/command/Argument.java index 591cc38..b7ec53b 100644 --- a/SpigotCore_Main/src/de/steamwar/command/Argument.java +++ b/SpigotCore_Main/src/de/steamwar/command/Argument.java @@ -71,8 +71,12 @@ public class Argument { public Optional> tabCompleteSupplier(String s) { try { - // Check if mappable - if (!s.isEmpty()) argumentType.mapper.apply(s); + if (!s.isEmpty()) { + // Check if mappable + T argumentMapped = argumentType.mapper.apply(s); + // Check number constraints if needed + if (argumentType.number && !constraint.test(argumentMapped)) return Optional.empty(); + } List strings = Arrays.stream(tabCompletes).filter(t -> t.startsWith(s)).collect(Collectors.toList()); if (strings.isEmpty()) strings.add(s); return Optional.of(strings); diff --git a/SpigotCore_Main/src/de/steamwar/command/ArgumentType.java b/SpigotCore_Main/src/de/steamwar/command/ArgumentType.java index f24cc1c..80f5531 100644 --- a/SpigotCore_Main/src/de/steamwar/command/ArgumentType.java +++ b/SpigotCore_Main/src/de/steamwar/command/ArgumentType.java @@ -25,16 +25,18 @@ import java.util.function.Function; public class ArgumentType { - public static final ArgumentType INT = new ArgumentType<>(Integer::parseInt); - public static final ArgumentType LONG = new ArgumentType<>(Long::parseLong); - public static final ArgumentType FLOAT = new ArgumentType<>(Float::parseFloat); - public static final ArgumentType DOUBLE = new ArgumentType<>(Double::parseDouble); - public static final ArgumentType STRING = new ArgumentType<>((s) -> s); + public static final ArgumentType INT = new ArgumentType<>(Integer::parseInt, true); + public static final ArgumentType LONG = new ArgumentType<>(Long::parseLong, true); + public static final ArgumentType FLOAT = new ArgumentType<>(Float::parseFloat, true); + public static final ArgumentType DOUBLE = new ArgumentType<>(Double::parseDouble, true); + public static final ArgumentType STRING = new ArgumentType<>((s) -> s, false); Function mapper; + boolean number; - private ArgumentType(Function mapper) { + private ArgumentType(Function mapper, boolean number) { this.mapper = mapper; + this.number = number; } } diff --git a/SpigotCore_Main/src/de/steamwar/command/SWCommandBundle.java b/SpigotCore_Main/src/de/steamwar/command/SWCommandBundle.java index e3954ca..44f9bdf 100644 --- a/SpigotCore_Main/src/de/steamwar/command/SWCommandBundle.java +++ b/SpigotCore_Main/src/de/steamwar/command/SWCommandBundle.java @@ -37,7 +37,7 @@ public class SWCommandBundle { return this; } - public SWCommandBundle add(SWCommandBundle swCommandBundle) { + public SWCommandBundle addAll(SWCommandBundle swCommandBundle) { if (swCommandBundle == null) return this; swCommandList.addAll(swCommandBundle.swCommandList); return this; @@ -51,4 +51,13 @@ public class SWCommandBundle { return Optional.empty(); } + public List tabComplete(String[] args) { + List strings = new ArrayList<>(); + for (SWCommand swCommand : swCommandList) { + Optional> tabCompletes = swCommand.tabComplete(args); + if (tabCompletes.isPresent()) strings.addAll(tabCompletes.get()); + } + return strings; + } + } -- 2.39.2 From b28100daed6a00a831783d230185763469f79148 Mon Sep 17 00:00:00 2001 From: jojo Date: Mon, 28 Dec 2020 16:17:25 +0100 Subject: [PATCH 12/53] Add Argument.ArgumentBuilder Add SWCommandBundle.addAll --- .../src/de/steamwar/command/Argument.java | 44 +++++++++++++++++++ .../de/steamwar/command/ArgumentUtils.java | 12 ++--- .../src/de/steamwar/command/SWCommand.java | 12 ----- .../de/steamwar/command/SWCommandBundle.java | 5 +++ 4 files changed, 53 insertions(+), 20 deletions(-) diff --git a/SpigotCore_Main/src/de/steamwar/command/Argument.java b/SpigotCore_Main/src/de/steamwar/command/Argument.java index b7ec53b..674da8a 100644 --- a/SpigotCore_Main/src/de/steamwar/command/Argument.java +++ b/SpigotCore_Main/src/de/steamwar/command/Argument.java @@ -23,6 +23,7 @@ package de.steamwar.command; import org.bukkit.Bukkit; +import java.util.ArrayList; import java.util.Arrays; import java.util.List; import java.util.Optional; @@ -87,4 +88,47 @@ public class Argument { } } + public static class ArgumentBuilder { + + private List[]> options = new ArrayList<>(); + + public ArgumentBuilder(int min, int max, Argument... arguments) { + if (min < 0) min = 0; + if (max >= arguments.length) max = arguments.length - 1; + for (int i = min; i <= max; i++) { + generate(arguments, i, 0, new Argument[i]); + } + } + + private void generate(Argument[] arguments, int length, int startPosition, Argument[] result) { + if (length == 0) { + options.add(Arrays.copyOf(result, result.length)); + return; + } + for (int i = startPosition; i <= arguments.length - length; i++) { + result[result.length - length] = arguments[i]; + generate(arguments, length - 1, startPosition + 1, result); + } + } + + public List[]> apply(Argument... arguments) { + List[]> args = new ArrayList<>(); + args.add(arguments); + return apply(args); + } + + public List[]> apply(List[]> arguments) { + List[]> results = new ArrayList<>(); + arguments.forEach(args -> { + for (Argument[] option : options) { + Argument[] result = Arrays.copyOf(args, args.length + option.length); + System.arraycopy(option, 0, result, args.length, option.length); + results.add(result); + } + }); + return results; + } + + } + } diff --git a/SpigotCore_Main/src/de/steamwar/command/ArgumentUtils.java b/SpigotCore_Main/src/de/steamwar/command/ArgumentUtils.java index 1ebfb78..724de1e 100644 --- a/SpigotCore_Main/src/de/steamwar/command/ArgumentUtils.java +++ b/SpigotCore_Main/src/de/steamwar/command/ArgumentUtils.java @@ -26,6 +26,10 @@ import java.util.function.Predicate; public class ArgumentUtils { + private ArgumentUtils() { + throw new IllegalStateException("Utility class"); + } + public static Argument of(String argument) { return new Argument<>(ArgumentType.STRING, string -> string.equals(argument), argument); } @@ -120,12 +124,4 @@ public class ArgumentUtils { return new Argument<>(ArgumentType.DOUBLE, predicate, Arrays.stream(tabValues).mapToObj(d -> d + "").toArray(String[]::new)); } - private static String[] toStringArray(Object[] objects) { - String[] strings = new String[objects.length]; - for (int i = 0; i < objects.length; i++) { - strings[i] = objects[i].toString(); - } - return strings; - } - } diff --git a/SpigotCore_Main/src/de/steamwar/command/SWCommand.java b/SpigotCore_Main/src/de/steamwar/command/SWCommand.java index 001605a..4d73c31 100644 --- a/SpigotCore_Main/src/de/steamwar/command/SWCommand.java +++ b/SpigotCore_Main/src/de/steamwar/command/SWCommand.java @@ -23,7 +23,6 @@ package de.steamwar.command; import org.bukkit.entity.Player; -import java.util.Arrays; import java.util.List; import java.util.Optional; @@ -37,17 +36,6 @@ public class SWCommand { this.executor = executor; } - public boolean checkValidity(String[] args) { - if (args.length != arguments.length) { - return false; - } - for (int i = 0; i < args.length; i++) { - Optional optional = arguments[i].valueSupplier(args[i]); - if (!optional.isPresent()) return false; - } - return true; - } - public Optional execute(Player player, String[] args) { if (args.length != arguments.length) { return Optional.empty(); diff --git a/SpigotCore_Main/src/de/steamwar/command/SWCommandBundle.java b/SpigotCore_Main/src/de/steamwar/command/SWCommandBundle.java index 44f9bdf..c5dcde0 100644 --- a/SpigotCore_Main/src/de/steamwar/command/SWCommandBundle.java +++ b/SpigotCore_Main/src/de/steamwar/command/SWCommandBundle.java @@ -43,6 +43,11 @@ public class SWCommandBundle { return this; } + public SWCommandBundle addAll(Executor executor, List[]> arguments) { + arguments.forEach(args -> swCommandList.add(new SWCommand(executor, args))); + return this; + } + public Optional execute(Player player, String[] args) { for (SWCommand swCommand : swCommandList) { Optional optionalBoolean = swCommand.execute(player, args); -- 2.39.2 From 7a199d31d18cef904f0bc7c0ee42cf1fde123097 Mon Sep 17 00:00:00 2001 From: jojo Date: Mon, 28 Dec 2020 16:30:40 +0100 Subject: [PATCH 13/53] Fix Argument.ArgumentBuilder --- SpigotCore_Main/src/de/steamwar/command/Argument.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/SpigotCore_Main/src/de/steamwar/command/Argument.java b/SpigotCore_Main/src/de/steamwar/command/Argument.java index 674da8a..24c550a 100644 --- a/SpigotCore_Main/src/de/steamwar/command/Argument.java +++ b/SpigotCore_Main/src/de/steamwar/command/Argument.java @@ -94,7 +94,7 @@ public class Argument { public ArgumentBuilder(int min, int max, Argument... arguments) { if (min < 0) min = 0; - if (max >= arguments.length) max = arguments.length - 1; + if (max > arguments.length) max = arguments.length; for (int i = min; i <= max; i++) { generate(arguments, i, 0, new Argument[i]); } -- 2.39.2 From 76fe648e85a7162db8c7c0893a5c321e0caefcab Mon Sep 17 00:00:00 2001 From: jojo Date: Mon, 28 Dec 2020 17:04:28 +0100 Subject: [PATCH 14/53] Fix Argument.ArgumentBuilder --- .../src/de/steamwar/command/Argument.java | 38 ++++++++++++++++--- 1 file changed, 33 insertions(+), 5 deletions(-) diff --git a/SpigotCore_Main/src/de/steamwar/command/Argument.java b/SpigotCore_Main/src/de/steamwar/command/Argument.java index 24c550a..e1aae74 100644 --- a/SpigotCore_Main/src/de/steamwar/command/Argument.java +++ b/SpigotCore_Main/src/de/steamwar/command/Argument.java @@ -23,10 +23,7 @@ package de.steamwar.command; import org.bukkit.Bukkit; -import java.util.ArrayList; -import java.util.Arrays; -import java.util.List; -import java.util.Optional; +import java.util.*; import java.util.function.Function; import java.util.function.Predicate; import java.util.stream.Collectors; @@ -100,9 +97,33 @@ public class Argument { } } + public void generate(int n, Argument[] elements) { + if (n == 1 || n == 0) { + options.add(Arrays.copyOf(elements, elements.length)); + return; + } + for (int i = 0; i < n - 1; i++) { + generate(n - 1, elements); + if (n % 2 == 0) { + swap(elements, i, n - 1); + } else { + swap(elements, 0, n - 1); + } + } + generate(n - 1, elements); + } + + private void swap(Argument[] elements, int a, int b) { + Argument tmp = elements[a]; + elements[a] = elements[b]; + elements[b] = tmp; + } + private void generate(Argument[] arguments, int length, int startPosition, Argument[] result) { if (length == 0) { - options.add(Arrays.copyOf(result, result.length)); + Set> argumentSet = new HashSet<>(Arrays.asList(result)); + if (argumentSet.size() != result.length) return; + generate(result.length, Arrays.copyOf(result, result.length)); return; } for (int i = startPosition; i <= arguments.length - length; i++) { @@ -131,4 +152,11 @@ public class Argument { } + @Override + public String toString() { + return "Argument{" + + "tabCompletes=" + Arrays.toString(tabCompletes) + + '}'; + } + } -- 2.39.2 From b87b1923512c6ee92d95698544714116527255b7 Mon Sep 17 00:00:00 2001 From: jojo Date: Mon, 28 Dec 2020 23:18:41 +0100 Subject: [PATCH 15/53] Add Argument.BOOLEAN Add ArgumentType.BOOLEAN --- SpigotCore_Main/src/de/steamwar/command/Argument.java | 1 + SpigotCore_Main/src/de/steamwar/command/ArgumentType.java | 1 + 2 files changed, 2 insertions(+) diff --git a/SpigotCore_Main/src/de/steamwar/command/Argument.java b/SpigotCore_Main/src/de/steamwar/command/Argument.java index e1aae74..15eb96e 100644 --- a/SpigotCore_Main/src/de/steamwar/command/Argument.java +++ b/SpigotCore_Main/src/de/steamwar/command/Argument.java @@ -30,6 +30,7 @@ import java.util.stream.Collectors; public class Argument { + public static final Argument BOOLEAN = new Argument<>(ArgumentType.BOOLEAN, bool -> true); public static final Argument INT = new Argument<>(ArgumentType.INT, integer -> true); public static final Argument LONG = new Argument<>(ArgumentType.LONG, l -> true); public static final Argument FLOAT = new Argument<>(ArgumentType.FLOAT, f -> true); diff --git a/SpigotCore_Main/src/de/steamwar/command/ArgumentType.java b/SpigotCore_Main/src/de/steamwar/command/ArgumentType.java index 80f5531..04df678 100644 --- a/SpigotCore_Main/src/de/steamwar/command/ArgumentType.java +++ b/SpigotCore_Main/src/de/steamwar/command/ArgumentType.java @@ -25,6 +25,7 @@ import java.util.function.Function; public class ArgumentType { + public static final ArgumentType BOOLEAN = new ArgumentType<>(Boolean::parseBoolean, false); public static final ArgumentType INT = new ArgumentType<>(Integer::parseInt, true); public static final ArgumentType LONG = new ArgumentType<>(Long::parseLong, true); public static final ArgumentType FLOAT = new ArgumentType<>(Float::parseFloat, true); -- 2.39.2 From b179eeb5df1432f8ed87cc6d1c27d3ae6494eb90 Mon Sep 17 00:00:00 2001 From: jojo Date: Mon, 28 Dec 2020 23:26:25 +0100 Subject: [PATCH 16/53] Add Argument.tabCompletes to Supplier for dynamic use --- .../src/de/steamwar/command/Argument.java | 14 ++++++++------ 1 file changed, 8 insertions(+), 6 deletions(-) diff --git a/SpigotCore_Main/src/de/steamwar/command/Argument.java b/SpigotCore_Main/src/de/steamwar/command/Argument.java index 15eb96e..d8de47b 100644 --- a/SpigotCore_Main/src/de/steamwar/command/Argument.java +++ b/SpigotCore_Main/src/de/steamwar/command/Argument.java @@ -22,10 +22,12 @@ package de.steamwar.command; import org.bukkit.Bukkit; +import org.bukkit.entity.Player; import java.util.*; import java.util.function.Function; import java.util.function.Predicate; +import java.util.function.Supplier; import java.util.stream.Collectors; public class Argument { @@ -36,18 +38,18 @@ public class Argument { public static final Argument FLOAT = new Argument<>(ArgumentType.FLOAT, f -> true); public static final Argument DOUBLE = new Argument<>(ArgumentType.DOUBLE, d -> true); public static final Argument STRING = new Argument<>(ArgumentType.STRING, string -> true); - public static final Argument PLAYER = new Argument<>(ArgumentType.STRING, string -> Bukkit.getPlayer(string) == null, Bukkit::getPlayer); + public static final Argument PLAYER = new Argument<>(ArgumentType.STRING, string -> Bukkit.getPlayer(string) == null, Bukkit::getPlayer, () -> Bukkit.getOnlinePlayers().stream().map(Player::getName).toArray(String[]::new)); private ArgumentType argumentType; private Predicate constraint; - private String[] tabCompletes; + private Supplier tabCompletes; private Function valueMapper; public Argument(ArgumentType argumentType, Predicate constraint, String... tabCompletes) { - this(argumentType, constraint, o -> o, tabCompletes); + this(argumentType, constraint, o -> o, () -> tabCompletes); } - public Argument(ArgumentType argumentType, Predicate constraint, Function valueMapper, String... tabCompletes) { + public Argument(ArgumentType argumentType, Predicate constraint, Function valueMapper, Supplier tabCompletes) { this.argumentType = argumentType; this.constraint = constraint; this.valueMapper = valueMapper; @@ -76,7 +78,7 @@ public class Argument { // Check number constraints if needed if (argumentType.number && !constraint.test(argumentMapped)) return Optional.empty(); } - List strings = Arrays.stream(tabCompletes).filter(t -> t.startsWith(s)).collect(Collectors.toList()); + List strings = Arrays.stream(tabCompletes.get()).filter(t -> t.startsWith(s)).collect(Collectors.toList()); if (strings.isEmpty()) strings.add(s); return Optional.of(strings); } catch (NumberFormatException e) { @@ -156,7 +158,7 @@ public class Argument { @Override public String toString() { return "Argument{" + - "tabCompletes=" + Arrays.toString(tabCompletes) + + "tabCompletes=" + Arrays.toString(tabCompletes.get()) + '}'; } -- 2.39.2 From a65ce1c04d3809fccd104cee18a1d11aba693793 Mon Sep 17 00:00:00 2001 From: jojo Date: Tue, 29 Dec 2020 09:47:34 +0100 Subject: [PATCH 17/53] Add Argument.BOOLEAN --- SpigotCore_Main/src/de/steamwar/command/Argument.java | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/SpigotCore_Main/src/de/steamwar/command/Argument.java b/SpigotCore_Main/src/de/steamwar/command/Argument.java index d8de47b..51403a8 100644 --- a/SpigotCore_Main/src/de/steamwar/command/Argument.java +++ b/SpigotCore_Main/src/de/steamwar/command/Argument.java @@ -32,7 +32,7 @@ import java.util.stream.Collectors; public class Argument { - public static final Argument BOOLEAN = new Argument<>(ArgumentType.BOOLEAN, bool -> true); + public static final Argument BOOLEAN = new Argument<>(ArgumentType.BOOLEAN, bool -> true, "true", "false"); public static final Argument INT = new Argument<>(ArgumentType.INT, integer -> true); public static final Argument LONG = new Argument<>(ArgumentType.LONG, l -> true); public static final Argument FLOAT = new Argument<>(ArgumentType.FLOAT, f -> true); @@ -49,6 +49,10 @@ public class Argument { this(argumentType, constraint, o -> o, () -> tabCompletes); } + public Argument(ArgumentType argumentType, Predicate constraint, Supplier tabCompletes) { + this(argumentType, constraint, o -> o, tabCompletes); + } + public Argument(ArgumentType argumentType, Predicate constraint, Function valueMapper, Supplier tabCompletes) { this.argumentType = argumentType; this.constraint = constraint; -- 2.39.2 From 52af8a71f51cbcb825751c18e682f20d1800bf02 Mon Sep 17 00:00:00 2001 From: jojo Date: Tue, 29 Dec 2020 13:29:32 +0100 Subject: [PATCH 18/53] Add Argument.GAMEMODE Add Argument.MATERIAL --- .../src/de/steamwar/command/Argument.java | 27 +++++++++++++++++++ 1 file changed, 27 insertions(+) diff --git a/SpigotCore_Main/src/de/steamwar/command/Argument.java b/SpigotCore_Main/src/de/steamwar/command/Argument.java index 51403a8..64cdb76 100644 --- a/SpigotCore_Main/src/de/steamwar/command/Argument.java +++ b/SpigotCore_Main/src/de/steamwar/command/Argument.java @@ -21,7 +21,10 @@ package de.steamwar.command; +import com.sk89q.worldedit.extent.world.SurvivalModeExtent; import org.bukkit.Bukkit; +import org.bukkit.GameMode; +import org.bukkit.Material; import org.bukkit.entity.Player; import java.util.*; @@ -38,8 +41,32 @@ public class Argument { public static final Argument FLOAT = new Argument<>(ArgumentType.FLOAT, f -> true); public static final Argument DOUBLE = new Argument<>(ArgumentType.DOUBLE, d -> true); public static final Argument STRING = new Argument<>(ArgumentType.STRING, string -> true); + public static final Argument PLAYER = new Argument<>(ArgumentType.STRING, string -> Bukkit.getPlayer(string) == null, Bukkit::getPlayer, () -> Bukkit.getOnlinePlayers().stream().map(Player::getName).toArray(String[]::new)); + public static final Argument GAMEMODE = new Argument<>(ArgumentType.STRING, + string -> string.equalsIgnoreCase("creative") || + string.equalsIgnoreCase("c") || + string.equalsIgnoreCase("1") || + string.equalsIgnoreCase("survival") || + string.equalsIgnoreCase("s") || + string.equalsIgnoreCase("0") || + string.equalsIgnoreCase("spectator") || + string.equalsIgnoreCase("sp") || + string.equalsIgnoreCase("3") || + string.equalsIgnoreCase("adventure") || + string.equalsIgnoreCase("a") || + string.equalsIgnoreCase("2"), + s -> { + if (s.equalsIgnoreCase("creative") || s.equalsIgnoreCase("c") || s.equalsIgnoreCase("1")) return GameMode.CREATIVE; + if (s.equalsIgnoreCase("spectator") || s.equalsIgnoreCase("sp") || s.equalsIgnoreCase("3")) return GameMode.SPECTATOR; + if (s.equalsIgnoreCase("adventure") || s.equalsIgnoreCase("a") || s.equalsIgnoreCase("2")) return GameMode.ADVENTURE; + return GameMode.SURVIVAL; + }, () -> new String[]{"creative", "survival", "adventure", "spectator"}); + + private static final String[] materialArray = Arrays.stream(Material.values()).map(Enum::name).toArray(String[]::new); + public static final Argument MATERIAL = new Argument<>(ArgumentType.STRING, string -> Material.valueOf(string) != null, Material::valueOf, () -> materialArray); + private ArgumentType argumentType; private Predicate constraint; private Supplier tabCompletes; -- 2.39.2 From 72863f30f0b7dbdd1957b8e5a8e97a26214a055f Mon Sep 17 00:00:00 2001 From: jojo Date: Tue, 29 Dec 2020 13:46:31 +0100 Subject: [PATCH 19/53] Add reactive dynamic Argument TabCompletion --- .../src/de/steamwar/command/Argument.java | 16 +++++++--- .../de/steamwar/command/ArgumentUtils.java | 29 +++++++++++++++++++ 2 files changed, 41 insertions(+), 4 deletions(-) diff --git a/SpigotCore_Main/src/de/steamwar/command/Argument.java b/SpigotCore_Main/src/de/steamwar/command/Argument.java index 64cdb76..4f80c92 100644 --- a/SpigotCore_Main/src/de/steamwar/command/Argument.java +++ b/SpigotCore_Main/src/de/steamwar/command/Argument.java @@ -21,7 +21,7 @@ package de.steamwar.command; -import com.sk89q.worldedit.extent.world.SurvivalModeExtent; +import com.mojang.datafixers.types.Func; import org.bukkit.Bukkit; import org.bukkit.GameMode; import org.bukkit.Material; @@ -69,7 +69,7 @@ public class Argument { private ArgumentType argumentType; private Predicate constraint; - private Supplier tabCompletes; + private Function tabCompletes; private Function valueMapper; public Argument(ArgumentType argumentType, Predicate constraint, String... tabCompletes) { @@ -80,7 +80,15 @@ public class Argument { this(argumentType, constraint, o -> o, tabCompletes); } + public Argument(ArgumentType argumentType, Predicate constraint, Function tabCompletes) { + this(argumentType, constraint, o -> o, tabCompletes); + } + public Argument(ArgumentType argumentType, Predicate constraint, Function valueMapper, Supplier tabCompletes) { + this(argumentType, constraint, valueMapper, s -> tabCompletes.get()); + } + + public Argument(ArgumentType argumentType, Predicate constraint, Function valueMapper, Function tabCompletes) { this.argumentType = argumentType; this.constraint = constraint; this.valueMapper = valueMapper; @@ -109,7 +117,7 @@ public class Argument { // Check number constraints if needed if (argumentType.number && !constraint.test(argumentMapped)) return Optional.empty(); } - List strings = Arrays.stream(tabCompletes.get()).filter(t -> t.startsWith(s)).collect(Collectors.toList()); + List strings = Arrays.stream(tabCompletes.apply(s)).filter(t -> t.startsWith(s)).collect(Collectors.toList()); if (strings.isEmpty()) strings.add(s); return Optional.of(strings); } catch (NumberFormatException e) { @@ -189,7 +197,7 @@ public class Argument { @Override public String toString() { return "Argument{" + - "tabCompletes=" + Arrays.toString(tabCompletes.get()) + + "tabCompletes=" + Arrays.toString(tabCompletes.apply("")) + '}'; } diff --git a/SpigotCore_Main/src/de/steamwar/command/ArgumentUtils.java b/SpigotCore_Main/src/de/steamwar/command/ArgumentUtils.java index 724de1e..6487576 100644 --- a/SpigotCore_Main/src/de/steamwar/command/ArgumentUtils.java +++ b/SpigotCore_Main/src/de/steamwar/command/ArgumentUtils.java @@ -21,6 +21,7 @@ package de.steamwar.command; +import javax.xml.crypto.dsig.spec.XSLTTransformParameterSpec; import java.util.Arrays; import java.util.function.Predicate; @@ -43,6 +44,20 @@ public class ArgumentUtils { }, arguments); } + public static Argument of(String[] commands, String[] tabCompletes) { + return new Argument<>(ArgumentType.STRING, string -> { + for (String arg : commands){ + if (string.equals(arg)) return true; + } + return false; + }, s -> { + if (s.isEmpty()) { + return tabCompletes; + } + return commands; + }); + } + public static Argument ofIgnoreCase(String argument) { return new Argument<>(ArgumentType.STRING, string -> string.equalsIgnoreCase(argument), argument); } @@ -56,6 +71,20 @@ public class ArgumentUtils { }, arguments); } + public static Argument ofIgnoreCase(String[] commands, String[] tabCompletes) { + return new Argument<>(ArgumentType.STRING, string -> { + for (String arg : commands){ + if (string.equalsIgnoreCase(arg)) return true; + } + return false; + }, s -> { + if (s.isEmpty()) { + return tabCompletes; + } + return commands; + }); + } + public static Argument above(int minValue, int... tabValues) { return between(minValue, Integer.MAX_VALUE, tabValues); } -- 2.39.2 From ee85ec6696e2c14546858e98bd4117d43f530d0f Mon Sep 17 00:00:00 2001 From: jojo Date: Tue, 29 Dec 2020 16:42:47 +0100 Subject: [PATCH 20/53] Simplify Argument.tabCompleteSupplier --- SpigotCore_Main/src/de/steamwar/command/Argument.java | 4 +--- SpigotCore_Main/src/de/steamwar/command/SWCommandBundle.java | 3 +-- 2 files changed, 2 insertions(+), 5 deletions(-) diff --git a/SpigotCore_Main/src/de/steamwar/command/Argument.java b/SpigotCore_Main/src/de/steamwar/command/Argument.java index 4f80c92..652c684 100644 --- a/SpigotCore_Main/src/de/steamwar/command/Argument.java +++ b/SpigotCore_Main/src/de/steamwar/command/Argument.java @@ -117,9 +117,7 @@ public class Argument { // Check number constraints if needed if (argumentType.number && !constraint.test(argumentMapped)) return Optional.empty(); } - List strings = Arrays.stream(tabCompletes.apply(s)).filter(t -> t.startsWith(s)).collect(Collectors.toList()); - if (strings.isEmpty()) strings.add(s); - return Optional.of(strings); + return Optional.of(Arrays.stream(tabCompletes.apply(s)).filter(t -> t.startsWith(s)).collect(Collectors.toList())); } catch (NumberFormatException e) { return Optional.empty(); } catch (Exception e) { diff --git a/SpigotCore_Main/src/de/steamwar/command/SWCommandBundle.java b/SpigotCore_Main/src/de/steamwar/command/SWCommandBundle.java index c5dcde0..24f24c7 100644 --- a/SpigotCore_Main/src/de/steamwar/command/SWCommandBundle.java +++ b/SpigotCore_Main/src/de/steamwar/command/SWCommandBundle.java @@ -59,8 +59,7 @@ public class SWCommandBundle { public List tabComplete(String[] args) { List strings = new ArrayList<>(); for (SWCommand swCommand : swCommandList) { - Optional> tabCompletes = swCommand.tabComplete(args); - if (tabCompletes.isPresent()) strings.addAll(tabCompletes.get()); + swCommand.tabComplete(args).ifPresent(strings::addAll); } return strings; } -- 2.39.2 From 742bc9a23c5ca38431154018f20c91117765411b Mon Sep 17 00:00:00 2001 From: jojo Date: Tue, 29 Dec 2020 19:05:39 +0100 Subject: [PATCH 21/53] Add Argument.PARTICLE Add Argument.ENTITY Add Argument.SOUND Add Argument.SOUND_CATEGORY --- .../src/de/steamwar/command/Argument.java | 18 ++++++++++++++---- 1 file changed, 14 insertions(+), 4 deletions(-) diff --git a/SpigotCore_Main/src/de/steamwar/command/Argument.java b/SpigotCore_Main/src/de/steamwar/command/Argument.java index 652c684..dadae09 100644 --- a/SpigotCore_Main/src/de/steamwar/command/Argument.java +++ b/SpigotCore_Main/src/de/steamwar/command/Argument.java @@ -21,10 +21,8 @@ package de.steamwar.command; -import com.mojang.datafixers.types.Func; -import org.bukkit.Bukkit; -import org.bukkit.GameMode; -import org.bukkit.Material; +import org.bukkit.*; +import org.bukkit.entity.EntityType; import org.bukkit.entity.Player; import java.util.*; @@ -67,6 +65,18 @@ public class Argument { private static final String[] materialArray = Arrays.stream(Material.values()).map(Enum::name).toArray(String[]::new); public static final Argument MATERIAL = new Argument<>(ArgumentType.STRING, string -> Material.valueOf(string) != null, Material::valueOf, () -> materialArray); + private static final String[] particleArray = Arrays.stream(Particle.values()).map(Enum::name).toArray(String[]::new); + public static final Argument PARTICLE = new Argument<>(ArgumentType.STRING, string -> Particle.valueOf(string) != null, Particle::valueOf, () -> particleArray); + + private static final String[] entityArray = Arrays.stream(EntityType.values()).map(Enum::name).toArray(String[]::new); + public static final Argument ENTITY = new Argument<>(ArgumentType.STRING, string -> EntityType.valueOf(string) != null, EntityType::valueOf, () -> entityArray); + + private static final String[] soundArray = Arrays.stream(Sound.values()).map(Enum::name).toArray(String[]::new); + public static final Argument SOUND = new Argument<>(ArgumentType.STRING, string -> Sound.valueOf(string) != null, Sound::valueOf, () -> soundArray); + + private static final String[] soundCategoryArray = Arrays.stream(SoundCategory.values()).map(Enum::name).toArray(String[]::new); + public static final Argument SOUND_CATEGORY = new Argument<>(ArgumentType.STRING, string -> SoundCategory.valueOf(string) != null, SoundCategory::valueOf, () -> soundCategoryArray); + private ArgumentType argumentType; private Predicate constraint; private Function tabCompletes; -- 2.39.2 From e6f948f35e204d58c77d2139c85f6cbb8b0915e1 Mon Sep 17 00:00:00 2001 From: jojo Date: Tue, 29 Dec 2020 20:32:00 +0100 Subject: [PATCH 22/53] Optimize Imports --- SpigotCore_Main/src/de/steamwar/command/ArgumentUtils.java | 1 - 1 file changed, 1 deletion(-) diff --git a/SpigotCore_Main/src/de/steamwar/command/ArgumentUtils.java b/SpigotCore_Main/src/de/steamwar/command/ArgumentUtils.java index 6487576..7e325cc 100644 --- a/SpigotCore_Main/src/de/steamwar/command/ArgumentUtils.java +++ b/SpigotCore_Main/src/de/steamwar/command/ArgumentUtils.java @@ -21,7 +21,6 @@ package de.steamwar.command; -import javax.xml.crypto.dsig.spec.XSLTTransformParameterSpec; import java.util.Arrays; import java.util.function.Predicate; -- 2.39.2 From 88083af07484df08f1775fa87000c39256d650b0 Mon Sep 17 00:00:00 2001 From: jojo Date: Tue, 29 Dec 2020 20:45:19 +0100 Subject: [PATCH 23/53] Add Readability --- SpigotCore_Main/src/de/steamwar/command/ArgumentType.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/SpigotCore_Main/src/de/steamwar/command/ArgumentType.java b/SpigotCore_Main/src/de/steamwar/command/ArgumentType.java index 04df678..9927841 100644 --- a/SpigotCore_Main/src/de/steamwar/command/ArgumentType.java +++ b/SpigotCore_Main/src/de/steamwar/command/ArgumentType.java @@ -30,7 +30,7 @@ public class ArgumentType { public static final ArgumentType LONG = new ArgumentType<>(Long::parseLong, true); public static final ArgumentType FLOAT = new ArgumentType<>(Float::parseFloat, true); public static final ArgumentType DOUBLE = new ArgumentType<>(Double::parseDouble, true); - public static final ArgumentType STRING = new ArgumentType<>((s) -> s, false); + public static final ArgumentType STRING = new ArgumentType<>(s -> s, false); Function mapper; boolean number; -- 2.39.2 From 80b85e3ee9c026f50beb94a78f94f8c9c2ab7123 Mon Sep 17 00:00:00 2001 From: jojo Date: Tue, 29 Dec 2020 22:21:06 +0100 Subject: [PATCH 24/53] Add Argument interface in commandn Add InvalidArgumentException --- .../src/de/steamwar/command/Argument.java | 83 +------------------ .../src/de/steamwar/command/ArgumentMap.java | 1 + .../src/de/steamwar/command/Executor.java | 2 +- .../src/de/steamwar/command/SWCommand.java | 9 +- .../de/steamwar/command/SWCommandBundle.java | 7 +- .../src/de/steamwar/commandn/Argument.java | 47 +++++++++++ .../commandn/InvalidArgumentException.java | 26 ++++++ 7 files changed, 87 insertions(+), 88 deletions(-) create mode 100644 SpigotCore_Main/src/de/steamwar/commandn/Argument.java create mode 100644 SpigotCore_Main/src/de/steamwar/commandn/InvalidArgumentException.java diff --git a/SpigotCore_Main/src/de/steamwar/command/Argument.java b/SpigotCore_Main/src/de/steamwar/command/Argument.java index dadae09..0a6b106 100644 --- a/SpigotCore_Main/src/de/steamwar/command/Argument.java +++ b/SpigotCore_Main/src/de/steamwar/command/Argument.java @@ -43,18 +43,10 @@ public class Argument { public static final Argument PLAYER = new Argument<>(ArgumentType.STRING, string -> Bukkit.getPlayer(string) == null, Bukkit::getPlayer, () -> Bukkit.getOnlinePlayers().stream().map(Player::getName).toArray(String[]::new)); public static final Argument GAMEMODE = new Argument<>(ArgumentType.STRING, - string -> string.equalsIgnoreCase("creative") || - string.equalsIgnoreCase("c") || - string.equalsIgnoreCase("1") || - string.equalsIgnoreCase("survival") || - string.equalsIgnoreCase("s") || - string.equalsIgnoreCase("0") || - string.equalsIgnoreCase("spectator") || - string.equalsIgnoreCase("sp") || - string.equalsIgnoreCase("3") || - string.equalsIgnoreCase("adventure") || - string.equalsIgnoreCase("a") || - string.equalsIgnoreCase("2"), + string -> string.equalsIgnoreCase("creative") || string.equalsIgnoreCase("c") || string.equalsIgnoreCase("1") || + string.equalsIgnoreCase("survival") || string.equalsIgnoreCase("s") || string.equalsIgnoreCase("0") || + string.equalsIgnoreCase("spectator") || string.equalsIgnoreCase("sp") || string.equalsIgnoreCase("3") || + string.equalsIgnoreCase("adventure") || string.equalsIgnoreCase("a") || string.equalsIgnoreCase("2"), s -> { if (s.equalsIgnoreCase("creative") || s.equalsIgnoreCase("c") || s.equalsIgnoreCase("1")) return GameMode.CREATIVE; if (s.equalsIgnoreCase("spectator") || s.equalsIgnoreCase("sp") || s.equalsIgnoreCase("3")) return GameMode.SPECTATOR; @@ -135,73 +127,6 @@ public class Argument { } } - public static class ArgumentBuilder { - - private List[]> options = new ArrayList<>(); - - public ArgumentBuilder(int min, int max, Argument... arguments) { - if (min < 0) min = 0; - if (max > arguments.length) max = arguments.length; - for (int i = min; i <= max; i++) { - generate(arguments, i, 0, new Argument[i]); - } - } - - public void generate(int n, Argument[] elements) { - if (n == 1 || n == 0) { - options.add(Arrays.copyOf(elements, elements.length)); - return; - } - for (int i = 0; i < n - 1; i++) { - generate(n - 1, elements); - if (n % 2 == 0) { - swap(elements, i, n - 1); - } else { - swap(elements, 0, n - 1); - } - } - generate(n - 1, elements); - } - - private void swap(Argument[] elements, int a, int b) { - Argument tmp = elements[a]; - elements[a] = elements[b]; - elements[b] = tmp; - } - - private void generate(Argument[] arguments, int length, int startPosition, Argument[] result) { - if (length == 0) { - Set> argumentSet = new HashSet<>(Arrays.asList(result)); - if (argumentSet.size() != result.length) return; - generate(result.length, Arrays.copyOf(result, result.length)); - return; - } - for (int i = startPosition; i <= arguments.length - length; i++) { - result[result.length - length] = arguments[i]; - generate(arguments, length - 1, startPosition + 1, result); - } - } - - public List[]> apply(Argument... arguments) { - List[]> args = new ArrayList<>(); - args.add(arguments); - return apply(args); - } - - public List[]> apply(List[]> arguments) { - List[]> results = new ArrayList<>(); - arguments.forEach(args -> { - for (Argument[] option : options) { - Argument[] result = Arrays.copyOf(args, args.length + option.length); - System.arraycopy(option, 0, result, args.length, option.length); - results.add(result); - } - }); - return results; - } - - } - @Override public String toString() { return "Argument{" + diff --git a/SpigotCore_Main/src/de/steamwar/command/ArgumentMap.java b/SpigotCore_Main/src/de/steamwar/command/ArgumentMap.java index 5ced8bc..1d3e51f 100644 --- a/SpigotCore_Main/src/de/steamwar/command/ArgumentMap.java +++ b/SpigotCore_Main/src/de/steamwar/command/ArgumentMap.java @@ -69,4 +69,5 @@ public class ArgumentMap { st.append("}"); return st.toString(); } + } diff --git a/SpigotCore_Main/src/de/steamwar/command/Executor.java b/SpigotCore_Main/src/de/steamwar/command/Executor.java index f752951..26d6bdc 100644 --- a/SpigotCore_Main/src/de/steamwar/command/Executor.java +++ b/SpigotCore_Main/src/de/steamwar/command/Executor.java @@ -25,5 +25,5 @@ import org.bukkit.entity.Player; @FunctionalInterface public interface Executor { - boolean execute(Player player, ArgumentMap argumentMap); + void execute(Player player, ArgumentMap argumentMap); } diff --git a/SpigotCore_Main/src/de/steamwar/command/SWCommand.java b/SpigotCore_Main/src/de/steamwar/command/SWCommand.java index 4d73c31..95d0d27 100644 --- a/SpigotCore_Main/src/de/steamwar/command/SWCommand.java +++ b/SpigotCore_Main/src/de/steamwar/command/SWCommand.java @@ -36,17 +36,18 @@ public class SWCommand { this.executor = executor; } - public Optional execute(Player player, String[] args) { + public boolean execute(Player player, String[] args) { if (args.length != arguments.length) { - return Optional.empty(); + return false; } Object[] objects = new Object[args.length]; for (int i = 0; i < args.length; i++) { Optional optional = arguments[i].valueSupplier(args[i]); - if (!optional.isPresent()) return Optional.empty(); + if (!optional.isPresent()) return false; objects[i] = optional.get(); } - return Optional.of(executor.execute(player, new ArgumentMap(objects))); + executor.execute(player, new ArgumentMap(objects)); + return true; } public Optional> tabComplete(String[] args) { diff --git a/SpigotCore_Main/src/de/steamwar/command/SWCommandBundle.java b/SpigotCore_Main/src/de/steamwar/command/SWCommandBundle.java index 24f24c7..d3e2590 100644 --- a/SpigotCore_Main/src/de/steamwar/command/SWCommandBundle.java +++ b/SpigotCore_Main/src/de/steamwar/command/SWCommandBundle.java @@ -48,12 +48,11 @@ public class SWCommandBundle { return this; } - public Optional execute(Player player, String[] args) { + public boolean execute(Player player, String[] args) { for (SWCommand swCommand : swCommandList) { - Optional optionalBoolean = swCommand.execute(player, args); - if (optionalBoolean.isPresent()) return optionalBoolean; + if (swCommand.execute(player, args)) return true; } - return Optional.empty(); + return false; } public List tabComplete(String[] args) { diff --git a/SpigotCore_Main/src/de/steamwar/commandn/Argument.java b/SpigotCore_Main/src/de/steamwar/commandn/Argument.java new file mode 100644 index 0000000..9a574f3 --- /dev/null +++ b/SpigotCore_Main/src/de/steamwar/commandn/Argument.java @@ -0,0 +1,47 @@ +/* + * + * This file is a part of the SteamWar software. + * + * Copyright (C) 2020 SteamWar.de-Serverteam + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Affero General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program 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 Affero General Public License for more details. + * + * You should have received a copy of the GNU Affero General Public License + * along with this program. If not, see . + * / + */ + +package de.steamwar.commandn; + +import org.bukkit.command.CommandSender; + +import java.util.List; + +public interface Argument { + + T parse(CommandSender sender, String arg); + List tabComplete(CommandSender sender, String arg) throws InvalidArgumentException; + + abstract class IntArgument implements Argument { + @Override + public Integer parse(CommandSender sender, String arg) { + return Integer.parseInt(arg); + } + } + + abstract class DoubleArgument implements Argument { + @Override + public Double parse(CommandSender sender, String arg) { + return Double.parseDouble(arg); + } + } + +} diff --git a/SpigotCore_Main/src/de/steamwar/commandn/InvalidArgumentException.java b/SpigotCore_Main/src/de/steamwar/commandn/InvalidArgumentException.java new file mode 100644 index 0000000..4c0fd78 --- /dev/null +++ b/SpigotCore_Main/src/de/steamwar/commandn/InvalidArgumentException.java @@ -0,0 +1,26 @@ +/* + * + * This file is a part of the SteamWar software. + * + * Copyright (C) 2020 SteamWar.de-Serverteam + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Affero General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program 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 Affero General Public License for more details. + * + * You should have received a copy of the GNU Affero General Public License + * along with this program. If not, see . + * / + */ + +package de.steamwar.commandn; + +public class InvalidArgumentException extends Exception { + +} -- 2.39.2 From 710ec9b6e7493dea4d8b94634b868d8ffbaded72 Mon Sep 17 00:00:00 2001 From: jojo Date: Tue, 29 Dec 2020 22:45:49 +0100 Subject: [PATCH 25/53] Add API in Argument --- .../src/de/steamwar/commandn/Argument.java | 12 +++++++++--- 1 file changed, 9 insertions(+), 3 deletions(-) diff --git a/SpigotCore_Main/src/de/steamwar/commandn/Argument.java b/SpigotCore_Main/src/de/steamwar/commandn/Argument.java index 9a574f3..92eb7d4 100644 --- a/SpigotCore_Main/src/de/steamwar/commandn/Argument.java +++ b/SpigotCore_Main/src/de/steamwar/commandn/Argument.java @@ -24,22 +24,28 @@ package de.steamwar.commandn; import org.bukkit.command.CommandSender; import java.util.List; +import java.util.function.BiPredicate; public interface Argument { - T parse(CommandSender sender, String arg); + T parse(String arg) throws InvalidArgumentException; + void checkConstraints(CommandSender sender, T argument) throws InvalidArgumentException; + List tabComplete(CommandSender sender, String arg) throws InvalidArgumentException; + default BiPredicate tabCompleteFilter() { + return String::startsWith; + } abstract class IntArgument implements Argument { @Override - public Integer parse(CommandSender sender, String arg) { + public Integer parse(String arg) { return Integer.parseInt(arg); } } abstract class DoubleArgument implements Argument { @Override - public Double parse(CommandSender sender, String arg) { + public Double parse(String arg) { return Double.parseDouble(arg); } } -- 2.39.2 From 3687b4b2678b0d22d45b99ca04acd4eb7c66f20d Mon Sep 17 00:00:00 2001 From: jojo Date: Wed, 30 Dec 2020 12:22:52 +0100 Subject: [PATCH 26/53] Simplify CommandFramework --- .../src/de/steamwar/command/Argument.java | 119 ++------------ .../src/de/steamwar/command/ArgumentType.java | 43 ----- .../de/steamwar/command/ArgumentUtils.java | 155 ------------------ .../src/de/steamwar/command/Executor.java | 4 +- .../InvalidArgumentException.java | 2 +- .../src/de/steamwar/command/SWCommand.java | 33 ++-- .../de/steamwar/command/SWCommandBundle.java | 9 +- .../src/de/steamwar/commandn/Argument.java | 53 ------ 8 files changed, 45 insertions(+), 373 deletions(-) delete mode 100644 SpigotCore_Main/src/de/steamwar/command/ArgumentType.java delete mode 100644 SpigotCore_Main/src/de/steamwar/command/ArgumentUtils.java rename SpigotCore_Main/src/de/steamwar/{commandn => command}/InvalidArgumentException.java (96%) delete mode 100644 SpigotCore_Main/src/de/steamwar/commandn/Argument.java diff --git a/SpigotCore_Main/src/de/steamwar/command/Argument.java b/SpigotCore_Main/src/de/steamwar/command/Argument.java index 0a6b106..9ed1b57 100644 --- a/SpigotCore_Main/src/de/steamwar/command/Argument.java +++ b/SpigotCore_Main/src/de/steamwar/command/Argument.java @@ -21,117 +21,34 @@ package de.steamwar.command; -import org.bukkit.*; -import org.bukkit.entity.EntityType; -import org.bukkit.entity.Player; +import org.bukkit.command.CommandSender; -import java.util.*; -import java.util.function.Function; -import java.util.function.Predicate; -import java.util.function.Supplier; -import java.util.stream.Collectors; +import java.util.List; +import java.util.function.BiPredicate; -public class Argument { +public interface Argument { - public static final Argument BOOLEAN = new Argument<>(ArgumentType.BOOLEAN, bool -> true, "true", "false"); - public static final Argument INT = new Argument<>(ArgumentType.INT, integer -> true); - public static final Argument LONG = new Argument<>(ArgumentType.LONG, l -> true); - public static final Argument FLOAT = new Argument<>(ArgumentType.FLOAT, f -> true); - public static final Argument DOUBLE = new Argument<>(ArgumentType.DOUBLE, d -> true); - public static final Argument STRING = new Argument<>(ArgumentType.STRING, string -> true); - - public static final Argument PLAYER = new Argument<>(ArgumentType.STRING, string -> Bukkit.getPlayer(string) == null, Bukkit::getPlayer, () -> Bukkit.getOnlinePlayers().stream().map(Player::getName).toArray(String[]::new)); - - public static final Argument GAMEMODE = new Argument<>(ArgumentType.STRING, - string -> string.equalsIgnoreCase("creative") || string.equalsIgnoreCase("c") || string.equalsIgnoreCase("1") || - string.equalsIgnoreCase("survival") || string.equalsIgnoreCase("s") || string.equalsIgnoreCase("0") || - string.equalsIgnoreCase("spectator") || string.equalsIgnoreCase("sp") || string.equalsIgnoreCase("3") || - string.equalsIgnoreCase("adventure") || string.equalsIgnoreCase("a") || string.equalsIgnoreCase("2"), - s -> { - if (s.equalsIgnoreCase("creative") || s.equalsIgnoreCase("c") || s.equalsIgnoreCase("1")) return GameMode.CREATIVE; - if (s.equalsIgnoreCase("spectator") || s.equalsIgnoreCase("sp") || s.equalsIgnoreCase("3")) return GameMode.SPECTATOR; - if (s.equalsIgnoreCase("adventure") || s.equalsIgnoreCase("a") || s.equalsIgnoreCase("2")) return GameMode.ADVENTURE; - return GameMode.SURVIVAL; - }, () -> new String[]{"creative", "survival", "adventure", "spectator"}); - - private static final String[] materialArray = Arrays.stream(Material.values()).map(Enum::name).toArray(String[]::new); - public static final Argument MATERIAL = new Argument<>(ArgumentType.STRING, string -> Material.valueOf(string) != null, Material::valueOf, () -> materialArray); - - private static final String[] particleArray = Arrays.stream(Particle.values()).map(Enum::name).toArray(String[]::new); - public static final Argument PARTICLE = new Argument<>(ArgumentType.STRING, string -> Particle.valueOf(string) != null, Particle::valueOf, () -> particleArray); - - private static final String[] entityArray = Arrays.stream(EntityType.values()).map(Enum::name).toArray(String[]::new); - public static final Argument ENTITY = new Argument<>(ArgumentType.STRING, string -> EntityType.valueOf(string) != null, EntityType::valueOf, () -> entityArray); - - private static final String[] soundArray = Arrays.stream(Sound.values()).map(Enum::name).toArray(String[]::new); - public static final Argument SOUND = new Argument<>(ArgumentType.STRING, string -> Sound.valueOf(string) != null, Sound::valueOf, () -> soundArray); - - private static final String[] soundCategoryArray = Arrays.stream(SoundCategory.values()).map(Enum::name).toArray(String[]::new); - public static final Argument SOUND_CATEGORY = new Argument<>(ArgumentType.STRING, string -> SoundCategory.valueOf(string) != null, SoundCategory::valueOf, () -> soundCategoryArray); - - private ArgumentType argumentType; - private Predicate constraint; - private Function tabCompletes; - private Function valueMapper; - - public Argument(ArgumentType argumentType, Predicate constraint, String... tabCompletes) { - this(argumentType, constraint, o -> o, () -> tabCompletes); + T parse(CommandSender sender, String arg) throws InvalidArgumentException; + default void checkConstraints(CommandSender sender, T argument) throws InvalidArgumentException { } - public Argument(ArgumentType argumentType, Predicate constraint, Supplier tabCompletes) { - this(argumentType, constraint, o -> o, tabCompletes); + List tabComplete(CommandSender sender, String arg); + default BiPredicate tabCompleteFilter() { + return String::startsWith; } - public Argument(ArgumentType argumentType, Predicate constraint, Function tabCompletes) { - this(argumentType, constraint, o -> o, tabCompletes); - } - - public Argument(ArgumentType argumentType, Predicate constraint, Function valueMapper, Supplier tabCompletes) { - this(argumentType, constraint, valueMapper, s -> tabCompletes.get()); - } - - public Argument(ArgumentType argumentType, Predicate constraint, Function valueMapper, Function tabCompletes) { - this.argumentType = argumentType; - this.constraint = constraint; - this.valueMapper = valueMapper; - this.tabCompletes = tabCompletes; - } - - public Optional valueSupplier(String s) { - try { - T argumentMapped = argumentType.mapper.apply(s); - if (constraint.test(argumentMapped)) { - return Optional.ofNullable(valueMapper.apply(argumentMapped)); - } - } catch (NumberFormatException e) { - return Optional.empty(); - } catch (Exception e) { - throw new SecurityException(e); - } - return Optional.empty(); - } - - public Optional> tabCompleteSupplier(String s) { - try { - if (!s.isEmpty()) { - // Check if mappable - T argumentMapped = argumentType.mapper.apply(s); - // Check number constraints if needed - if (argumentType.number && !constraint.test(argumentMapped)) return Optional.empty(); - } - return Optional.of(Arrays.stream(tabCompletes.apply(s)).filter(t -> t.startsWith(s)).collect(Collectors.toList())); - } catch (NumberFormatException e) { - return Optional.empty(); - } catch (Exception e) { - throw new SecurityException(e); + abstract class IntArgument implements Argument { + @Override + public Integer parse(CommandSender sender, String arg) { + return Integer.parseInt(arg); } } - @Override - public String toString() { - return "Argument{" + - "tabCompletes=" + Arrays.toString(tabCompletes.apply("")) + - '}'; + abstract class DoubleArgument implements Argument { + @Override + public Double parse(CommandSender sender, String arg) { + return Double.parseDouble(arg); + } } } diff --git a/SpigotCore_Main/src/de/steamwar/command/ArgumentType.java b/SpigotCore_Main/src/de/steamwar/command/ArgumentType.java deleted file mode 100644 index 9927841..0000000 --- a/SpigotCore_Main/src/de/steamwar/command/ArgumentType.java +++ /dev/null @@ -1,43 +0,0 @@ -/* - * - * This file is a part of the SteamWar software. - * - * Copyright (C) 2020 SteamWar.de-Serverteam - * - * This program is free software: you can redistribute it and/or modify - * it under the terms of the GNU Affero General Public License as published by - * the Free Software Foundation, either version 3 of the License, or - * (at your option) any later version. - * - * This program 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 Affero General Public License for more details. - * - * You should have received a copy of the GNU Affero General Public License - * along with this program. If not, see . - * / - */ - -package de.steamwar.command; - -import java.util.function.Function; - -public class ArgumentType { - - public static final ArgumentType BOOLEAN = new ArgumentType<>(Boolean::parseBoolean, false); - public static final ArgumentType INT = new ArgumentType<>(Integer::parseInt, true); - public static final ArgumentType LONG = new ArgumentType<>(Long::parseLong, true); - public static final ArgumentType FLOAT = new ArgumentType<>(Float::parseFloat, true); - public static final ArgumentType DOUBLE = new ArgumentType<>(Double::parseDouble, true); - public static final ArgumentType STRING = new ArgumentType<>(s -> s, false); - - Function mapper; - boolean number; - - private ArgumentType(Function mapper, boolean number) { - this.mapper = mapper; - this.number = number; - } - -} diff --git a/SpigotCore_Main/src/de/steamwar/command/ArgumentUtils.java b/SpigotCore_Main/src/de/steamwar/command/ArgumentUtils.java deleted file mode 100644 index 7e325cc..0000000 --- a/SpigotCore_Main/src/de/steamwar/command/ArgumentUtils.java +++ /dev/null @@ -1,155 +0,0 @@ -/* - * - * This file is a part of the SteamWar software. - * - * Copyright (C) 2020 SteamWar.de-Serverteam - * - * This program is free software: you can redistribute it and/or modify - * it under the terms of the GNU Affero General Public License as published by - * the Free Software Foundation, either version 3 of the License, or - * (at your option) any later version. - * - * This program 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 Affero General Public License for more details. - * - * You should have received a copy of the GNU Affero General Public License - * along with this program. If not, see . - * / - */ - -package de.steamwar.command; - -import java.util.Arrays; -import java.util.function.Predicate; - -public class ArgumentUtils { - - private ArgumentUtils() { - throw new IllegalStateException("Utility class"); - } - - public static Argument of(String argument) { - return new Argument<>(ArgumentType.STRING, string -> string.equals(argument), argument); - } - - public static Argument of(String... arguments) { - return new Argument<>(ArgumentType.STRING, string -> { - for (String arg : arguments) { - if (string.equals(arg)) return true; - } - return false; - }, arguments); - } - - public static Argument of(String[] commands, String[] tabCompletes) { - return new Argument<>(ArgumentType.STRING, string -> { - for (String arg : commands){ - if (string.equals(arg)) return true; - } - return false; - }, s -> { - if (s.isEmpty()) { - return tabCompletes; - } - return commands; - }); - } - - public static Argument ofIgnoreCase(String argument) { - return new Argument<>(ArgumentType.STRING, string -> string.equalsIgnoreCase(argument), argument); - } - - public static Argument ofIgnoreCase(String... arguments) { - return new Argument<>(ArgumentType.STRING, string -> { - for (String arg : arguments) { - if (string.equalsIgnoreCase(arg)) return true; - } - return false; - }, arguments); - } - - public static Argument ofIgnoreCase(String[] commands, String[] tabCompletes) { - return new Argument<>(ArgumentType.STRING, string -> { - for (String arg : commands){ - if (string.equalsIgnoreCase(arg)) return true; - } - return false; - }, s -> { - if (s.isEmpty()) { - return tabCompletes; - } - return commands; - }); - } - - public static Argument above(int minValue, int... tabValues) { - return between(minValue, Integer.MAX_VALUE, tabValues); - } - - public static Argument below(int maxValue, int... tabValues) { - return between(Integer.MIN_VALUE, maxValue, tabValues); - } - - public static Argument between(int minValue, int maxValue, int... tabValues) { - Predicate predicate = i -> i >= minValue && i <= maxValue; - for (int tabValue : tabValues) { - if (!predicate.test(tabValue)) throw new IllegalArgumentException(); - } - return new Argument<>(ArgumentType.INT, predicate, Arrays.stream(tabValues).mapToObj(i -> i + "").toArray(String[]::new)); - } - - public static Argument above(long minValue, long... tabValues) { - return between(minValue, Long.MAX_VALUE, tabValues); - } - - public static Argument below(long maxValue, long... tabValues) { - return between(Long.MIN_VALUE, maxValue, tabValues); - } - - public static Argument between(long minValue, long maxValue, long... tabValues) { - Predicate predicate = l -> l >= minValue && l <= maxValue; - for (long tabValue : tabValues) { - if (!predicate.test(tabValue)) throw new IllegalArgumentException(); - } - return new Argument<>(ArgumentType.LONG, predicate, Arrays.stream(tabValues).mapToObj(l -> l + "").toArray(String[]::new)); - } - - public static Argument above(float minValue, float... tabValues) { - return between(minValue, Float.MAX_VALUE, tabValues); - } - - public static Argument below(float maxValue, float... tabValues) { - return between(Float.MIN_VALUE, maxValue, tabValues); - } - - public static Argument between(float minValue, float maxValue, float... tabValues) { - Predicate predicate = f -> f >= minValue && f <= maxValue; - for (float tabValue : tabValues) { - if (!predicate.test(tabValue)) throw new IllegalArgumentException(); - } - String[] strings = new String[tabValues.length]; - for (int i = 0; i < tabValues.length; i++) { - strings[i] = tabValues[i] + ""; - } - return new Argument<>(ArgumentType.FLOAT, predicate, strings); - } - - public static Argument above(double minValue, double... tabValues) { - return between(minValue, Double.MAX_VALUE, tabValues); - } - - public static Argument below(double maxValue, double... tabValues) { - return between(Double.MIN_VALUE, maxValue, tabValues); - } - - public static Argument between(double minValue, double maxValue, double... tabValues) { - Predicate predicate = d -> d >= minValue && d <= maxValue; - for (double tabValue : tabValues) { - if (!predicate.test(tabValue)) throw new IllegalArgumentException(); - } - return new Argument<>(ArgumentType.DOUBLE, predicate, Arrays.stream(tabValues).mapToObj(d -> d + "").toArray(String[]::new)); - } - -} diff --git a/SpigotCore_Main/src/de/steamwar/command/Executor.java b/SpigotCore_Main/src/de/steamwar/command/Executor.java index 26d6bdc..f089b51 100644 --- a/SpigotCore_Main/src/de/steamwar/command/Executor.java +++ b/SpigotCore_Main/src/de/steamwar/command/Executor.java @@ -21,9 +21,9 @@ package de.steamwar.command; -import org.bukkit.entity.Player; +import org.bukkit.command.CommandSender; @FunctionalInterface public interface Executor { - void execute(Player player, ArgumentMap argumentMap); + void execute(CommandSender sender, ArgumentMap argumentMap); } diff --git a/SpigotCore_Main/src/de/steamwar/commandn/InvalidArgumentException.java b/SpigotCore_Main/src/de/steamwar/command/InvalidArgumentException.java similarity index 96% rename from SpigotCore_Main/src/de/steamwar/commandn/InvalidArgumentException.java rename to SpigotCore_Main/src/de/steamwar/command/InvalidArgumentException.java index 4c0fd78..8184b24 100644 --- a/SpigotCore_Main/src/de/steamwar/commandn/InvalidArgumentException.java +++ b/SpigotCore_Main/src/de/steamwar/command/InvalidArgumentException.java @@ -19,7 +19,7 @@ * / */ -package de.steamwar.commandn; +package de.steamwar.command; public class InvalidArgumentException extends Exception { diff --git a/SpigotCore_Main/src/de/steamwar/command/SWCommand.java b/SpigotCore_Main/src/de/steamwar/command/SWCommand.java index 95d0d27..e92e7dc 100644 --- a/SpigotCore_Main/src/de/steamwar/command/SWCommand.java +++ b/SpigotCore_Main/src/de/steamwar/command/SWCommand.java @@ -21,45 +21,50 @@ package de.steamwar.command; -import org.bukkit.entity.Player; +import org.bukkit.command.CommandSender; +import java.util.ArrayList; import java.util.List; -import java.util.Optional; public class SWCommand { - private Argument[] arguments; private Executor executor; + private Argument[] arguments; public SWCommand(Executor executor, Argument... arguments) { - this.arguments = arguments; this.executor = executor; + this.arguments = arguments; } - public boolean execute(Player player, String[] args) { + public boolean execute(CommandSender sender, String[] args) { if (args.length != arguments.length) { return false; } Object[] objects = new Object[args.length]; for (int i = 0; i < args.length; i++) { - Optional optional = arguments[i].valueSupplier(args[i]); - if (!optional.isPresent()) return false; - objects[i] = optional.get(); + try { + objects[i] = arguments[i].parse(sender, args[i]); + } catch (InvalidArgumentException e) { + return false; + } } - executor.execute(player, new ArgumentMap(objects)); + executor.execute(sender, new ArgumentMap(objects)); return true; } - public Optional> tabComplete(String[] args) { + public List tabComplete(CommandSender sender, String[] args) { if (args.length > arguments.length) { - return Optional.empty(); + return new ArrayList<>(); } for (int i = 0; i < args.length - 1; i++) { - Optional optional = arguments[i].valueSupplier(args[i]); - if (!optional.isPresent()) return Optional.empty(); + try { + arguments[i].parse(sender, args[i]); + } catch (InvalidArgumentException e) { + return new ArrayList<>(); + } } int index = args.length - 1; - return arguments[index].tabCompleteSupplier(args[index]); + return arguments[index].tabComplete(sender, args[index]); } } diff --git a/SpigotCore_Main/src/de/steamwar/command/SWCommandBundle.java b/SpigotCore_Main/src/de/steamwar/command/SWCommandBundle.java index d3e2590..1f0f1e1 100644 --- a/SpigotCore_Main/src/de/steamwar/command/SWCommandBundle.java +++ b/SpigotCore_Main/src/de/steamwar/command/SWCommandBundle.java @@ -21,6 +21,7 @@ package de.steamwar.command; +import org.bukkit.command.CommandSender; import org.bukkit.entity.Player; import java.util.ArrayList; @@ -48,17 +49,17 @@ public class SWCommandBundle { return this; } - public boolean execute(Player player, String[] args) { + public boolean execute(CommandSender sender, String[] args) { for (SWCommand swCommand : swCommandList) { - if (swCommand.execute(player, args)) return true; + if (swCommand.execute(sender, args)) return true; } return false; } - public List tabComplete(String[] args) { + public List tabComplete(CommandSender sender, String[] args) { List strings = new ArrayList<>(); for (SWCommand swCommand : swCommandList) { - swCommand.tabComplete(args).ifPresent(strings::addAll); + strings.addAll(swCommand.tabComplete(sender, args)); } return strings; } diff --git a/SpigotCore_Main/src/de/steamwar/commandn/Argument.java b/SpigotCore_Main/src/de/steamwar/commandn/Argument.java deleted file mode 100644 index 92eb7d4..0000000 --- a/SpigotCore_Main/src/de/steamwar/commandn/Argument.java +++ /dev/null @@ -1,53 +0,0 @@ -/* - * - * This file is a part of the SteamWar software. - * - * Copyright (C) 2020 SteamWar.de-Serverteam - * - * This program is free software: you can redistribute it and/or modify - * it under the terms of the GNU Affero General Public License as published by - * the Free Software Foundation, either version 3 of the License, or - * (at your option) any later version. - * - * This program 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 Affero General Public License for more details. - * - * You should have received a copy of the GNU Affero General Public License - * along with this program. If not, see . - * / - */ - -package de.steamwar.commandn; - -import org.bukkit.command.CommandSender; - -import java.util.List; -import java.util.function.BiPredicate; - -public interface Argument { - - T parse(String arg) throws InvalidArgumentException; - void checkConstraints(CommandSender sender, T argument) throws InvalidArgumentException; - - List tabComplete(CommandSender sender, String arg) throws InvalidArgumentException; - default BiPredicate tabCompleteFilter() { - return String::startsWith; - } - - abstract class IntArgument implements Argument { - @Override - public Integer parse(String arg) { - return Integer.parseInt(arg); - } - } - - abstract class DoubleArgument implements Argument { - @Override - public Double parse(String arg) { - return Double.parseDouble(arg); - } - } - -} -- 2.39.2 From da4362b356b0034bfbf11dd26dc228b70f0d63fd Mon Sep 17 00:00:00 2001 From: jojo Date: Wed, 30 Dec 2020 12:44:06 +0100 Subject: [PATCH 27/53] Revert "Simplify CommandFramework" This reverts commit 3687b4b2 --- .../src/de/steamwar/command/Argument.java | 119 ++++++++++++-- .../src/de/steamwar/command/ArgumentType.java | 43 +++++ .../de/steamwar/command/ArgumentUtils.java | 155 ++++++++++++++++++ .../src/de/steamwar/command/Executor.java | 4 +- .../src/de/steamwar/command/SWCommand.java | 33 ++-- .../de/steamwar/command/SWCommandBundle.java | 9 +- .../src/de/steamwar/commandn/Argument.java | 53 ++++++ .../InvalidArgumentException.java | 2 +- 8 files changed, 373 insertions(+), 45 deletions(-) create mode 100644 SpigotCore_Main/src/de/steamwar/command/ArgumentType.java create mode 100644 SpigotCore_Main/src/de/steamwar/command/ArgumentUtils.java create mode 100644 SpigotCore_Main/src/de/steamwar/commandn/Argument.java rename SpigotCore_Main/src/de/steamwar/{command => commandn}/InvalidArgumentException.java (96%) diff --git a/SpigotCore_Main/src/de/steamwar/command/Argument.java b/SpigotCore_Main/src/de/steamwar/command/Argument.java index 9ed1b57..0a6b106 100644 --- a/SpigotCore_Main/src/de/steamwar/command/Argument.java +++ b/SpigotCore_Main/src/de/steamwar/command/Argument.java @@ -21,34 +21,117 @@ package de.steamwar.command; -import org.bukkit.command.CommandSender; +import org.bukkit.*; +import org.bukkit.entity.EntityType; +import org.bukkit.entity.Player; -import java.util.List; -import java.util.function.BiPredicate; +import java.util.*; +import java.util.function.Function; +import java.util.function.Predicate; +import java.util.function.Supplier; +import java.util.stream.Collectors; -public interface Argument { +public class Argument { - T parse(CommandSender sender, String arg) throws InvalidArgumentException; - default void checkConstraints(CommandSender sender, T argument) throws InvalidArgumentException { + public static final Argument BOOLEAN = new Argument<>(ArgumentType.BOOLEAN, bool -> true, "true", "false"); + public static final Argument INT = new Argument<>(ArgumentType.INT, integer -> true); + public static final Argument LONG = new Argument<>(ArgumentType.LONG, l -> true); + public static final Argument FLOAT = new Argument<>(ArgumentType.FLOAT, f -> true); + public static final Argument DOUBLE = new Argument<>(ArgumentType.DOUBLE, d -> true); + public static final Argument STRING = new Argument<>(ArgumentType.STRING, string -> true); + + public static final Argument PLAYER = new Argument<>(ArgumentType.STRING, string -> Bukkit.getPlayer(string) == null, Bukkit::getPlayer, () -> Bukkit.getOnlinePlayers().stream().map(Player::getName).toArray(String[]::new)); + + public static final Argument GAMEMODE = new Argument<>(ArgumentType.STRING, + string -> string.equalsIgnoreCase("creative") || string.equalsIgnoreCase("c") || string.equalsIgnoreCase("1") || + string.equalsIgnoreCase("survival") || string.equalsIgnoreCase("s") || string.equalsIgnoreCase("0") || + string.equalsIgnoreCase("spectator") || string.equalsIgnoreCase("sp") || string.equalsIgnoreCase("3") || + string.equalsIgnoreCase("adventure") || string.equalsIgnoreCase("a") || string.equalsIgnoreCase("2"), + s -> { + if (s.equalsIgnoreCase("creative") || s.equalsIgnoreCase("c") || s.equalsIgnoreCase("1")) return GameMode.CREATIVE; + if (s.equalsIgnoreCase("spectator") || s.equalsIgnoreCase("sp") || s.equalsIgnoreCase("3")) return GameMode.SPECTATOR; + if (s.equalsIgnoreCase("adventure") || s.equalsIgnoreCase("a") || s.equalsIgnoreCase("2")) return GameMode.ADVENTURE; + return GameMode.SURVIVAL; + }, () -> new String[]{"creative", "survival", "adventure", "spectator"}); + + private static final String[] materialArray = Arrays.stream(Material.values()).map(Enum::name).toArray(String[]::new); + public static final Argument MATERIAL = new Argument<>(ArgumentType.STRING, string -> Material.valueOf(string) != null, Material::valueOf, () -> materialArray); + + private static final String[] particleArray = Arrays.stream(Particle.values()).map(Enum::name).toArray(String[]::new); + public static final Argument PARTICLE = new Argument<>(ArgumentType.STRING, string -> Particle.valueOf(string) != null, Particle::valueOf, () -> particleArray); + + private static final String[] entityArray = Arrays.stream(EntityType.values()).map(Enum::name).toArray(String[]::new); + public static final Argument ENTITY = new Argument<>(ArgumentType.STRING, string -> EntityType.valueOf(string) != null, EntityType::valueOf, () -> entityArray); + + private static final String[] soundArray = Arrays.stream(Sound.values()).map(Enum::name).toArray(String[]::new); + public static final Argument SOUND = new Argument<>(ArgumentType.STRING, string -> Sound.valueOf(string) != null, Sound::valueOf, () -> soundArray); + + private static final String[] soundCategoryArray = Arrays.stream(SoundCategory.values()).map(Enum::name).toArray(String[]::new); + public static final Argument SOUND_CATEGORY = new Argument<>(ArgumentType.STRING, string -> SoundCategory.valueOf(string) != null, SoundCategory::valueOf, () -> soundCategoryArray); + + private ArgumentType argumentType; + private Predicate constraint; + private Function tabCompletes; + private Function valueMapper; + + public Argument(ArgumentType argumentType, Predicate constraint, String... tabCompletes) { + this(argumentType, constraint, o -> o, () -> tabCompletes); } - List tabComplete(CommandSender sender, String arg); - default BiPredicate tabCompleteFilter() { - return String::startsWith; + public Argument(ArgumentType argumentType, Predicate constraint, Supplier tabCompletes) { + this(argumentType, constraint, o -> o, tabCompletes); } - abstract class IntArgument implements Argument { - @Override - public Integer parse(CommandSender sender, String arg) { - return Integer.parseInt(arg); + public Argument(ArgumentType argumentType, Predicate constraint, Function tabCompletes) { + this(argumentType, constraint, o -> o, tabCompletes); + } + + public Argument(ArgumentType argumentType, Predicate constraint, Function valueMapper, Supplier tabCompletes) { + this(argumentType, constraint, valueMapper, s -> tabCompletes.get()); + } + + public Argument(ArgumentType argumentType, Predicate constraint, Function valueMapper, Function tabCompletes) { + this.argumentType = argumentType; + this.constraint = constraint; + this.valueMapper = valueMapper; + this.tabCompletes = tabCompletes; + } + + public Optional valueSupplier(String s) { + try { + T argumentMapped = argumentType.mapper.apply(s); + if (constraint.test(argumentMapped)) { + return Optional.ofNullable(valueMapper.apply(argumentMapped)); + } + } catch (NumberFormatException e) { + return Optional.empty(); + } catch (Exception e) { + throw new SecurityException(e); + } + return Optional.empty(); + } + + public Optional> tabCompleteSupplier(String s) { + try { + if (!s.isEmpty()) { + // Check if mappable + T argumentMapped = argumentType.mapper.apply(s); + // Check number constraints if needed + if (argumentType.number && !constraint.test(argumentMapped)) return Optional.empty(); + } + return Optional.of(Arrays.stream(tabCompletes.apply(s)).filter(t -> t.startsWith(s)).collect(Collectors.toList())); + } catch (NumberFormatException e) { + return Optional.empty(); + } catch (Exception e) { + throw new SecurityException(e); } } - abstract class DoubleArgument implements Argument { - @Override - public Double parse(CommandSender sender, String arg) { - return Double.parseDouble(arg); - } + @Override + public String toString() { + return "Argument{" + + "tabCompletes=" + Arrays.toString(tabCompletes.apply("")) + + '}'; } } diff --git a/SpigotCore_Main/src/de/steamwar/command/ArgumentType.java b/SpigotCore_Main/src/de/steamwar/command/ArgumentType.java new file mode 100644 index 0000000..9927841 --- /dev/null +++ b/SpigotCore_Main/src/de/steamwar/command/ArgumentType.java @@ -0,0 +1,43 @@ +/* + * + * This file is a part of the SteamWar software. + * + * Copyright (C) 2020 SteamWar.de-Serverteam + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Affero General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program 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 Affero General Public License for more details. + * + * You should have received a copy of the GNU Affero General Public License + * along with this program. If not, see . + * / + */ + +package de.steamwar.command; + +import java.util.function.Function; + +public class ArgumentType { + + public static final ArgumentType BOOLEAN = new ArgumentType<>(Boolean::parseBoolean, false); + public static final ArgumentType INT = new ArgumentType<>(Integer::parseInt, true); + public static final ArgumentType LONG = new ArgumentType<>(Long::parseLong, true); + public static final ArgumentType FLOAT = new ArgumentType<>(Float::parseFloat, true); + public static final ArgumentType DOUBLE = new ArgumentType<>(Double::parseDouble, true); + public static final ArgumentType STRING = new ArgumentType<>(s -> s, false); + + Function mapper; + boolean number; + + private ArgumentType(Function mapper, boolean number) { + this.mapper = mapper; + this.number = number; + } + +} diff --git a/SpigotCore_Main/src/de/steamwar/command/ArgumentUtils.java b/SpigotCore_Main/src/de/steamwar/command/ArgumentUtils.java new file mode 100644 index 0000000..7e325cc --- /dev/null +++ b/SpigotCore_Main/src/de/steamwar/command/ArgumentUtils.java @@ -0,0 +1,155 @@ +/* + * + * This file is a part of the SteamWar software. + * + * Copyright (C) 2020 SteamWar.de-Serverteam + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Affero General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program 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 Affero General Public License for more details. + * + * You should have received a copy of the GNU Affero General Public License + * along with this program. If not, see . + * / + */ + +package de.steamwar.command; + +import java.util.Arrays; +import java.util.function.Predicate; + +public class ArgumentUtils { + + private ArgumentUtils() { + throw new IllegalStateException("Utility class"); + } + + public static Argument of(String argument) { + return new Argument<>(ArgumentType.STRING, string -> string.equals(argument), argument); + } + + public static Argument of(String... arguments) { + return new Argument<>(ArgumentType.STRING, string -> { + for (String arg : arguments) { + if (string.equals(arg)) return true; + } + return false; + }, arguments); + } + + public static Argument of(String[] commands, String[] tabCompletes) { + return new Argument<>(ArgumentType.STRING, string -> { + for (String arg : commands){ + if (string.equals(arg)) return true; + } + return false; + }, s -> { + if (s.isEmpty()) { + return tabCompletes; + } + return commands; + }); + } + + public static Argument ofIgnoreCase(String argument) { + return new Argument<>(ArgumentType.STRING, string -> string.equalsIgnoreCase(argument), argument); + } + + public static Argument ofIgnoreCase(String... arguments) { + return new Argument<>(ArgumentType.STRING, string -> { + for (String arg : arguments) { + if (string.equalsIgnoreCase(arg)) return true; + } + return false; + }, arguments); + } + + public static Argument ofIgnoreCase(String[] commands, String[] tabCompletes) { + return new Argument<>(ArgumentType.STRING, string -> { + for (String arg : commands){ + if (string.equalsIgnoreCase(arg)) return true; + } + return false; + }, s -> { + if (s.isEmpty()) { + return tabCompletes; + } + return commands; + }); + } + + public static Argument above(int minValue, int... tabValues) { + return between(minValue, Integer.MAX_VALUE, tabValues); + } + + public static Argument below(int maxValue, int... tabValues) { + return between(Integer.MIN_VALUE, maxValue, tabValues); + } + + public static Argument between(int minValue, int maxValue, int... tabValues) { + Predicate predicate = i -> i >= minValue && i <= maxValue; + for (int tabValue : tabValues) { + if (!predicate.test(tabValue)) throw new IllegalArgumentException(); + } + return new Argument<>(ArgumentType.INT, predicate, Arrays.stream(tabValues).mapToObj(i -> i + "").toArray(String[]::new)); + } + + public static Argument above(long minValue, long... tabValues) { + return between(minValue, Long.MAX_VALUE, tabValues); + } + + public static Argument below(long maxValue, long... tabValues) { + return between(Long.MIN_VALUE, maxValue, tabValues); + } + + public static Argument between(long minValue, long maxValue, long... tabValues) { + Predicate predicate = l -> l >= minValue && l <= maxValue; + for (long tabValue : tabValues) { + if (!predicate.test(tabValue)) throw new IllegalArgumentException(); + } + return new Argument<>(ArgumentType.LONG, predicate, Arrays.stream(tabValues).mapToObj(l -> l + "").toArray(String[]::new)); + } + + public static Argument above(float minValue, float... tabValues) { + return between(minValue, Float.MAX_VALUE, tabValues); + } + + public static Argument below(float maxValue, float... tabValues) { + return between(Float.MIN_VALUE, maxValue, tabValues); + } + + public static Argument between(float minValue, float maxValue, float... tabValues) { + Predicate predicate = f -> f >= minValue && f <= maxValue; + for (float tabValue : tabValues) { + if (!predicate.test(tabValue)) throw new IllegalArgumentException(); + } + String[] strings = new String[tabValues.length]; + for (int i = 0; i < tabValues.length; i++) { + strings[i] = tabValues[i] + ""; + } + return new Argument<>(ArgumentType.FLOAT, predicate, strings); + } + + public static Argument above(double minValue, double... tabValues) { + return between(minValue, Double.MAX_VALUE, tabValues); + } + + public static Argument below(double maxValue, double... tabValues) { + return between(Double.MIN_VALUE, maxValue, tabValues); + } + + public static Argument between(double minValue, double maxValue, double... tabValues) { + Predicate predicate = d -> d >= minValue && d <= maxValue; + for (double tabValue : tabValues) { + if (!predicate.test(tabValue)) throw new IllegalArgumentException(); + } + return new Argument<>(ArgumentType.DOUBLE, predicate, Arrays.stream(tabValues).mapToObj(d -> d + "").toArray(String[]::new)); + } + +} diff --git a/SpigotCore_Main/src/de/steamwar/command/Executor.java b/SpigotCore_Main/src/de/steamwar/command/Executor.java index f089b51..26d6bdc 100644 --- a/SpigotCore_Main/src/de/steamwar/command/Executor.java +++ b/SpigotCore_Main/src/de/steamwar/command/Executor.java @@ -21,9 +21,9 @@ package de.steamwar.command; -import org.bukkit.command.CommandSender; +import org.bukkit.entity.Player; @FunctionalInterface public interface Executor { - void execute(CommandSender sender, ArgumentMap argumentMap); + void execute(Player player, ArgumentMap argumentMap); } diff --git a/SpigotCore_Main/src/de/steamwar/command/SWCommand.java b/SpigotCore_Main/src/de/steamwar/command/SWCommand.java index e92e7dc..95d0d27 100644 --- a/SpigotCore_Main/src/de/steamwar/command/SWCommand.java +++ b/SpigotCore_Main/src/de/steamwar/command/SWCommand.java @@ -21,50 +21,45 @@ package de.steamwar.command; -import org.bukkit.command.CommandSender; +import org.bukkit.entity.Player; -import java.util.ArrayList; import java.util.List; +import java.util.Optional; public class SWCommand { - private Executor executor; private Argument[] arguments; + private Executor executor; public SWCommand(Executor executor, Argument... arguments) { - this.executor = executor; this.arguments = arguments; + this.executor = executor; } - public boolean execute(CommandSender sender, String[] args) { + public boolean execute(Player player, String[] args) { if (args.length != arguments.length) { return false; } Object[] objects = new Object[args.length]; for (int i = 0; i < args.length; i++) { - try { - objects[i] = arguments[i].parse(sender, args[i]); - } catch (InvalidArgumentException e) { - return false; - } + Optional optional = arguments[i].valueSupplier(args[i]); + if (!optional.isPresent()) return false; + objects[i] = optional.get(); } - executor.execute(sender, new ArgumentMap(objects)); + executor.execute(player, new ArgumentMap(objects)); return true; } - public List tabComplete(CommandSender sender, String[] args) { + public Optional> tabComplete(String[] args) { if (args.length > arguments.length) { - return new ArrayList<>(); + return Optional.empty(); } for (int i = 0; i < args.length - 1; i++) { - try { - arguments[i].parse(sender, args[i]); - } catch (InvalidArgumentException e) { - return new ArrayList<>(); - } + Optional optional = arguments[i].valueSupplier(args[i]); + if (!optional.isPresent()) return Optional.empty(); } int index = args.length - 1; - return arguments[index].tabComplete(sender, args[index]); + return arguments[index].tabCompleteSupplier(args[index]); } } diff --git a/SpigotCore_Main/src/de/steamwar/command/SWCommandBundle.java b/SpigotCore_Main/src/de/steamwar/command/SWCommandBundle.java index 1f0f1e1..d3e2590 100644 --- a/SpigotCore_Main/src/de/steamwar/command/SWCommandBundle.java +++ b/SpigotCore_Main/src/de/steamwar/command/SWCommandBundle.java @@ -21,7 +21,6 @@ package de.steamwar.command; -import org.bukkit.command.CommandSender; import org.bukkit.entity.Player; import java.util.ArrayList; @@ -49,17 +48,17 @@ public class SWCommandBundle { return this; } - public boolean execute(CommandSender sender, String[] args) { + public boolean execute(Player player, String[] args) { for (SWCommand swCommand : swCommandList) { - if (swCommand.execute(sender, args)) return true; + if (swCommand.execute(player, args)) return true; } return false; } - public List tabComplete(CommandSender sender, String[] args) { + public List tabComplete(String[] args) { List strings = new ArrayList<>(); for (SWCommand swCommand : swCommandList) { - strings.addAll(swCommand.tabComplete(sender, args)); + swCommand.tabComplete(args).ifPresent(strings::addAll); } return strings; } diff --git a/SpigotCore_Main/src/de/steamwar/commandn/Argument.java b/SpigotCore_Main/src/de/steamwar/commandn/Argument.java new file mode 100644 index 0000000..92eb7d4 --- /dev/null +++ b/SpigotCore_Main/src/de/steamwar/commandn/Argument.java @@ -0,0 +1,53 @@ +/* + * + * This file is a part of the SteamWar software. + * + * Copyright (C) 2020 SteamWar.de-Serverteam + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Affero General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program 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 Affero General Public License for more details. + * + * You should have received a copy of the GNU Affero General Public License + * along with this program. If not, see . + * / + */ + +package de.steamwar.commandn; + +import org.bukkit.command.CommandSender; + +import java.util.List; +import java.util.function.BiPredicate; + +public interface Argument { + + T parse(String arg) throws InvalidArgumentException; + void checkConstraints(CommandSender sender, T argument) throws InvalidArgumentException; + + List tabComplete(CommandSender sender, String arg) throws InvalidArgumentException; + default BiPredicate tabCompleteFilter() { + return String::startsWith; + } + + abstract class IntArgument implements Argument { + @Override + public Integer parse(String arg) { + return Integer.parseInt(arg); + } + } + + abstract class DoubleArgument implements Argument { + @Override + public Double parse(String arg) { + return Double.parseDouble(arg); + } + } + +} diff --git a/SpigotCore_Main/src/de/steamwar/command/InvalidArgumentException.java b/SpigotCore_Main/src/de/steamwar/commandn/InvalidArgumentException.java similarity index 96% rename from SpigotCore_Main/src/de/steamwar/command/InvalidArgumentException.java rename to SpigotCore_Main/src/de/steamwar/commandn/InvalidArgumentException.java index 8184b24..4c0fd78 100644 --- a/SpigotCore_Main/src/de/steamwar/command/InvalidArgumentException.java +++ b/SpigotCore_Main/src/de/steamwar/commandn/InvalidArgumentException.java @@ -19,7 +19,7 @@ * / */ -package de.steamwar.command; +package de.steamwar.commandn; public class InvalidArgumentException extends Exception { -- 2.39.2 From b72f7b698e907cfed26b2b8df6f5d9200a948933 Mon Sep 17 00:00:00 2001 From: jojo Date: Wed, 30 Dec 2020 13:18:39 +0100 Subject: [PATCH 28/53] Simplify Argument Remove ArgumentType.java --- .../src/de/steamwar/command/Argument.java | 96 ++++++++++--------- .../src/de/steamwar/command/ArgumentType.java | 43 --------- .../de/steamwar/command/ArgumentUtils.java | 31 +++--- 3 files changed, 69 insertions(+), 101 deletions(-) delete mode 100644 SpigotCore_Main/src/de/steamwar/command/ArgumentType.java diff --git a/SpigotCore_Main/src/de/steamwar/command/Argument.java b/SpigotCore_Main/src/de/steamwar/command/Argument.java index 0a6b106..d481f12 100644 --- a/SpigotCore_Main/src/de/steamwar/command/Argument.java +++ b/SpigotCore_Main/src/de/steamwar/command/Argument.java @@ -33,75 +33,83 @@ import java.util.stream.Collectors; public class Argument { - public static final Argument BOOLEAN = new Argument<>(ArgumentType.BOOLEAN, bool -> true, "true", "false"); - public static final Argument INT = new Argument<>(ArgumentType.INT, integer -> true); - public static final Argument LONG = new Argument<>(ArgumentType.LONG, l -> true); - public static final Argument FLOAT = new Argument<>(ArgumentType.FLOAT, f -> true); - public static final Argument DOUBLE = new Argument<>(ArgumentType.DOUBLE, d -> true); - public static final Argument STRING = new Argument<>(ArgumentType.STRING, string -> true); + private static final Set> numbers = new HashSet<>(); + static { + numbers.add(Integer.class); + numbers.add(Long.class); + numbers.add(Double.class); + numbers.add(Float.class); + } - public static final Argument PLAYER = new Argument<>(ArgumentType.STRING, string -> Bukkit.getPlayer(string) == null, Bukkit::getPlayer, () -> Bukkit.getOnlinePlayers().stream().map(Player::getName).toArray(String[]::new)); + public static final Argument BOOLEAN = new Argument<>(Boolean::parseBoolean, bool -> true, "true", "false"); + public static final Argument INT = new Argument<>(Integer::parseInt, integer -> true); + public static final Argument LONG = new Argument<>(Long::parseLong, l -> true); + public static final Argument FLOAT = new Argument<>(Float::parseFloat, f -> true); + public static final Argument DOUBLE = new Argument<>(Double::parseDouble, d -> true); + public static final Argument STRING = new Argument<>(s -> s, string -> true); - public static final Argument GAMEMODE = new Argument<>(ArgumentType.STRING, - string -> string.equalsIgnoreCase("creative") || string.equalsIgnoreCase("c") || string.equalsIgnoreCase("1") || - string.equalsIgnoreCase("survival") || string.equalsIgnoreCase("s") || string.equalsIgnoreCase("0") || - string.equalsIgnoreCase("spectator") || string.equalsIgnoreCase("sp") || string.equalsIgnoreCase("3") || - string.equalsIgnoreCase("adventure") || string.equalsIgnoreCase("a") || string.equalsIgnoreCase("2"), - s -> { - if (s.equalsIgnoreCase("creative") || s.equalsIgnoreCase("c") || s.equalsIgnoreCase("1")) return GameMode.CREATIVE; - if (s.equalsIgnoreCase("spectator") || s.equalsIgnoreCase("sp") || s.equalsIgnoreCase("3")) return GameMode.SPECTATOR; - if (s.equalsIgnoreCase("adventure") || s.equalsIgnoreCase("a") || s.equalsIgnoreCase("2")) return GameMode.ADVENTURE; - return GameMode.SURVIVAL; - }, () -> new String[]{"creative", "survival", "adventure", "spectator"}); + public static final Argument PLAYER = new Argument<>(Bukkit::getPlayer, Objects::nonNull, () -> Bukkit.getOnlinePlayers().stream().map(Player::getName).toArray(String[]::new)); + + public static final Argument GAMEMODE = new Argument<>(s -> { + switch (s) { + case "creative": + case "c": + case "1": + return GameMode.CREATIVE; + case "survival": + case "s": + case "0": + return GameMode.SURVIVAL; + case "spectator": + case "sp": + case "3": + return GameMode.SPECTATOR; + case "adventure": + case "a": + case "2": + return GameMode.ADVENTURE; + } + return null; + }, Objects::nonNull, "creative", "survival", "spectator"); private static final String[] materialArray = Arrays.stream(Material.values()).map(Enum::name).toArray(String[]::new); - public static final Argument MATERIAL = new Argument<>(ArgumentType.STRING, string -> Material.valueOf(string) != null, Material::valueOf, () -> materialArray); + public static final Argument MATERIAL = new Argument<>(Material::valueOf, Objects::nonNull, materialArray); private static final String[] particleArray = Arrays.stream(Particle.values()).map(Enum::name).toArray(String[]::new); - public static final Argument PARTICLE = new Argument<>(ArgumentType.STRING, string -> Particle.valueOf(string) != null, Particle::valueOf, () -> particleArray); + public static final Argument PARTICLE = new Argument<>(Particle::valueOf, Objects::nonNull, particleArray); private static final String[] entityArray = Arrays.stream(EntityType.values()).map(Enum::name).toArray(String[]::new); - public static final Argument ENTITY = new Argument<>(ArgumentType.STRING, string -> EntityType.valueOf(string) != null, EntityType::valueOf, () -> entityArray); + public static final Argument ENTITY = new Argument<>(EntityType::valueOf, Objects::nonNull, entityArray); private static final String[] soundArray = Arrays.stream(Sound.values()).map(Enum::name).toArray(String[]::new); - public static final Argument SOUND = new Argument<>(ArgumentType.STRING, string -> Sound.valueOf(string) != null, Sound::valueOf, () -> soundArray); + public static final Argument SOUND = new Argument<>(Sound::valueOf, Objects::nonNull, soundArray); private static final String[] soundCategoryArray = Arrays.stream(SoundCategory.values()).map(Enum::name).toArray(String[]::new); - public static final Argument SOUND_CATEGORY = new Argument<>(ArgumentType.STRING, string -> SoundCategory.valueOf(string) != null, SoundCategory::valueOf, () -> soundCategoryArray); + public static final Argument SOUND_CATEGORY = new Argument<>(SoundCategory::valueOf, Objects::nonNull, soundCategoryArray); - private ArgumentType argumentType; + private Function mapper; private Predicate constraint; private Function tabCompletes; - private Function valueMapper; - public Argument(ArgumentType argumentType, Predicate constraint, String... tabCompletes) { - this(argumentType, constraint, o -> o, () -> tabCompletes); + public Argument(Function mapper, Predicate constraint, String... tabCompletes) { + this(mapper, constraint, () -> tabCompletes); } - public Argument(ArgumentType argumentType, Predicate constraint, Supplier tabCompletes) { - this(argumentType, constraint, o -> o, tabCompletes); + public Argument(Function mapper, Predicate constraint, Supplier tabCompletes) { + this(mapper, constraint, s -> tabCompletes.get()); } - public Argument(ArgumentType argumentType, Predicate constraint, Function tabCompletes) { - this(argumentType, constraint, o -> o, tabCompletes); - } - - public Argument(ArgumentType argumentType, Predicate constraint, Function valueMapper, Supplier tabCompletes) { - this(argumentType, constraint, valueMapper, s -> tabCompletes.get()); - } - - public Argument(ArgumentType argumentType, Predicate constraint, Function valueMapper, Function tabCompletes) { - this.argumentType = argumentType; + public Argument(Function mapper, Predicate constraint, Function tabCompletes) { + this.mapper = mapper; this.constraint = constraint; - this.valueMapper = valueMapper; this.tabCompletes = tabCompletes; } public Optional valueSupplier(String s) { try { - T argumentMapped = argumentType.mapper.apply(s); + T argumentMapped = mapper.apply(s); if (constraint.test(argumentMapped)) { - return Optional.ofNullable(valueMapper.apply(argumentMapped)); + return Optional.ofNullable(argumentMapped); } } catch (NumberFormatException e) { return Optional.empty(); @@ -115,9 +123,9 @@ public class Argument { try { if (!s.isEmpty()) { // Check if mappable - T argumentMapped = argumentType.mapper.apply(s); + T argumentMapped = mapper.apply(s); // Check number constraints if needed - if (argumentType.number && !constraint.test(argumentMapped)) return Optional.empty(); + if (numbers.contains(argumentMapped.getClass()) && !constraint.test(argumentMapped)) return Optional.empty(); } return Optional.of(Arrays.stream(tabCompletes.apply(s)).filter(t -> t.startsWith(s)).collect(Collectors.toList())); } catch (NumberFormatException e) { diff --git a/SpigotCore_Main/src/de/steamwar/command/ArgumentType.java b/SpigotCore_Main/src/de/steamwar/command/ArgumentType.java deleted file mode 100644 index 9927841..0000000 --- a/SpigotCore_Main/src/de/steamwar/command/ArgumentType.java +++ /dev/null @@ -1,43 +0,0 @@ -/* - * - * This file is a part of the SteamWar software. - * - * Copyright (C) 2020 SteamWar.de-Serverteam - * - * This program is free software: you can redistribute it and/or modify - * it under the terms of the GNU Affero General Public License as published by - * the Free Software Foundation, either version 3 of the License, or - * (at your option) any later version. - * - * This program 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 Affero General Public License for more details. - * - * You should have received a copy of the GNU Affero General Public License - * along with this program. If not, see . - * / - */ - -package de.steamwar.command; - -import java.util.function.Function; - -public class ArgumentType { - - public static final ArgumentType BOOLEAN = new ArgumentType<>(Boolean::parseBoolean, false); - public static final ArgumentType INT = new ArgumentType<>(Integer::parseInt, true); - public static final ArgumentType LONG = new ArgumentType<>(Long::parseLong, true); - public static final ArgumentType FLOAT = new ArgumentType<>(Float::parseFloat, true); - public static final ArgumentType DOUBLE = new ArgumentType<>(Double::parseDouble, true); - public static final ArgumentType STRING = new ArgumentType<>(s -> s, false); - - Function mapper; - boolean number; - - private ArgumentType(Function mapper, boolean number) { - this.mapper = mapper; - this.number = number; - } - -} diff --git a/SpigotCore_Main/src/de/steamwar/command/ArgumentUtils.java b/SpigotCore_Main/src/de/steamwar/command/ArgumentUtils.java index 7e325cc..6ab22dd 100644 --- a/SpigotCore_Main/src/de/steamwar/command/ArgumentUtils.java +++ b/SpigotCore_Main/src/de/steamwar/command/ArgumentUtils.java @@ -31,11 +31,11 @@ public class ArgumentUtils { } public static Argument of(String argument) { - return new Argument<>(ArgumentType.STRING, string -> string.equals(argument), argument); + return new Argument<>(s -> s, string -> string.equals(argument), argument); } public static Argument of(String... arguments) { - return new Argument<>(ArgumentType.STRING, string -> { + return new Argument<>(s -> s, string -> { for (String arg : arguments) { if (string.equals(arg)) return true; } @@ -44,8 +44,8 @@ public class ArgumentUtils { } public static Argument of(String[] commands, String[] tabCompletes) { - return new Argument<>(ArgumentType.STRING, string -> { - for (String arg : commands){ + return new Argument<>(s -> s, string -> { + for (String arg : commands) { if (string.equals(arg)) return true; } return false; @@ -58,11 +58,11 @@ public class ArgumentUtils { } public static Argument ofIgnoreCase(String argument) { - return new Argument<>(ArgumentType.STRING, string -> string.equalsIgnoreCase(argument), argument); + return new Argument<>(s -> s, string -> string.equalsIgnoreCase(argument), argument); } public static Argument ofIgnoreCase(String... arguments) { - return new Argument<>(ArgumentType.STRING, string -> { + return new Argument<>(s -> s, string -> { for (String arg : arguments) { if (string.equalsIgnoreCase(arg)) return true; } @@ -71,8 +71,8 @@ public class ArgumentUtils { } public static Argument ofIgnoreCase(String[] commands, String[] tabCompletes) { - return new Argument<>(ArgumentType.STRING, string -> { - for (String arg : commands){ + return new Argument<>(s -> s, string -> { + for (String arg : commands) { if (string.equalsIgnoreCase(arg)) return true; } return false; @@ -97,7 +97,8 @@ public class ArgumentUtils { for (int tabValue : tabValues) { if (!predicate.test(tabValue)) throw new IllegalArgumentException(); } - return new Argument<>(ArgumentType.INT, predicate, Arrays.stream(tabValues).mapToObj(i -> i + "").toArray(String[]::new)); + String[] array = Arrays.stream(tabValues).mapToObj(i -> i + "").toArray(String[]::new); + return new Argument<>(Integer::parseInt, predicate, array); } public static Argument above(long minValue, long... tabValues) { @@ -113,7 +114,8 @@ public class ArgumentUtils { for (long tabValue : tabValues) { if (!predicate.test(tabValue)) throw new IllegalArgumentException(); } - return new Argument<>(ArgumentType.LONG, predicate, Arrays.stream(tabValues).mapToObj(l -> l + "").toArray(String[]::new)); + String[] array = Arrays.stream(tabValues).mapToObj(l -> l + "").toArray(String[]::new); + return new Argument<>(Long::parseLong, predicate, array); } public static Argument above(float minValue, float... tabValues) { @@ -129,11 +131,11 @@ public class ArgumentUtils { for (float tabValue : tabValues) { if (!predicate.test(tabValue)) throw new IllegalArgumentException(); } - String[] strings = new String[tabValues.length]; + String[] array = new String[tabValues.length]; for (int i = 0; i < tabValues.length; i++) { - strings[i] = tabValues[i] + ""; + array[i] = tabValues[i] + ""; } - return new Argument<>(ArgumentType.FLOAT, predicate, strings); + return new Argument<>(Float::parseFloat, predicate, array); } public static Argument above(double minValue, double... tabValues) { @@ -149,7 +151,8 @@ public class ArgumentUtils { for (double tabValue : tabValues) { if (!predicate.test(tabValue)) throw new IllegalArgumentException(); } - return new Argument<>(ArgumentType.DOUBLE, predicate, Arrays.stream(tabValues).mapToObj(d -> d + "").toArray(String[]::new)); + String[] array = Arrays.stream(tabValues).mapToObj(d -> d + "").toArray(String[]::new); + return new Argument<>(Double::parseDouble, predicate, array); } } -- 2.39.2 From b2894aeecbf31e6b42fb17fde0fe24c32ff417f7 Mon Sep 17 00:00:00 2001 From: jojo Date: Wed, 30 Dec 2020 13:22:44 +0100 Subject: [PATCH 29/53] Simplify Code --- .../src/de/steamwar/command/Argument.java | 1 - .../src/de/steamwar/command/ArgumentMap.java | 3 +- .../de/steamwar/command/ArgumentUtils.java | 1 - .../src/de/steamwar/command/Executor.java | 1 - .../src/de/steamwar/command/SWCommand.java | 1 - .../de/steamwar/command/SWCommandBundle.java | 2 - .../src/de/steamwar/commandn/Argument.java | 53 ------------------- .../commandn/InvalidArgumentException.java | 26 --------- 8 files changed, 1 insertion(+), 87 deletions(-) delete mode 100644 SpigotCore_Main/src/de/steamwar/commandn/Argument.java delete mode 100644 SpigotCore_Main/src/de/steamwar/commandn/InvalidArgumentException.java diff --git a/SpigotCore_Main/src/de/steamwar/command/Argument.java b/SpigotCore_Main/src/de/steamwar/command/Argument.java index d481f12..0fe920d 100644 --- a/SpigotCore_Main/src/de/steamwar/command/Argument.java +++ b/SpigotCore_Main/src/de/steamwar/command/Argument.java @@ -16,7 +16,6 @@ * * You should have received a copy of the GNU Affero General Public License * along with this program. If not, see . - * / */ package de.steamwar.command; diff --git a/SpigotCore_Main/src/de/steamwar/command/ArgumentMap.java b/SpigotCore_Main/src/de/steamwar/command/ArgumentMap.java index 1d3e51f..ba046a7 100644 --- a/SpigotCore_Main/src/de/steamwar/command/ArgumentMap.java +++ b/SpigotCore_Main/src/de/steamwar/command/ArgumentMap.java @@ -15,8 +15,7 @@ * GNU Affero General Public License for more details. * * You should have received a copy of the GNU Affero General Public License - * along with this program. If not, see . - * / + * along with this program. If not, see */ package de.steamwar.command; diff --git a/SpigotCore_Main/src/de/steamwar/command/ArgumentUtils.java b/SpigotCore_Main/src/de/steamwar/command/ArgumentUtils.java index 6ab22dd..5301d9e 100644 --- a/SpigotCore_Main/src/de/steamwar/command/ArgumentUtils.java +++ b/SpigotCore_Main/src/de/steamwar/command/ArgumentUtils.java @@ -16,7 +16,6 @@ * * You should have received a copy of the GNU Affero General Public License * along with this program. If not, see . - * / */ package de.steamwar.command; diff --git a/SpigotCore_Main/src/de/steamwar/command/Executor.java b/SpigotCore_Main/src/de/steamwar/command/Executor.java index 26d6bdc..28fff3e 100644 --- a/SpigotCore_Main/src/de/steamwar/command/Executor.java +++ b/SpigotCore_Main/src/de/steamwar/command/Executor.java @@ -16,7 +16,6 @@ * * You should have received a copy of the GNU Affero General Public License * along with this program. If not, see . - * / */ package de.steamwar.command; diff --git a/SpigotCore_Main/src/de/steamwar/command/SWCommand.java b/SpigotCore_Main/src/de/steamwar/command/SWCommand.java index 95d0d27..34159e9 100644 --- a/SpigotCore_Main/src/de/steamwar/command/SWCommand.java +++ b/SpigotCore_Main/src/de/steamwar/command/SWCommand.java @@ -16,7 +16,6 @@ * * You should have received a copy of the GNU Affero General Public License * along with this program. If not, see . - * / */ package de.steamwar.command; diff --git a/SpigotCore_Main/src/de/steamwar/command/SWCommandBundle.java b/SpigotCore_Main/src/de/steamwar/command/SWCommandBundle.java index d3e2590..52ce3fd 100644 --- a/SpigotCore_Main/src/de/steamwar/command/SWCommandBundle.java +++ b/SpigotCore_Main/src/de/steamwar/command/SWCommandBundle.java @@ -16,7 +16,6 @@ * * You should have received a copy of the GNU Affero General Public License * along with this program. If not, see . - * / */ package de.steamwar.command; @@ -25,7 +24,6 @@ import org.bukkit.entity.Player; import java.util.ArrayList; import java.util.List; -import java.util.Optional; public class SWCommandBundle { diff --git a/SpigotCore_Main/src/de/steamwar/commandn/Argument.java b/SpigotCore_Main/src/de/steamwar/commandn/Argument.java deleted file mode 100644 index 92eb7d4..0000000 --- a/SpigotCore_Main/src/de/steamwar/commandn/Argument.java +++ /dev/null @@ -1,53 +0,0 @@ -/* - * - * This file is a part of the SteamWar software. - * - * Copyright (C) 2020 SteamWar.de-Serverteam - * - * This program is free software: you can redistribute it and/or modify - * it under the terms of the GNU Affero General Public License as published by - * the Free Software Foundation, either version 3 of the License, or - * (at your option) any later version. - * - * This program 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 Affero General Public License for more details. - * - * You should have received a copy of the GNU Affero General Public License - * along with this program. If not, see . - * / - */ - -package de.steamwar.commandn; - -import org.bukkit.command.CommandSender; - -import java.util.List; -import java.util.function.BiPredicate; - -public interface Argument { - - T parse(String arg) throws InvalidArgumentException; - void checkConstraints(CommandSender sender, T argument) throws InvalidArgumentException; - - List tabComplete(CommandSender sender, String arg) throws InvalidArgumentException; - default BiPredicate tabCompleteFilter() { - return String::startsWith; - } - - abstract class IntArgument implements Argument { - @Override - public Integer parse(String arg) { - return Integer.parseInt(arg); - } - } - - abstract class DoubleArgument implements Argument { - @Override - public Double parse(String arg) { - return Double.parseDouble(arg); - } - } - -} diff --git a/SpigotCore_Main/src/de/steamwar/commandn/InvalidArgumentException.java b/SpigotCore_Main/src/de/steamwar/commandn/InvalidArgumentException.java deleted file mode 100644 index 4c0fd78..0000000 --- a/SpigotCore_Main/src/de/steamwar/commandn/InvalidArgumentException.java +++ /dev/null @@ -1,26 +0,0 @@ -/* - * - * This file is a part of the SteamWar software. - * - * Copyright (C) 2020 SteamWar.de-Serverteam - * - * This program is free software: you can redistribute it and/or modify - * it under the terms of the GNU Affero General Public License as published by - * the Free Software Foundation, either version 3 of the License, or - * (at your option) any later version. - * - * This program 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 Affero General Public License for more details. - * - * You should have received a copy of the GNU Affero General Public License - * along with this program. If not, see . - * / - */ - -package de.steamwar.commandn; - -public class InvalidArgumentException extends Exception { - -} -- 2.39.2 From deb25ab789ab705c118ecc956d68d742bfd52c0c Mon Sep 17 00:00:00 2001 From: jojo Date: Wed, 30 Dec 2020 13:24:11 +0100 Subject: [PATCH 30/53] Simplify Argument constructor chain --- SpigotCore_Main/src/de/steamwar/command/Argument.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/SpigotCore_Main/src/de/steamwar/command/Argument.java b/SpigotCore_Main/src/de/steamwar/command/Argument.java index 0fe920d..400a49d 100644 --- a/SpigotCore_Main/src/de/steamwar/command/Argument.java +++ b/SpigotCore_Main/src/de/steamwar/command/Argument.java @@ -91,7 +91,7 @@ public class Argument { private Function tabCompletes; public Argument(Function mapper, Predicate constraint, String... tabCompletes) { - this(mapper, constraint, () -> tabCompletes); + this(mapper, constraint, s -> tabCompletes); } public Argument(Function mapper, Predicate constraint, Supplier tabCompletes) { -- 2.39.2 From cac4cd26e0bbde881c47bbff2a5a1df1137d27ff Mon Sep 17 00:00:00 2001 From: jojo Date: Wed, 30 Dec 2020 13:35:44 +0100 Subject: [PATCH 31/53] Simplify ArgumentUtils Simplify ArgumentMap.toString() Remove Argument.toString() --- .../src/de/steamwar/command/Argument.java | 7 --- .../src/de/steamwar/command/ArgumentMap.java | 13 +--- .../de/steamwar/command/ArgumentUtils.java | 63 ++++++------------- 3 files changed, 20 insertions(+), 63 deletions(-) diff --git a/SpigotCore_Main/src/de/steamwar/command/Argument.java b/SpigotCore_Main/src/de/steamwar/command/Argument.java index 400a49d..ff3ecfd 100644 --- a/SpigotCore_Main/src/de/steamwar/command/Argument.java +++ b/SpigotCore_Main/src/de/steamwar/command/Argument.java @@ -134,11 +134,4 @@ public class Argument { } } - @Override - public String toString() { - return "Argument{" + - "tabCompletes=" + Arrays.toString(tabCompletes.apply("")) + - '}'; - } - } diff --git a/SpigotCore_Main/src/de/steamwar/command/ArgumentMap.java b/SpigotCore_Main/src/de/steamwar/command/ArgumentMap.java index ba046a7..2a62c89 100644 --- a/SpigotCore_Main/src/de/steamwar/command/ArgumentMap.java +++ b/SpigotCore_Main/src/de/steamwar/command/ArgumentMap.java @@ -21,6 +21,7 @@ package de.steamwar.command; import java.util.Arrays; +import java.util.stream.Collectors; public class ArgumentMap { @@ -56,17 +57,7 @@ public class ArgumentMap { @Override public String toString() { - StringBuilder st = new StringBuilder(); - st.append("ArgumentMap{"); - boolean b = false; - for (Object o : objects) { - if (b) st.append(", "); - b = true; - - st.append(o.getClass().getSimpleName()).append("=").append(o); - } - st.append("}"); - return st.toString(); + return "ArgumentMap{" + Arrays.stream(objects).map(o -> o.getClass().getSimpleName() + "=" + o.toString()).collect(Collectors.joining(",")) + "}"; } } diff --git a/SpigotCore_Main/src/de/steamwar/command/ArgumentUtils.java b/SpigotCore_Main/src/de/steamwar/command/ArgumentUtils.java index 5301d9e..4ad0746 100644 --- a/SpigotCore_Main/src/de/steamwar/command/ArgumentUtils.java +++ b/SpigotCore_Main/src/de/steamwar/command/ArgumentUtils.java @@ -21,6 +21,8 @@ package de.steamwar.command; import java.util.Arrays; +import java.util.function.BiPredicate; +import java.util.function.Function; import java.util.function.Predicate; public class ArgumentUtils { @@ -29,29 +31,22 @@ public class ArgumentUtils { throw new IllegalStateException("Utility class"); } + private static boolean contains(String[] arguments, String string, BiPredicate predicate) { + for (String arg : arguments) if (predicate.test(string, arg)) return true; + return false; + } + public static Argument of(String argument) { return new Argument<>(s -> s, string -> string.equals(argument), argument); } public static Argument of(String... arguments) { - return new Argument<>(s -> s, string -> { - for (String arg : arguments) { - if (string.equals(arg)) return true; - } - return false; - }, arguments); + return new Argument<>(s -> s, string -> contains(arguments, string, String::equals), arguments); } public static Argument of(String[] commands, String[] tabCompletes) { - return new Argument<>(s -> s, string -> { - for (String arg : commands) { - if (string.equals(arg)) return true; - } - return false; - }, s -> { - if (s.isEmpty()) { - return tabCompletes; - } + return new Argument<>(s -> s, string -> contains(commands, string, String::equals), s -> { + if (s.isEmpty()) return tabCompletes; return commands; }); } @@ -61,24 +56,12 @@ public class ArgumentUtils { } public static Argument ofIgnoreCase(String... arguments) { - return new Argument<>(s -> s, string -> { - for (String arg : arguments) { - if (string.equalsIgnoreCase(arg)) return true; - } - return false; - }, arguments); + return new Argument<>(s -> s, string -> contains(arguments, string, String::equals), arguments); } public static Argument ofIgnoreCase(String[] commands, String[] tabCompletes) { - return new Argument<>(s -> s, string -> { - for (String arg : commands) { - if (string.equalsIgnoreCase(arg)) return true; - } - return false; - }, s -> { - if (s.isEmpty()) { - return tabCompletes; - } + return new Argument<>(s -> s, string -> contains(commands, string, String::equals), s -> { + if (s.isEmpty()) return tabCompletes; return commands; }); } @@ -93,9 +76,7 @@ public class ArgumentUtils { public static Argument between(int minValue, int maxValue, int... tabValues) { Predicate predicate = i -> i >= minValue && i <= maxValue; - for (int tabValue : tabValues) { - if (!predicate.test(tabValue)) throw new IllegalArgumentException(); - } + for (int tabValue : tabValues) if (!predicate.test(tabValue)) throw new IllegalArgumentException(); String[] array = Arrays.stream(tabValues).mapToObj(i -> i + "").toArray(String[]::new); return new Argument<>(Integer::parseInt, predicate, array); } @@ -110,9 +91,7 @@ public class ArgumentUtils { public static Argument between(long minValue, long maxValue, long... tabValues) { Predicate predicate = l -> l >= minValue && l <= maxValue; - for (long tabValue : tabValues) { - if (!predicate.test(tabValue)) throw new IllegalArgumentException(); - } + for (long tabValue : tabValues) if (!predicate.test(tabValue)) throw new IllegalArgumentException(); String[] array = Arrays.stream(tabValues).mapToObj(l -> l + "").toArray(String[]::new); return new Argument<>(Long::parseLong, predicate, array); } @@ -127,13 +106,9 @@ public class ArgumentUtils { public static Argument between(float minValue, float maxValue, float... tabValues) { Predicate predicate = f -> f >= minValue && f <= maxValue; - for (float tabValue : tabValues) { - if (!predicate.test(tabValue)) throw new IllegalArgumentException(); - } + for (float tabValue : tabValues) if (!predicate.test(tabValue)) throw new IllegalArgumentException(); String[] array = new String[tabValues.length]; - for (int i = 0; i < tabValues.length; i++) { - array[i] = tabValues[i] + ""; - } + for (int i = 0; i < tabValues.length; i++) array[i] = tabValues[i] + ""; return new Argument<>(Float::parseFloat, predicate, array); } @@ -147,9 +122,7 @@ public class ArgumentUtils { public static Argument between(double minValue, double maxValue, double... tabValues) { Predicate predicate = d -> d >= minValue && d <= maxValue; - for (double tabValue : tabValues) { - if (!predicate.test(tabValue)) throw new IllegalArgumentException(); - } + for (double tabValue : tabValues) if (!predicate.test(tabValue)) throw new IllegalArgumentException(); String[] array = Arrays.stream(tabValues).mapToObj(d -> d + "").toArray(String[]::new); return new Argument<>(Double::parseDouble, predicate, array); } -- 2.39.2 From 8d86ee4f162335efeb4851c9d4c4f4025ea8fce5 Mon Sep 17 00:00:00 2001 From: jojo Date: Wed, 30 Dec 2020 13:39:05 +0100 Subject: [PATCH 32/53] Optimize Argument.GAMEMODE --- .../src/de/steamwar/command/Argument.java | 22 +++++-------------- .../de/steamwar/command/ArgumentUtils.java | 1 - 2 files changed, 6 insertions(+), 17 deletions(-) diff --git a/SpigotCore_Main/src/de/steamwar/command/Argument.java b/SpigotCore_Main/src/de/steamwar/command/Argument.java index ff3ecfd..d5b680c 100644 --- a/SpigotCore_Main/src/de/steamwar/command/Argument.java +++ b/SpigotCore_Main/src/de/steamwar/command/Argument.java @@ -50,22 +50,14 @@ public class Argument { public static final Argument PLAYER = new Argument<>(Bukkit::getPlayer, Objects::nonNull, () -> Bukkit.getOnlinePlayers().stream().map(Player::getName).toArray(String[]::new)); public static final Argument GAMEMODE = new Argument<>(s -> { - switch (s) { - case "creative": - case "c": - case "1": + switch (s.toLowerCase()) { + case "creative": case "c": case "1": return GameMode.CREATIVE; - case "survival": - case "s": - case "0": + case "survival": case "s": case "0": return GameMode.SURVIVAL; - case "spectator": - case "sp": - case "3": + case "spectator": case "sp": case "3": return GameMode.SPECTATOR; - case "adventure": - case "a": - case "2": + case "adventure": case "a": case "2": return GameMode.ADVENTURE; } return null; @@ -107,9 +99,7 @@ public class Argument { public Optional valueSupplier(String s) { try { T argumentMapped = mapper.apply(s); - if (constraint.test(argumentMapped)) { - return Optional.ofNullable(argumentMapped); - } + if (constraint.test(argumentMapped)) return Optional.ofNullable(argumentMapped); } catch (NumberFormatException e) { return Optional.empty(); } catch (Exception e) { diff --git a/SpigotCore_Main/src/de/steamwar/command/ArgumentUtils.java b/SpigotCore_Main/src/de/steamwar/command/ArgumentUtils.java index 4ad0746..676482f 100644 --- a/SpigotCore_Main/src/de/steamwar/command/ArgumentUtils.java +++ b/SpigotCore_Main/src/de/steamwar/command/ArgumentUtils.java @@ -22,7 +22,6 @@ package de.steamwar.command; import java.util.Arrays; import java.util.function.BiPredicate; -import java.util.function.Function; import java.util.function.Predicate; public class ArgumentUtils { -- 2.39.2 From 35a4b39758ea9bab40942f1d61755fac8e4cfcd4 Mon Sep 17 00:00:00 2001 From: jojo Date: Wed, 30 Dec 2020 13:53:47 +0100 Subject: [PATCH 33/53] Optimize ArgumentUtils Optimize SWCommand Optimize SWCommandBundle --- .../de/steamwar/command/ArgumentUtils.java | 63 +++---------------- .../src/de/steamwar/command/SWCommand.java | 11 +--- .../de/steamwar/command/SWCommandBundle.java | 4 +- 3 files changed, 13 insertions(+), 65 deletions(-) diff --git a/SpigotCore_Main/src/de/steamwar/command/ArgumentUtils.java b/SpigotCore_Main/src/de/steamwar/command/ArgumentUtils.java index 676482f..65b57d8 100644 --- a/SpigotCore_Main/src/de/steamwar/command/ArgumentUtils.java +++ b/SpigotCore_Main/src/de/steamwar/command/ArgumentUtils.java @@ -35,8 +35,9 @@ public class ArgumentUtils { return false; } - public static Argument of(String argument) { - return new Argument<>(s -> s, string -> string.equals(argument), argument); + private static String[] supply(String s, String[] empty, String[] notEmpty) { + if (s.isEmpty()) return empty; + return notEmpty; } public static Argument of(String... arguments) { @@ -44,14 +45,7 @@ public class ArgumentUtils { } public static Argument of(String[] commands, String[] tabCompletes) { - return new Argument<>(s -> s, string -> contains(commands, string, String::equals), s -> { - if (s.isEmpty()) return tabCompletes; - return commands; - }); - } - - public static Argument ofIgnoreCase(String argument) { - return new Argument<>(s -> s, string -> string.equalsIgnoreCase(argument), argument); + return new Argument<>(s -> s, string -> contains(commands, string, String::equals), s -> supply(s, tabCompletes, commands)); } public static Argument ofIgnoreCase(String... arguments) { @@ -59,70 +53,31 @@ public class ArgumentUtils { } public static Argument ofIgnoreCase(String[] commands, String[] tabCompletes) { - return new Argument<>(s -> s, string -> contains(commands, string, String::equals), s -> { - if (s.isEmpty()) return tabCompletes; - return commands; - }); - } - - public static Argument above(int minValue, int... tabValues) { - return between(minValue, Integer.MAX_VALUE, tabValues); - } - - public static Argument below(int maxValue, int... tabValues) { - return between(Integer.MIN_VALUE, maxValue, tabValues); + return new Argument<>(s -> s, string -> contains(commands, string, String::equals), s -> supply(s, tabCompletes, commands)); } public static Argument between(int minValue, int maxValue, int... tabValues) { Predicate predicate = i -> i >= minValue && i <= maxValue; - for (int tabValue : tabValues) if (!predicate.test(tabValue)) throw new IllegalArgumentException(); - String[] array = Arrays.stream(tabValues).mapToObj(i -> i + "").toArray(String[]::new); + String[] array = Arrays.stream(tabValues).boxed().filter(predicate).map(i -> i + "").toArray(String[]::new); return new Argument<>(Integer::parseInt, predicate, array); } - public static Argument above(long minValue, long... tabValues) { - return between(minValue, Long.MAX_VALUE, tabValues); - } - - public static Argument below(long maxValue, long... tabValues) { - return between(Long.MIN_VALUE, maxValue, tabValues); - } - public static Argument between(long minValue, long maxValue, long... tabValues) { Predicate predicate = l -> l >= minValue && l <= maxValue; - for (long tabValue : tabValues) if (!predicate.test(tabValue)) throw new IllegalArgumentException(); - String[] array = Arrays.stream(tabValues).mapToObj(l -> l + "").toArray(String[]::new); + String[] array = Arrays.stream(tabValues).boxed().filter(predicate).map(l -> l + "").toArray(String[]::new); return new Argument<>(Long::parseLong, predicate, array); } - public static Argument above(float minValue, float... tabValues) { - return between(minValue, Float.MAX_VALUE, tabValues); - } - - public static Argument below(float maxValue, float... tabValues) { - return between(Float.MIN_VALUE, maxValue, tabValues); - } - public static Argument between(float minValue, float maxValue, float... tabValues) { Predicate predicate = f -> f >= minValue && f <= maxValue; - for (float tabValue : tabValues) if (!predicate.test(tabValue)) throw new IllegalArgumentException(); String[] array = new String[tabValues.length]; - for (int i = 0; i < tabValues.length; i++) array[i] = tabValues[i] + ""; + for (int i = 0; i < tabValues.length; i++) if (predicate.test(tabValues[i])) array[i] = tabValues[i] + ""; return new Argument<>(Float::parseFloat, predicate, array); } - public static Argument above(double minValue, double... tabValues) { - return between(minValue, Double.MAX_VALUE, tabValues); - } - - public static Argument below(double maxValue, double... tabValues) { - return between(Double.MIN_VALUE, maxValue, tabValues); - } - public static Argument between(double minValue, double maxValue, double... tabValues) { Predicate predicate = d -> d >= minValue && d <= maxValue; - for (double tabValue : tabValues) if (!predicate.test(tabValue)) throw new IllegalArgumentException(); - String[] array = Arrays.stream(tabValues).mapToObj(d -> d + "").toArray(String[]::new); + String[] array = Arrays.stream(tabValues).boxed().filter(predicate).map(d -> d + "").toArray(String[]::new); return new Argument<>(Double::parseDouble, predicate, array); } diff --git a/SpigotCore_Main/src/de/steamwar/command/SWCommand.java b/SpigotCore_Main/src/de/steamwar/command/SWCommand.java index 34159e9..948c8de 100644 --- a/SpigotCore_Main/src/de/steamwar/command/SWCommand.java +++ b/SpigotCore_Main/src/de/steamwar/command/SWCommand.java @@ -36,9 +36,7 @@ public class SWCommand { } public boolean execute(Player player, String[] args) { - if (args.length != arguments.length) { - return false; - } + if (args.length != arguments.length) return false; Object[] objects = new Object[args.length]; for (int i = 0; i < args.length; i++) { Optional optional = arguments[i].valueSupplier(args[i]); @@ -50,12 +48,9 @@ public class SWCommand { } public Optional> tabComplete(String[] args) { - if (args.length > arguments.length) { - return Optional.empty(); - } + if (args.length > arguments.length) return Optional.empty(); for (int i = 0; i < args.length - 1; i++) { - Optional optional = arguments[i].valueSupplier(args[i]); - if (!optional.isPresent()) return Optional.empty(); + if (!arguments[i].valueSupplier(args[i]).isPresent()) return Optional.empty(); } int index = args.length - 1; return arguments[index].tabCompleteSupplier(args[index]); diff --git a/SpigotCore_Main/src/de/steamwar/command/SWCommandBundle.java b/SpigotCore_Main/src/de/steamwar/command/SWCommandBundle.java index 52ce3fd..1f798ca 100644 --- a/SpigotCore_Main/src/de/steamwar/command/SWCommandBundle.java +++ b/SpigotCore_Main/src/de/steamwar/command/SWCommandBundle.java @@ -55,9 +55,7 @@ public class SWCommandBundle { public List tabComplete(String[] args) { List strings = new ArrayList<>(); - for (SWCommand swCommand : swCommandList) { - swCommand.tabComplete(args).ifPresent(strings::addAll); - } + swCommandList.forEach(swCommand -> swCommand.tabComplete(args).ifPresent(strings::addAll)); return strings; } -- 2.39.2 From fe8c387df5f01075c2834274eec43f452fc6962e Mon Sep 17 00:00:00 2001 From: jojo Date: Wed, 30 Dec 2020 14:07:07 +0100 Subject: [PATCH 34/53] Remove Executor.java Chnage SWCommand Executor to BiConsumer --- .../src/de/steamwar/command/Argument.java | 12 ++++---- .../de/steamwar/command/ArgumentUtils.java | 15 ++++++---- .../src/de/steamwar/command/Executor.java | 28 ------------------- .../src/de/steamwar/command/SWCommand.java | 7 +++-- .../de/steamwar/command/SWCommandBundle.java | 3 +- 5 files changed, 20 insertions(+), 45 deletions(-) delete mode 100644 SpigotCore_Main/src/de/steamwar/command/Executor.java diff --git a/SpigotCore_Main/src/de/steamwar/command/Argument.java b/SpigotCore_Main/src/de/steamwar/command/Argument.java index d5b680c..b02bd93 100644 --- a/SpigotCore_Main/src/de/steamwar/command/Argument.java +++ b/SpigotCore_Main/src/de/steamwar/command/Argument.java @@ -28,6 +28,7 @@ import java.util.*; import java.util.function.Function; import java.util.function.Predicate; import java.util.function.Supplier; +import java.util.logging.Level; import java.util.stream.Collectors; public class Argument { @@ -96,14 +97,12 @@ public class Argument { this.tabCompletes = tabCompletes; } - public Optional valueSupplier(String s) { + public Optional valueSupplier(String s) { try { T argumentMapped = mapper.apply(s); if (constraint.test(argumentMapped)) return Optional.ofNullable(argumentMapped); - } catch (NumberFormatException e) { - return Optional.empty(); } catch (Exception e) { - throw new SecurityException(e); + Bukkit.getLogger().log(Level.SEVERE, e.getMessage(), e); } return Optional.empty(); } @@ -117,10 +116,9 @@ public class Argument { if (numbers.contains(argumentMapped.getClass()) && !constraint.test(argumentMapped)) return Optional.empty(); } return Optional.of(Arrays.stream(tabCompletes.apply(s)).filter(t -> t.startsWith(s)).collect(Collectors.toList())); - } catch (NumberFormatException e) { - return Optional.empty(); } catch (Exception e) { - throw new SecurityException(e); + Bukkit.getLogger().log(Level.SEVERE, e.getMessage(), e); + return Optional.empty(); } } diff --git a/SpigotCore_Main/src/de/steamwar/command/ArgumentUtils.java b/SpigotCore_Main/src/de/steamwar/command/ArgumentUtils.java index 65b57d8..52f8c16 100644 --- a/SpigotCore_Main/src/de/steamwar/command/ArgumentUtils.java +++ b/SpigotCore_Main/src/de/steamwar/command/ArgumentUtils.java @@ -21,8 +21,10 @@ package de.steamwar.command; import java.util.Arrays; +import java.util.function.BiConsumer; import java.util.function.BiPredicate; import java.util.function.Predicate; +import java.util.stream.Stream; public class ArgumentUtils { @@ -40,6 +42,10 @@ public class ArgumentUtils { return notEmpty; } + private static String[] tabCompletes(Stream stream, Predicate predicate) { + return stream.filter(predicate).map(value -> value + "").toArray(String[]::new); + } + public static Argument of(String... arguments) { return new Argument<>(s -> s, string -> contains(arguments, string, String::equals), arguments); } @@ -58,14 +64,12 @@ public class ArgumentUtils { public static Argument between(int minValue, int maxValue, int... tabValues) { Predicate predicate = i -> i >= minValue && i <= maxValue; - String[] array = Arrays.stream(tabValues).boxed().filter(predicate).map(i -> i + "").toArray(String[]::new); - return new Argument<>(Integer::parseInt, predicate, array); + return new Argument<>(Integer::parseInt, predicate, tabCompletes(Arrays.stream(tabValues).boxed(), predicate)); } public static Argument between(long minValue, long maxValue, long... tabValues) { Predicate predicate = l -> l >= minValue && l <= maxValue; - String[] array = Arrays.stream(tabValues).boxed().filter(predicate).map(l -> l + "").toArray(String[]::new); - return new Argument<>(Long::parseLong, predicate, array); + return new Argument<>(Long::parseLong, predicate, tabCompletes(Arrays.stream(tabValues).boxed(), predicate)); } public static Argument between(float minValue, float maxValue, float... tabValues) { @@ -77,8 +81,7 @@ public class ArgumentUtils { public static Argument between(double minValue, double maxValue, double... tabValues) { Predicate predicate = d -> d >= minValue && d <= maxValue; - String[] array = Arrays.stream(tabValues).boxed().filter(predicate).map(d -> d + "").toArray(String[]::new); - return new Argument<>(Double::parseDouble, predicate, array); + return new Argument<>(Double::parseDouble, predicate, tabCompletes(Arrays.stream(tabValues).boxed(), predicate)); } } diff --git a/SpigotCore_Main/src/de/steamwar/command/Executor.java b/SpigotCore_Main/src/de/steamwar/command/Executor.java deleted file mode 100644 index 28fff3e..0000000 --- a/SpigotCore_Main/src/de/steamwar/command/Executor.java +++ /dev/null @@ -1,28 +0,0 @@ -/* - * - * This file is a part of the SteamWar software. - * - * Copyright (C) 2020 SteamWar.de-Serverteam - * - * This program is free software: you can redistribute it and/or modify - * it under the terms of the GNU Affero General Public License as published by - * the Free Software Foundation, either version 3 of the License, or - * (at your option) any later version. - * - * This program 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 Affero General Public License for more details. - * - * You should have received a copy of the GNU Affero General Public License - * along with this program. If not, see . - */ - -package de.steamwar.command; - -import org.bukkit.entity.Player; - -@FunctionalInterface -public interface Executor { - void execute(Player player, ArgumentMap argumentMap); -} diff --git a/SpigotCore_Main/src/de/steamwar/command/SWCommand.java b/SpigotCore_Main/src/de/steamwar/command/SWCommand.java index 948c8de..502bd4a 100644 --- a/SpigotCore_Main/src/de/steamwar/command/SWCommand.java +++ b/SpigotCore_Main/src/de/steamwar/command/SWCommand.java @@ -24,13 +24,14 @@ import org.bukkit.entity.Player; import java.util.List; import java.util.Optional; +import java.util.function.BiConsumer; public class SWCommand { private Argument[] arguments; - private Executor executor; + private BiConsumer executor; - public SWCommand(Executor executor, Argument... arguments) { + public SWCommand(BiConsumer executor, Argument... arguments) { this.arguments = arguments; this.executor = executor; } @@ -43,7 +44,7 @@ public class SWCommand { if (!optional.isPresent()) return false; objects[i] = optional.get(); } - executor.execute(player, new ArgumentMap(objects)); + executor.accept(player, new ArgumentMap(objects)); return true; } diff --git a/SpigotCore_Main/src/de/steamwar/command/SWCommandBundle.java b/SpigotCore_Main/src/de/steamwar/command/SWCommandBundle.java index 1f798ca..4b00d93 100644 --- a/SpigotCore_Main/src/de/steamwar/command/SWCommandBundle.java +++ b/SpigotCore_Main/src/de/steamwar/command/SWCommandBundle.java @@ -24,6 +24,7 @@ import org.bukkit.entity.Player; import java.util.ArrayList; import java.util.List; +import java.util.function.BiConsumer; public class SWCommandBundle { @@ -41,7 +42,7 @@ public class SWCommandBundle { return this; } - public SWCommandBundle addAll(Executor executor, List[]> arguments) { + public SWCommandBundle addAll(BiConsumer executor, List[]> arguments) { arguments.forEach(args -> swCommandList.add(new SWCommand(executor, args))); return this; } -- 2.39.2 From 9eb691859440238fc3f0437d8248a62e572e3817 Mon Sep 17 00:00:00 2001 From: jojo Date: Wed, 30 Dec 2020 14:13:57 +0100 Subject: [PATCH 35/53] Simplify Argument --- .../src/de/steamwar/command/Argument.java | 25 ++++++++----------- 1 file changed, 10 insertions(+), 15 deletions(-) diff --git a/SpigotCore_Main/src/de/steamwar/command/Argument.java b/SpigotCore_Main/src/de/steamwar/command/Argument.java index b02bd93..6655357 100644 --- a/SpigotCore_Main/src/de/steamwar/command/Argument.java +++ b/SpigotCore_Main/src/de/steamwar/command/Argument.java @@ -62,22 +62,13 @@ public class Argument { return GameMode.ADVENTURE; } return null; - }, Objects::nonNull, "creative", "survival", "spectator"); + }, Objects::nonNull, GameMode.class); - private static final String[] materialArray = Arrays.stream(Material.values()).map(Enum::name).toArray(String[]::new); - public static final Argument MATERIAL = new Argument<>(Material::valueOf, Objects::nonNull, materialArray); - - private static final String[] particleArray = Arrays.stream(Particle.values()).map(Enum::name).toArray(String[]::new); - public static final Argument PARTICLE = new Argument<>(Particle::valueOf, Objects::nonNull, particleArray); - - private static final String[] entityArray = Arrays.stream(EntityType.values()).map(Enum::name).toArray(String[]::new); - public static final Argument ENTITY = new Argument<>(EntityType::valueOf, Objects::nonNull, entityArray); - - private static final String[] soundArray = Arrays.stream(Sound.values()).map(Enum::name).toArray(String[]::new); - public static final Argument SOUND = new Argument<>(Sound::valueOf, Objects::nonNull, soundArray); - - private static final String[] soundCategoryArray = Arrays.stream(SoundCategory.values()).map(Enum::name).toArray(String[]::new); - public static final Argument SOUND_CATEGORY = new Argument<>(SoundCategory::valueOf, Objects::nonNull, soundCategoryArray); + public static final Argument MATERIAL = new Argument<>(Material::valueOf, Objects::nonNull, Material.class); + public static final Argument PARTICLE = new Argument<>(Particle::valueOf, Objects::nonNull, Particle.class); + public static final Argument ENTITY = new Argument<>(EntityType::valueOf, Objects::nonNull, EntityType.class); + public static final Argument SOUND = new Argument<>(Sound::valueOf, Objects::nonNull, Sound.class); + public static final Argument SOUND_CATEGORY = new Argument<>(SoundCategory::valueOf, Objects::nonNull, SoundCategory.class); private Function mapper; private Predicate constraint; @@ -87,6 +78,10 @@ public class Argument { this(mapper, constraint, s -> tabCompletes); } + public Argument(Function mapper, Predicate constraint, Class> tabCompletes) { + this(mapper, constraint, s -> Arrays.stream(tabCompletes.getEnumConstants()).map(e -> e.name().toLowerCase()).toArray(String[]::new)); + } + public Argument(Function mapper, Predicate constraint, Supplier tabCompletes) { this(mapper, constraint, s -> tabCompletes.get()); } -- 2.39.2 From 3e0fb9fde1974d12e2ab58fd80834b3e58b05de2 Mon Sep 17 00:00:00 2001 From: jojo Date: Wed, 30 Dec 2020 14:31:02 +0100 Subject: [PATCH 36/53] Simplify ArgumentMap --- .../src/de/steamwar/command/Argument.java | 2 -- .../src/de/steamwar/command/ArgumentMap.java | 12 ------------ 2 files changed, 14 deletions(-) diff --git a/SpigotCore_Main/src/de/steamwar/command/Argument.java b/SpigotCore_Main/src/de/steamwar/command/Argument.java index 6655357..aeffb72 100644 --- a/SpigotCore_Main/src/de/steamwar/command/Argument.java +++ b/SpigotCore_Main/src/de/steamwar/command/Argument.java @@ -49,7 +49,6 @@ public class Argument { public static final Argument STRING = new Argument<>(s -> s, string -> true); public static final Argument PLAYER = new Argument<>(Bukkit::getPlayer, Objects::nonNull, () -> Bukkit.getOnlinePlayers().stream().map(Player::getName).toArray(String[]::new)); - public static final Argument GAMEMODE = new Argument<>(s -> { switch (s.toLowerCase()) { case "creative": case "c": case "1": @@ -63,7 +62,6 @@ public class Argument { } return null; }, Objects::nonNull, GameMode.class); - public static final Argument MATERIAL = new Argument<>(Material::valueOf, Objects::nonNull, Material.class); public static final Argument PARTICLE = new Argument<>(Particle::valueOf, Objects::nonNull, Particle.class); public static final Argument ENTITY = new Argument<>(EntityType::valueOf, Objects::nonNull, EntityType.class); diff --git a/SpigotCore_Main/src/de/steamwar/command/ArgumentMap.java b/SpigotCore_Main/src/de/steamwar/command/ArgumentMap.java index 2a62c89..804ef2b 100644 --- a/SpigotCore_Main/src/de/steamwar/command/ArgumentMap.java +++ b/SpigotCore_Main/src/de/steamwar/command/ArgumentMap.java @@ -43,18 +43,6 @@ public class ArgumentMap { return (T)objects[index]; } - public T get(int index, T t) { - return get(index); - } - - public T get(int index, Class clazz) { - return get(index); - } - - public Class[] typeArray() { - return Arrays.stream(objects).map(Object::getClass).toArray(Class[]::new); - } - @Override public String toString() { return "ArgumentMap{" + Arrays.stream(objects).map(o -> o.getClass().getSimpleName() + "=" + o.toString()).collect(Collectors.joining(",")) + "}"; -- 2.39.2 From 085382296f61ff58a6b038ef104ca5b999eabedb Mon Sep 17 00:00:00 2001 From: jojo Date: Wed, 30 Dec 2020 14:33:03 +0100 Subject: [PATCH 37/53] Simplify ArgumentMap --- SpigotCore_Main/src/de/steamwar/command/ArgumentMap.java | 4 ---- 1 file changed, 4 deletions(-) diff --git a/SpigotCore_Main/src/de/steamwar/command/ArgumentMap.java b/SpigotCore_Main/src/de/steamwar/command/ArgumentMap.java index 804ef2b..5db8a44 100644 --- a/SpigotCore_Main/src/de/steamwar/command/ArgumentMap.java +++ b/SpigotCore_Main/src/de/steamwar/command/ArgumentMap.java @@ -35,10 +35,6 @@ public class ArgumentMap { return objects.length; } - public Class getType(int index) { - return objects[index].getClass(); - } - public T get(int index) { return (T)objects[index]; } -- 2.39.2 From 27b8bd43da2ed09f00c1989f6a7194e13f50dff6 Mon Sep 17 00:00:00 2001 From: jojo Date: Wed, 30 Dec 2020 14:35:06 +0100 Subject: [PATCH 38/53] Simplify SWCommandBundle --- .../src/de/steamwar/command/SWCommandBundle.java | 12 ------------ 1 file changed, 12 deletions(-) diff --git a/SpigotCore_Main/src/de/steamwar/command/SWCommandBundle.java b/SpigotCore_Main/src/de/steamwar/command/SWCommandBundle.java index 4b00d93..c99b343 100644 --- a/SpigotCore_Main/src/de/steamwar/command/SWCommandBundle.java +++ b/SpigotCore_Main/src/de/steamwar/command/SWCommandBundle.java @@ -24,7 +24,6 @@ import org.bukkit.entity.Player; import java.util.ArrayList; import java.util.List; -import java.util.function.BiConsumer; public class SWCommandBundle { @@ -36,17 +35,6 @@ public class SWCommandBundle { return this; } - public SWCommandBundle addAll(SWCommandBundle swCommandBundle) { - if (swCommandBundle == null) return this; - swCommandList.addAll(swCommandBundle.swCommandList); - return this; - } - - public SWCommandBundle addAll(BiConsumer executor, List[]> arguments) { - arguments.forEach(args -> swCommandList.add(new SWCommand(executor, args))); - return this; - } - public boolean execute(Player player, String[] args) { for (SWCommand swCommand : swCommandList) { if (swCommand.execute(player, args)) return true; -- 2.39.2 From cfa3ff0d8d214cf45f692838bb58506518b3fd77 Mon Sep 17 00:00:00 2001 From: jojo Date: Wed, 30 Dec 2020 14:40:30 +0100 Subject: [PATCH 39/53] Remove SWCommandBundle.java Add utility from SWCommandBundle.java to SWCommand --- .../src/de/steamwar/command/SWCommand.java | 14 +++++ .../de/steamwar/command/SWCommandBundle.java | 51 ------------------- 2 files changed, 14 insertions(+), 51 deletions(-) delete mode 100644 SpigotCore_Main/src/de/steamwar/command/SWCommandBundle.java diff --git a/SpigotCore_Main/src/de/steamwar/command/SWCommand.java b/SpigotCore_Main/src/de/steamwar/command/SWCommand.java index 502bd4a..faf90f4 100644 --- a/SpigotCore_Main/src/de/steamwar/command/SWCommand.java +++ b/SpigotCore_Main/src/de/steamwar/command/SWCommand.java @@ -22,6 +22,7 @@ package de.steamwar.command; import org.bukkit.entity.Player; +import java.util.ArrayList; import java.util.List; import java.util.Optional; import java.util.function.BiConsumer; @@ -57,4 +58,17 @@ public class SWCommand { return arguments[index].tabCompleteSupplier(args[index]); } + public static boolean execute(List swCommandList, Player player, String[] args) { + for (SWCommand swCommand : swCommandList) { + if (swCommand.execute(player, args)) return true; + } + return false; + } + + public static List tabComplete(List swCommandList, String[] args) { + List strings = new ArrayList<>(); + swCommandList.forEach(swCommand -> swCommand.tabComplete(args).ifPresent(strings::addAll)); + return strings; + } + } diff --git a/SpigotCore_Main/src/de/steamwar/command/SWCommandBundle.java b/SpigotCore_Main/src/de/steamwar/command/SWCommandBundle.java deleted file mode 100644 index c99b343..0000000 --- a/SpigotCore_Main/src/de/steamwar/command/SWCommandBundle.java +++ /dev/null @@ -1,51 +0,0 @@ -/* - * - * This file is a part of the SteamWar software. - * - * Copyright (C) 2020 SteamWar.de-Serverteam - * - * This program is free software: you can redistribute it and/or modify - * it under the terms of the GNU Affero General Public License as published by - * the Free Software Foundation, either version 3 of the License, or - * (at your option) any later version. - * - * This program 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 Affero General Public License for more details. - * - * You should have received a copy of the GNU Affero General Public License - * along with this program. If not, see . - */ - -package de.steamwar.command; - -import org.bukkit.entity.Player; - -import java.util.ArrayList; -import java.util.List; - -public class SWCommandBundle { - - private List swCommandList = new ArrayList<>(); - - public SWCommandBundle add(SWCommand swCommand) { - if (swCommand == null) return this; - swCommandList.add(swCommand); - return this; - } - - public boolean execute(Player player, String[] args) { - for (SWCommand swCommand : swCommandList) { - if (swCommand.execute(player, args)) return true; - } - return false; - } - - public List tabComplete(String[] args) { - List strings = new ArrayList<>(); - swCommandList.forEach(swCommand -> swCommand.tabComplete(args).ifPresent(strings::addAll)); - return strings; - } - -} -- 2.39.2 From d0672072d8bc548f6a8bf06ad51dfc95703bd0c2 Mon Sep 17 00:00:00 2001 From: jojo Date: Wed, 30 Dec 2020 15:20:16 +0100 Subject: [PATCH 40/53] Generify SWCommand to any thing implementing CommandSender --- .../src/de/steamwar/command/SWCommand.java | 27 ++++++++++--------- 1 file changed, 14 insertions(+), 13 deletions(-) diff --git a/SpigotCore_Main/src/de/steamwar/command/SWCommand.java b/SpigotCore_Main/src/de/steamwar/command/SWCommand.java index faf90f4..47a4abf 100644 --- a/SpigotCore_Main/src/de/steamwar/command/SWCommand.java +++ b/SpigotCore_Main/src/de/steamwar/command/SWCommand.java @@ -20,6 +20,7 @@ package de.steamwar.command; +import org.bukkit.command.CommandSender; import org.bukkit.entity.Player; import java.util.ArrayList; @@ -27,17 +28,17 @@ import java.util.List; import java.util.Optional; import java.util.function.BiConsumer; -public class SWCommand { +public class SWCommand { private Argument[] arguments; - private BiConsumer executor; + private BiConsumer executor; - public SWCommand(BiConsumer executor, Argument... arguments) { - this.arguments = arguments; + public SWCommand(BiConsumer executor, Argument... arguments) { this.executor = executor; + this.arguments = arguments; } - public boolean execute(Player player, String[] args) { + public boolean execute(T sender, String[] args) { if (args.length != arguments.length) return false; Object[] objects = new Object[args.length]; for (int i = 0; i < args.length; i++) { @@ -45,29 +46,29 @@ public class SWCommand { if (!optional.isPresent()) return false; objects[i] = optional.get(); } - executor.accept(player, new ArgumentMap(objects)); + executor.accept(sender, new ArgumentMap(objects)); return true; } - public Optional> tabComplete(String[] args) { - if (args.length > arguments.length) return Optional.empty(); + public List tabComplete(String[] args) { + if (args.length > arguments.length) return new ArrayList<>(); for (int i = 0; i < args.length - 1; i++) { - if (!arguments[i].valueSupplier(args[i]).isPresent()) return Optional.empty(); + if (!arguments[i].valueSupplier(args[i]).isPresent()) return new ArrayList<>(); } int index = args.length - 1; - return arguments[index].tabCompleteSupplier(args[index]); + return arguments[index].tabCompleteSupplier(args[index]).orElseGet(ArrayList::new); } - public static boolean execute(List swCommandList, Player player, String[] args) { + public static boolean execute(List> swCommandList, Player player, String[] args) { for (SWCommand swCommand : swCommandList) { if (swCommand.execute(player, args)) return true; } return false; } - public static List tabComplete(List swCommandList, String[] args) { + public static List tabComplete(List> swCommandList, String[] args) { List strings = new ArrayList<>(); - swCommandList.forEach(swCommand -> swCommand.tabComplete(args).ifPresent(strings::addAll)); + swCommandList.forEach(swCommand -> strings.addAll(swCommand.tabComplete(args))); return strings; } -- 2.39.2 From 3f9850ce26576fa5a8b28e838f54c0aba89d0079 Mon Sep 17 00:00:00 2001 From: jojo Date: Wed, 30 Dec 2020 16:40:39 +0100 Subject: [PATCH 41/53] Simplify ArgumentUtils Remove unused Argument Types Add SWCommand.lastArgRepeatable --- .../src/de/steamwar/command/Argument.java | 5 ---- .../de/steamwar/command/ArgumentUtils.java | 17 +----------- .../src/de/steamwar/command/SWCommand.java | 26 ++++++++++++++----- 3 files changed, 21 insertions(+), 27 deletions(-) diff --git a/SpigotCore_Main/src/de/steamwar/command/Argument.java b/SpigotCore_Main/src/de/steamwar/command/Argument.java index aeffb72..fe0ee2f 100644 --- a/SpigotCore_Main/src/de/steamwar/command/Argument.java +++ b/SpigotCore_Main/src/de/steamwar/command/Argument.java @@ -62,11 +62,6 @@ public class Argument { } return null; }, Objects::nonNull, GameMode.class); - public static final Argument MATERIAL = new Argument<>(Material::valueOf, Objects::nonNull, Material.class); - public static final Argument PARTICLE = new Argument<>(Particle::valueOf, Objects::nonNull, Particle.class); - public static final Argument ENTITY = new Argument<>(EntityType::valueOf, Objects::nonNull, EntityType.class); - public static final Argument SOUND = new Argument<>(Sound::valueOf, Objects::nonNull, Sound.class); - public static final Argument SOUND_CATEGORY = new Argument<>(SoundCategory::valueOf, Objects::nonNull, SoundCategory.class); private Function mapper; private Predicate constraint; diff --git a/SpigotCore_Main/src/de/steamwar/command/ArgumentUtils.java b/SpigotCore_Main/src/de/steamwar/command/ArgumentUtils.java index 52f8c16..16738c1 100644 --- a/SpigotCore_Main/src/de/steamwar/command/ArgumentUtils.java +++ b/SpigotCore_Main/src/de/steamwar/command/ArgumentUtils.java @@ -21,16 +21,13 @@ package de.steamwar.command; import java.util.Arrays; -import java.util.function.BiConsumer; import java.util.function.BiPredicate; import java.util.function.Predicate; import java.util.stream.Stream; public class ArgumentUtils { - private ArgumentUtils() { - throw new IllegalStateException("Utility class"); - } + private ArgumentUtils() {} private static boolean contains(String[] arguments, String string, BiPredicate predicate) { for (String arg : arguments) if (predicate.test(string, arg)) return true; @@ -67,18 +64,6 @@ public class ArgumentUtils { return new Argument<>(Integer::parseInt, predicate, tabCompletes(Arrays.stream(tabValues).boxed(), predicate)); } - public static Argument between(long minValue, long maxValue, long... tabValues) { - Predicate predicate = l -> l >= minValue && l <= maxValue; - return new Argument<>(Long::parseLong, predicate, tabCompletes(Arrays.stream(tabValues).boxed(), predicate)); - } - - public static Argument between(float minValue, float maxValue, float... tabValues) { - Predicate predicate = f -> f >= minValue && f <= maxValue; - String[] array = new String[tabValues.length]; - for (int i = 0; i < tabValues.length; i++) if (predicate.test(tabValues[i])) array[i] = tabValues[i] + ""; - return new Argument<>(Float::parseFloat, predicate, array); - } - public static Argument between(double minValue, double maxValue, double... tabValues) { Predicate predicate = d -> d >= minValue && d <= maxValue; return new Argument<>(Double::parseDouble, predicate, tabCompletes(Arrays.stream(tabValues).boxed(), predicate)); diff --git a/SpigotCore_Main/src/de/steamwar/command/SWCommand.java b/SpigotCore_Main/src/de/steamwar/command/SWCommand.java index 47a4abf..6c56ade 100644 --- a/SpigotCore_Main/src/de/steamwar/command/SWCommand.java +++ b/SpigotCore_Main/src/de/steamwar/command/SWCommand.java @@ -21,7 +21,6 @@ package de.steamwar.command; import org.bukkit.command.CommandSender; -import org.bukkit.entity.Player; import java.util.ArrayList; import java.util.List; @@ -32,20 +31,35 @@ public class SWCommand { private Argument[] arguments; private BiConsumer executor; + private boolean lastArgRepeatable = false; public SWCommand(BiConsumer executor, Argument... arguments) { this.executor = executor; this.arguments = arguments; } + public SWCommand(BiConsumer executor, boolean lastArgRepeatable, Argument... arguments) { + this(executor, arguments); + this.lastArgRepeatable = lastArgRepeatable; + } + public boolean execute(T sender, String[] args) { if (args.length != arguments.length) return false; Object[] objects = new Object[args.length]; - for (int i = 0; i < args.length; i++) { + for (int i = 0; i < (lastArgRepeatable ? arguments.length - 1 : arguments.length); i++) { Optional optional = arguments[i].valueSupplier(args[i]); if (!optional.isPresent()) return false; objects[i] = optional.get(); } + if (lastArgRepeatable) { + Object[] lastArg = new Object[args.length - arguments.length + 1]; + for (int i = arguments.length - 1; i < args.length; i++) { + Optional optional = arguments[i].valueSupplier(args[i]); + if (!optional.isPresent()) return false; + lastArg[i] = optional.get(); + } + objects[objects.length - 1] = lastArg; + } executor.accept(sender, new ArgumentMap(objects)); return true; } @@ -59,14 +73,14 @@ public class SWCommand { return arguments[index].tabCompleteSupplier(args[index]).orElseGet(ArrayList::new); } - public static boolean execute(List> swCommandList, Player player, String[] args) { - for (SWCommand swCommand : swCommandList) { - if (swCommand.execute(player, args)) return true; + public static boolean execute(List> swCommandList, T sender, String[] args) { + for (SWCommand swCommand : swCommandList) { + if (swCommand.execute(sender, args)) return true; } return false; } - public static List tabComplete(List> swCommandList, String[] args) { + public static List tabComplete(List> swCommandList, String[] args) { List strings = new ArrayList<>(); swCommandList.forEach(swCommand -> strings.addAll(swCommand.tabComplete(args))); return strings; -- 2.39.2 From fc315019263b01b8ff41467064c6d109879f9701 Mon Sep 17 00:00:00 2001 From: jojo Date: Wed, 30 Dec 2020 17:38:14 +0100 Subject: [PATCH 42/53] Add SWCommand.tabComplete repeatable --- .../src/de/steamwar/command/SWCommand.java | 14 ++++++++++---- 1 file changed, 10 insertions(+), 4 deletions(-) diff --git a/SpigotCore_Main/src/de/steamwar/command/SWCommand.java b/SpigotCore_Main/src/de/steamwar/command/SWCommand.java index 6c56ade..9192772 100644 --- a/SpigotCore_Main/src/de/steamwar/command/SWCommand.java +++ b/SpigotCore_Main/src/de/steamwar/command/SWCommand.java @@ -65,12 +65,18 @@ public class SWCommand { } public List tabComplete(String[] args) { - if (args.length > arguments.length) return new ArrayList<>(); - for (int i = 0; i < args.length - 1; i++) { + if (args.length > arguments.length && !lastArgRepeatable) { + return new ArrayList<>(); + } + for (int i = 0; i < Math.min(args.length - 1, arguments.length - 1); i++) { if (!arguments[i].valueSupplier(args[i]).isPresent()) return new ArrayList<>(); } - int index = args.length - 1; - return arguments[index].tabCompleteSupplier(args[index]).orElseGet(ArrayList::new); + if (lastArgRepeatable) { + for (int i = arguments.length; i < args.length; i++) { + if (!arguments[arguments.length - 1].valueSupplier(args[i]).isPresent()) return new ArrayList<>(); + } + } + return arguments[arguments.length - 1].tabCompleteSupplier(args[args.length - 1]).orElseGet(ArrayList::new); } public static boolean execute(List> swCommandList, T sender, String[] args) { -- 2.39.2 From 8ea8fb6e7b017e03885c5ffd514154ba6696c847 Mon Sep 17 00:00:00 2001 From: jojo Date: Wed, 30 Dec 2020 19:12:01 +0100 Subject: [PATCH 43/53] Add Argument.USER Add ( Argument.SCHEMATIC ) --- SpigotCore_Main/src/de/steamwar/command/Argument.java | 10 ++++++++-- 1 file changed, 8 insertions(+), 2 deletions(-) diff --git a/SpigotCore_Main/src/de/steamwar/command/Argument.java b/SpigotCore_Main/src/de/steamwar/command/Argument.java index fe0ee2f..b74443a 100644 --- a/SpigotCore_Main/src/de/steamwar/command/Argument.java +++ b/SpigotCore_Main/src/de/steamwar/command/Argument.java @@ -20,8 +20,11 @@ package de.steamwar.command; -import org.bukkit.*; -import org.bukkit.entity.EntityType; +import de.steamwar.core.Core; +import de.steamwar.sql.Schematic; +import de.steamwar.sql.SteamwarUser; +import org.bukkit.Bukkit; +import org.bukkit.GameMode; import org.bukkit.entity.Player; import java.util.*; @@ -62,6 +65,9 @@ public class Argument { } return null; }, Objects::nonNull, GameMode.class); + public static final Argument USER = new Argument<>(SteamwarUser::get, Objects::nonNull, PLAYER.tabCompletes); + // MAKE mapper a BiFunction + // public static final Argument SCHEMATIC = new Argument<>(s -> Schematic.getSchemFromDB(s, null), Objects::nonNull, ""); private Function mapper; private Predicate constraint; -- 2.39.2 From 0b389f2f9917964ac270a6816a2b74bede3c4454 Mon Sep 17 00:00:00 2001 From: jojo Date: Wed, 30 Dec 2020 20:24:48 +0100 Subject: [PATCH 44/53] Add Argument Add SWCommand --- .../src/de/steamwar/command/Argument.java | 29 ++++++++++++------- .../src/de/steamwar/command/SWCommand.java | 16 +++++----- 2 files changed, 26 insertions(+), 19 deletions(-) diff --git a/SpigotCore_Main/src/de/steamwar/command/Argument.java b/SpigotCore_Main/src/de/steamwar/command/Argument.java index b74443a..f387430 100644 --- a/SpigotCore_Main/src/de/steamwar/command/Argument.java +++ b/SpigotCore_Main/src/de/steamwar/command/Argument.java @@ -20,14 +20,15 @@ package de.steamwar.command; -import de.steamwar.core.Core; import de.steamwar.sql.Schematic; import de.steamwar.sql.SteamwarUser; import org.bukkit.Bukkit; import org.bukkit.GameMode; +import org.bukkit.command.CommandSender; import org.bukkit.entity.Player; import java.util.*; +import java.util.function.BiFunction; import java.util.function.Function; import java.util.function.Predicate; import java.util.function.Supplier; @@ -66,34 +67,40 @@ public class Argument { return null; }, Objects::nonNull, GameMode.class); public static final Argument USER = new Argument<>(SteamwarUser::get, Objects::nonNull, PLAYER.tabCompletes); - // MAKE mapper a BiFunction - // public static final Argument SCHEMATIC = new Argument<>(s -> Schematic.getSchemFromDB(s, null), Objects::nonNull, ""); + public static final Argument SCHEMATIC = new Argument<>((s, sender) -> { + if (sender instanceof Player) return Schematic.getSchemFromDB(s, ((Player) sender).getUniqueId()); + return null; + }, Objects::nonNull, s -> new String[]{""}); - private Function mapper; + private BiFunction mapper; private Predicate constraint; private Function tabCompletes; public Argument(Function mapper, Predicate constraint, String... tabCompletes) { - this(mapper, constraint, s -> tabCompletes); + this((s, player) -> mapper.apply(s), constraint, s -> tabCompletes); } public Argument(Function mapper, Predicate constraint, Class> tabCompletes) { - this(mapper, constraint, s -> Arrays.stream(tabCompletes.getEnumConstants()).map(e -> e.name().toLowerCase()).toArray(String[]::new)); + this((s, player) -> mapper.apply(s), constraint, s -> Arrays.stream(tabCompletes.getEnumConstants()).map(e -> e.name().toLowerCase()).toArray(String[]::new)); } public Argument(Function mapper, Predicate constraint, Supplier tabCompletes) { - this(mapper, constraint, s -> tabCompletes.get()); + this((s, player) -> mapper.apply(s), constraint, s -> tabCompletes.get()); } public Argument(Function mapper, Predicate constraint, Function tabCompletes) { + this((s, player) -> mapper.apply(s), constraint, tabCompletes); + } + + public Argument(BiFunction mapper, Predicate constraint, Function tabCompletes) { this.mapper = mapper; this.constraint = constraint; this.tabCompletes = tabCompletes; } - public Optional valueSupplier(String s) { + public Optional valueSupplier(String s, CommandSender sender) { try { - T argumentMapped = mapper.apply(s); + T argumentMapped = mapper.apply(s, sender); if (constraint.test(argumentMapped)) return Optional.ofNullable(argumentMapped); } catch (Exception e) { Bukkit.getLogger().log(Level.SEVERE, e.getMessage(), e); @@ -101,11 +108,11 @@ public class Argument { return Optional.empty(); } - public Optional> tabCompleteSupplier(String s) { + public Optional> tabCompleteSupplier(String s, CommandSender sender) { try { if (!s.isEmpty()) { // Check if mappable - T argumentMapped = mapper.apply(s); + T argumentMapped = mapper.apply(s, sender); // Check number constraints if needed if (numbers.contains(argumentMapped.getClass()) && !constraint.test(argumentMapped)) return Optional.empty(); } diff --git a/SpigotCore_Main/src/de/steamwar/command/SWCommand.java b/SpigotCore_Main/src/de/steamwar/command/SWCommand.java index 9192772..e1aefde 100644 --- a/SpigotCore_Main/src/de/steamwar/command/SWCommand.java +++ b/SpigotCore_Main/src/de/steamwar/command/SWCommand.java @@ -47,14 +47,14 @@ public class SWCommand { if (args.length != arguments.length) return false; Object[] objects = new Object[args.length]; for (int i = 0; i < (lastArgRepeatable ? arguments.length - 1 : arguments.length); i++) { - Optional optional = arguments[i].valueSupplier(args[i]); + Optional optional = arguments[i].valueSupplier(args[i], sender); if (!optional.isPresent()) return false; objects[i] = optional.get(); } if (lastArgRepeatable) { Object[] lastArg = new Object[args.length - arguments.length + 1]; for (int i = arguments.length - 1; i < args.length; i++) { - Optional optional = arguments[i].valueSupplier(args[i]); + Optional optional = arguments[i].valueSupplier(args[i], sender); if (!optional.isPresent()) return false; lastArg[i] = optional.get(); } @@ -64,19 +64,19 @@ public class SWCommand { return true; } - public List tabComplete(String[] args) { + public List tabComplete(T sender, String[] args) { if (args.length > arguments.length && !lastArgRepeatable) { return new ArrayList<>(); } for (int i = 0; i < Math.min(args.length - 1, arguments.length - 1); i++) { - if (!arguments[i].valueSupplier(args[i]).isPresent()) return new ArrayList<>(); + if (!arguments[i].valueSupplier(args[i], sender).isPresent()) return new ArrayList<>(); } if (lastArgRepeatable) { for (int i = arguments.length; i < args.length; i++) { - if (!arguments[arguments.length - 1].valueSupplier(args[i]).isPresent()) return new ArrayList<>(); + if (!arguments[arguments.length - 1].valueSupplier(args[i], sender).isPresent()) return new ArrayList<>(); } } - return arguments[arguments.length - 1].tabCompleteSupplier(args[args.length - 1]).orElseGet(ArrayList::new); + return arguments[arguments.length - 1].tabCompleteSupplier(args[args.length - 1], sender).orElseGet(ArrayList::new); } public static boolean execute(List> swCommandList, T sender, String[] args) { @@ -86,9 +86,9 @@ public class SWCommand { return false; } - public static List tabComplete(List> swCommandList, String[] args) { + public static List tabComplete(List> swCommandList, T sender, String[] args) { List strings = new ArrayList<>(); - swCommandList.forEach(swCommand -> strings.addAll(swCommand.tabComplete(args))); + swCommandList.forEach(swCommand -> strings.addAll(swCommand.tabComplete(sender, args))); return strings; } -- 2.39.2 From 03bdb926ca2f88d323d4cc66e1bbb8a4a4920e73 Mon Sep 17 00:00:00 2001 From: jojo Date: Wed, 30 Dec 2020 22:06:33 +0100 Subject: [PATCH 45/53] Add easier Enum Support in ArgumentUtils --- .../src/de/steamwar/command/Argument.java | 2 -- .../src/de/steamwar/command/ArgumentUtils.java | 12 ++++++++++++ 2 files changed, 12 insertions(+), 2 deletions(-) diff --git a/SpigotCore_Main/src/de/steamwar/command/Argument.java b/SpigotCore_Main/src/de/steamwar/command/Argument.java index f387430..9d1676f 100644 --- a/SpigotCore_Main/src/de/steamwar/command/Argument.java +++ b/SpigotCore_Main/src/de/steamwar/command/Argument.java @@ -47,8 +47,6 @@ public class Argument { public static final Argument BOOLEAN = new Argument<>(Boolean::parseBoolean, bool -> true, "true", "false"); public static final Argument INT = new Argument<>(Integer::parseInt, integer -> true); - public static final Argument LONG = new Argument<>(Long::parseLong, l -> true); - public static final Argument FLOAT = new Argument<>(Float::parseFloat, f -> true); public static final Argument DOUBLE = new Argument<>(Double::parseDouble, d -> true); public static final Argument STRING = new Argument<>(s -> s, string -> true); diff --git a/SpigotCore_Main/src/de/steamwar/command/ArgumentUtils.java b/SpigotCore_Main/src/de/steamwar/command/ArgumentUtils.java index 16738c1..92b4aa6 100644 --- a/SpigotCore_Main/src/de/steamwar/command/ArgumentUtils.java +++ b/SpigotCore_Main/src/de/steamwar/command/ArgumentUtils.java @@ -21,6 +21,7 @@ package de.steamwar.command; import java.util.Arrays; +import java.util.Objects; import java.util.function.BiPredicate; import java.util.function.Predicate; import java.util.stream.Stream; @@ -51,6 +52,17 @@ public class ArgumentUtils { return new Argument<>(s -> s, string -> contains(commands, string, String::equals), s -> supply(s, tabCompletes, commands)); } + public static > Argument enumValue(Class enumClass) { + T[] enumValues = enumClass.getEnumConstants(); + String[] strings = Arrays.stream(enumValues).map(Enum::name).toArray(String[]::new); + return new Argument<>((s, sender) -> { + for (T enumValue : enumValues) { + if (enumValue.name().startsWith(s)) return enumValue; + } + return null; + }, Objects::nonNull, s -> strings); + } + public static Argument ofIgnoreCase(String... arguments) { return new Argument<>(s -> s, string -> contains(arguments, string, String::equals), arguments); } -- 2.39.2 From 215db51837887528e306fcc86f280eb5e20af84e Mon Sep 17 00:00:00 2001 From: jojo Date: Wed, 30 Dec 2020 22:14:27 +0100 Subject: [PATCH 46/53] Rename ArgumentUtils.ofEnum Remove Argument.BOOLEAN --- .../src/de/steamwar/command/Argument.java | 1 - .../de/steamwar/command/ArgumentUtils.java | 21 +++++++++---------- 2 files changed, 10 insertions(+), 12 deletions(-) diff --git a/SpigotCore_Main/src/de/steamwar/command/Argument.java b/SpigotCore_Main/src/de/steamwar/command/Argument.java index 9d1676f..c04e9e2 100644 --- a/SpigotCore_Main/src/de/steamwar/command/Argument.java +++ b/SpigotCore_Main/src/de/steamwar/command/Argument.java @@ -45,7 +45,6 @@ public class Argument { numbers.add(Float.class); } - public static final Argument BOOLEAN = new Argument<>(Boolean::parseBoolean, bool -> true, "true", "false"); public static final Argument INT = new Argument<>(Integer::parseInt, integer -> true); public static final Argument DOUBLE = new Argument<>(Double::parseDouble, d -> true); public static final Argument STRING = new Argument<>(s -> s, string -> true); diff --git a/SpigotCore_Main/src/de/steamwar/command/ArgumentUtils.java b/SpigotCore_Main/src/de/steamwar/command/ArgumentUtils.java index 92b4aa6..e1e51b6 100644 --- a/SpigotCore_Main/src/de/steamwar/command/ArgumentUtils.java +++ b/SpigotCore_Main/src/de/steamwar/command/ArgumentUtils.java @@ -21,6 +21,7 @@ package de.steamwar.command; import java.util.Arrays; +import java.util.Collection; import java.util.Objects; import java.util.function.BiPredicate; import java.util.function.Predicate; @@ -52,17 +53,6 @@ public class ArgumentUtils { return new Argument<>(s -> s, string -> contains(commands, string, String::equals), s -> supply(s, tabCompletes, commands)); } - public static > Argument enumValue(Class enumClass) { - T[] enumValues = enumClass.getEnumConstants(); - String[] strings = Arrays.stream(enumValues).map(Enum::name).toArray(String[]::new); - return new Argument<>((s, sender) -> { - for (T enumValue : enumValues) { - if (enumValue.name().startsWith(s)) return enumValue; - } - return null; - }, Objects::nonNull, s -> strings); - } - public static Argument ofIgnoreCase(String... arguments) { return new Argument<>(s -> s, string -> contains(arguments, string, String::equals), arguments); } @@ -81,4 +71,13 @@ public class ArgumentUtils { return new Argument<>(Double::parseDouble, predicate, tabCompletes(Arrays.stream(tabValues).boxed(), predicate)); } + public static > Argument ofEnum(Class enumClass) { + T[] enumValues = enumClass.getEnumConstants(); + String[] strings = Arrays.stream(enumValues).map(Enum::name).toArray(String[]::new); + return new Argument<>((s, sender) -> { + for (T enumValue : enumValues) if (enumValue.name().startsWith(s)) return enumValue; + return null; + }, Objects::nonNull, s -> strings); + } + } -- 2.39.2 From 28f1802a35a35139bf584abe8765c0edf19151a3 Mon Sep 17 00:00:00 2001 From: jojo Date: Wed, 30 Dec 2020 22:17:38 +0100 Subject: [PATCH 47/53] Simplify ArgumentUtils.ofEnum --- .../src/de/steamwar/command/ArgumentUtils.java | 10 +++------- 1 file changed, 3 insertions(+), 7 deletions(-) diff --git a/SpigotCore_Main/src/de/steamwar/command/ArgumentUtils.java b/SpigotCore_Main/src/de/steamwar/command/ArgumentUtils.java index e1e51b6..5ed9cfb 100644 --- a/SpigotCore_Main/src/de/steamwar/command/ArgumentUtils.java +++ b/SpigotCore_Main/src/de/steamwar/command/ArgumentUtils.java @@ -71,13 +71,9 @@ public class ArgumentUtils { return new Argument<>(Double::parseDouble, predicate, tabCompletes(Arrays.stream(tabValues).boxed(), predicate)); } - public static > Argument ofEnum(Class enumClass) { - T[] enumValues = enumClass.getEnumConstants(); - String[] strings = Arrays.stream(enumValues).map(Enum::name).toArray(String[]::new); - return new Argument<>((s, sender) -> { - for (T enumValue : enumValues) if (enumValue.name().startsWith(s)) return enumValue; - return null; - }, Objects::nonNull, s -> strings); + public static > Argument ofEnum(Class enumClass) { + String[] strings = Arrays.stream(enumClass.getEnumConstants()).map(Enum::name).toArray(String[]::new); + return new Argument<>((s, sender) -> Enum.valueOf(enumClass, s), Objects::nonNull, s -> strings); } } -- 2.39.2 From 8b36a64f94eea67333babf70c8c94d04ede42da8 Mon Sep 17 00:00:00 2001 From: jojo Date: Wed, 30 Dec 2020 22:40:41 +0100 Subject: [PATCH 48/53] Add SWCommand.register --- .../src/de/steamwar/command/SWCommand.java | 51 ++++++++++++++++++- 1 file changed, 50 insertions(+), 1 deletion(-) diff --git a/SpigotCore_Main/src/de/steamwar/command/SWCommand.java b/SpigotCore_Main/src/de/steamwar/command/SWCommand.java index e1aefde..239b0ad 100644 --- a/SpigotCore_Main/src/de/steamwar/command/SWCommand.java +++ b/SpigotCore_Main/src/de/steamwar/command/SWCommand.java @@ -20,15 +20,34 @@ package de.steamwar.command; +import org.bukkit.Bukkit; +import org.bukkit.command.Command; +import org.bukkit.command.CommandMap; import org.bukkit.command.CommandSender; +import java.lang.reflect.Field; import java.util.ArrayList; +import java.util.Arrays; import java.util.List; import java.util.Optional; import java.util.function.BiConsumer; public class SWCommand { + private static final CommandMap commandMap; + + static { + try { + final Field commandMapField = Bukkit.getServer().getClass().getDeclaredField("commandMap"); + commandMapField.setAccessible(true); + commandMap = (CommandMap) commandMapField.get(Bukkit.getServer()); + } catch (NoSuchFieldException | IllegalAccessException exception) { + Bukkit.shutdown(); + throw new SecurityException("Oh shit. Commands cannot not register.", exception); + } + } + + private SWCommand instance; private Argument[] arguments; private BiConsumer executor; private boolean lastArgRepeatable = false; @@ -36,6 +55,7 @@ public class SWCommand { public SWCommand(BiConsumer executor, Argument... arguments) { this.executor = executor; this.arguments = arguments; + this.instance = this; } public SWCommand(BiConsumer executor, boolean lastArgRepeatable, Argument... arguments) { @@ -43,6 +63,34 @@ public class SWCommand { this.lastArgRepeatable = lastArgRepeatable; } + protected void register(String name, String... aliases) { + commandMap.register("steamwar", new Command(name, "", "/" + name, Arrays.asList(aliases)) { + @Override + public boolean execute(CommandSender sender, String alias, String[] args) { + if (!isInstance(sender)) return false; + instance.execute((T) sender, args); + return true; + } + + @Override + public List tabComplete(CommandSender sender, String alias, String[] args) { + if (!isInstance(sender)) new ArrayList<>(); + return SWCommand.this.tabComplete((T) sender, args); + } + + private boolean isInstance(CommandSender sender) { + try { + if (Class.forName(getClass().getGenericInterfaces()[0].getTypeName()).isInstance(sender)) { + return true; + } + } catch (ClassNotFoundException e) { + // Ignored + } + return false; + } + }); + } + public boolean execute(T sender, String[] args) { if (args.length != arguments.length) return false; Object[] objects = new Object[args.length]; @@ -73,7 +121,8 @@ public class SWCommand { } if (lastArgRepeatable) { for (int i = arguments.length; i < args.length; i++) { - if (!arguments[arguments.length - 1].valueSupplier(args[i], sender).isPresent()) return new ArrayList<>(); + if (!arguments[arguments.length - 1].valueSupplier(args[i], sender).isPresent()) + return new ArrayList<>(); } } return arguments[arguments.length - 1].tabCompleteSupplier(args[args.length - 1], sender).orElseGet(ArrayList::new); -- 2.39.2 From a60fa5923c48097fe8275665609c7bfd7bfc0a4e Mon Sep 17 00:00:00 2001 From: jojo Date: Wed, 30 Dec 2020 22:57:56 +0100 Subject: [PATCH 49/53] Simplify SWCommand.register --- .../src/de/steamwar/command/SWCommand.java | 56 +++++++++---------- 1 file changed, 28 insertions(+), 28 deletions(-) diff --git a/SpigotCore_Main/src/de/steamwar/command/SWCommand.java b/SpigotCore_Main/src/de/steamwar/command/SWCommand.java index 239b0ad..bbd881d 100644 --- a/SpigotCore_Main/src/de/steamwar/command/SWCommand.java +++ b/SpigotCore_Main/src/de/steamwar/command/SWCommand.java @@ -63,34 +63,6 @@ public class SWCommand { this.lastArgRepeatable = lastArgRepeatable; } - protected void register(String name, String... aliases) { - commandMap.register("steamwar", new Command(name, "", "/" + name, Arrays.asList(aliases)) { - @Override - public boolean execute(CommandSender sender, String alias, String[] args) { - if (!isInstance(sender)) return false; - instance.execute((T) sender, args); - return true; - } - - @Override - public List tabComplete(CommandSender sender, String alias, String[] args) { - if (!isInstance(sender)) new ArrayList<>(); - return SWCommand.this.tabComplete((T) sender, args); - } - - private boolean isInstance(CommandSender sender) { - try { - if (Class.forName(getClass().getGenericInterfaces()[0].getTypeName()).isInstance(sender)) { - return true; - } - } catch (ClassNotFoundException e) { - // Ignored - } - return false; - } - }); - } - public boolean execute(T sender, String[] args) { if (args.length != arguments.length) return false; Object[] objects = new Object[args.length]; @@ -141,4 +113,32 @@ public class SWCommand { return strings; } + public static void register(List> commandList, String name, String... aliases) { + commandMap.register("steamwar", new Command(name, "", "/" + name, Arrays.asList(aliases)) { + @Override + public boolean execute(CommandSender sender, String alias, String[] args) { + if (!isInstance(sender)) return false; + SWCommand.execute(commandList, (T) sender, args); + return true; + } + + @Override + public List tabComplete(CommandSender sender, String alias, String[] args) { + if (!isInstance(sender)) new ArrayList<>(); + return SWCommand.tabComplete(commandList, (T) sender, args); + } + + private boolean isInstance(CommandSender sender) { + try { + if (Class.forName(getClass().getGenericInterfaces()[0].getTypeName()).isInstance(sender)) { + return true; + } + } catch (ClassNotFoundException e) { + // Ignored + } + return false; + } + }); + } + } -- 2.39.2 From 45dc828d6c72e0c44ff06e7d1c0fcc7454f98b7d Mon Sep 17 00:00:00 2001 From: jojo Date: Thu, 31 Dec 2020 13:05:43 +0100 Subject: [PATCH 50/53] Simplify SWCommand.register --- SpigotCore_Main/src/de/steamwar/command/SWCommand.java | 9 ++++++--- 1 file changed, 6 insertions(+), 3 deletions(-) diff --git a/SpigotCore_Main/src/de/steamwar/command/SWCommand.java b/SpigotCore_Main/src/de/steamwar/command/SWCommand.java index bbd881d..d6e7c4b 100644 --- a/SpigotCore_Main/src/de/steamwar/command/SWCommand.java +++ b/SpigotCore_Main/src/de/steamwar/command/SWCommand.java @@ -31,6 +31,7 @@ import java.util.Arrays; import java.util.List; import java.util.Optional; import java.util.function.BiConsumer; +import java.util.function.Predicate; public class SWCommand { @@ -113,12 +114,14 @@ public class SWCommand { return strings; } - public static void register(List> commandList, String name, String... aliases) { - commandMap.register("steamwar", new Command(name, "", "/" + name, Arrays.asList(aliases)) { + public static void register(List> commandList, String plugin, String name, Predicate permissionPredicate, String... aliases) { + commandMap.register(plugin, new Command(name, "", "/" + name, Arrays.asList(aliases)) { @Override public boolean execute(CommandSender sender, String alias, String[] args) { if (!isInstance(sender)) return false; - SWCommand.execute(commandList, (T) sender, args); + T t = (T) sender; + if (!permissionPredicate.test(t)) return false; + SWCommand.execute(commandList, t, args); return true; } -- 2.39.2 From e999cbc2fbe7ddc5313f84139cfbcb1afe0b8254 Mon Sep 17 00:00:00 2001 From: jojo Date: Thu, 31 Dec 2020 13:06:04 +0100 Subject: [PATCH 51/53] Simplify SWCommand.register --- SpigotCore_Main/src/de/steamwar/command/SWCommand.java | 2 -- 1 file changed, 2 deletions(-) diff --git a/SpigotCore_Main/src/de/steamwar/command/SWCommand.java b/SpigotCore_Main/src/de/steamwar/command/SWCommand.java index d6e7c4b..0faa1db 100644 --- a/SpigotCore_Main/src/de/steamwar/command/SWCommand.java +++ b/SpigotCore_Main/src/de/steamwar/command/SWCommand.java @@ -48,7 +48,6 @@ public class SWCommand { } } - private SWCommand instance; private Argument[] arguments; private BiConsumer executor; private boolean lastArgRepeatable = false; @@ -56,7 +55,6 @@ public class SWCommand { public SWCommand(BiConsumer executor, Argument... arguments) { this.executor = executor; this.arguments = arguments; - this.instance = this; } public SWCommand(BiConsumer executor, boolean lastArgRepeatable, Argument... arguments) { -- 2.39.2 From 76b99d20db942f77e05ca89b76a5abe75405dc65 Mon Sep 17 00:00:00 2001 From: jojo Date: Thu, 31 Dec 2020 16:09:11 +0100 Subject: [PATCH 52/53] Optimize Imports --- SpigotCore_Main/src/de/steamwar/command/ArgumentUtils.java | 1 - 1 file changed, 1 deletion(-) diff --git a/SpigotCore_Main/src/de/steamwar/command/ArgumentUtils.java b/SpigotCore_Main/src/de/steamwar/command/ArgumentUtils.java index 5ed9cfb..afd763d 100644 --- a/SpigotCore_Main/src/de/steamwar/command/ArgumentUtils.java +++ b/SpigotCore_Main/src/de/steamwar/command/ArgumentUtils.java @@ -21,7 +21,6 @@ package de.steamwar.command; import java.util.Arrays; -import java.util.Collection; import java.util.Objects; import java.util.function.BiPredicate; import java.util.function.Predicate; -- 2.39.2 From 050fcafc7183c0787efee076c59d2e72be28336d Mon Sep 17 00:00:00 2001 From: yoyosource Date: Fri, 12 Mar 2021 10:57:23 +0100 Subject: [PATCH 53/53] Fix Argument --- .../src/de/steamwar/command/Argument.java | 13 +++++-------- 1 file changed, 5 insertions(+), 8 deletions(-) diff --git a/SpigotCore_Main/src/de/steamwar/command/Argument.java b/SpigotCore_Main/src/de/steamwar/command/Argument.java index c04e9e2..635b868 100644 --- a/SpigotCore_Main/src/de/steamwar/command/Argument.java +++ b/SpigotCore_Main/src/de/steamwar/command/Argument.java @@ -20,7 +20,6 @@ package de.steamwar.command; -import de.steamwar.sql.Schematic; import de.steamwar.sql.SteamwarUser; import org.bukkit.Bukkit; import org.bukkit.GameMode; @@ -32,7 +31,6 @@ import java.util.function.BiFunction; import java.util.function.Function; import java.util.function.Predicate; import java.util.function.Supplier; -import java.util.logging.Level; import java.util.stream.Collectors; public class Argument { @@ -64,10 +62,6 @@ public class Argument { return null; }, Objects::nonNull, GameMode.class); public static final Argument USER = new Argument<>(SteamwarUser::get, Objects::nonNull, PLAYER.tabCompletes); - public static final Argument SCHEMATIC = new Argument<>((s, sender) -> { - if (sender instanceof Player) return Schematic.getSchemFromDB(s, ((Player) sender).getUniqueId()); - return null; - }, Objects::nonNull, s -> new String[]{""}); private BiFunction mapper; private Predicate constraint; @@ -100,7 +94,7 @@ public class Argument { T argumentMapped = mapper.apply(s, sender); if (constraint.test(argumentMapped)) return Optional.ofNullable(argumentMapped); } catch (Exception e) { - Bukkit.getLogger().log(Level.SEVERE, e.getMessage(), e); + // Ignored } return Optional.empty(); } @@ -113,9 +107,12 @@ public class Argument { // Check number constraints if needed if (numbers.contains(argumentMapped.getClass()) && !constraint.test(argumentMapped)) return Optional.empty(); } + } catch (Exception e) { + // Ignored + } + try { return Optional.of(Arrays.stream(tabCompletes.apply(s)).filter(t -> t.startsWith(s)).collect(Collectors.toList())); } catch (Exception e) { - Bukkit.getLogger().log(Level.SEVERE, e.getMessage(), e); return Optional.empty(); } } -- 2.39.2