Add ExecutableBy.BLOCKS option

Author: APickledWalrus

src/main/java/ch/njol/util/coll/CollectionUtils.java

@@ -478,4 +478,29 @@ public static Double[] wrap(double[] primitive) {
 		return wrapped;
 	}
 
+	/**
+	 * Stringifies a collection as an "and" or "or" list.
+	 * @param collection The collection to stringify.
+	 * @param and Whether this is an "and" list or an "or" list.
+	 * @return Stringification of {@code collection}.
+	 * For example, {@code "x, y, and z"}.
+	 */
+	public static String toString(Collection<?> collection, boolean and) {
+		StringBuilder builder = new StringBuilder();
+		int i = 0;
+		int end = collection.size() - 1;
+		for (Object object : collection) {
+			if (i > 0) {
+				if (i == end) {
+					builder.append(and ? " and " : " or ");
+				} else {
+					builder.append(", ");
+				}
+			}
+			builder.append(object);
+			i++;
+		}
+		return builder.toString();
+	}
+
 }

src/main/java/org/skriptlang/skript/bukkit/command/custom/CommandParsingData.java

@@ -9,6 +9,7 @@
 import java.util.Deque;
 import java.util.LinkedList;
 import java.util.List;
+import java.util.Set;
 import java.util.function.Function;
 
 /**
@@ -17,11 +18,11 @@
 public final class CommandParsingData extends Data {
 
 	/**
-	 * @param executableBy Describes what kind of {@link CommandSender} can execute the command.
+	 * @param executableBy Set describing what kinds of {@link CommandSender} can execute the command.
 	 * @param cooldownManager Handles cooldown management for cooldown command entries.
 	 */
 	public record ExecutorData(
-		@Nullable ExecutableBy executableBy,
+		@Nullable Set<ExecutableBy> executableBy,
 		@Nullable CooldownManager cooldownManager
 	) { }
 

src/main/java/org/skriptlang/skript/bukkit/command/custom/ExecutableBy.java

@@ -1,5 +1,6 @@
 package org.skriptlang.skript.bukkit.command.custom;
 
+import org.bukkit.command.BlockCommandSender;
 import org.bukkit.command.CommandSender;
 import org.bukkit.command.ConsoleCommandSender;
 import org.bukkit.command.RemoteConsoleCommandSender;
@@ -23,14 +24,9 @@ public enum ExecutableBy {
 	CONSOLE(sender -> sender instanceof ConsoleCommandSender || sender instanceof RemoteConsoleCommandSender),
 
 	/**
-	 * This command is executable by any {@link CommandSender}.
+	 * This command is only executable by blocks (e.g, command blocks).
 	 */
-	ALL(ignored -> true),
-
-	/**
-	 * This command is not executable.
-	 */
-	NONE(ignored -> false);
+	BLOCKS(sender -> sender instanceof BlockCommandSender);
 
 	private final Predicate<CommandSender> predicate;
 
@@ -45,37 +41,12 @@ public Predicate<CommandSender> predicate() {
 		return predicate;
 	}
 
-	/**
-	 * Combines (ORs) this ExecutableBy with another.
-	 * For example, {@link #PLAYERS}.with({@link #CONSOLE}) is {@link #ALL}.
-	 *
-	 * @param other Other to OR with.
-	 * @return The resulting ExecutableBy.
-	 */
-	public ExecutableBy with(ExecutableBy other) {
-		if (this == NONE) {
-			return other;
-		} else if (other == NONE) {
-			return this;
-		}
-		return this == other ? this : ALL;
-	}
-
-	/**
-	 * @param other Subset ExecutableBy to consider.
-	 * @return Whether this ExecutableBy is the same as or covers a superset of {@code other}.
-	 */
-	public boolean includes(ExecutableBy other) {
-		return this == ALL || this == other;
-	}
-
 	@Override
 	public String toString() {
 		return switch (this) {
 			case PLAYERS -> "players";
 			case CONSOLE -> "the console";
-			case ALL -> "the console and players";
-			case NONE -> "none";
+			case BLOCKS -> "blocks";
 		};
 	}
 

src/main/java/org/skriptlang/skript/bukkit/command/elements/structures/util/SubCommandEntryData.java

@@ -11,6 +11,7 @@
 import ch.njol.skript.util.StringMode;
 import ch.njol.skript.util.Timespan;
 import ch.njol.skript.variables.HintManager;
+import ch.njol.util.coll.CollectionUtils;
 import com.mojang.brigadier.arguments.ArgumentType;
 import com.mojang.brigadier.arguments.StringArgumentType;
 import com.mojang.brigadier.builder.ArgumentBuilder;
@@ -46,7 +47,9 @@
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collection;
+import java.util.EnumSet;
 import java.util.List;
+import java.util.Set;
 import java.util.function.Predicate;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
@@ -88,20 +91,22 @@ protected List<String> getValue(String value) {
 		.addEntryData(new VariableStringEntryData("usage", null, true))
 		.addEntry("prefix", null, true)
 		.addEntry("permission", null, true)
-		.addEntryData(new KeyValueEntryData<ExecutableBy>("executable by", null, true) {
-			private final Pattern pattern = Pattern.compile("\\s*,\\s*|\\s+(and|or)\\s+");
+		.addEntryData(new KeyValueEntryData<Set<ExecutableBy>>("executable by", null, true) {
+			private final Pattern pattern = Pattern.compile("\\s*,(?:\\s+(?:and|or)\\s+)?\\s*|\\s+(?:and|or)\\s+");
 
 			@Override
-			protected ExecutableBy getValue(String value) {
-				ExecutableBy executableBy = ExecutableBy.NONE;
+			protected Set<ExecutableBy> getValue(String value) {
+				EnumSet<ExecutableBy> executableBy = EnumSet.noneOf(ExecutableBy.class);
 				for (String type : pattern.split(value)) {
 					if (type.equalsIgnoreCase("console") || type.equalsIgnoreCase("the console")) {
-						executableBy = executableBy.with(ExecutableBy.CONSOLE);
+						executableBy.add(ExecutableBy.CONSOLE);
 					} else if (type.equalsIgnoreCase("players") || type.equalsIgnoreCase("player")) {
-						executableBy = executableBy.with(ExecutableBy.PLAYERS);
+						executableBy.add(ExecutableBy.PLAYERS);
+					} else if (type.equalsIgnoreCase("blocks") || type.equalsIgnoreCase("block")) {
+						executableBy.add(ExecutableBy.BLOCKS);
 					} else {
 						Skript.error("Invalid command sender type: " + type);
-						return ExecutableBy.NONE;
+						return Set.of();
 					}
 				}
 				return executableBy;
@@ -228,18 +233,21 @@ public SubCommandEntryData(String key, boolean optional, boolean multiple) {
 		}
 
 		// executable by requirement
-		ExecutableBy executableBy = entryContainer.getOptional("executable by", ExecutableBy.class, false);
+		Set<ExecutableBy> executableBy = entryContainer.getOptional("executable by", Set.class, false);
 		if (executableBy != null) {
-			if (executableBy == ExecutableBy.NONE) { // parsing failed
+			if (executableBy.isEmpty()) { // parsing failed
 				return null;
 			}
-			ExecutableBy parent = parsingData.getExecutorData(ExecutorData::executableBy);
-			if (parent != null && !parent.includes(executableBy)) {
-				Skript.error("It is not possible to restrict execution to " + executableBy +
-					" as the parent command is only executable by " + parent + ".");
+			Set<ExecutableBy> parent = parsingData.getExecutorData(ExecutorData::executableBy);
+			if (parent != null && !parent.containsAll(executableBy)) {
+				Skript.error("It is not possible to restrict execution to " + CollectionUtils.toString(executableBy, true) +
+					" as the parent command is only executable by " + CollectionUtils.toString(parent, true) + ".");
 				return null;
 			}
-			requires = requires.and(executableBy.predicate());
+			requires = requires.and(executableBy.stream()
+				.map(ExecutableBy::predicate)
+				.reduce(Predicate::or)
+				.orElseThrow());
 		}
 
 		// prepare final requirements predicate