Simplify message building and add reply method

CHANGELOG

 vNEXT (in development)
 
-  *
+  * Simplified how messages are constructed.
+    Instead of: client.send(joinMessage("#channel"))
+    Now use: client.sendJoin("#channel")
+  * Added reply utility to easily send replies to message events
 
 v0.2.1
 

README.md

 simple bot might look like:
 
 ```kotlin
-val client = IrcClientImpl(Server("my.server.com", 6667), Profile("nick", "realName", "userName"))
-client.onEvent { event ->
-    when (event) {
-        is ServerWelcome ->
-            client.send(joinMessage("#ktirc"))
-        is MessageReceived ->
-            if (event.message == "!test")
-                client.send(privmsgMessage(event.target, "Test successful!"))
+with(IrcClientImpl(Server("my.server.com", 6667), Profile("nick", "realName", "userName"))) {
+    onEvent { event ->
+        when (event) {
+            is ServerWelcome -> sendJoin("#ktirc")
+            is MessageReceived ->
+                if (event.message == "!test")
+                    reply(event, "Test successful!")
+        }
     }
+    connect()
 }
-client.connect()
 ```
 
 ## Contributing

src/itest/kotlin/com/dmdirc/ktirc/KtIrcIntegrationTest.kt

 import com.dmdirc.irctest.IrcLibraryTests
 import com.dmdirc.ktirc.model.Profile
 import com.dmdirc.ktirc.model.Server
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.GlobalScope
-import kotlinx.coroutines.launch
 import org.junit.jupiter.api.TestFactory
 
 class KtIrcIntegrationTest {
 
         override fun connect(nick: String, ident: String, realName: String, password: String?) {
             ircClient = IrcClientImpl(Server("localhost", 12321, password = password), Profile(nick, ident, realName))
-            GlobalScope.launch(Dispatchers.IO) {
-                ircClient.connect()
-            }
+            ircClient.connect()
         }
 
         override fun terminate() {

src/main/kotlin/com/dmdirc/ktirc/IrcClient.kt

                 socket = this
                 connect()
                 sendLine("CAP LS 302")
-                server.password?.let { pass -> sendLine(passwordMessage(pass)) }
-                sendLine(nickMessage(profile.initialNick))
+                server.password?.let { pass -> sendPassword(pass) }
+                sendNickChange(profile.initialNick)
                 // TODO: Send correct host
-                sendLine(userMessage(profile.userName, "localhost", server.host, profile.realName))
+                sendUser(profile.userName, "localhost", server.host, profile.realName)
                 // TODO: This should be elsewhere
                 messageHandler.processMessages(this@IrcClientImpl, readLines(scope).map { parser.parse(it) })
             }
     }
 
     runBlocking {
-        val client = IrcClientImpl(Server("testnet.inspircd.org", 6667), Profile("KtIrc", "Kotlin!", "kotlin"))
-        client.onEvent { event ->
-            when (event) {
-                is ServerWelcome -> client.send(joinMessage("#ktirc"))
-                is MessageReceived ->
-                    if (event.message == "!test")
-                        client.send(privmsgMessage(event.target, "Test successful!"))
+        with(IrcClientImpl(Server("testnet.inspircd.org", 6667), Profile("KtIrc", "Kotlin!", "kotlin"))) {
+            onEvent { event ->
+                when (event) {
+                    is ServerWelcome -> sendJoin("#ktirc")
+                    is MessageReceived ->
+                        if (event.message == "!test")
+                            reply(event, "Test successful!")
+                }
             }
+            connect()
+            join()
         }
-        client.connect()
-        client.join()
     }
 }

src/main/kotlin/com/dmdirc/ktirc/events/CapabilitiesHandler.kt

 package com.dmdirc.ktirc.events
 
 import com.dmdirc.ktirc.IrcClient
-import com.dmdirc.ktirc.messages.capabilityEndMessage
-import com.dmdirc.ktirc.messages.capabilityRequestMessage
+import com.dmdirc.ktirc.messages.sendCapabilityEnd
+import com.dmdirc.ktirc.messages.sendCapabilityRequest
 import com.dmdirc.ktirc.model.CapabilitiesNegotiationState
 import com.dmdirc.ktirc.model.CapabilitiesState
 import com.dmdirc.ktirc.model.Capability
         with (client.serverState.capabilities) {
             if (advertisedCapabilities.keys.isEmpty()) {
                 negotiationState = CapabilitiesNegotiationState.FINISHED
-                client.send(capabilityEndMessage())
+                client.sendCapabilityEnd()
             } else {
                 negotiationState = CapabilitiesNegotiationState.AWAITING_ACK
                 advertisedCapabilities.keys.map { it.name }.let {
                     log.info { "Requesting capabilities: ${it.toList()}" }
-                    client.send(capabilityRequestMessage(it))
+                    client.sendCapabilityRequest(it)
                 }
             }
         }
             log.info { "Acknowledged capabilities: ${capabilities.keys.map { it.name }.toList()}" }
             negotiationState = CapabilitiesNegotiationState.FINISHED
             enabledCapabilities.putAll(capabilities)
-            client.send(capabilityEndMessage())
+            client.sendCapabilityEnd()
         }
     }
 

src/main/kotlin/com/dmdirc/ktirc/events/EventUtils.kt

 package com.dmdirc.ktirc.events
 
 import com.dmdirc.ktirc.IrcClient
+import com.dmdirc.ktirc.messages.sendMessage
 import com.dmdirc.ktirc.model.ServerFeature
 import com.dmdirc.ktirc.model.asUser
 
         }
     }
 }.toList()
+
+fun IrcClient.reply(message: MessageReceived, response: String, prefixWithNickname: Boolean = false) {
+    if (caseMapping.areEquivalent(message.target, serverState.localNickname)) {
+        sendMessage(message.user.nickname, response)
+    } else {
+        sendMessage(message.target, if (prefixWithNickname) "${message.user.nickname}: $response" else response)
+    }
+}

src/main/kotlin/com/dmdirc/ktirc/events/PingHandler.kt

 package com.dmdirc.ktirc.events
 
 import com.dmdirc.ktirc.IrcClient
-import com.dmdirc.ktirc.messages.pongMessage
+import com.dmdirc.ktirc.messages.sendPong
 
 internal class PingHandler : EventHandler {
 
     override fun processEvent(client: IrcClient, event: IrcEvent) {
         when (event) {
-            is PingReceived -> client.send(pongMessage(event.nonce))
+            is PingReceived -> client.sendPong(event.nonce)
         }
     }
 

src/main/kotlin/com/dmdirc/ktirc/messages/MessageBuilders.kt

 package com.dmdirc.ktirc.messages
 
-/** Construct a message indicating the end of capability negotiation. */
-internal fun capabilityEndMessage() = "CAP END"
-/** Construct a message requesting the specified caps are enabled. */
-internal fun capabilityRequestMessage(capabilities: List<String>) = "CAP REQ :${capabilities.joinToString(" ")}"
-/** Construct a message to join the given channel. */
-fun joinMessage(channel: String) = "JOIN :$channel"
-/** Construct a message to change to the given nickname. */
-fun nickMessage(nick: String) = "NICK :$nick"
-/** Construct a message to provide the connection password to the server. */
-internal fun passwordMessage(password: String) = "PASS :$password"
-/** Construct a message to reply to a PING event. */
-internal fun pongMessage(nonce: ByteArray) = "PONG :${String(nonce)}"
-/** Construct a message to send a private message to a user or channel. */
-fun privmsgMessage(target: String, message: String) = "PRIVMSG $target :$message"
-/** Construct a message to register a user with the server. */
-internal fun userMessage(userName: String, localHostName: String, serverHostName: String, realName: String) = "USER $userName $localHostName $serverHostName :$realName"
+import com.dmdirc.ktirc.IrcClient
+
+/** Sends a message indicating the end of capability negotiation. */
+internal fun IrcClient.sendCapabilityEnd() = send("CAP END")
+/** Sends a message requesting the specified caps are enabled. */
+internal fun IrcClient.sendCapabilityRequest(capabilities: List<String>) = send("CAP REQ :${capabilities.joinToString(" ")}")
+/** Sends a request to join the given channel. */
+fun IrcClient.sendJoin(channel: String) = send("JOIN :$channel")
+/** Sends a request to change to the given nickname. */
+fun IrcClient.sendNickChange(nick: String) = send("NICK :$nick")
+/** Sends the connection password to the server. */
+internal fun IrcClient.sendPassword(password: String) = send("PASS :$password")
+/** Sends a response to a PING event. */
+internal fun IrcClient.sendPong(nonce: ByteArray) = send("PONG :${String(nonce)}")
+/** Sends a private message to a user or channel. */
+fun IrcClient.sendMessage(target: String, message: String) = send("PRIVMSG $target :$message")
+/** Sends a message to register a user with the server. */
+internal fun IrcClient.sendUser(userName: String, localHostName: String, serverHostName: String, realName: String) = send("USER $userName $localHostName $serverHostName :$realName")

src/test/kotlin/com/dmdirc/ktirc/events/EventUtilsTest.kt

 
 import com.dmdirc.ktirc.IrcClient
 import com.dmdirc.ktirc.TestConstants
+import com.dmdirc.ktirc.io.CaseMapping
 import com.dmdirc.ktirc.model.ModePrefixMapping
 import com.dmdirc.ktirc.model.ServerFeature
 import com.dmdirc.ktirc.model.ServerState
+import com.dmdirc.ktirc.model.User
 import com.nhaarman.mockitokotlin2.doReturn
 import com.nhaarman.mockitokotlin2.mock
+import com.nhaarman.mockitokotlin2.verify
 import org.junit.jupiter.api.Assertions.assertEquals
 import org.junit.jupiter.api.BeforeEach
 import org.junit.jupiter.api.Test
     private val serverState = ServerState("")
     private val ircClient = mock<IrcClient> {
         on { serverState } doReturn serverState
+        on { caseMapping } doReturn CaseMapping.Ascii
     }
 
     @BeforeEach
         assertEquals("root.localhost", result[1].second.hostname)
     }
 
+    @Test
+    fun `reply sends response to user when message is private`() {
+        serverState.localNickname = "zeroCool"
+        val message = MessageReceived(TestConstants.time, User("acidBurn"), "Zerocool", "Hack the planet!")
+
+        ircClient.reply(message, "OK")
+        verify(ircClient).send("PRIVMSG acidBurn :OK")
+    }
+
+    @Test
+    fun `reply sends unprefixed response to user when message is in a channel`() {
+        val message = MessageReceived(TestConstants.time, User("acidBurn"), "#TheGibson", "Hack the planet!")
+
+        ircClient.reply(message, "OK")
+        verify(ircClient).send("PRIVMSG #TheGibson :OK")
+    }
+
+    @Test
+    fun `reply sends prefixed response to user when message is in a channel`() {
+        val message = MessageReceived(TestConstants.time, User("acidBurn"), "#TheGibson", "Hack the planet!")
+
+        ircClient.reply(message, "OK", prefixWithNickname = true)
+        verify(ircClient).send("PRIVMSG #TheGibson :acidBurn: OK")
+    }
+
 
 }

src/test/kotlin/com/dmdirc/ktirc/messages/MessageBuildersTest.kt

 package com.dmdirc.ktirc.messages
 
-import org.junit.jupiter.api.Assertions.assertEquals
+import com.dmdirc.ktirc.IrcClient
+import com.nhaarman.mockitokotlin2.mock
+import com.nhaarman.mockitokotlin2.verify
 import org.junit.jupiter.api.Test
 
 internal class MessageBuildersTest {
 
+    private val mockClient = mock<IrcClient>()
+
     @Test
-    fun `CapabilityRequestMessage creates CAP REQ message with single argument`() = assertEquals("CAP REQ :a", capabilityRequestMessage(listOf("a")))
+    fun `CapabilityRequestMessage creates CAP REQ message with single argument`() {
+        mockClient.sendCapabilityRequest(listOf("a"))
+        verify(mockClient).send("CAP REQ :a")
+    }
 
     @Test
-    fun `CapabilityRequestMessage creates CAP REQ message with multiple args`() = assertEquals("CAP REQ :a b c", capabilityRequestMessage(listOf("a b c")))
+    fun `CapabilityRequestMessage creates CAP REQ message with multiple args`() {
+        mockClient.sendCapabilityRequest(listOf("a b c"))
+        verify(mockClient).send("CAP REQ :a b c")
+    }
 
     @Test
-    fun `JoinMessage creates correct JOIN message`() = assertEquals("JOIN :#Test123", joinMessage("#Test123"))
+    fun `JoinMessage creates correct JOIN message`() {
+        mockClient.sendJoin("#TheGibson")
+        verify(mockClient).send("JOIN :#TheGibson")
+    }
 
     @Test
-    fun `NickMessage creates correct NICK message`() = assertEquals("NICK :AcidBurn", nickMessage("AcidBurn"))
+    fun `NickMessage creates correct NICK message`() {
+        mockClient.sendNickChange("AcidBurn")
+        verify(mockClient).send("NICK :AcidBurn")
+    }
 
     @Test
-    fun `PasswordMessage creates correct PASS message`() = assertEquals("PASS :abcdef", passwordMessage("abcdef"))
+    fun `PasswordMessage creates correct PASS message`() {
+        mockClient.sendPassword("hacktheplanet")
+        verify(mockClient).send("PASS :hacktheplanet")
+    }
 
     @Test
-    fun `PongMessage creates correct PONG message`() = assertEquals("PONG :abcdef", pongMessage("abcdef".toByteArray()))
+    fun `PongMessage creates correct PONG message`() {
+        mockClient.sendPong("abcdef".toByteArray())
+        verify(mockClient).send("PONG :abcdef")
+    }
 
     @Test
-    fun `PrivmsgMessage creates correct PRIVMSG message`() = assertEquals("PRIVMSG acidBurn :Hack the planet!", privmsgMessage("acidBurn", "Hack the planet!"))
+    fun `PrivmsgMessage creates correct PRIVMSG message`() {
+        mockClient.sendMessage("acidBurn", "Hack the planet!")
+        verify(mockClient).send("PRIVMSG acidBurn :Hack the planet!")
+    }
 
     @Test
-    fun `UserMessage creates correct USER message`() = assertEquals("USER AcidBurn localhost gibson :Kate", userMessage("AcidBurn", "localhost", "gibson", "Kate"))
+    fun `UserMessage creates correct USER message`() {
+        mockClient.sendUser("AcidBurn", "localhost", "gibson", "Kate")
+        verify(mockClient).send("USER AcidBurn localhost gibson :Kate")
+    }
 
 }