From 935daedab5e6cad4322823392897cef7412c9e09 Mon Sep 17 00:00:00 2001
From: DiamondIceNS <fawfulcopter@gmail.com>
Date: Sun, 10 Dec 2017 13:14:08 -0600
Subject: [PATCH 1/5] Update Kotlin version

---
 build.gradle | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/build.gradle b/build.gradle
index b7c8c60..9fb60cc 100644
--- a/build.gradle
+++ b/build.gradle
@@ -1,7 +1,7 @@
 import org.apache.tools.ant.filters.ReplaceTokens
 
 buildscript {
-    ext.kotlin_version = '1.1.51'
+    ext.kotlin_version = '1.2.0'
 
     repositories {
         mavenCentral()

From 1ab20a097343f378f96a629e620761640a26a3f7 Mon Sep 17 00:00:00 2001
From: DiamondIceNS <fawfulcopter@gmail.com>
Date: Sun, 10 Dec 2017 14:20:37 -0600
Subject: [PATCH 2/5] Implement rudimentary command forwarding

<prefix> commands in Discord will now send to Minecraft and
execute as expected. Works with any command added by any plugin
that can be executed as server.

Command forwarding is not very robust, does not give feedback,
and will attempt to send a command before checking if it exists or not.
Will work on fixing those in future commits.

Also removed some console spam.
---
 build.gradle                                              | 2 +-
 .../commands/controllers/BotControllerManager.kt          | 8 +++++++-
 .../gg/obsidian/discordbridge/minecraft/EventListener.kt  | 1 -
 3 files changed, 8 insertions(+), 3 deletions(-)

diff --git a/build.gradle b/build.gradle
index 9fb60cc..d29f7b1 100644
--- a/build.gradle
+++ b/build.gradle
@@ -22,7 +22,7 @@ plugins {
 apply plugin: 'kotlin'
 
 group = 'gg.obsidian'
-version = '3.0.1'
+version = '3.1.0-dev1'
 description = """Bridge chat between Minecraft and Discord"""
 ext.url = 'https://github.com/the-obsidian/DiscordBridge'
 
diff --git a/src/main/kotlin/gg/obsidian/discordbridge/commands/controllers/BotControllerManager.kt b/src/main/kotlin/gg/obsidian/discordbridge/commands/controllers/BotControllerManager.kt
index 2a40453..74a8a6a 100644
--- a/src/main/kotlin/gg/obsidian/discordbridge/commands/controllers/BotControllerManager.kt
+++ b/src/main/kotlin/gg/obsidian/discordbridge/commands/controllers/BotControllerManager.kt
@@ -11,6 +11,7 @@ import gg.obsidian.discordbridge.utils.UtilFunctions.noSpace
 import gg.obsidian.discordbridge.utils.UtilFunctions.stripColor
 import gg.obsidian.discordbridge.utils.UtilFunctions.toDiscordChatMessage
 import gg.obsidian.discordbridge.utils.UtilFunctions.toMinecraftChatMessage
+import org.bukkit.Bukkit
 import java.lang.reflect.Method
 import java.util.*
 import java.util.logging.Level
@@ -110,6 +111,12 @@ class BotControllerManager(val plugin: Plugin) {
             val command = commands[commandName]
 
             if (command == null) {
+                // Attempt to run as a server command
+                val serverCommandSuccess = Bukkit.getServer().dispatchCommand(Bukkit.getServer().consoleSender, args.joinToString(" ").substring(Config.COMMAND_PREFIX.length))
+                if (serverCommandSuccess)
+                    return true
+
+
                 commandNotFound(event, commandName)
                 return false
             }
@@ -361,7 +368,6 @@ class BotControllerManager(val plugin: Plugin) {
      * message is not relayed to Minecraft
      */
     private fun relay(event: IEventWrapper, logIgnore: Boolean) {
-        plugin.logger.info("Entered relay. event: ${event.message}")
         when (event) {
             is AsyncPlayerChatEventWrapper -> {
                 var worldname = event.event.player.world.name
diff --git a/src/main/kotlin/gg/obsidian/discordbridge/minecraft/EventListener.kt b/src/main/kotlin/gg/obsidian/discordbridge/minecraft/EventListener.kt
index 72c1c13..04495ac 100644
--- a/src/main/kotlin/gg/obsidian/discordbridge/minecraft/EventListener.kt
+++ b/src/main/kotlin/gg/obsidian/discordbridge/minecraft/EventListener.kt
@@ -73,7 +73,6 @@ class EventListener(val plugin: Plugin): Listener {
         plugin.server.scheduler.runTaskAsynchronously(plugin, { controllerManager.dispatchMessage(wrapper) })
 
         event.message = MarkdownToMinecraftSeralizer().toMinecraft(plugin.pegDownProc.parseMarkdown(event.message.toCharArray()))
-        plugin.logger.info("Seralized! (synchronous)")
     }
 
     /**

From 68258c2b011af37980476b24811affc6e450363c Mon Sep 17 00:00:00 2001
From: DiamondIceNS <fawfulcopter@gmail.com>
Date: Wed, 13 Dec 2017 14:47:05 -0600
Subject: [PATCH 3/5] Fully implement command forwarding

Added:
+ Command forwarding is now possible using either prefix or
  @tag syntax
+ Command forwarding works with any command from any plugin
  that can be run from server console
+ Command output is sent back to Discord

Modified:
* Refactored some of the icky duplicate code in dispatchMessage into
  a standalone function
---
 .../commands/DiscordCommandSender.kt          |  96 +++++++
 .../commands/annotations/BotCommand.kt        |   4 +-
 .../controllers/BotControllerManager.kt       | 249 +++++++++++++-----
 .../controllers/FunCommandsController.kt      |  10 +-
 4 files changed, 292 insertions(+), 67 deletions(-)
 create mode 100644 src/main/kotlin/gg/obsidian/discordbridge/commands/DiscordCommandSender.kt

diff --git a/src/main/kotlin/gg/obsidian/discordbridge/commands/DiscordCommandSender.kt b/src/main/kotlin/gg/obsidian/discordbridge/commands/DiscordCommandSender.kt
new file mode 100644
index 0000000..8658bcf
--- /dev/null
+++ b/src/main/kotlin/gg/obsidian/discordbridge/commands/DiscordCommandSender.kt
@@ -0,0 +1,96 @@
+package gg.obsidian.discordbridge.commands
+
+import net.dv8tion.jda.core.entities.MessageChannel
+import org.bukkit.Bukkit
+import org.bukkit.Server
+import org.bukkit.command.CommandSender
+import org.bukkit.command.ConsoleCommandSender
+import org.bukkit.command.RemoteConsoleCommandSender
+import org.bukkit.permissions.Permission
+import org.bukkit.permissions.PermissionAttachment
+import org.bukkit.permissions.PermissionAttachmentInfo
+import org.bukkit.plugin.Plugin
+
+class DiscordCommandSender(val channel: MessageChannel) : RemoteConsoleCommandSender {
+
+    private val sender:ConsoleCommandSender = Bukkit.getServer().consoleSender
+
+    init {
+
+    }
+
+    override fun sendMessage(message: String?) {
+        channel.sendMessage(message).queue()
+    }
+
+    override fun sendMessage(messages: Array<out String>?) {
+        if (messages != null)
+            for (m in messages) channel.sendMessage(m)
+    }
+
+    override fun spigot(): CommandSender.Spigot {
+        return sender.spigot()
+    }
+
+    override fun addAttachment(plugin: Plugin?): PermissionAttachment {
+        return sender.addAttachment(plugin)
+    }
+
+    override fun addAttachment(plugin: Plugin?, ticks: Int): PermissionAttachment {
+        return sender.addAttachment(plugin, ticks)
+    }
+
+    override fun addAttachment(plugin: Plugin?, name: String?, value: Boolean): PermissionAttachment {
+        return sender.addAttachment(plugin, name, value)
+    }
+
+    override fun addAttachment(plugin: Plugin?, name: String?, value: Boolean, ticks: Int): PermissionAttachment {
+        return sender.addAttachment(plugin, name, value, ticks)
+    }
+
+    override fun getEffectivePermissions(): MutableSet<PermissionAttachmentInfo> {
+        return sender.effectivePermissions
+    }
+
+    override fun getName(): String {
+        return sender.name
+    }
+
+    override fun getServer(): Server {
+        return sender.server
+    }
+
+    override fun hasPermission(name: String?): Boolean {
+        return sender.hasPermission(name)
+    }
+
+    override fun hasPermission(perm: Permission?): Boolean {
+        return sender.hasPermission(perm)
+    }
+
+    override fun isOp(): Boolean {
+        return sender.isOp
+    }
+
+    override fun isPermissionSet(name: String?): Boolean {
+        return sender.isPermissionSet(name)
+    }
+
+    override fun isPermissionSet(perm: Permission?): Boolean {
+        return sender.isPermissionSet(perm)
+    }
+
+    override fun recalculatePermissions() {
+        return sender.recalculatePermissions()
+    }
+
+    override fun removeAttachment(attachment: PermissionAttachment?) {
+        return sender.removeAttachment(attachment)
+    }
+
+    override fun setOp(value: Boolean) {
+        return sender.setOp(value)
+    }
+
+
+}
\ No newline at end of file
diff --git a/src/main/kotlin/gg/obsidian/discordbridge/commands/annotations/BotCommand.kt b/src/main/kotlin/gg/obsidian/discordbridge/commands/annotations/BotCommand.kt
index ed1de34..766751f 100644
--- a/src/main/kotlin/gg/obsidian/discordbridge/commands/annotations/BotCommand.kt
+++ b/src/main/kotlin/gg/obsidian/discordbridge/commands/annotations/BotCommand.kt
@@ -7,9 +7,9 @@ package gg.obsidian.discordbridge.commands.annotations
  * @param description a short string that describes the command's function
  * @param name an optional field to override the command's access name if it is not the same as the method name
  * @param relayTriggerMessage whether the message used to trigger this command should be relayed
- * @param ignoreExcessArguments if false, this command will fail if the invoker provides too many arguments
+ * @param squishExcessArgs if true, this command will put all extra args passed to it into a single string
  */
 @Target(AnnotationTarget.FUNCTION)
 @Retention(AnnotationRetention.RUNTIME)
 annotation class BotCommand(val usage: String, val description: String, val name: String = "",
-                            val relayTriggerMessage: Boolean = true, val ignoreExcessArguments: Boolean = true)
+                            val relayTriggerMessage: Boolean = true, val squishExcessArgs: Boolean = false)
diff --git a/src/main/kotlin/gg/obsidian/discordbridge/commands/controllers/BotControllerManager.kt b/src/main/kotlin/gg/obsidian/discordbridge/commands/controllers/BotControllerManager.kt
index 74a8a6a..7b00d05 100644
--- a/src/main/kotlin/gg/obsidian/discordbridge/commands/controllers/BotControllerManager.kt
+++ b/src/main/kotlin/gg/obsidian/discordbridge/commands/controllers/BotControllerManager.kt
@@ -11,6 +11,7 @@ import gg.obsidian.discordbridge.utils.UtilFunctions.noSpace
 import gg.obsidian.discordbridge.utils.UtilFunctions.stripColor
 import gg.obsidian.discordbridge.utils.UtilFunctions.toDiscordChatMessage
 import gg.obsidian.discordbridge.utils.UtilFunctions.toMinecraftChatMessage
+import net.dv8tion.jda.core.Permission
 import org.bukkit.Bukkit
 import java.lang.reflect.Method
 import java.util.*
@@ -76,7 +77,7 @@ class BotControllerManager(val plugin: Plugin) {
         val isTagged: Boolean = method.getAnnotation(TaggedResponse::class.java) != null
         val isPrivate: Boolean = method.getAnnotation(PrivateResponse::class.java) != null
         val command = Command(commandName, usage, annotation.description, parameters, annotation.relayTriggerMessage,
-                annotation.ignoreExcessArguments, isTagged, isPrivate, controllerClass, method)
+                annotation.squishExcessArgs, isTagged, isPrivate, controllerClass, method)
         commands.put(command.name, command)
     }
 
@@ -95,66 +96,62 @@ class BotControllerManager(val plugin: Plugin) {
                 commandNotFound(event, event.command.name)
                 return true
             }
-            val inputArguments = event.rawMessage.split("\\s+".toRegex(), command.parameters.size).toTypedArray()
-            return invokeCommand(command, controllers, event, inputArguments)
+            return invokeCommand(command, controllers, event, event.args.asList().toTypedArray())
         }
 
         // Short circuit scripted responses
         if (scriptedResponse(event)) return true
 
-        val args = event.rawMessage.trim().split("\\s+".toRegex(), 2).toTypedArray()
-
         // <prefix>command
-        if (Config.COMMAND_PREFIX.isNotBlank() && args[0].startsWith(Config.COMMAND_PREFIX)) {
-            val commandName = args[0].substring(Config.COMMAND_PREFIX.length).toLowerCase()
-            if (commandName == "") return true
-            val command = commands[commandName]
-
-            if (command == null) {
-                // Attempt to run as a server command
-                val serverCommandSuccess = Bukkit.getServer().dispatchCommand(Bukkit.getServer().consoleSender, args.joinToString(" ").substring(Config.COMMAND_PREFIX.length))
-                if (serverCommandSuccess)
-                    return true
+        if (Config.COMMAND_PREFIX.isNotBlank() && event.rawMessage.startsWith(Config.COMMAND_PREFIX)) {
+            val split = event.rawMessage.replaceFirst(Config.COMMAND_PREFIX, "").trim().split("\\s+".toRegex()).toTypedArray()
+            return parseCommand(event, split, false)
+        }
 
+        // @<mention> command from Minecraft
+        if (event is AsyncPlayerChatEventWrapper && event.rawMessage.startsWith("@${Config.USERNAME.noSpace()} ")) {
+            val split = event.rawMessage.replaceFirst("@${Config.USERNAME.noSpace()} ", "").trim().split("\\s+".toRegex()).toTypedArray()
+            return parseCommand(event, split, true)
+        }
 
-                commandNotFound(event, commandName)
-                return false
-            }
+        // @<mention> command from Discord
+        if (event is MessageWrapper && event.rawMessage.startsWith(Connection.JDA.selfUser.asMention + " ")) {
+            val split = event.rawMessage.replaceFirst(Connection.JDA.selfUser.asMention + " ", "").trim().split("\\s+".toRegex()).toTypedArray()
+            return parseCommand(event, split, true)
+        }
 
-            val inputArguments = if (args.size == 1) arrayOf<String>()
-            else args[1].split("\\s+".toRegex(), command.parameters.size).toTypedArray()
+        // Just relay the message if it is neither
+        relay(event, true)
+        return true
+    }
 
-            return invokeCommand(command, controllers, event, inputArguments)
-        }
+    /**
+     * Attempt to parse and execute a command from an input string
+     *
+     * @param event the original event object
+     * @param args the input string broken up into an array of words, with the command as the first element
+     * @param defaultToTalk if true, failure to find a command to execute will execute Talk with Cleverbot using the
+     * full string as an argument. If false, failure will do nothing and the method call will return false.
+     */
+    private fun parseCommand(event: IEventWrapper, args: Array<String>, defaultToTalk: Boolean): Boolean {
+        val commandName = args[0].toLowerCase()
+        if (commandName == "") return true
+        var command = commands[commandName]
 
-        // @<mention> command
-        if ((event is AsyncPlayerChatEventWrapper && args[0] == "@"+Config.USERNAME.noSpace() ||
-                args[0] == Connection.JDA.selfUser.asMention) && args.count() == 2) {
-            val args2 = args[1].split("\\s+".toRegex(), 2).toTypedArray()
-            val commandName = args2[0].toLowerCase()
-            if (commandName == "") return true
-            var params = if (args2.size > 1) args2[1] else ""
-            var command = commands[commandName]
+        if (command == null) {
+            // Attempt to run as a server command if sent from Discord
+            if (event is MessageWrapper && event.originalMessage.member.hasPermission(Permission.ADMINISTRATOR))
+                if (serverCommand(event, args)) return true
 
+            if (defaultToTalk) command = commands["talk"]
             if (command == null) {
-                // Assume user wants to talk to Cleverbot
-                command = commands["talk"]
-                if (command == null) {
-                    commandNotFound(event, commandName)
-                    return false
-                }
-                params = args[1]
+                commandNotFound(event, commandName)
+                return false
             }
-
-            val inputArguments = if (params == "") arrayOf<String>()
-            else params.split("\\s+".toRegex(), command.parameters.size).toTypedArray()
-
-            return invokeCommand(command, controllers, event, inputArguments)
         }
 
-        // Just relay the message if it is neither
-        relay(event, true)
-        return true
+        val slicedArgs = if (args.size > 1) args.slice(1 until args.size).toTypedArray() else arrayOf()
+        return invokeCommand(command, controllers, event, slicedArgs)
     }
 
     /**
@@ -221,14 +218,16 @@ class BotControllerManager(val plugin: Plugin) {
      * @param command the command to invoke
      * @param instances a map of IBotController instances accessed by their Java classes
      * @param event the incoming event object
-     * @param inputArguments an array of String arguments to pass to the command method
+     * @param args an array of String arguments to pass to the command method
      * @return false if the command invocation has invalid arguments, true otherwise
      */
     private fun invokeCommand(command: Command, instances: Map<Class<out IBotController>, IBotController>,
-                              event: IEventWrapper, inputArguments: Array<String>): Boolean {
+                              event: IEventWrapper, args: Array<String>): Boolean {
         // Relay the trigger if applicable
         if (command.relayTriggerMessage) relay(event, false)
 
+        var squishedArgs = args
+
         when {
             // Check for permission
             event is AsyncPlayerChatEventWrapper && !event.event.player.hasPermission("discordbridge.${command.name}") -> {
@@ -255,15 +254,19 @@ class BotControllerManager(val plugin: Plugin) {
                 }
             }
 
-            // Fail if not enough arguments
-            inputArguments.size < command.parameters.size -> {
-                commandWrongParameterCount(event, command.name, command.usage, inputArguments.size, command.parameters.size)
-                return false
+            // If command is squishy, pack excess args into final string
+            command.squishExcessArgs -> {
+                if (args.size == 1)
+                    squishedArgs = arrayOf(args.joinToString(" "))
+                else {
+                    squishedArgs = args.sliceArray(0 until command.parameters.size)
+                    squishedArgs[command.parameters.size-1] = args.sliceArray(command.parameters.size until args.size).joinToString(" ")
+                }
             }
 
-            // Fail if command forces exact argument count AND the supplied argument count does not match expected
-            inputArguments.size != command.parameters.size && !command.ignoreExcessArguments -> {
-                commandWrongParameterCount(event, command.name, command.usage, inputArguments.size, command.parameters.size)
+            // Fail if wrong number of arguments
+            squishedArgs.size != command.parameters.size -> {
+                commandWrongParameterCount(event, command.name, command.usage, squishedArgs.size, command.parameters.size)
                 return false
             }
         }
@@ -271,15 +274,15 @@ class BotControllerManager(val plugin: Plugin) {
         // Package arguments to send to method
         val arguments = arrayOfNulls<Any>(command.parameters.size + 1)
         arguments[0] = event
-        val paramRange = if (command.ignoreExcessArguments && inputArguments.size > command.parameters.size)
+        val paramRange = if (command.squishExcessArgs && squishedArgs.size > command.parameters.size)
             IntRange(0, command.parameters.size - 1) else command.parameters.indices
         for (i in paramRange) {
             val parameterClass = command.parameters[i]
 
             try {
-                arguments[i + 1] = parseArgument(parameterClass, inputArguments[i])
+                arguments[i + 1] = parseArgument(parameterClass, squishedArgs[i])
             } catch (ignored: IllegalArgumentException) {
-                commandWrongParameterType(event, command.name, command.usage, i, inputArguments[i].javaClass, parameterClass)
+                commandWrongParameterType(event, command.name, command.usage, i, squishedArgs[i].javaClass, parameterClass)
                 return false
             }
         }
@@ -290,7 +293,7 @@ class BotControllerManager(val plugin: Plugin) {
             respond(event, command, response)
             return true
         } catch (e: IllegalArgumentException) {
-            commandWrongParameterCount(event, command.name, command.usage, inputArguments.size, command.parameters.size)
+            commandWrongParameterCount(event, command.name, command.usage, squishedArgs.size, command.parameters.size)
             return false
         } catch (e: Exception) {
             commandException(event, e)
@@ -299,6 +302,46 @@ class BotControllerManager(val plugin: Plugin) {
 
     }
 
+    /**
+     * Attempts to run a default or installed chat command as server
+     *
+     * @param event the incoming event object
+     * @param args the arguments associated with the command, space-delimited
+     */
+    private fun serverCommand(event: IEventWrapper, args: Array<String>): Boolean {
+            val sender = DiscordCommandSender(event.channel)
+            val commandName = args[0].toLowerCase()
+            when {
+                DefaultCommands.minecraft.contains(commandName) -> {
+                    plugin.logDebug("Discord user ${event.senderName} invoked Minecraft command '${args.joinToString(" ")}'")
+                    Bukkit.getServer().dispatchCommand(sender, args.joinToString(" "))
+                    return true
+                }
+
+                DefaultCommands.bukkit.contains(commandName) -> {
+                    plugin.logDebug("Discord user ${event.senderName} invoked Bukkit command '${args.joinToString(" ")}'")
+                    Bukkit.getServer().dispatchCommand(sender, args.joinToString(" "))
+                    return true
+                }
+
+                DefaultCommands.spigot.contains(commandName) -> {
+                    plugin.logDebug("Discord user ${event.senderName} invoked Spigot command '${args.joinToString(" ")}'")
+                    Bukkit.getServer().dispatchCommand(sender, args.joinToString(" "))
+                    return true
+                }
+
+                else -> {
+                    val pluginCommand = Bukkit.getServer().getPluginCommand(commandName)
+                    if (pluginCommand != null) {
+                        plugin.logDebug("Discord user ${event.senderName} invoked ${pluginCommand.plugin.name} command '${args.joinToString(" ")}'")
+                        pluginCommand.execute(sender, commandName, args.sliceArray(1 until args.size))
+                        return true
+                    }
+                }
+            }
+        return false
+    }
+
     /**
      * Sends the response of a successful command invocation to its respective medium
      *
@@ -587,7 +630,7 @@ class BotControllerManager(val plugin: Plugin) {
      * @param description a description of the command's function
      * @param parameters a List of the command arguments' expected Java class types
      * @param relayTriggerMessage whether the message that triggered this command should be relayed
-     * @param ignoreExcessArguments whether this command should ignore excess arguments
+     * @param squishExcessArgs whether this command should combine excess arguments into one
      * @param isTagged if the output of this command should be prepended with "@invokerName | "
      * @param isPrivate if the output of this command should be sent via DM/PM to the invoker
      * @param controllerClass the Java class type of the IBotController that defines this command
@@ -599,10 +642,96 @@ class BotControllerManager(val plugin: Plugin) {
             val description: String,
             val parameters: List<Class<*>>,
             val relayTriggerMessage: Boolean,
-            val ignoreExcessArguments: Boolean,
+            val squishExcessArgs: Boolean,
             val isTagged: Boolean,
             val isPrivate: Boolean,
             val controllerClass: Class<*>,
             val commandMethod: Method
     )
+
+    private object DefaultCommands {
+        val minecraft : List<String> = listOf(
+                "advancement",
+                "ban",
+                "blockdata",
+                "clear",
+                "clone",
+                //"data",
+                //"datapack",
+                "debug",
+                "defaultgamemode",
+                "deop",
+                "difficulty",
+                "effect",
+                "enchant",
+                "entitydata",
+                //"experience",
+                "execute",
+                "fill",
+                "function",
+                "gamemode",
+                "gamerule",
+                "give",
+                "help",
+                "kick",
+                "kill",
+                "list",
+                "locate",
+                "me",
+                "op",
+                "pardon",
+                "particle",
+                "playsound",
+                "publish",
+                "recipe",
+                "reload",
+                "replaceitem",
+                "save",
+                "say",
+                "scoreboard",
+                "seed",
+                "setblock",
+                "setidletimeout",
+                "setmaxplayers",
+                "setworldspawn",
+                "spawnpoint",
+                "spreadplayers",
+                "stats",
+                "stop",
+                "stopsound",
+                "summon",
+                "teleport",
+                "tell",
+                //"tag",
+                //"team",
+                "tellraw",
+                "testfor",
+                "testforblock",
+                "testforblocks",
+                "tickingarea",
+                "time",
+                "title",
+                "toggledownfall",
+                "tp",
+                "transferserver",
+                "trigger",
+                "weather",
+                "whitelist",
+                "worldborder",
+                "wsserver"
+        )
+
+        val bukkit : List<String> = listOf(
+                "version",
+                "plugins",
+                "help",
+                "reload",
+                "timings"
+        )
+
+        val spigot:List<String> = listOf(
+                "restart",
+                "tps"
+        )
+    }
 }
diff --git a/src/main/kotlin/gg/obsidian/discordbridge/commands/controllers/FunCommandsController.kt b/src/main/kotlin/gg/obsidian/discordbridge/commands/controllers/FunCommandsController.kt
index 1214aa5..836d9ce 100644
--- a/src/main/kotlin/gg/obsidian/discordbridge/commands/controllers/FunCommandsController.kt
+++ b/src/main/kotlin/gg/obsidian/discordbridge/commands/controllers/FunCommandsController.kt
@@ -29,7 +29,7 @@ class FunCommandsController(val plugin: Plugin) : IBotController {
      * @param event the incoming event object
      * @return the response string
      */
-    @BotCommand(name = "8ball", usage = "<question>", description = "Consult the Magic 8 Ball")
+    @BotCommand(name = "8ball", usage = "<question>", description = "Consult the Magic 8 Ball", squishExcessArgs = true)
     @TaggedResponse
     private fun eightBall(event: IEventWrapper): String {
         plugin.logDebug("user ${event.senderName} consults the Magic 8-Ball")
@@ -46,7 +46,7 @@ class FunCommandsController(val plugin: Plugin) : IBotController {
      * @return the response string
      */
     @BotCommand(name = "choose", usage = "<option>, <option>, ... (delimiters include ',', 'or', '|')",
-            description = "Have the bot choose between given options")
+            description = "Have the bot choose between given options", squishExcessArgs = true)
     @TaggedResponse
     private fun choose(event: IEventWrapper, query: String): String {
         plugin.logDebug("user ${event.senderName} needs a choice made")
@@ -100,7 +100,7 @@ class FunCommandsController(val plugin: Plugin) : IBotController {
      * @param thingToInsult the target of the insult
      * @return the response string
      */
-    @BotCommand(usage="<thing to insult>", description = "Make the bot insult something for you")
+    @BotCommand(usage="<thing to insult>", description = "Make the bot insult something for you", squishExcessArgs = true)
     private fun insult(event: IEventWrapper, thingToInsult: String): String {
         plugin.logDebug("user ${event.senderName} requests an insult against '$thingToInsult'")
         val responses = plugin.insult.data.getStringList("responses")
@@ -115,7 +115,7 @@ class FunCommandsController(val plugin: Plugin) : IBotController {
      * @param thingToRate the thing that will receive the rating
      * @return the response string
      */
-    @BotCommand(usage="<thing to be rated>", description = "Have the bot rate something for you")
+    @BotCommand(usage="<thing to be rated>", description = "Have the bot rate something for you", squishExcessArgs = true)
     @TaggedResponse
     private fun rate(event: IEventWrapper, thingToRate: String): String {
         plugin.logDebug("user ${event.senderName} requests a rating")
@@ -182,7 +182,7 @@ class FunCommandsController(val plugin: Plugin) : IBotController {
      * @return the response string
      */
     @TaggedResponse
-    @BotCommand(usage="<say something>", description = "Say something to Cleverbot")
+    @BotCommand(usage="<say something>", description = "Say something to Cleverbot", squishExcessArgs = true)
     private fun talk(event: IEventWrapper, query: String): String {
         plugin.logDebug("user ${event.senderName} invokes Cleverbot")
 

From 582f754b9cdc3b9078581d2f6670915514f768d2 Mon Sep 17 00:00:00 2001
From: DiamondIceNS <fawfulcopter@gmail.com>
Date: Wed, 13 Dec 2017 15:32:15 -0600
Subject: [PATCH 4/5] Fix bug that drops first argument for commands

---
 .../commands/controllers/BotControllerManager.kt          | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/main/kotlin/gg/obsidian/discordbridge/commands/controllers/BotControllerManager.kt b/src/main/kotlin/gg/obsidian/discordbridge/commands/controllers/BotControllerManager.kt
index 7b00d05..064d017 100644
--- a/src/main/kotlin/gg/obsidian/discordbridge/commands/controllers/BotControllerManager.kt
+++ b/src/main/kotlin/gg/obsidian/discordbridge/commands/controllers/BotControllerManager.kt
@@ -73,7 +73,7 @@ class BotControllerManager(val plugin: Plugin) {
         if (methodParameters.isEmpty() || !methodParameters[0].type.isAssignableFrom(IEventWrapper::class.java)) return
 
         method.isAccessible = true
-        val parameters = (1..methodParameters.size - 1).mapTo(ArrayList<Class<*>>()) { methodParameters[it].type }
+        val parameters = (1 until methodParameters.size).mapTo(ArrayList<Class<*>>()) { methodParameters[it].type }
         val isTagged: Boolean = method.getAnnotation(TaggedResponse::class.java) != null
         val isPrivate: Boolean = method.getAnnotation(PrivateResponse::class.java) != null
         val command = Command(commandName, usage, annotation.description, parameters, annotation.relayTriggerMessage,
@@ -256,11 +256,11 @@ class BotControllerManager(val plugin: Plugin) {
 
             // If command is squishy, pack excess args into final string
             command.squishExcessArgs -> {
-                if (args.size == 1)
+                if (command.parameters.size == 1)
                     squishedArgs = arrayOf(args.joinToString(" "))
                 else {
-                    squishedArgs = args.sliceArray(0 until command.parameters.size)
-                    squishedArgs[command.parameters.size-1] = args.sliceArray(command.parameters.size until args.size).joinToString(" ")
+                    squishedArgs = args.sliceArray(0 until command.parameters.size-1)
+                    squishedArgs[command.parameters.size-1] = args.sliceArray(command.parameters.size-1 until args.size).joinToString(" ")
                 }
             }
 

From ad69465900259981d10d7364487df491ef69ceee Mon Sep 17 00:00:00 2001
From: DiamondIceNS <fawfulcopter@gmail.com>
Date: Thu, 14 Dec 2017 19:25:38 -0600
Subject: [PATCH 5/5] Update version to 3.1.0

Modified:
- Reorganized BotControllerManager to be a little more navigable
- Minor syntax tweaks taking advantage of new Kotlin syntax
- Added 'private' and removed some explicit type declarations so
  IDEA would make the squiggly lines go away
---
 build.gradle                                  |   2 +-
 .../gg/obsidian/discordbridge/Plugin.kt       |  26 +-
 .../obsidian/discordbridge/UserAliasConfig.kt |   4 +-
 .../controllers/BotControllerManager.kt       | 272 ++++++++++--------
 .../controllers/FunCommandsController.kt      |  10 +-
 .../discordbridge/discord/Connection.kt       |   2 +-
 .../discordbridge/discord/Listener.kt         |   2 +-
 .../minecraft/CommandListener.kt              |   2 +-
 .../discordbridge/minecraft/EventListener.kt  |   2 +-
 9 files changed, 170 insertions(+), 152 deletions(-)

diff --git a/build.gradle b/build.gradle
index d29f7b1..ce9bd56 100644
--- a/build.gradle
+++ b/build.gradle
@@ -22,7 +22,7 @@ plugins {
 apply plugin: 'kotlin'
 
 group = 'gg.obsidian'
-version = '3.1.0-dev1'
+version = '3.1.0'
 description = """Bridge chat between Minecraft and Discord"""
 ext.url = 'https://github.com/the-obsidian/DiscordBridge'
 
diff --git a/src/main/kotlin/gg/obsidian/discordbridge/Plugin.kt b/src/main/kotlin/gg/obsidian/discordbridge/Plugin.kt
index adf5411..b84c691 100644
--- a/src/main/kotlin/gg/obsidian/discordbridge/Plugin.kt
+++ b/src/main/kotlin/gg/obsidian/discordbridge/Plugin.kt
@@ -136,7 +136,7 @@ class Plugin : JavaPlugin() {
     /**
      * Saves all default configs where configs do not exist and reloads data from file into memory
      */
-    fun updateConfig(version: String) {
+    private fun updateConfig(version: String) {
         this.saveDefaultConfig()
         config.options().copyDefaults(true)
         config.set("version", version)
@@ -182,7 +182,7 @@ class Plugin : JavaPlugin() {
         val users = Connection.listUsers()
         val found: Member = users.find { it.user.name + "#" + it.user.discriminator == discriminator } ?: return null
 
-        val ua: UserAlias = UserAlias(player.uniqueId, found.user.id)
+        val ua = UserAlias(player.uniqueId, found.user.id)
         requests.add(ua)
         val msg = "Minecraft user '${server.getOfflinePlayer(ua.mcUuid).name}' has requested to become associated with your Discord" +
                 " account. If this is you, respond '${Connection.JDA.selfUser.asMention} confirm'. If this is not" +
@@ -203,8 +203,8 @@ class Plugin : JavaPlugin() {
 
         var response = "${CC.YELLOW}Discord users:"
         for (user in users) {
-            if (user.user.isBot) response += "\n${CC.GOLD}- ${user.effectiveName} (Bot) | ${user.user.name}#${user.user.discriminator}${CC.RESET}"
-            else response += "\n${CC.YELLOW}- ${user.effectiveName} | ${user.user.name}#${user.user.discriminator}${CC.RESET}"
+            response += if (user.user.isBot) "\n${CC.GOLD}- ${user.effectiveName} (Bot) | ${user.user.name}#${user.user.discriminator}${CC.RESET}"
+            else "\n${CC.YELLOW}- ${user.effectiveName} | ${user.user.name}#${user.user.discriminator}${CC.RESET}"
         }
         return response.trim()
     }
@@ -218,25 +218,25 @@ class Plugin : JavaPlugin() {
             return "${CC.YELLOW}No Discord members could be found. Either server is empty or an error has occurred."
 
         var response = ""
-        if (onlineUsers.filter { it.onlineStatus == OnlineStatus.ONLINE }.isNotEmpty()) {
+        if (onlineUsers.any { it.onlineStatus == OnlineStatus.ONLINE }) {
             response += "\n${CC.DARK_GREEN}Online:${CC.RESET}"
             for (user in onlineUsers.filter { it.onlineStatus == OnlineStatus.ONLINE }) {
-                if (user.user.isBot) response += "\n${CC.DARK_GREEN}- ${user.effectiveName} (Bot)${CC.RESET}"
-                else response += "\n${CC.DARK_GREEN}- ${user.effectiveName}${CC.RESET}"
+                response += if (user.user.isBot) "\n${CC.DARK_GREEN}- ${user.effectiveName} (Bot)${CC.RESET}"
+                else "\n${CC.DARK_GREEN}- ${user.effectiveName}${CC.RESET}"
             }
         }
-        if (onlineUsers.filter { it.onlineStatus == OnlineStatus.IDLE }.isNotEmpty()) {
+        if (onlineUsers.any { it.onlineStatus == OnlineStatus.IDLE }) {
             response += "\n${CC.YELLOW}Idle:${CC.RESET}"
             for (user in onlineUsers.filter { it.onlineStatus == OnlineStatus.IDLE }) {
-                if (user.user.isBot) response += "\n${CC.YELLOW}- ${user.effectiveName} (Bot)${CC.RESET}"
-                else response += "\n${CC.YELLOW}- ${user.effectiveName}${CC.RESET}"
+                response += if (user.user.isBot) "\n${CC.YELLOW}- ${user.effectiveName} (Bot)${CC.RESET}"
+                else "\n${CC.YELLOW}- ${user.effectiveName}${CC.RESET}"
             }
         }
-        if (onlineUsers.filter { it.onlineStatus == OnlineStatus.DO_NOT_DISTURB }.isNotEmpty()) {
+        if (onlineUsers.any { it.onlineStatus == OnlineStatus.DO_NOT_DISTURB }) {
             response += "\n${CC.RED}Do Not Disturb:${CC.RESET}"
             for (user in onlineUsers.filter { it.onlineStatus == OnlineStatus.DO_NOT_DISTURB }) {
-                if (user.user.isBot) response += "\n${CC.RED}- ${user.effectiveName} (Bot)${CC.RESET}"
-                else response += "\n${CC.RED}- ${user.effectiveName}${CC.RESET}"
+                response += if (user.user.isBot) "\n${CC.RED}- ${user.effectiveName} (Bot)${CC.RESET}"
+                else "\n${CC.RED}- ${user.effectiveName}${CC.RESET}"
             }
         }
 
diff --git a/src/main/kotlin/gg/obsidian/discordbridge/UserAliasConfig.kt b/src/main/kotlin/gg/obsidian/discordbridge/UserAliasConfig.kt
index 2398afa..05e8b41 100644
--- a/src/main/kotlin/gg/obsidian/discordbridge/UserAliasConfig.kt
+++ b/src/main/kotlin/gg/obsidian/discordbridge/UserAliasConfig.kt
@@ -13,7 +13,7 @@ object UserAliasConfig {
      */
     fun load(plugin: Plugin) {
         val list = plugin.users.data.getList("aliases")
-        if (list != null) aliases = list.checkItemsAre<UserAlias>() ?:
+        if (list != null) aliases = list.checkItemsAre() ?:
                 throw IllegalStateException("usernames.yml could not be read - list items are not properly formatted")
         else mutableListOf<UserAlias>()
     }
@@ -42,5 +42,5 @@ object UserAliasConfig {
      * A function to assert that all the items in a given list are of a specific type
      */
     @Suppress("UNCHECKED_CAST")
-    inline fun <reified T : Any> List<*>.checkItemsAre() = if (all { it is T }) this as List<T> else null
+    private inline fun <reified T : Any> List<*>.checkItemsAre() = if (all { it is T }) this as List<T> else null
 }
diff --git a/src/main/kotlin/gg/obsidian/discordbridge/commands/controllers/BotControllerManager.kt b/src/main/kotlin/gg/obsidian/discordbridge/commands/controllers/BotControllerManager.kt
index 064d017..8f09c83 100644
--- a/src/main/kotlin/gg/obsidian/discordbridge/commands/controllers/BotControllerManager.kt
+++ b/src/main/kotlin/gg/obsidian/discordbridge/commands/controllers/BotControllerManager.kt
@@ -31,6 +31,9 @@ class BotControllerManager(val plugin: Plugin) {
     private val commands: MutableMap<String, Command> = mutableMapOf()
     private val controllers: MutableMap<Class<out IBotController>, IBotController> = mutableMapOf()
 
+    // =============================================
+    // =============== SETUP METHODS ===============
+
     /**
      * Adds an IBotController to the manager.
      *
@@ -81,6 +84,9 @@ class BotControllerManager(val plugin: Plugin) {
         commands.put(command.name, command)
     }
 
+    // =============================================
+    // ============== MESSAGE HANDLING =============
+
     /**
      * Reads an incoming message and attempts to parse and execute a command.
      *
@@ -96,11 +102,11 @@ class BotControllerManager(val plugin: Plugin) {
                 commandNotFound(event, event.command.name)
                 return true
             }
-            return invokeCommand(command, controllers, event, event.args.asList().toTypedArray())
+            return invokeBotCommand(command, controllers, event, event.args.asList().toTypedArray())
         }
 
         // Short circuit scripted responses
-        if (scriptedResponse(event)) return true
+        if (sendScriptedResponse(event)) return true
 
         // <prefix>command
         if (Config.COMMAND_PREFIX.isNotBlank() && event.rawMessage.startsWith(Config.COMMAND_PREFIX)) {
@@ -120,47 +126,18 @@ class BotControllerManager(val plugin: Plugin) {
             return parseCommand(event, split, true)
         }
 
-        // Just relay the message if it is neither
+        // Just relay the message if no command is found
         relay(event, true)
         return true
     }
 
-    /**
-     * Attempt to parse and execute a command from an input string
-     *
-     * @param event the original event object
-     * @param args the input string broken up into an array of words, with the command as the first element
-     * @param defaultToTalk if true, failure to find a command to execute will execute Talk with Cleverbot using the
-     * full string as an argument. If false, failure will do nothing and the method call will return false.
-     */
-    private fun parseCommand(event: IEventWrapper, args: Array<String>, defaultToTalk: Boolean): Boolean {
-        val commandName = args[0].toLowerCase()
-        if (commandName == "") return true
-        var command = commands[commandName]
-
-        if (command == null) {
-            // Attempt to run as a server command if sent from Discord
-            if (event is MessageWrapper && event.originalMessage.member.hasPermission(Permission.ADMINISTRATOR))
-                if (serverCommand(event, args)) return true
-
-            if (defaultToTalk) command = commands["talk"]
-            if (command == null) {
-                commandNotFound(event, commandName)
-                return false
-            }
-        }
-
-        val slicedArgs = if (args.size > 1) args.slice(1 until args.size).toTypedArray() else arrayOf()
-        return invokeCommand(command, controllers, event, slicedArgs)
-    }
-
     /**
      * Looks for a scripted trigger and returns a respective response
      *
      * @param event the incoming event object
      * @return true if a trigger was found and successfully responded to, false otherwise
      */
-    private fun scriptedResponse(event: IEventWrapper): Boolean {
+    private fun sendScriptedResponse(event: IEventWrapper): Boolean {
         val responses = plugin.script.data.getList("responses").checkItemsAre<Script>() ?: return false
 
         var response: Script? = null
@@ -213,7 +190,36 @@ class BotControllerManager(val plugin: Plugin) {
     }
 
     /**
-     * Attempts to invoke a discovered command
+     * Attempt to parse and execute a command from an input string
+     *
+     * @param event the original event object
+     * @param args the input string broken up into an array of words, with the command as the first element
+     * @param defaultToTalk if true, failure to find a command to execute will execute Talk with Cleverbot using the
+     * full string as an argument. If false, failure will do nothing and the method call will return false.
+     */
+    private fun parseCommand(event: IEventWrapper, args: Array<String>, defaultToTalk: Boolean): Boolean {
+        val commandName = args[0].toLowerCase()
+        if (commandName == "") return true
+        var command = commands[commandName]
+
+        if (command == null) {
+            // Attempt to run as a server command if sent from Discord
+            if (event is MessageWrapper && event.originalMessage.member.hasPermission(Permission.ADMINISTRATOR))
+                if (invokeServerCommand(event, args)) return true
+
+            if (defaultToTalk) command = commands["talk"]
+            if (command == null) {
+                commandNotFound(event, commandName)
+                return false
+            }
+        }
+
+        val slicedArgs = if (args.size > 1) args.slice(1 until args.size).toTypedArray() else arrayOf()
+        return invokeBotCommand(command, controllers, event, slicedArgs)
+    }
+
+    /**
+     * Attempts to run a DiscordBridge command
      *
      * @param command the command to invoke
      * @param instances a map of IBotController instances accessed by their Java classes
@@ -221,8 +227,8 @@ class BotControllerManager(val plugin: Plugin) {
      * @param args an array of String arguments to pass to the command method
      * @return false if the command invocation has invalid arguments, true otherwise
      */
-    private fun invokeCommand(command: Command, instances: Map<Class<out IBotController>, IBotController>,
-                              event: IEventWrapper, args: Array<String>): Boolean {
+    private fun invokeBotCommand(command: Command, instances: Map<Class<out IBotController>, IBotController>,
+                                 event: IEventWrapper, args: Array<String>): Boolean {
         // Relay the trigger if applicable
         if (command.relayTriggerMessage) relay(event, false)
 
@@ -243,7 +249,7 @@ class BotControllerManager(val plugin: Plugin) {
             command.name == "help" -> {
                 try {
                     val response = command.commandMethod.invoke(instances[command.controllerClass], event, commands, instances) as? String ?: return true
-                    respond(event, command, response)
+                    sendBotCommandOutput(event, command, response)
                     return true
                 } catch (e: IllegalArgumentException) {
                     commandWrongParameterCount(event, command.name, command.usage, 2, command.parameters.size)
@@ -290,7 +296,7 @@ class BotControllerManager(val plugin: Plugin) {
         // Invoke the method
         try {
             val response = command.commandMethod.invoke(instances[command.controllerClass], *arguments) as? String ?: return true
-            respond(event, command, response)
+            sendBotCommandOutput(event, command, response)
             return true
         } catch (e: IllegalArgumentException) {
             commandWrongParameterCount(event, command.name, command.usage, squishedArgs.size, command.parameters.size)
@@ -303,53 +309,13 @@ class BotControllerManager(val plugin: Plugin) {
     }
 
     /**
-     * Attempts to run a default or installed chat command as server
-     *
-     * @param event the incoming event object
-     * @param args the arguments associated with the command, space-delimited
-     */
-    private fun serverCommand(event: IEventWrapper, args: Array<String>): Boolean {
-            val sender = DiscordCommandSender(event.channel)
-            val commandName = args[0].toLowerCase()
-            when {
-                DefaultCommands.minecraft.contains(commandName) -> {
-                    plugin.logDebug("Discord user ${event.senderName} invoked Minecraft command '${args.joinToString(" ")}'")
-                    Bukkit.getServer().dispatchCommand(sender, args.joinToString(" "))
-                    return true
-                }
-
-                DefaultCommands.bukkit.contains(commandName) -> {
-                    plugin.logDebug("Discord user ${event.senderName} invoked Bukkit command '${args.joinToString(" ")}'")
-                    Bukkit.getServer().dispatchCommand(sender, args.joinToString(" "))
-                    return true
-                }
-
-                DefaultCommands.spigot.contains(commandName) -> {
-                    plugin.logDebug("Discord user ${event.senderName} invoked Spigot command '${args.joinToString(" ")}'")
-                    Bukkit.getServer().dispatchCommand(sender, args.joinToString(" "))
-                    return true
-                }
-
-                else -> {
-                    val pluginCommand = Bukkit.getServer().getPluginCommand(commandName)
-                    if (pluginCommand != null) {
-                        plugin.logDebug("Discord user ${event.senderName} invoked ${pluginCommand.plugin.name} command '${args.joinToString(" ")}'")
-                        pluginCommand.execute(sender, commandName, args.sliceArray(1 until args.size))
-                        return true
-                    }
-                }
-            }
-        return false
-    }
-
-    /**
-     * Sends the response of a successful command invocation to its respective medium
+     * Sends the response of a successful bot command invocation to its respective medium
      *
      * @param event the incoming event object
      * @param command the command that was invoked
      * @param response the output string of the invoked command
      */
-    private fun respond(event: IEventWrapper, command: Command, response: String) {
+    private fun sendBotCommandOutput(event: IEventWrapper, command: Command, response: String) {
         var modifiedResponse = response
         when (event) {
             is AsyncPlayerChatEventWrapper -> {
@@ -403,6 +369,46 @@ class BotControllerManager(val plugin: Plugin) {
         }
     }
 
+    /**
+     * Attempts to run a Spigot command
+     *
+     * @param event the incoming event object
+     * @param args the arguments associated with the command, space-delimited
+     */
+    private fun invokeServerCommand(event: IEventWrapper, args: Array<String>): Boolean {
+            val sender = DiscordCommandSender(event.channel)
+            val commandName = args[0].toLowerCase()
+            when {
+                DefaultCommands.minecraft.contains(commandName) -> {
+                    plugin.logDebug("Discord user ${event.senderName} invoked Minecraft command '${args.joinToString(" ")}'")
+                    Bukkit.getServer().dispatchCommand(sender, args.joinToString(" "))
+                    return true
+                }
+
+                DefaultCommands.bukkit.contains(commandName) -> {
+                    plugin.logDebug("Discord user ${event.senderName} invoked Bukkit command '${args.joinToString(" ")}'")
+                    Bukkit.getServer().dispatchCommand(sender, args.joinToString(" "))
+                    return true
+                }
+
+                DefaultCommands.spigot.contains(commandName) -> {
+                    plugin.logDebug("Discord user ${event.senderName} invoked Spigot command '${args.joinToString(" ")}'")
+                    Bukkit.getServer().dispatchCommand(sender, args.joinToString(" "))
+                    return true
+                }
+
+                else -> {
+                    val pluginCommand = Bukkit.getServer().getPluginCommand(commandName)
+                    if (pluginCommand != null) {
+                        plugin.logDebug("Discord user ${event.senderName} invoked ${pluginCommand.plugin.name} command '${args.joinToString(" ")}'")
+                        pluginCommand.execute(sender, commandName, args.sliceArray(1 until args.size))
+                        return true
+                    }
+                }
+            }
+        return false
+    }
+
     /**
      * Attempts to relay the message between Minecraft and Discord, if applicable
      *
@@ -443,53 +449,8 @@ class BotControllerManager(val plugin: Plugin) {
         }
     }
 
-    /**
-     * Attempts to parse a string parameter to an expected value type
-     *
-     * @param parameterClass the expected type of the parameter
-     * @param value a string representation of the value to be parsed
-     */
-    private fun parseArgument(parameterClass: Class<*>, value: String): Any {
-        try {
-            when (parameterClass) {
-                String::class.java -> return value
-                Int::class.javaPrimitiveType, Int::class.java -> return Integer.valueOf(value)
-                Long::class.javaPrimitiveType, Long::class.java -> return java.lang.Long.valueOf(value)
-                Boolean::class.javaPrimitiveType, Boolean::class.java -> return parseBooleanArgument(value)
-                Float::class.javaPrimitiveType, Float::class.java -> return java.lang.Float.valueOf(value)
-                Double::class.javaPrimitiveType, Double::class.java -> return java.lang.Double.valueOf(value)
-                else -> throw IllegalArgumentException()
-            }
-        } catch (ignored: NumberFormatException) {
-            throw IllegalArgumentException()
-        }
-    }
-
-    /**
-     * Attempts to parse a string parameter to a Boolean type
-     *
-     * @param value a string representation of the value to be parsed
-     */
-    private fun parseBooleanArgument(value: String): Boolean {
-        when (value.toLowerCase()) {
-            "yes", "true" -> return true
-            "no", "false" -> return false
-            else -> {
-                val integerValue = Integer.valueOf(value)!!
-                when (integerValue) {
-                    1 -> return true
-                    0 -> return false
-                    else -> throw IllegalArgumentException()
-                }
-            }
-        }
-    }
-
-    /**
-     * A function to assert that all the items in a given list are of a specific type
-     */
-    @Suppress("UNCHECKED_CAST")
-    private inline fun <reified T : Any> List<*>.checkItemsAre() = if (all { it is T }) this as List<T> else null
+    // =============================================
+    // ============= Exception Handling ============
 
     /**
      * Handler for if command syntax is given but no matching command is found
@@ -617,11 +578,63 @@ class BotControllerManager(val plugin: Plugin) {
         }
     }
 
+    // =============================================
+    // ============== HELPER FUNCTIONS =============
+
+    /**
+     * Attempts to parse a string parameter to an expected value type
+     *
+     * @param parameterClass the expected type of the parameter
+     * @param value a string representation of the value to be parsed
+     */
+    private fun parseArgument(parameterClass: Class<*>, value: String): Any {
+        return try {
+            when (parameterClass) {
+                String::class.java -> value
+                Int::class.javaPrimitiveType, Int::class.java -> Integer.valueOf(value)
+                Long::class.javaPrimitiveType, Long::class.java -> java.lang.Long.valueOf(value)
+                Boolean::class.javaPrimitiveType, Boolean::class.java -> parseBooleanArgument(value)
+                Float::class.javaPrimitiveType, Float::class.java -> java.lang.Float.valueOf(value)
+                Double::class.javaPrimitiveType, Double::class.java -> java.lang.Double.valueOf(value)
+                else -> throw IllegalArgumentException()
+            }
+        } catch (ignored: NumberFormatException) {
+            throw IllegalArgumentException()
+        }
+    }
+
+    /**
+     * Attempts to parse a string parameter to a Boolean type
+     *
+     * @param value a string representation of the value to be parsed
+     */
+    private fun parseBooleanArgument(value: String): Boolean = when (value.toLowerCase()) {
+        "yes", "true" -> true
+        "no", "false" -> false
+        else -> {
+            val integerValue = Integer.valueOf(value)!!
+            when (integerValue) {
+                1 -> true
+                0 -> false
+                else -> throw IllegalArgumentException()
+            }
+        }
+    }
+
     /**
      * Shortcut method for adding "or <prefix>help " to the CommandNotFound output if a COMMAND_PREFIX is set in config
      */
     private fun orPrefixHelp(): String = if (Config.COMMAND_PREFIX != "") "or ${Config.COMMAND_PREFIX}help " else ""
 
+    /**
+     * A function to assert that all the items in a given list are of a specific type
+     */
+    @Suppress("UNCHECKED_CAST")
+    private inline fun <reified T : Any> List<*>.checkItemsAre() = if (all { it is T }) this as List<T> else null
+
+    // =============================================
+    // =============== HELPER OBJECTS ==============
+
     /**
      * Represents a command that the bot can execute
      *
@@ -649,6 +662,11 @@ class BotControllerManager(val plugin: Plugin) {
             val commandMethod: Method
     )
 
+    /**
+     * A simple list of all commands native to Minecraft, Bukkit, and Spigot
+     *
+     * TODO: Can this list be attained programmatically??
+     */
     private object DefaultCommands {
         val minecraft : List<String> = listOf(
                 "advancement",
diff --git a/src/main/kotlin/gg/obsidian/discordbridge/commands/controllers/FunCommandsController.kt b/src/main/kotlin/gg/obsidian/discordbridge/commands/controllers/FunCommandsController.kt
index 836d9ce..0ca3c56 100644
--- a/src/main/kotlin/gg/obsidian/discordbridge/commands/controllers/FunCommandsController.kt
+++ b/src/main/kotlin/gg/obsidian/discordbridge/commands/controllers/FunCommandsController.kt
@@ -80,11 +80,11 @@ class FunCommandsController(val plugin: Plugin) : IBotController {
 
         totalRespects += found!!.count
         val msg: String
-        if (found.message.contains("%u"))
-            msg = found.message.replace("%u", event.senderAsMention).replace("%t", totalRespects.toString())
-                .replace("%c", found.count.toString())
+        msg = if (found.message.contains("%u"))
+            found.message.replace("%u", event.senderAsMention).replace("%t", totalRespects.toString())
+                    .replace("%c", found.count.toString())
         else
-            msg = "${event.senderAsMention} | ${found.message}".replace("%t", totalRespects.toString())
+            "${event.senderAsMention} | ${found.message}".replace("%t", totalRespects.toString())
                     .replace("%c", found.count.toString())
 
         plugin.f.data.set("total-respects", totalRespects)
@@ -188,7 +188,7 @@ class FunCommandsController(val plugin: Plugin) : IBotController {
 
         if (Config.CLEVERBOT_KEY.isEmpty())
             return "You do not have an API key. Go to https://www.cleverbot.com/JDA/ for more information."
-        val bot: CleverBotQuery = CleverBotQuery(Config.CLEVERBOT_KEY, query)
+        val bot = CleverBotQuery(Config.CLEVERBOT_KEY, query)
         bot.sendRequest()
         return bot.response
     }
diff --git a/src/main/kotlin/gg/obsidian/discordbridge/discord/Connection.kt b/src/main/kotlin/gg/obsidian/discordbridge/discord/Connection.kt
index 1c93493..d5b9295 100644
--- a/src/main/kotlin/gg/obsidian/discordbridge/discord/Connection.kt
+++ b/src/main/kotlin/gg/obsidian/discordbridge/discord/Connection.kt
@@ -15,7 +15,7 @@ import net.dv8tion.jda.core.entities.*
 object Connection: Runnable {
     lateinit var plugin: Plugin
     lateinit var JDA: JDA
-    lateinit var listener: Listener
+    private lateinit var listener: Listener
     var server: Guild? = null
     var channel: TextChannel? = null
 
diff --git a/src/main/kotlin/gg/obsidian/discordbridge/discord/Listener.kt b/src/main/kotlin/gg/obsidian/discordbridge/discord/Listener.kt
index adce7a5..e9b78a6 100644
--- a/src/main/kotlin/gg/obsidian/discordbridge/discord/Listener.kt
+++ b/src/main/kotlin/gg/obsidian/discordbridge/discord/Listener.kt
@@ -15,7 +15,7 @@ import net.dv8tion.jda.core.hooks.ListenerAdapter
  */
 class Listener(val plugin: Plugin) : ListenerAdapter() {
 
-    val controllerManager = BotControllerManager(plugin)
+    private val controllerManager = BotControllerManager(plugin)
 
     init {
         controllerManager.registerController(FunCommandsController(plugin), discordExclusive = true, chatExclusive = true)
diff --git a/src/main/kotlin/gg/obsidian/discordbridge/minecraft/CommandListener.kt b/src/main/kotlin/gg/obsidian/discordbridge/minecraft/CommandListener.kt
index ce806d9..7063646 100644
--- a/src/main/kotlin/gg/obsidian/discordbridge/minecraft/CommandListener.kt
+++ b/src/main/kotlin/gg/obsidian/discordbridge/minecraft/CommandListener.kt
@@ -16,7 +16,7 @@ import org.bukkit.command.CommandSender
  */
 class CommandListener(val plugin: Plugin) : CommandExecutor {
 
-    val controllerManager = BotControllerManager(plugin)
+    private val controllerManager = BotControllerManager(plugin)
 
     init {
         controllerManager.registerController(FunCommandsController(plugin), minecraftExclusive = true)
diff --git a/src/main/kotlin/gg/obsidian/discordbridge/minecraft/EventListener.kt b/src/main/kotlin/gg/obsidian/discordbridge/minecraft/EventListener.kt
index 04495ac..bdc4df2 100644
--- a/src/main/kotlin/gg/obsidian/discordbridge/minecraft/EventListener.kt
+++ b/src/main/kotlin/gg/obsidian/discordbridge/minecraft/EventListener.kt
@@ -31,7 +31,7 @@ import org.bukkit.ChatColor as CC
  */
 class EventListener(val plugin: Plugin): Listener {
 
-    val controllerManager = BotControllerManager(plugin)
+    private val controllerManager = BotControllerManager(plugin)
 
     init {
         controllerManager.registerController(FunCommandsController(plugin), chatExclusive = true)