Add back several command entries

Author: APickledWalrus

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

@@ -2,11 +2,13 @@
 
 import ch.njol.skript.lang.parser.ParserInstance;
 import ch.njol.skript.lang.parser.ParserInstance.Data;
+import org.jetbrains.annotations.Nullable;
 
 import java.util.ArrayDeque;
 import java.util.Deque;
 import java.util.LinkedList;
 import java.util.List;
+import java.util.function.Function;
 
 /**
  * Parsing data holding command context.
@@ -16,10 +18,19 @@ public final class CommandParsingData extends Data {
 	private final LinkedList<ArgumentData<?>> arguments = new LinkedList<>();
 	private final Deque<Integer> indices = new ArrayDeque<>(4);
 
+	private final Deque<ExecutorData> executorDatas = new ArrayDeque<>(4);
+
 	public CommandParsingData(ParserInstance parserInstance) {
 		super(parserInstance);
 	}
 
+	/**
+	 * @return Whether this parsing data contains any data.
+	 */
+	public boolean isEmpty() {
+		return indices.isEmpty();
+	}
+
 	/**
 	 * @return Arguments currently stored on this data, in declaration order.
 	 */
@@ -29,7 +40,7 @@ public List<ArgumentData<?>> getArguments() {
 
 	/**
 	 * Pushes arguments to this data.
-	 * @param arguments The arguments to record.
+	 * @param arguments The arguments to push.
 	 * @see #popArguments()
 	 */
 	public void pushArguments(List<ArgumentData<?>> arguments) {
@@ -45,4 +56,36 @@ public void popArguments() {
 		arguments.subList(indices.pop(), arguments.size()).clear();
 	}
 
+	/**
+	 * Pushes executor data to this data.
+	 * @param executorData The data to push.
+	 * @see #popExecutorData()
+	 */
+	public void pushExecutorData(ExecutorData executorData) {
+		executorDatas.push(executorData);
+	}
+
+	/**
+	 * Removes the last pushed executor data from this data.
+	 * @see #pushExecutorData(ExecutorData)
+	 */
+	public void popExecutorData() {
+		executorDatas.pop();
+	}
+
+	/**
+	 * Obtains the first non-null instance of a value from the pushed executors.
+	 * @param function A function to obtain the desired value from the data.
+	 * @return The value, or null if it was never set.
+	 */
+	public @Nullable <T> T getExecutorData(Function<ExecutorData, T> function) {
+		for (ExecutorData executorData : executorDatas) {
+			T result = function.apply(executorData);
+			if (result != null) {
+				return result;
+			}
+		}
+		return null;
+	}
+
 }

src/main/java/org/skriptlang/skript/bukkit/command/brigadier/ExecutorData.java

@@ -0,0 +1,90 @@
+package org.skriptlang.skript.bukkit.command.brigadier;
+
+import org.bukkit.command.CommandSender;
+import org.bukkit.command.ConsoleCommandSender;
+import org.bukkit.command.RemoteConsoleCommandSender;
+import org.bukkit.entity.Player;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.function.Predicate;
+
+public record ExecutorData(
+	@Nullable SkriptCommandExecutor executor,
+	@Nullable ExecutableBy executableBy,
+	@Nullable String permission
+) {
+
+	/**
+	 * Enum describing the types of {@link org.bukkit.command.CommandSender}s that can execute this command.
+	 */
+	public enum ExecutableBy {
+
+		/**
+		 * This command is only executable by players.
+		 */
+		PLAYERS(sender -> sender instanceof Player),
+
+		/**
+		 * This command is only executable by console.
+		 */
+		CONSOLE(sender -> sender instanceof ConsoleCommandSender || sender instanceof RemoteConsoleCommandSender),
+
+		/**
+		 * This command is executable by any {@link org.bukkit.command.CommandSender}.
+		 */
+		ALL(ignored -> true),
+
+		/**
+		 * This command is not executable.
+		 */
+		NONE(ignored -> false);
+
+		private final Predicate<CommandSender> predicate;
+
+		ExecutableBy(Predicate<CommandSender> predicate) {
+			this.predicate = predicate;
+		}
+
+		/**
+		 * @return A predicate to validate the behavior expected by this restriction.
+		 */
+		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";
+			};
+		}
+
+	}
+
+}

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

@@ -21,6 +21,7 @@
 import org.skriptlang.skript.registration.SyntaxInfo;
 import org.skriptlang.skript.registration.SyntaxRegistry;
 
+import java.util.List;
 import java.util.Set;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.atomic.AtomicBoolean;
@@ -38,14 +39,22 @@ public static void register(SkriptAddon addon, SyntaxRegistry syntaxRegistry) {
 
 		Skript.getInstance().getLifecycleManager().registerEventHandler(LifecycleEvents.COMMANDS,commands -> {
 			var registrar = commands.registrar();
-			COMMANDS.forEach(registrar::register);
+			for (var registration : COMMANDS) {
+				registrar.register(registration.node, registration.description, registration.aliases);
+			}
 		});
 	}
 
 	private static final SubCommandEntryData ROOT_ENTRY_DATA =
 		new SubCommandEntryData("command", false, false);
 
-	private static final Set<LiteralCommandNode<CommandSourceStack>> COMMANDS = ConcurrentHashMap.newKeySet();
+	private record CommandRegistration(
+		LiteralCommandNode<CommandSourceStack> node,
+		List<String> aliases,
+		String description
+	) { }
+
+	private static final Set<CommandRegistration> COMMANDS = ConcurrentHashMap.newKeySet();
 	private static final AtomicBoolean SYNC_COMMANDS = new AtomicBoolean();
 
 	private static void performSync() {
@@ -55,7 +64,7 @@ private static void performSync() {
 	}
 
 	private SectionNode rootNode;
-	private LiteralCommandNode<CommandSourceStack> command;
+	private CommandRegistration command;
 
 	@Override
 	public boolean init(Literal<?>[] args, int matchedPattern, ParseResult parseResult, EntryContainer entryContainer) {
@@ -65,15 +74,15 @@ public boolean init(Literal<?>[] args, int matchedPattern, ParseResult parseResu
 
 	@Override
 	public boolean load() {
-		var command = ROOT_ENTRY_DATA.getValue(rootNode);
-		if (command == null) {
+		var result = ROOT_ENTRY_DATA.getValue(rootNode);
+		if (result == null) { // parsing failed, entry will have emitted a specific error message
 			return false;
 		}
-		if (command.size() != 1 || !(command.getFirst().build() instanceof LiteralCommandNode<CommandSourceStack> commandNode)) {
+		if (result.arguments().size() != 1 || !(result.arguments().getFirst().build() instanceof LiteralCommandNode<CommandSourceStack> node)) {
 			Skript.error("A command must have a name.");
 			return false;
 		}
-		this.command = commandNode;
+		this.command = new CommandRegistration(node, result.aliases(), result.description());
 		// TODO validate whether command already exists
 
 		COMMANDS.add(this.command);