Add support for receiving actions and CTCPs

CHANGELOG

 vNEXT (in development)
 
+ * Added CtcpReceived and ActionReceived events
+
 v0.3.1
 
   * Added more documentation to public methods/classes

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

         socket?.disconnect()
     }
 
+    /**
+     * Joins the coroutine running the message loop, and blocks until it is completed.
+     */
     suspend fun join() {
         connectionJob?.join()
     }

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

     }
 }.toList()
 
+/**
+ * Replies in the appropriate place to a message received.
+ *
+ * Messages sent direct to the client will be responded to in direct message back; messages sent to a channel
+ * will be replied to in the channel. If [prefixWithNickname] is `true`, channel messages will be prefixed
+ * with the other user's nickname (separated from the message by a colon and space).
+ */
 fun IrcClient.reply(message: MessageReceived, response: String, prefixWithNickname: Boolean = false) {
     if (caseMapping.areEquivalent(message.target, serverState.localNickname)) {
         sendMessage(message.user.nickname, response)

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

 /** Raised when a message is received. */
 class MessageReceived(time: LocalDateTime, val user: User, val target: String, val message: String) : IrcEvent(time)
 
+/** Raised when an action is received. */
+class ActionReceived(time: LocalDateTime, val user: User, val target: String, val action: String) : IrcEvent(time)
+
+/** Raised when a CTCP is received. */
+class CtcpReceived(time: LocalDateTime, val user: User, val target: String, val type: String, val content: String) : IrcEvent(time)
+
 /** Raised when a user quits. */
 class UserQuit(time: LocalDateTime, val user: User, val reason: String = "") : IrcEvent(time)
 

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

 package com.dmdirc.ktirc.messages
 
+import com.dmdirc.ktirc.events.ActionReceived
+import com.dmdirc.ktirc.events.CtcpReceived
+import com.dmdirc.ktirc.events.IrcEvent
 import com.dmdirc.ktirc.events.MessageReceived
 import com.dmdirc.ktirc.model.IrcMessage
+import com.dmdirc.ktirc.model.User
+
+private const val CTCP_BYTE : Byte = 1
 
 internal class PrivmsgProcessor : MessageProcessor {
 
     override val commands = arrayOf("PRIVMSG")
 
     override fun process(message: IrcMessage) = message.sourceUser?.let { user ->
-        listOf(MessageReceived(message.time, user, String(message.params[0]), String(message.params[1])))
+        listOf(when {
+            message.isCtcp() -> handleCtcp(message, user)
+            else -> MessageReceived(message.time, user, String(message.params[0]), String(message.params[1]))
+        })
     } ?: emptyList()
 
+    private fun handleCtcp(message: IrcMessage, user: User): IrcEvent {
+        val content = String(message.params[1]).substring(1 until message.params[1].size - 1)
+        val parts = content.split(' ', limit=2)
+        val body = if (parts.size == 2) parts[1] else ""
+        return when (parts[0].toUpperCase()) {
+            "ACTION" -> ActionReceived(message.time, user, String(message.params[0]), body)
+            else -> CtcpReceived(message.time, user, String(message.params[0]), parts[0], body)
+        }
+    }
+
+    private fun IrcMessage.isCtcp() = params[1].size > 2 && params[1][0] == CTCP_BYTE && params[1][params[1].size - 1] == CTCP_BYTE
+
 }

src/main/kotlin/com/dmdirc/ktirc/model/IrcMessage.kt

 }
 
 /**
- * Supported tags that may be applied to messages
+ * Supported tags that may be applied to messages.
  */
 sealed class MessageTag(val name: String) {
     /** Specifies the account name of the user, if the `account-tag` capability is negotiated. */

src/main/kotlin/com/dmdirc/ktirc/model/UserState.kt

 
     private val users = UserMap(caseMappingProvider)
 
+    /** Gets the [KnownUser] with the given nickname. */
     operator fun get(nickname: String) = users[nickname]
+    /** Gets the [KnownUser] for a given user. */
     operator fun get(user: User) = users[user.nickname]
 
     internal operator fun plusAssign(details: User) { users += KnownUser(caseMappingProvider, details) }

src/main/kotlin/com/dmdirc/ktirc/util/Time.kt

 import java.time.ZoneId
 
 internal var currentTimeZoneProvider = { ZoneId.systemDefault() }
-internal var currentTimeProvider = { LocalDateTime.now(currentTimeZoneProvider()) }
+internal var currentTimeProvider = { LocalDateTime.now(currentTimeZoneProvider()) }

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

 package com.dmdirc.ktirc.messages
 
 import com.dmdirc.ktirc.TestConstants
+import com.dmdirc.ktirc.events.ActionReceived
+import com.dmdirc.ktirc.events.CtcpReceived
+import com.dmdirc.ktirc.events.MessageReceived
 import com.dmdirc.ktirc.model.IrcMessage
 import com.dmdirc.ktirc.model.User
 import com.dmdirc.ktirc.util.currentTimeProvider
                 IrcMessage(emptyMap(), "acidburn!libby@root.localhost".toByteArray(), "PRIVMSG", listOf("#crashandburn".toByteArray(), "hack the planet!".toByteArray())))
         assertEquals(1, events.size)
 
-        assertEquals(TestConstants.time, events[0].time)
-        assertEquals(User("acidburn", "libby", "root.localhost"), events[0].user)
-        assertEquals("#crashandburn", events[0].target)
-        assertEquals("hack the planet!", events[0].message)
+        val event = events[0] as MessageReceived
+        assertEquals(TestConstants.time, event.time)
+        assertEquals(User("acidburn", "libby", "root.localhost"), event.user)
+        assertEquals("#crashandburn", event.target)
+        assertEquals("hack the planet!", event.message)
+    }
+
+    @Test
+    fun `PrivsgProcessor raises action received event with content`() {
+        val events = PrivmsgProcessor().process(
+                IrcMessage(emptyMap(), "acidburn!libby@root.localhost".toByteArray(), "PRIVMSG", listOf("#crashandburn".toByteArray(), "\u0001ACTION hacks the planet\u0001".toByteArray())))
+        assertEquals(1, events.size)
+
+        val event = events[0] as ActionReceived
+        assertEquals(TestConstants.time, event.time)
+        assertEquals(User("acidburn", "libby", "root.localhost"), event.user)
+        assertEquals("#crashandburn", event.target)
+        assertEquals("hacks the planet", event.action)
+    }
+
+    @Test
+    fun `PrivsgProcessor raises action received event without content`() {
+        val events = PrivmsgProcessor().process(
+                IrcMessage(emptyMap(), "acidburn!libby@root.localhost".toByteArray(), "PRIVMSG", listOf("#crashandburn".toByteArray(), "\u0001ACTION\u0001".toByteArray())))
+        assertEquals(1, events.size)
+
+        val event = events[0] as ActionReceived
+        assertEquals(TestConstants.time, event.time)
+        assertEquals(User("acidburn", "libby", "root.localhost"), event.user)
+        assertEquals("#crashandburn", event.target)
+        assertEquals("", event.action)
+    }
+
+    @Test
+    fun `PrivsgProcessor raises action received event with lowercase type`() {
+        val events = PrivmsgProcessor().process(
+                IrcMessage(emptyMap(), "acidburn!libby@root.localhost".toByteArray(), "PRIVMSG", listOf("#crashandburn".toByteArray(), "\u0001action hacks the planet\u0001".toByteArray())))
+        assertEquals(1, events.size)
+
+        val event = events[0] as ActionReceived
+        assertEquals(TestConstants.time, event.time)
+        assertEquals(User("acidburn", "libby", "root.localhost"), event.user)
+        assertEquals("#crashandburn", event.target)
+        assertEquals("hacks the planet", event.action)
+    }
+
+    @Test
+    fun `PrivsgProcessor raises CTCP received event with content`() {
+        val events = PrivmsgProcessor().process(
+                IrcMessage(emptyMap(), "acidburn!libby@root.localhost".toByteArray(), "PRIVMSG", listOf("#crashandburn".toByteArray(), "\u0001PING 12345\u0001".toByteArray())))
+        assertEquals(1, events.size)
+
+        val event = events[0] as CtcpReceived
+        assertEquals(TestConstants.time, event.time)
+        assertEquals(User("acidburn", "libby", "root.localhost"), event.user)
+        assertEquals("#crashandburn", event.target)
+        assertEquals("PING", event.type)
+        assertEquals("12345", event.content)
+    }
+
+    @Test
+    fun `PrivsgProcessor raises CTCP received event without content`() {
+        val events = PrivmsgProcessor().process(
+                IrcMessage(emptyMap(), "acidburn!libby@root.localhost".toByteArray(), "PRIVMSG", listOf("#crashandburn".toByteArray(), "\u0001PING\u0001".toByteArray())))
+        assertEquals(1, events.size)
+
+        val event = events[0] as CtcpReceived
+        assertEquals(TestConstants.time, event.time)
+        assertEquals(User("acidburn", "libby", "root.localhost"), event.user)
+        assertEquals("#crashandburn", event.target)
+        assertEquals("PING", event.type)
+        assertEquals("", event.content)
     }
 
     @Test