Replace region literal parsing in favor of runtime computation

Safer in case world/region gets unloaded/deleted

Author: APickledWalrus

src/main/java/org/skriptlang/skriptworldguard/SkriptWorldGuard.java

@@ -16,12 +16,9 @@
 import ch.njol.yggdrasil.Fields;
 import com.sk89q.worldguard.WorldGuard;
 import com.sk89q.worldguard.session.MoveType;
-import org.bukkit.Bukkit;
 import org.bukkit.World;
 import org.bukkit.plugin.Plugin;
 import org.bukkit.plugin.java.JavaPlugin;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
 import org.skriptlang.skript.addon.AddonModule;
 import org.skriptlang.skript.addon.SkriptAddon;
 import org.skriptlang.skript.registration.SyntaxRegistry;
@@ -32,8 +29,6 @@
 
 import java.io.StreamCorruptedException;
 import java.lang.reflect.InvocationTargetException;
-import java.util.regex.Matcher;
-import java.util.regex.Pattern;
 
 public class SkriptWorldGuard extends JavaPlugin implements AddonModule {
 
@@ -96,55 +91,37 @@ public void init(SkriptAddon addon) {
 				.requiredPlugins("WorldGuard 7")
 				.since("1.0")
 				.parser(new Parser<>() {
-					// TODO maybe we should do something else here... perhaps make use of SkriptParser methods?
-					final Pattern regionPattern = Pattern.compile(
-							"(?:the )?(?:worldguard )?region (?:with (?:the )?(?:name|id) |named )?\"(.+)\" (?:in|of) (?:(?:the )?world )?\"(.+)\""
-					);
-
-					@Override
-					public @Nullable WorldGuardRegion parse(@NotNull String input, @NotNull ParseContext context) {
-						if (context == ParseContext.EVENT || context == ParseContext.COMMAND) {
-							Matcher matcher = regionPattern.matcher(input);
-							if (matcher.matches()) {
-								String id = matcher.group(1);
-								World world = Bukkit.getWorld(matcher.group(2));
-								return world == null ? null : RegionUtils.getRegion(world, id);
-							}
-						}
-						return null;
-					}
-
 					@Override
-					public boolean canParse(@NotNull ParseContext context) {
-						return context == ParseContext.EVENT || context == ParseContext.COMMAND;
+					public boolean canParse(ParseContext context) {
+						return false;
 					}
 
 					@Override
-					public @NotNull String toString(WorldGuardRegion region, int flags) {
+					public String toString(WorldGuardRegion region, int flags) {
 						return region.toString();
 					}
 
 					@Override
-					public @NotNull String toVariableNameString(WorldGuardRegion region) {
+					public String toVariableNameString(WorldGuardRegion region) {
 						return "worldguardregion:" + region;
 					}
 				})
 				.serializer(new Serializer<>() {
 					@Override
-					public @NotNull Fields serialize(WorldGuardRegion region) {
+					public Fields serialize(WorldGuardRegion region) {
 						Fields fields = new Fields();
 						fields.putObject("world", region.world());
 						fields.putObject("id", region.region().getId());
 						return fields;
 					}
 
 					@Override
-					public void deserialize(WorldGuardRegion region, @NotNull Fields fields) {
+					public void deserialize(WorldGuardRegion region, Fields fields) {
 						assert false;
 					}
 
 					@Override
-					protected WorldGuardRegion deserialize(@NotNull Fields fields) throws StreamCorruptedException {
+					protected WorldGuardRegion deserialize(Fields fields) throws StreamCorruptedException {
 						World world = fields.getObject("world", World.class);
 						String id = fields.getObject("id", String.class);
 						if (world == null || id == null) {

src/main/java/org/skriptlang/skriptworldguard/elements/events/EvtRegionEnterLeave.java

@@ -1,30 +1,37 @@
 package org.skriptlang.skriptworldguard.elements.events;
 
+import ch.njol.skript.config.Node;
 import ch.njol.skript.lang.Literal;
 import ch.njol.skript.lang.SkriptEvent;
 import ch.njol.skript.lang.SkriptParser.ParseResult;
 import ch.njol.skript.lang.SyntaxStringBuilder;
+import ch.njol.skript.lang.util.SimpleExpression;
 import ch.njol.skript.registrations.EventValues;
 import com.sk89q.worldguard.session.MoveType;
+import org.bukkit.Bukkit;
+import org.bukkit.World;
 import org.bukkit.entity.Player;
 import org.bukkit.event.Event;
 import org.jetbrains.annotations.Nullable;
 import org.skriptlang.skript.bukkit.registration.BukkitRegistryKeys;
 import org.skriptlang.skript.bukkit.registration.BukkitSyntaxInfos;
+import org.skriptlang.skript.log.runtime.SyntaxRuntimeErrorProducer;
 import org.skriptlang.skript.registration.SyntaxRegistry;
 import org.skriptlang.skriptworldguard.worldguard.RegionEnterLeaveEvent;
+import org.skriptlang.skriptworldguard.worldguard.RegionUtils;
 import org.skriptlang.skriptworldguard.worldguard.WorldGuardRegion;
 
-public class EvtRegionEnterLeave extends SkriptEvent {
+public class EvtRegionEnterLeave extends SkriptEvent implements SyntaxRuntimeErrorProducer {
 
 	public static void register(SyntaxRegistry registry) {
+		String regionPattern = "[the] [worldguard] region[s] [with [the] (name[s]|id[s])|named] %*strings% (in|of) [[the] world] %*string%";
 		registry.register(BukkitRegistryKeys.EVENT, BukkitSyntaxInfos.Event.builder(EvtRegionEnterLeave.class, "Region Enter/Leave")
 				.supplier(EvtRegionEnterLeave::new)
 				.addEvent(RegionEnterLeaveEvent.class)
-				.addPatterns("enter[ing] of ([a] region|%-worldguardregions%)",
-						"(region|%-worldguardregions%) enter[ing]",
-						"(leav(e|ing)|exit[ing]) of ([a] region|%-worldguardregions%)",
-						"(region|%-worldguardregions%) (leav(e|ing)|exit[ing])")
+				.addPatterns("region enter[ing]",
+						"enter[ing] of " + regionPattern,
+						"region (exit[ing]|leav(e|ing))",
+						"exit[ing] of " + regionPattern)
 				.addDescription("Called when a player enters or leaves a region (or the specified region(s))")
 				.addExample("""
 						on region enter:
@@ -38,39 +45,83 @@ public static void register(SyntaxRegistry registry) {
 		EventValues.registerEventValue(RegionEnterLeaveEvent.class, MoveType.class, RegionEnterLeaveEvent::getMoveType);
 	}
 
-	private @Nullable Literal<WorldGuardRegion> regions;
-	private boolean enter;
+	private Node node;
+
+	private @Nullable Literal<String> regionIds;
+	private @Nullable Literal<String> world;
+	private boolean isEntering;
 
 	@Override
 	public boolean init(Literal<?>[] args, int matchedPattern, ParseResult parseResult) {
-		//noinspection unchecked
-		regions = (Literal<WorldGuardRegion>) args[0];
-		enter = matchedPattern <= 1;
+		node = getParser().getNode();
+		if (args.length != 0) {
+			//noinspection unchecked
+			regionIds = (Literal<String>) args[0];
+			//noinspection unchecked
+			world = (Literal<String>) args[1];
+		}
+		isEntering = matchedPattern <= 1;
 		return true;
 	}
 
 	@Override
 	public boolean check(Event event) {
-		return event instanceof RegionEnterLeaveEvent enterLeaveEvent
-				&& enterLeaveEvent.isEntering() == enter
-				&& (regions == null || regions.check(enterLeaveEvent, region -> region.equals(enterLeaveEvent.getRegion())));
+		if (!(event instanceof RegionEnterLeaveEvent enterLeaveEvent) || enterLeaveEvent.isEntering() != isEntering) {
+			return false;
+		}
+		if (regionIds == null) {
+			return true;
+		}
+		assert world != null;
+
+		// validate world
+		World world = Bukkit.getWorld(this.world.getSingle());
+		if (world == null) {
+			error("The world '" + this.world.getSingle() + "' does not exist");
+			return false;
+		}
+
+		// map regions
+		String[] regionIds = this.regionIds.getAll();
+		WorldGuardRegion[] regions = new WorldGuardRegion[regionIds.length];
+		for (int i = 0; i < regionIds.length; i++) {
+			regions[i] = RegionUtils.getRegion(world, regionIds[i]);
+			if (regions[i] == null) {
+				error("The region '" + regionIds[i] + "' does not exist in the world '" + world.getName() + "'");
+				return false;
+			}
+		}
+
+		return SimpleExpression.check(regions, region -> region.equals(enterLeaveEvent.getRegion()), false, false);
 	}
 
 	@Override
 	public String toString(@Nullable Event event, boolean debug) {
 		SyntaxStringBuilder builder = new SyntaxStringBuilder(event, debug);
-		if (enter) {
-			builder.append("entering");
-		} else {
-			builder.append("leaving");
+		if (regionIds == null) {
+			builder.append("region");
 		}
-		builder.append("of");
-		if (regions == null) {
-			builder.append("a region");
+		if (isEntering) {
+			builder.append("enter");
 		} else {
-			builder.append(regions);
+			builder.append("exit");
+		}
+		if (regionIds != null) {
+			assert world != null;
+			builder.append("of");
+			if (regionIds.isSingle()) {
+				builder.append("region");
+			} else {
+				builder.append("regions");
+			}
+			builder.append("named", regionIds, "in the world", world);
 		}
 		return builder.toString();
 	}
 
+	@Override
+	public Node getNode() {
+		return node;
+	}
+
 }

src/main/java/org/skriptlang/skriptworldguard/elements/expressions/ExprRegionNamed.java

@@ -34,8 +34,8 @@ public class ExprRegionNamed extends SimpleExpression<WorldGuardRegion> {
 	public static void register(SyntaxRegistry registry) {
 		registry.register(SyntaxRegistry.EXPRESSION, SyntaxInfo.Expression.builder(ExprRegionNamed.class, WorldGuardRegion.class)
 				.supplier(ExprRegionNamed::new)
-				.addPatterns("[the] [worldguard] region[s] [named] %strings% [in %world%]",
-						"[the] [worldguard] region[s] with [the] (name[s]|id[s]) %strings% [in %world%]")
+				.addPatterns("[the] [worldguard] region[s] [named] %strings% [(in|of) %world%]",
+						"[the] [worldguard] region[s] with [the] (name[s]|id[s]) %strings% [(in|of) %world%]")
 				.build());
 	}