#829 Move CommandSender / name to first argument to avoid confusion with varargs

- Overloaded method with (String, String...) as args was problematic as it could be confusing on its own and also confusing with the (CommandSender, String...) flavor

src/main/java/fr/xephi/authme/command/executable/authme/RegisterAdminCommand.java

@@ -74,7 +74,7 @@ public class RegisterAdminCommand implements ExecutableCommand {
             final Player player = bukkitService.getPlayerExact(playerName);
             if (player != null) {
                 bukkitService.scheduleSyncTaskFromOptionallyAsyncTask(() ->
-                    player.kickPlayer(commonService.retrieveSingleMessage(MessageKey.KICK_FOR_ADMIN_REGISTER, player)));
+                    player.kickPlayer(commonService.retrieveSingleMessage(player, MessageKey.KICK_FOR_ADMIN_REGISTER)));
             }
         });
     }

src/main/java/fr/xephi/authme/data/TempbanManager.java

@@ -97,7 +97,7 @@ public class TempbanManager implements SettingsDependent, HasCleanup {
         if (isEnabled) {
             final String name = player.getName();
             final String ip = PlayerUtils.getPlayerIp(player);
-            final String reason = messages.retrieveSingle(MessageKey.TEMPBAN_MAX_LOGINS, player);
+            final String reason = messages.retrieveSingle(player, MessageKey.TEMPBAN_MAX_LOGINS);
 
             final Date expires = new Date();
             long newTime = expires.getTime() + (length * MILLIS_PER_MINUTE);

src/main/java/fr/xephi/authme/data/limbo/LimboPlayerTaskManager.java

@@ -51,7 +51,7 @@ class LimboPlayerTaskManager {
         int interval = settings.getProperty(RegistrationSettings.MESSAGE_INTERVAL);
         MessageResult result = getMessageKey(player.getName(), isRegistered);
         if (interval > 0) {
-            String[] joinMessage = messages.retrieveSingle(result.messageKey, player, result.args).split("\n");
+            String[] joinMessage = messages.retrieveSingle(player, result.messageKey, result.args).split("\n");
             MessageTask messageTask = new MessageTask(player, joinMessage);
             bukkitService.runTaskTimer(messageTask, 2 * TICKS_PER_SECOND, interval * TICKS_PER_SECOND);
             limbo.setMessageTask(messageTask);
@@ -67,7 +67,7 @@ class LimboPlayerTaskManager {
     void registerTimeoutTask(Player player, LimboPlayer limbo) {
         final int timeout = settings.getProperty(RestrictionSettings.TIMEOUT) * TICKS_PER_SECOND;
         if (timeout > 0) {
-            String message = messages.retrieveSingle(MessageKey.LOGIN_TIMEOUT_ERROR, player);
+            String message = messages.retrieveSingle(player, MessageKey.LOGIN_TIMEOUT_ERROR);
             BukkitTask task = bukkitService.runTaskLater(new TimeoutTask(player, message, playerCache), timeout);
             limbo.setTimeoutTask(task);
         }

src/main/java/fr/xephi/authme/listener/OnJoinVerifier.java

@@ -123,7 +123,7 @@ public class OnJoinVerifier implements Reloadable {
             return false;
         } else if (!permissionsManager.hasPermission(player, PlayerStatePermission.IS_VIP)) {
             // Server is full and player is NOT VIP; set kick message and proceed with kick
-            event.setKickMessage(messages.retrieveSingle(MessageKey.KICK_FULL_SERVER, player));
+            event.setKickMessage(messages.retrieveSingle(player, MessageKey.KICK_FULL_SERVER));
             return true;
         }
 
@@ -135,12 +135,12 @@ public class OnJoinVerifier implements Reloadable {
         }
         Player nonVipPlayer = generateKickPlayer(onlinePlayers);
         if (nonVipPlayer != null) {
-            nonVipPlayer.kickPlayer(messages.retrieveSingle(MessageKey.KICK_FOR_VIP, player));
+            nonVipPlayer.kickPlayer(messages.retrieveSingle(player, MessageKey.KICK_FOR_VIP));
             event.allow();
             return false;
         } else {
             ConsoleLogger.info("VIP player " + player.getName() + " tried to join, but the server was full");
-            event.setKickMessage(messages.retrieveSingle(MessageKey.KICK_FULL_SERVER, player));
+            event.setKickMessage(messages.retrieveSingle(player, MessageKey.KICK_FULL_SERVER));
             return true;
         }
     }

src/main/java/fr/xephi/authme/listener/PlayerListener.java

@@ -257,7 +257,7 @@ public class PlayerListener implements Listener {
         try {
             runOnJoinChecks(JoiningPlayer.fromName(name), event.getAddress().getHostAddress());
         } catch (FailedVerificationException e) {
-            event.setKickMessage(m.retrieveSingle(e.getReason(), name, e.getArgs()));
+            event.setKickMessage(m.retrieveSingle(name, e.getReason(), e.getArgs()));
             event.setLoginResult(AsyncPlayerPreLoginEvent.Result.KICK_OTHER);
         }
     }
@@ -285,7 +285,7 @@ public class PlayerListener implements Listener {
             try {
                 runOnJoinChecks(JoiningPlayer.fromPlayerObject(player), event.getAddress().getHostAddress());
             } catch (FailedVerificationException e) {
-                event.setKickMessage(m.retrieveSingle(e.getReason(), player, e.getArgs()));
+                event.setKickMessage(m.retrieveSingle(player, e.getReason(), e.getArgs()));
                 event.setResult(PlayerLoginEvent.Result.KICK_OTHER);
             }
         }

src/main/java/fr/xephi/authme/message/Messages.java

@@ -70,7 +70,7 @@ public class Messages {
      * @param replacements The replacements to apply for the tags
      */
     public void send(CommandSender sender, MessageKey key, String... replacements) {
-        String message = retrieveSingle(key, sender, replacements);
+        String message = retrieveSingle(sender, key, replacements);
         for (String line : message.split("\n")) {
             sender.sendMessage(line);
         }
@@ -149,12 +149,12 @@ public class Messages {
      * logs an error if the number of supplied replacements doesn't correspond to the number of tags
      * the message key contains.
      *
-     * @param key The key of the message to send
      * @param sender The entity to send the message to
+     * @param key The key of the message to send
      * @param replacements The replacements to apply for the tags
      * @return The message from the file with replacements
      */
-    public String retrieveSingle(MessageKey key, CommandSender sender, String... replacements) {
+    public String retrieveSingle(CommandSender sender, MessageKey key, String... replacements) {
         String message = retrieveMessage(key, sender);
         String[] tags = key.getTags();
         if (replacements.length == tags.length) {
@@ -172,12 +172,12 @@ public class Messages {
      * logs an error if the number of supplied replacements doesn't correspond to the number of tags
      * the message key contains.
      *
-     * @param key The key of the message to send
      * @param name The name of the entity to send the message to
+     * @param key The key of the message to send
      * @param replacements The replacements to apply for the tags
      * @return The message from the file with replacements
      */
-    public String retrieveSingle(MessageKey key, String name, String... replacements) {
+    public String retrieveSingle(String name, MessageKey key, String... replacements) {
         String message = retrieveMessage(key, name);
         String[] tags = key.getTags();
         if (replacements.length == tags.length) {

src/main/java/fr/xephi/authme/process/join/AsynchronousJoin.java

@@ -138,7 +138,7 @@ public class AsynchronousJoin implements AsynchronousProcess {
 
     private void handlePlayerWithUnmetNameRestriction(Player player, String ip) {
         bukkitService.scheduleSyncTaskFromOptionallyAsyncTask(() -> {
-            player.kickPlayer(service.retrieveSingleMessage(MessageKey.NOT_OWNER_ERROR, player));
+            player.kickPlayer(service.retrieveSingleMessage(player, MessageKey.NOT_OWNER_ERROR));
             if (service.getProperty(RestrictionSettings.BAN_UNKNOWN_IP)) {
                 server.banIP(ip);
             }
@@ -188,7 +188,7 @@ public class AsynchronousJoin implements AsynchronousProcess {
             && countOnlinePlayersByIp(ip) > service.getProperty(RestrictionSettings.MAX_JOIN_PER_IP)) {
 
             bukkitService.scheduleSyncTaskFromOptionallyAsyncTask(
-                () -> player.kickPlayer(service.retrieveSingleMessage(MessageKey.SAME_IP_ONLINE, player)));
+                () -> player.kickPlayer(service.retrieveSingleMessage(player, MessageKey.SAME_IP_ONLINE)));
             return false;
         }
         return true;

src/main/java/fr/xephi/authme/process/login/AsynchronousLogin.java

@@ -197,7 +197,7 @@ public class AsynchronousLogin implements AsynchronousProcess {
             tempbanManager.tempbanPlayer(player);
         } else if (service.getProperty(RestrictionSettings.KICK_ON_WRONG_PASSWORD)) {
             bukkitService.scheduleSyncTaskFromOptionallyAsyncTask(
-                () -> player.kickPlayer(service.retrieveSingleMessage(MessageKey.WRONG_PASSWORD, player)));
+                () -> player.kickPlayer(service.retrieveSingleMessage(player, MessageKey.WRONG_PASSWORD)));
         } else {
             service.send(player, MessageKey.WRONG_PASSWORD);
 

src/main/java/fr/xephi/authme/process/register/ProcessSyncPasswordRegister.java

@@ -58,7 +58,7 @@ public class ProcessSyncPasswordRegister implements SynchronousProcess {
 
         // Kick Player after Registration is enabled, kick the player
         if (service.getProperty(RegistrationSettings.FORCE_KICK_AFTER_REGISTER)) {
-            player.kickPlayer(service.retrieveSingleMessage(MessageKey.REGISTER_SUCCESS, player));
+            player.kickPlayer(service.retrieveSingleMessage(player, MessageKey.REGISTER_SUCCESS));
             return;
         }
 

src/main/java/fr/xephi/authme/service/CommonService.java

@@ -63,12 +63,12 @@ public class CommonService {
     /**
      * Retrieves a message in one piece.
      *
-     * @param key the key of the message
      * @param sender The entity to send the message to
+     * @param key the key of the message
      * @return the message
      */
-    public String retrieveSingleMessage(MessageKey key, CommandSender sender) {
+    public String retrieveSingleMessage(CommandSender sender, MessageKey key) {
-        return messages.retrieveSingle(key, sender);
+        return messages.retrieveSingle(sender, key);
     }
 
     /**

src/test/java/fr/xephi/authme/command/executable/authme/RegisterAdminCommandTest.java

@@ -160,7 +160,7 @@ public class RegisterAdminCommandTest {
         Player player = mock(Player.class);
         given(bukkitService.getPlayerExact(user)).willReturn(player);
         String kickForAdminRegister = "Admin registered you -- log in again";
-        given(commandService.retrieveSingleMessage(MessageKey.KICK_FOR_ADMIN_REGISTER, player)).willReturn(kickForAdminRegister);
+        given(commandService.retrieveSingleMessage(player, MessageKey.KICK_FOR_ADMIN_REGISTER)).willReturn(kickForAdminRegister);
         CommandSender sender = mock(CommandSender.class);
         setBukkitServiceToScheduleSyncTaskFromOptionallyAsyncTask(bukkitService);
         setBukkitServiceToRunTaskOptionallyAsync(bukkitService);

src/test/java/fr/xephi/authme/data/TempbanManagerTest.java

@@ -149,7 +149,7 @@ public class TempbanManagerTest {
         String ip = "123.45.67.89";
         TestHelper.mockPlayerIp(player, ip);
         String banReason = "IP ban too many logins";
-        given(messages.retrieveSingle(MessageKey.TEMPBAN_MAX_LOGINS, player)).willReturn(banReason);
+        given(messages.retrieveSingle(player, MessageKey.TEMPBAN_MAX_LOGINS)).willReturn(banReason);
         Settings settings = mockSettings(2, 100, "");
         TempbanManager manager = new TempbanManager(bukkitService, messages, settings);
         setBukkitServiceToScheduleSyncDelayedTask(bukkitService);
@@ -195,7 +195,7 @@ public class TempbanManagerTest {
         String ip = "22.44.66.88";
         TestHelper.mockPlayerIp(player, ip);
         String banReason = "kick msg";
-        given(messages.retrieveSingle(MessageKey.TEMPBAN_MAX_LOGINS, player)).willReturn(banReason);
+        given(messages.retrieveSingle(player, MessageKey.TEMPBAN_MAX_LOGINS)).willReturn(banReason);
         Settings settings = mockSettings(10, 60, "");
         TempbanManager manager = new TempbanManager(bukkitService, messages, settings);
         manager.increaseCount(ip, "user");

src/test/java/fr/xephi/authme/data/limbo/LimboPlayerTaskManagerTest.java

@@ -71,7 +71,7 @@ public class LimboPlayerTaskManagerTest {
         Player player = mock(Player.class);
         LimboPlayer limboPlayer = mock(LimboPlayer.class);
         MessageKey key = MessageKey.REGISTER_MESSAGE;
-        given(messages.retrieveSingle(key, player)).willReturn("Please register!");
+        given(messages.retrieveSingle(player, key)).willReturn("Please register!");
         int interval = 12;
         given(settings.getProperty(RegistrationSettings.MESSAGE_INTERVAL)).willReturn(interval);
 
@@ -80,7 +80,7 @@ public class LimboPlayerTaskManagerTest {
 
         // then
         verify(limboPlayer).setMessageTask(any(MessageTask.class));
-        verify(messages).retrieveSingle(key, player);
+        verify(messages).retrieveSingle(player, key);
         verify(bukkitService).runTaskTimer(
             any(MessageTask.class), eq(2L * TICKS_PER_SECOND), eq((long) interval * TICKS_PER_SECOND));
     }
@@ -110,7 +110,7 @@ public class LimboPlayerTaskManagerTest {
         MessageTask existingMessageTask = mock(MessageTask.class);
         limboPlayer.setMessageTask(existingMessageTask);
         given(settings.getProperty(RegistrationSettings.MESSAGE_INTERVAL)).willReturn(8);
-        given(messages.retrieveSingle(MessageKey.REGISTER_MESSAGE, player)).willReturn("Please register!");
+        given(messages.retrieveSingle(player, MessageKey.REGISTER_MESSAGE)).willReturn("Please register!");
 
         // when
         limboPlayerTaskManager.registerMessageTask(player, limboPlayer, false);
@@ -119,7 +119,7 @@ public class LimboPlayerTaskManagerTest {
         assertThat(limboPlayer.getMessageTask(), not(nullValue()));
         assertThat(limboPlayer.getMessageTask(), not(sameInstance(existingMessageTask)));
         verify(registrationCaptchaManager).isCaptchaRequired(name);
-        verify(messages).retrieveSingle(MessageKey.REGISTER_MESSAGE, player);
+        verify(messages).retrieveSingle(player, MessageKey.REGISTER_MESSAGE);
         verify(existingMessageTask).cancel();
     }
 
@@ -134,14 +134,14 @@ public class LimboPlayerTaskManagerTest {
         given(registrationCaptchaManager.isCaptchaRequired(name)).willReturn(true);
         String captcha = "M032";
         given(registrationCaptchaManager.getCaptchaCodeOrGenerateNew(name)).willReturn(captcha);
-        given(messages.retrieveSingle(MessageKey.CAPTCHA_FOR_REGISTRATION_REQUIRED, player, captcha)).willReturn("Need to use captcha");
+        given(messages.retrieveSingle(player, MessageKey.CAPTCHA_FOR_REGISTRATION_REQUIRED, captcha)).willReturn("Need to use captcha");
 
         // when
         limboPlayerTaskManager.registerMessageTask(player, limboPlayer, false);
 
         // then
         assertThat(limboPlayer.getMessageTask(), not(nullValue()));
-        verify(messages).retrieveSingle(MessageKey.CAPTCHA_FOR_REGISTRATION_REQUIRED, player, captcha);
+        verify(messages).retrieveSingle(player, MessageKey.CAPTCHA_FOR_REGISTRATION_REQUIRED, captcha);
     }
 
     @Test
@@ -159,7 +159,7 @@ public class LimboPlayerTaskManagerTest {
         // then
         verify(limboPlayer).setTimeoutTask(bukkitTask);
         verify(bukkitService).runTaskLater(any(TimeoutTask.class), eq(600L)); // 30 * TICKS_PER_SECOND
-        verify(messages).retrieveSingle(MessageKey.LOGIN_TIMEOUT_ERROR, player);
+        verify(messages).retrieveSingle(player, MessageKey.LOGIN_TIMEOUT_ERROR);
     }
 
     @Test
@@ -194,7 +194,7 @@ public class LimboPlayerTaskManagerTest {
         verify(existingTask).cancel();
         assertThat(limboPlayer.getTimeoutTask(), equalTo(bukkitTask));
         verify(bukkitService).runTaskLater(any(TimeoutTask.class), eq(360L)); // 18 * TICKS_PER_SECOND
-        verify(messages).retrieveSingle(MessageKey.LOGIN_TIMEOUT_ERROR, player);
+        verify(messages).retrieveSingle(player, MessageKey.LOGIN_TIMEOUT_ERROR);
     }
 
 }

src/test/java/fr/xephi/authme/listener/OnJoinVerifierTest.java

@@ -101,7 +101,7 @@ public class OnJoinVerifierTest {
         event.setResult(PlayerLoginEvent.Result.KICK_FULL);
         given(permissionsManager.hasPermission(player, PlayerStatePermission.IS_VIP)).willReturn(false);
         String serverFullMessage = "server is full";
-        given(messages.retrieveSingle(MessageKey.KICK_FULL_SERVER, player)).willReturn(serverFullMessage);
+        given(messages.retrieveSingle(player, MessageKey.KICK_FULL_SERVER)).willReturn(serverFullMessage);
 
         // when
         boolean result = onJoinVerifier.refusePlayerForFullServer(event);
@@ -125,7 +125,7 @@ public class OnJoinVerifierTest {
         given(permissionsManager.hasPermission(onlinePlayers.get(1), PlayerStatePermission.IS_VIP)).willReturn(false);
         returnOnlineListFromBukkitServer(onlinePlayers);
         given(server.getMaxPlayers()).willReturn(onlinePlayers.size());
-        given(messages.retrieveSingle(MessageKey.KICK_FOR_VIP, player)).willReturn("kick for vip");
+        given(messages.retrieveSingle(player, MessageKey.KICK_FOR_VIP)).willReturn("kick for vip");
 
         // when
         boolean result = onJoinVerifier.refusePlayerForFullServer(event);
@@ -149,7 +149,7 @@ public class OnJoinVerifierTest {
         given(permissionsManager.hasPermission(onlinePlayers.get(0), PlayerStatePermission.IS_VIP)).willReturn(true);
         returnOnlineListFromBukkitServer(onlinePlayers);
         given(server.getMaxPlayers()).willReturn(onlinePlayers.size());
-        given(messages.retrieveSingle(MessageKey.KICK_FULL_SERVER, player)).willReturn("kick full server");
+        given(messages.retrieveSingle(player, MessageKey.KICK_FULL_SERVER)).willReturn("kick full server");
 
         // when
         boolean result = onJoinVerifier.refusePlayerForFullServer(event);

src/test/java/fr/xephi/authme/listener/PlayerListenerTest.java

@@ -596,7 +596,7 @@ public class PlayerListenerTest {
             MessageKey.INVALID_NAME_CHARACTERS, "[a-z]");
         doThrow(exception).when(onJoinVerifier).checkIsValidName(name);
         String message = "Invalid characters!";
-        given(messages.retrieveSingle(exception.getReason(), player, exception.getArgs())).willReturn(message);
+        given(messages.retrieveSingle(player, exception.getReason(), exception.getArgs())).willReturn(message);
 
         // when
         listener.onPlayerLogin(event);

src/test/java/fr/xephi/authme/message/MessagesIntegrationTest.java

@@ -100,7 +100,7 @@ public class MessagesIntegrationTest {
         given(sender.getName()).willReturn("Tester");
 
         // when
-        String message = messages.retrieveSingle(key, sender);
+        String message = messages.retrieveSingle(sender, key);
 
         // then
         assertThat(message, equalTo("We've got\nnew lines\nand ' apostrophes"));
@@ -252,7 +252,7 @@ public class MessagesIntegrationTest {
         given(sender.getName()).willReturn("Tester");
 
         // when
-        String message = messages.retrieveSingle(key, sender);
+        String message = messages.retrieveSingle(sender, key);
 
         // then
         assertThat(message, equalTo("§cWrong password!"));
@@ -266,7 +266,7 @@ public class MessagesIntegrationTest {
         given(sender.getName()).willReturn("Tester");
 
         // when
-        String result = messages.retrieveSingle(key, sender.getName(), "24680");
+        String result = messages.retrieveSingle(sender.getName(), key, "24680");
 
         // then
         assertThat(result, equalTo("Use /captcha 24680 to solve the captcha"));

src/test/java/fr/xephi/authme/service/CommonServiceTest.java

@@ -85,14 +85,14 @@ public class CommonServiceTest {
         MessageKey key = MessageKey.ACCOUNT_NOT_ACTIVATED;
         Player player = mock(Player.class);
         String text = "Test text";
-        given(messages.retrieveSingle(key, player)).willReturn(text);
+        given(messages.retrieveSingle(player, key)).willReturn(text);
 
         // when
-        String result = commonService.retrieveSingleMessage(key, player);
+        String result = commonService.retrieveSingleMessage(player, key);
 
         // then
         assertThat(result, equalTo(text));
-        verify(messages).retrieveSingle(key, player);
+        verify(messages).retrieveSingle(player, key);
     }
 
     @Test