Refactor all remaining issuer raw string messages to use localized strings

src/main/java/org/mvplugins/multiverse/core/command/MVCommandContexts.java

@@ -39,7 +39,9 @@
 import org.mvplugins.multiverse.core.display.filters.DefaultContentFilter;
 import org.mvplugins.multiverse.core.display.filters.RegexContentFilter;
 import org.mvplugins.multiverse.core.exceptions.command.MVInvalidCommandArgument;
+import org.mvplugins.multiverse.core.locale.MVCorei18n;
 import org.mvplugins.multiverse.core.locale.message.Message;
+import org.mvplugins.multiverse.core.locale.message.MessageReplacement.Replace;
 import org.mvplugins.multiverse.core.utils.PlayerFinder;
 import org.mvplugins.multiverse.core.utils.REPatterns;
 import org.mvplugins.multiverse.core.utils.tick.TickDuration;
@@ -168,15 +170,67 @@ private GeneratorPlugin parseGeneratorPlugin(BukkitCommandExecutionContext conte
         return generatorPlugin;
     }
 
+    private Message loadedMultiverseWorldPlayerOnlyMessage() {
+        return Message.of(MVCorei18n.COMMANDS_ERROR_LOADEDMULTIVERSEWORLD_PLAYERSONLY);
+    }
+
+    private Message loadedMultiverseWorldIssuerMessage() {
+        return Message.of(MVCorei18n.COMMANDS_ERROR_LOADEDMULTIVERSEWORLD_ISSUER);
+    }
+
+    private Message loadedMultiverseWorldInputConsoleMessage(String worldName) {
+        return Message.of(MVCorei18n.COMMANDS_ERROR_LOADEDMULTIVERSEWORLD_INPUTCONSOLE,
+                Replace.WORLD.with(worldName));
+    }
+
+    private Message loadedMultiverseWorldInputMessage(String worldName) {
+        return Message.of(MVCorei18n.COMMANDS_ERROR_LOADEDMULTIVERSEWORLD_INPUT, Replace.WORLD.with(worldName));
+    }
+
+    private Message multiverseWorldPlayerOnlyMessage() {
+        return Message.of(MVCorei18n.COMMANDS_ERROR_MULTIVERSEWORLD_PLAYERSONLY);
+    }
+
+    private Message multiverseWorldIssuerMessage() {
+        return Message.of(MVCorei18n.COMMANDS_ERROR_MULTIVERSEWORLD_ISSUER);
+    }
+
+    private Message multiverseWorldInputConsoleMessage(String worldName) {
+        return Message.of(MVCorei18n.COMMANDS_ERROR_MULTIVERSEWORLD_INPUTCONSOLE, Replace.WORLD.with(worldName));
+    }
+
+    private Message multiverseWorldInputMessage(String worldName) {
+        return Message.of(MVCorei18n.COMMANDS_ERROR_MULTIVERSEWORLD_INPUT, Replace.WORLD.with(worldName));
+    }
+
+    private Message playerOnlyMessage() {
+        return Message.of(MVCorei18n.COMMANDS_ERROR_PLAYERSONLY);
+    }
+
+    private Message playerInputIssuerMessage(String playerName) {
+        return Message.of(MVCorei18n.COMMANDS_ERROR_PLAYER_ISSUERINPUT, Replace.PLAYER.with(playerName));
+    }
+
+    private Message playerInputMessage(String playerName) {
+        return Message.of(MVCorei18n.COMMANDS_ERROR_PLAYER_INPUT, Replace.PLAYER.with(playerName));
+    }
+
+    private Message playerSelectorMessage(String selector) {
+        return Message.of(MVCorei18n.COMMANDS_ERROR_PLAYER_SELECTOR, Replace.PLAYER.with(selector));
+    }
+
+    private Message playersInputMessage(String playerName) {
+        return Message.of(MVCorei18n.COMMANDS_ERROR_PLAYERS_INPUT, Replace.PLAYER.with(playerName));
+    }
 
     private IssuerAwareContextBuilder<LoadedMultiverseWorld> loadedMultiverseWorldContextBuilder() {
         return new IssuerAwareContextBuilder<LoadedMultiverseWorld>()
                 .fromPlayer((context, player) -> worldManager.getLoadedWorld(player.getWorld()).getOrNull())
                 .fromInput((context, input) -> getLoadedMultiverseWorld(input))
-                .issuerOnlyFailMessage((context) -> Message.of("This command can only be used by a player in a loaded Multiverse World."))
-                .issuerAwarePlayerFailMessage((context, player) -> Message.of("You are not in a loaded multiverse world. Either specify a multiverse world name or use this command in a loaded multiverse world."))
-                .issuerAwareInputFailMessage((context, input) -> Message.of("World '" + input + "' is not a loaded multiverse world. Remember to specify the world name when using this command in console."))
-                .inputOnlyFailMessage((context, input) -> Message.of("World " + input + " is not a loaded multiverse world."));
+                .issuerOnlyFailMessage((context) -> loadedMultiverseWorldPlayerOnlyMessage())
+                .issuerAwarePlayerFailMessage((context, player) -> loadedMultiverseWorldIssuerMessage())
+                .issuerAwareInputFailMessage((context, input) -> loadedMultiverseWorldInputConsoleMessage(input))
+                .inputOnlyFailMessage((context, input) -> loadedMultiverseWorldInputMessage(input));
     }
 
     private IssuerAwareContextBuilder<LoadedMultiverseWorld[]> loadedMultiverseWorldArrayContextBuilder() {
@@ -194,16 +248,17 @@ private IssuerAwareContextBuilder<LoadedMultiverseWorld[]> loadedMultiverseWorld
                         }
                         LoadedMultiverseWorld world = getLoadedMultiverseWorld(worldName);
                         if (world == null) {
-                            throw new InvalidCommandArgument("World " + worldName + " is not a loaded multiverse world.");
+                            throw new InvalidCommandArgument(
+                                    loadedMultiverseWorldInputMessage(worldName).formatted(context.getIssuer()));
                         }
                         worlds.add(world);
                     }
                     return worlds.isEmpty() ? null : worlds.toArray(new LoadedMultiverseWorld[0]);
                 })
-                .issuerOnlyFailMessage((context) -> Message.of("This command can only be used by a player in a loaded Multiverse World."))
-                .issuerAwarePlayerFailMessage((context, player) -> Message.of("You are not in a loaded multiverse world. Either specify a multiverse world name or use this command in a loaded multiverse world."))
-                .issuerAwareInputFailMessage((context, input) -> Message.of("World '" + input + "' is not a loaded multiverse world. Remember to specify the world name when using this command in console."))
-                .inputOnlyFailMessage((context, input) -> Message.of("World " + input + " is not a loaded multiverse world."));
+                .issuerOnlyFailMessage((context) -> loadedMultiverseWorldPlayerOnlyMessage())
+                .issuerAwarePlayerFailMessage((context, player) -> loadedMultiverseWorldIssuerMessage())
+                .issuerAwareInputFailMessage((context, input) -> loadedMultiverseWorldInputConsoleMessage(input))
+                .inputOnlyFailMessage((context, input) -> loadedMultiverseWorldInputMessage(input));
     }
 
     @Nullable
@@ -217,10 +272,10 @@ private IssuerAwareContextBuilder<MultiverseWorld> multiverseWorldContextBuilder
         return new IssuerAwareContextBuilder<MultiverseWorld>()
                 .fromPlayer((context, player) -> worldManager.getWorld(player.getWorld()).getOrNull())
                 .fromInput((context, input) -> getMultiverseWorld(input))
-                .issuerOnlyFailMessage((context) -> Message.of("This command can only be used by a player in a Multiverse World."))
-                .issuerAwarePlayerFailMessage((context, player) -> Message.of("You are not in a multiverse world. Either specify a multiverse world name or use this command in a multiverse world."))
-                .issuerAwareInputFailMessage((context, input) -> Message.of("World '" + input + "' is not a multiverse world. Remember to specify the world name when using this command in console."))
-                .inputOnlyFailMessage((context, input) -> Message.of("World " + input + " is not a multiverse world."));
+                .issuerOnlyFailMessage((context) -> multiverseWorldPlayerOnlyMessage())
+                .issuerAwarePlayerFailMessage((context, player) -> multiverseWorldIssuerMessage())
+                .issuerAwareInputFailMessage((context, input) -> multiverseWorldInputConsoleMessage(input))
+                .inputOnlyFailMessage((context, input) -> multiverseWorldInputMessage(input));
     }
 
     private IssuerAwareContextBuilder<MultiverseWorld[]> multiverseWorldArrayContextBuilder() {
@@ -238,16 +293,17 @@ private IssuerAwareContextBuilder<MultiverseWorld[]> multiverseWorldArrayContext
                         }
                         MultiverseWorld world = getMultiverseWorld(worldName);
                         if (world == null) {
-                            throw new InvalidCommandArgument("World " + worldName + " is not a multiverse world.");
+                            throw new InvalidCommandArgument(
+                                    multiverseWorldInputMessage(worldName).formatted(context.getIssuer()));
                         }
                         worlds.add(world);
                     }
                     return worlds.isEmpty() ? null : worlds.toArray(new MultiverseWorld[0]);
                 })
-                .issuerOnlyFailMessage((context) -> Message.of("This command can only be used by a player in a Multiverse World."))
-                .issuerAwarePlayerFailMessage((context, player) -> Message.of("You are not in a multiverse world. Either specify a multiverse world name or use this command in a multiverse world."))
-                .issuerAwareInputFailMessage((context, input) -> Message.of("World '" + input + "' is not a multiverse world. Remember to specify the world name when using this command in console."))
-                .inputOnlyFailMessage((context, input) -> Message.of("World " + input + " is not a multiverse world."));
+                .issuerOnlyFailMessage((context) -> multiverseWorldPlayerOnlyMessage())
+                .issuerAwarePlayerFailMessage((context, player) -> multiverseWorldIssuerMessage())
+                .issuerAwareInputFailMessage((context, input) -> multiverseWorldInputConsoleMessage(input))
+                .inputOnlyFailMessage((context, input) -> multiverseWorldInputMessage(input));
     }
 
     @Nullable
@@ -267,9 +323,9 @@ private IssuerAwareContextBuilder<Player> playerContextBuilder() {
         return new IssuerAwareContextBuilder<Player>()
                 .fromPlayer((context, player) -> player)
                 .fromInput((context, input) -> PlayerFinder.get(input, context.getSender()))
-                .issuerOnlyFailMessage((context) -> Message.of("This command can only be used by a player."))
-                .issuerAwareInputFailMessage((context, input) -> Message.of("Invalid player: " + input + ". Either specify an online player or use this command as a player."))
-                .inputOnlyFailMessage((context, input) -> Message.of("Player " + input + " not found."));
+                .issuerOnlyFailMessage((context) -> playerOnlyMessage())
+                .issuerAwareInputFailMessage((context, input) -> playerInputIssuerMessage(input))
+                .inputOnlyFailMessage((context, input) -> playerInputMessage(input));
     }
 
     private IssuerAwareContextBuilder<Player[]> playerArrayContextBuilder() {
@@ -286,13 +342,13 @@ private IssuerAwareContextBuilder<Player[]> playerArrayContextBuilder() {
                             throw new InvalidCommandArgument(failure.getLocalizedMessage() + " "
                                     + Option.of(failure.getCause()).map(Throwable::getLocalizedMessage).getOrElse(""));
                         }))
-                .issuerOnlyFailMessage((context) -> Message.of("This command can only be used by a player."))
-                .issuerAwareInputFailMessage((context, input) -> Message.of("Invalid player: " + input + ". Either specify an online player or use this command as a player."))
+                .issuerOnlyFailMessage((context) -> playerOnlyMessage())
+                .issuerAwareInputFailMessage((context, input) -> playerInputIssuerMessage(input))
                 .inputOnlyFailMessage((context, input) -> {
                     if (PlayerFinder.isSelector(input)) {
-                        return Message.of("No player(s) matched selector: " + input + ".");
+                        return playerSelectorMessage(input);
                     }
-                    return Message.of("Player(s) " + input + " not found.");
+                    return playersInputMessage(input);
                 });
     }
 

src/main/java/org/mvplugins/multiverse/core/command/context/issueraware/IssuerAwareContextBuilder.java

@@ -6,12 +6,16 @@
 import co.aikar.commands.contexts.IssuerAwareContextResolver;
 import org.bukkit.entity.Player;
 import org.jetbrains.annotations.ApiStatus;
+import org.mvplugins.multiverse.core.locale.MVCorei18n;
 import org.mvplugins.multiverse.core.locale.message.Message;
+import org.mvplugins.multiverse.core.locale.message.MessageReplacement.Replace;
 
 import java.util.Objects;
 import java.util.function.BiFunction;
 import java.util.function.Function;
 
+import static org.mvplugins.multiverse.core.locale.message.MessageReplacement.replace;
+
 /**
  * Reusable logic of issuer only and issuer aware context resolvers
  *
@@ -22,10 +26,17 @@ public final class IssuerAwareContextBuilder<T> {
 
     private BiFunction<BukkitCommandExecutionContext, Player, T> fromPlayer;
     private BiFunction<BukkitCommandExecutionContext, String, T> fromInput;
-    private Function<BukkitCommandExecutionContext, Message> issuerOnlyFailMessage = context -> Message.of("This command can only be used by a player.");
-    private BiFunction<BukkitCommandExecutionContext, Player, Message> issuerAwarePlayerFailMessage = (context, player) -> Message.of("Unable to resolve context for player '" + player.getName() + "'.");
-    private BiFunction<BukkitCommandExecutionContext, String, Message> issuerAwareInputFailMessage = (context, input) -> Message.of("Unable to resolve context for input '" + input + "'.");
-    private BiFunction<BukkitCommandExecutionContext, String, Message> inputOnlyFailMessage = (context, input) -> Message.of("Unable to resolve context for input '" + input + "'.");
+    private Function<BukkitCommandExecutionContext, Message> issuerOnlyFailMessage =
+            context -> Message.of(MVCorei18n.COMMANDS_ERROR_PLAYERSONLY);
+    private BiFunction<BukkitCommandExecutionContext, Player, Message> issuerAwarePlayerFailMessage =
+            (context, player) -> Message.of(MVCorei18n.COMMANDS_ERROR_RESOLVE_PLAYER,
+                    Replace.PLAYER.with(player.getName()));
+    private BiFunction<BukkitCommandExecutionContext, String, Message> issuerAwareInputFailMessage =
+            (context, input) -> Message.of(MVCorei18n.COMMANDS_ERROR_RESOLVE_INPUT,
+                    replace("{input}").with(input));
+    private BiFunction<BukkitCommandExecutionContext, String, Message> inputOnlyFailMessage =
+            (context, input) -> Message.of(MVCorei18n.COMMANDS_ERROR_RESOLVE_INPUT,
+                    replace("{input}").with(input));
 
     public IssuerAwareContextBuilder() {
     }

src/main/java/org/mvplugins/multiverse/core/command/flags/RemovePlayerDestinationFlags.java

@@ -1,6 +1,5 @@
 package org.mvplugins.multiverse.core.command.flags;
 
-import co.aikar.commands.InvalidCommandArgument;
 import jakarta.inject.Inject;
 import org.bukkit.Bukkit;
 import org.jetbrains.annotations.ApiStatus;
@@ -13,6 +12,8 @@
 import org.mvplugins.multiverse.core.destination.DestinationsProvider;
 import org.mvplugins.multiverse.core.destination.core.WorldDestination;
 import org.mvplugins.multiverse.core.exceptions.command.MVInvalidCommandArgument;
+import org.mvplugins.multiverse.core.locale.MVCorei18n;
+import org.mvplugins.multiverse.core.locale.message.Message;
 import org.mvplugins.multiverse.core.world.WorldManager;
 
 @ApiStatus.AvailableSince("5.7")
@@ -55,7 +56,8 @@ private RemovePlayerDestinationFlags(
             .addAlias("-r")
             .defaultValue(() -> worldManager.getDefaultWorld()
                     .map(defaultWorld -> worldDestination.fromWorld(defaultWorld))
-                    .getOrElseThrow(() -> new InvalidCommandArgument("No default world found, so the --remove-players flag requires a destination argument."))) //TODO: locale
+                    .getOrElseThrow(() -> MVInvalidCommandArgument.of(
+                            Message.of(MVCorei18n.COMMANDS_ERROR_REMOVEPLAYERS_NODEFAULT))))
             .completion(input -> destinationsProvider.suggestDestinationStrings(Bukkit.getConsoleSender(), input))
             .context(input -> destinationsProvider.parseDestination(input)
                     .getOrThrow(failure ->

src/main/java/org/mvplugins/multiverse/core/command/queue/CommandQueueManager.java

@@ -15,7 +15,6 @@
 import io.vavr.control.Option;
 import jakarta.inject.Inject;
 import org.bukkit.Bukkit;
-import org.bukkit.ChatColor;
 import org.bukkit.block.data.type.CommandBlock;
 import org.bukkit.command.BlockCommandSender;
 import org.bukkit.command.CommandSender;
@@ -28,6 +27,7 @@
 import org.mvplugins.multiverse.core.MultiverseCore;
 import org.mvplugins.multiverse.core.command.MVCommandIssuer;
 import org.mvplugins.multiverse.core.config.CoreConfig;
+import org.mvplugins.multiverse.core.locale.MVCorei18n;
 import org.mvplugins.multiverse.core.utils.result.Attempt;
 
 import static org.mvplugins.multiverse.core.locale.message.MessageReplacement.*;
@@ -79,8 +79,9 @@ public void addToQueue(CommandQueuePayload payload) {
         if (config.getUseConfirmOtp()) {
             confirmCommand += " " + payload.otp();
         }
-        payload.issuer().sendMessage(String.format("Run %s%s %sto continue. This will expire in %s seconds.",
-                ChatColor.GREEN, confirmCommand, ChatColor.WHITE, config.getConfirmTimeout()));
+        payload.issuer().sendMessage(MVCorei18n.QUEUECOMMAND_PROMPT,
+                replace("{command}").with(confirmCommand),
+                replace("{timeout}").with(config.getConfirmTimeout()));
     }
 
     /**
@@ -127,7 +128,7 @@ private Runnable expireRunnable(@NotNull String senderName) {
                 // Payload already removed
                 return;
             }
-            payload.issuer().sendMessage("Your queued command has expired.");
+            payload.issuer().sendMessage(MVCorei18n.QUEUECOMMAND_EXPIRED);
         };
     }
 

src/main/java/org/mvplugins/multiverse/core/command/queue/CommandQueuePayload.java

@@ -5,6 +5,7 @@
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.mvplugins.multiverse.core.command.MVCommandIssuer;
+import org.mvplugins.multiverse.core.locale.MVCorei18n;
 import org.mvplugins.multiverse.core.locale.message.Message;
 
 /**
@@ -23,12 +24,10 @@ public static CommandQueuePayload issuer(@NotNull MVCommandIssuer issuer) {
         return new CommandQueuePayload(issuer);
     }
 
-    private static final String DEFAULT_PROMPT_MESSAGE = "The command you are trying to run is deemed dangerous."; // todo: localize
-
     private final MVCommandIssuer issuer;
     private String otp;
     private Runnable action = () -> {};
-    private Message prompt = Message.of(DEFAULT_PROMPT_MESSAGE);
+    private Message prompt = Message.of(MVCorei18n.QUEUECOMMAND_DEFAULTPROMPT);
     private BukkitTask expireTask;
 
     protected CommandQueuePayload(@NotNull MVCommandIssuer issuer) {

src/main/java/org/mvplugins/multiverse/core/commands/AnchorDeleteCommand.java

@@ -12,6 +12,9 @@
 import org.mvplugins.multiverse.core.anchor.AnchorManager;
 import org.mvplugins.multiverse.core.anchor.MultiverseAnchor;
 import org.mvplugins.multiverse.core.command.MVCommandIssuer;
+import org.mvplugins.multiverse.core.locale.MVCorei18n;
+
+import static org.mvplugins.multiverse.core.locale.message.MessageReplacement.replace;
 
 @Service
 final class AnchorDeleteCommand extends CoreCommand {
@@ -35,9 +38,9 @@ void onAnchorDeleteCommand(
             @Description("")
             MultiverseAnchor anchor) {
         if (anchorManager.deleteAnchor(anchor).isSuccess()) {
-            issuer.sendMessage("&aAnchor &f" + anchor.getName() + "&a deleted.");
+            issuer.sendMessage(MVCorei18n.ANCHOR_DELETE_SUCCESS, replace("{anchor}").with(anchor.getName()));
         } else {
-            issuer.sendMessage("&cFailed to delete anchor.");
+            issuer.sendError(MVCorei18n.ANCHOR_DELETE_FAILURE);
         }
     }
 }