Tag parsing support

build.gradle.kts

 import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
 
 plugins {
-    kotlin("jvm") version "1.3.0-rc-80"
+    kotlin("jvm") version "1.3.0-rc-190"
 }
 
 repositories {
 
 dependencies {
     implementation(kotlin("stdlib-jdk8"))
-    implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:0.30.0-eap13")
-    implementation("io.ktor:ktor-network:0.9.6-alpha-1-rc13")
+    implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:0.30.2-eap13")
+    implementation("io.ktor:ktor-network:1.0.0-beta-1")
 
     testCompile("org.junit.jupiter:junit-jupiter-api:5.3.1")
     testCompile("org.junit.jupiter:junit-jupiter-params:5.3.1")
 configurations.all {
     resolutionStrategy.eachDependency {
         if (requested.group == "org.jetbrains.kotlin") {
-            useVersion("1.3.0-rc-80")
+            useVersion("1.3.0-rc-190")
         }
     }
 }

src/main/kotlin/com/dmdirc/ktirc/io/LineBufferedSocket.kt

 import io.ktor.network.sockets.aSocket
 import io.ktor.network.sockets.openReadChannel
 import io.ktor.network.sockets.openWriteChannel
-import io.ktor.network.util.ioCoroutineDispatcher
 import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.channels.ReceiveChannel
 import kotlinx.coroutines.channels.produce
 import kotlinx.coroutines.io.ByteReadChannel
     private lateinit var readChannel: ByteReadChannel
     private lateinit var writeChannel: ByteWriteChannel
 
+    @Suppress("EXPERIMENTAL_API_USAGE")
     override suspend fun connect() {
         log.info { "Connecting..." }
-        socket = aSocket(ActorSelectorManager(ioCoroutineDispatcher)).tcp().connect(InetSocketAddress(host, port))
+        socket = aSocket(ActorSelectorManager(Dispatchers.IO)).tcp().connect(InetSocketAddress(host, port))
         readChannel = socket.openReadChannel()
         writeChannel = socket.openWriteChannel()
     }

src/main/kotlin/com/dmdirc/ktirc/io/MessageHandler.kt

 import com.dmdirc.ktirc.IrcClient
 import com.dmdirc.ktirc.events.EventHandler
 import com.dmdirc.ktirc.messages.MessageProcessor
+import com.dmdirc.ktirc.model.IrcMessage
 import com.dmdirc.ktirc.util.logger
 import kotlinx.coroutines.channels.ReceiveChannel
 import kotlinx.coroutines.channels.consumeEach

src/main/kotlin/com/dmdirc/ktirc/io/MessageParser.kt

 package com.dmdirc.ktirc.io
 
+import com.dmdirc.ktirc.model.IrcMessage
+import com.dmdirc.ktirc.model.messageTags
+import com.dmdirc.ktirc.util.logger
+
 /**
  * Parses a message received from an IRC server.
  *
         private const val COLON = ':'.toByte()
     }
 
+    private val log by logger()
+
     fun parse(message: ByteArray) = CursorByteArray(message).run {
-        IrcMessage(takeTags(), takePrefix(), String(takeWord()), takeParams().toList())
+        IrcMessage(takeTags(), takePrefix(), String(takeWord()), takeParams())
     }
 
     /**
      * Attempts to read IRCv3 tags from the message.
      */
-    private fun CursorByteArray.takeTags() = takeOptionalPrefixedSection(AT)
+    private fun CursorByteArray.takeTags() = takeOptionalPrefixedSection(AT).toTagMap()
 
     /**
      * Attempts to read a prefix from the message.
         while (!exhausted()) {
             yield(takeParam())
         }
-    }
+    }.toList()
 
+    /**
+     * If the next word starts with the given prefix, takes and returns it, otherwise returns null.
+     */
     private fun CursorByteArray.takeOptionalPrefixedSection(prefix: Byte) = when {
         exhausted() -> null
         peek() == prefix -> takeWord(skip = 1)
         else -> null
     }
 
-}
+    /**
+     * Parses the bytes as a list of message tags. Unknown tags are discarded.
+     */
+    private fun ByteArray?.toTagMap() = sequence {
+        forEachPart(';') { tag ->
+            val index = tag.indexOf('=')
+            val name = if (index == -1) tag else tag.substring(0 until index)
+            messageTags[name]?.let {
+                yield(Pair(it, if (index == -1) "" else tag.substring(index + 1).unescapeTagValue()))
+            } ?: log.severe { "Unknown message tag: $name"}
+        }
+    }.toMap()
 
-class IrcMessage(val tags: ByteArray?, val prefix: ByteArray?, val command: String, val params: List<ByteArray>)
+    /**
+     * Resolves any backslash escaped characters in a tag value.
+     */
+    private fun String.unescapeTagValue() = String(sequence {
+        var escaped = false
+        forEach { char ->
+            when {
+                escaped -> {
+                    char.unescaped()?.let { yield(it) }
+                    escaped = false
+                }
+                char == '\\' -> escaped = true
+                else -> yield(char)
+            }
+        }
+    }.toList().toCharArray())
+
+    /**
+     * Maps an escaped character in a tag value back to its real form. Returns null if the sequence is invalid.
+     */
+    private fun Char.unescaped() = when (this) {
+        ':' -> ';'
+        'n' -> '\n'
+        'r' -> '\r'
+        's' -> ' '
+        '\\' -> '\\'
+        else -> null
+    }
+
+    private inline fun ByteArray?.forEachPart(delimiter: Char, action: (String) -> Unit) = this?.let {
+        String(it).split(delimiter).forEach(action)
+    }
+
+}
 
 /**
  * A ByteArray with a 'cursor' that tracks the current read position.

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

 import com.dmdirc.ktirc.events.ServerCapabilitiesAcknowledged
 import com.dmdirc.ktirc.events.ServerCapabilitiesFinished
 import com.dmdirc.ktirc.events.ServerCapabilitiesReceived
-import com.dmdirc.ktirc.io.IrcMessage
+import com.dmdirc.ktirc.model.IrcMessage
 import com.dmdirc.ktirc.model.capabilities
 import com.dmdirc.ktirc.util.logger
 

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

 
 import com.dmdirc.ktirc.events.ServerFeaturesUpdated
 import com.dmdirc.ktirc.io.CaseMapping
-import com.dmdirc.ktirc.io.IrcMessage
+import com.dmdirc.ktirc.model.IrcMessage
 import com.dmdirc.ktirc.model.ModePrefixMapping
 import com.dmdirc.ktirc.model.ServerFeatureMap
 import com.dmdirc.ktirc.model.serverFeatures

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

 package com.dmdirc.ktirc.messages
 
 import com.dmdirc.ktirc.events.ChannelJoined
-import com.dmdirc.ktirc.io.IrcMessage
+import com.dmdirc.ktirc.model.IrcMessage
 import com.dmdirc.ktirc.model.asUser
 
 internal class JoinProcessor : MessageProcessor {

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

 package com.dmdirc.ktirc.messages
 
 import com.dmdirc.ktirc.events.IrcEvent
-import com.dmdirc.ktirc.io.IrcMessage
+import com.dmdirc.ktirc.model.IrcMessage
 
 interface MessageProcessor {
 

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

 
 import com.dmdirc.ktirc.events.ChannelNamesFinished
 import com.dmdirc.ktirc.events.ChannelNamesReceived
-import com.dmdirc.ktirc.io.IrcMessage
+import com.dmdirc.ktirc.model.IrcMessage
 
 internal class NamesProcessor : MessageProcessor {
 

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

 package com.dmdirc.ktirc.messages
 
 import com.dmdirc.ktirc.events.ChannelParted
-import com.dmdirc.ktirc.io.IrcMessage
+import com.dmdirc.ktirc.model.IrcMessage
 import com.dmdirc.ktirc.model.asUser
 
 internal class PartProcessor : MessageProcessor {

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

 package com.dmdirc.ktirc.messages
 
 import com.dmdirc.ktirc.events.PingReceived
-import com.dmdirc.ktirc.io.IrcMessage
+import com.dmdirc.ktirc.model.IrcMessage
 
 internal class PingProcessor : MessageProcessor {
 

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

 package com.dmdirc.ktirc.messages
 
 import com.dmdirc.ktirc.events.MessageReceived
-import com.dmdirc.ktirc.io.IrcMessage
+import com.dmdirc.ktirc.model.IrcMessage
 import com.dmdirc.ktirc.model.asUser
 
 internal class PrivmsgProcessor : MessageProcessor {

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

 package com.dmdirc.ktirc.messages
 
 import com.dmdirc.ktirc.events.UserQuit
-import com.dmdirc.ktirc.io.IrcMessage
+import com.dmdirc.ktirc.model.IrcMessage
 import com.dmdirc.ktirc.model.asUser
 
 internal class QuitProcessor : MessageProcessor {

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

 package com.dmdirc.ktirc.messages
 
 import com.dmdirc.ktirc.events.ServerWelcome
-import com.dmdirc.ktirc.io.IrcMessage
+import com.dmdirc.ktirc.model.IrcMessage
 
 internal class WelcomeProcessor : MessageProcessor {
 

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

     object UserAccountMessageTag : Capability("account-tag") // TODO: Add accounts to user info
 
     // Capabilities that extend existing commands to supply extra information:
-    object HostsInNamesReply : Capability("userhost-in-names") // TODO: Parse these hosts
+    object HostsInNamesReply : Capability("userhost-in-names")
     object MultipleUserModePrefixes : Capability("multi-prefix")
     object AccountAndRealNameInJoinMessages : Capability("extended-join") // TODO: Parse this
 

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

+package com.dmdirc.ktirc.model
+
+class IrcMessage(val tags: Map<MessageTag, String>, val prefix: ByteArray?, val command: String, val params: List<ByteArray>)
+
+sealed class MessageTag(val name: String) {
+    object AccountName: MessageTag("account")
+    object ServerTime : MessageTag("time")
+}
+
+val messageTags: Map<String, MessageTag> by lazy {
+    MessageTag::class.nestedClasses.map { it.objectInstance as MessageTag }.associateBy { it.name }
+}

src/test/kotlin/com/dmdirc/ktirc/io/MessageHandlerTest.kt

 import com.dmdirc.ktirc.events.ServerConnected
 import com.dmdirc.ktirc.events.ServerWelcome
 import com.dmdirc.ktirc.messages.MessageProcessor
+import com.dmdirc.ktirc.model.IrcMessage
 import com.nhaarman.mockitokotlin2.*
 import kotlinx.coroutines.channels.Channel
 import kotlinx.coroutines.runBlocking
     @Test
     fun `MessageHandler passes message on to correct processor`() = runBlocking {
         val handler = MessageHandler(listOf(joinProcessor, nickProcessor), mutableListOf())
-        val message = IrcMessage(null, null, "JOIN", emptyList())
+        val message = IrcMessage(emptyMap(), null, "JOIN", emptyList())
 
         with(Channel<IrcMessage>(1)) {
             send(message)
     @Test
     fun `MessageHandler reads multiple messages`() = runBlocking {
         val handler = MessageHandler(listOf(joinProcessor, nickProcessor), mutableListOf())
-        val joinMessage = IrcMessage(null, null, "JOIN", emptyList())
-        val nickMessage = IrcMessage(null, null, "NICK", emptyList())
-        val otherMessage = IrcMessage(null, null, "OTHER", emptyList())
+        val joinMessage = IrcMessage(emptyMap(), null, "JOIN", emptyList())
+        val nickMessage = IrcMessage(emptyMap(), null, "NICK", emptyList())
+        val otherMessage = IrcMessage(emptyMap(), null, "OTHER", emptyList())
 
         with(Channel<IrcMessage>(3)) {
             send(joinMessage)
         val eventHandler1 = mock<EventHandler>()
         val eventHandler2 = mock<EventHandler>()
         val handler = MessageHandler(listOf(joinProcessor, nickProcessor), mutableListOf(eventHandler1, eventHandler2))
-        val joinMessage = IrcMessage(null, null, "JOIN", emptyList())
+        val joinMessage = IrcMessage(emptyMap(), null, "JOIN", emptyList())
         whenever(joinProcessor.process(any())).thenReturn(listOf(ServerConnected, ServerWelcome("abc")))
 
         with(Channel<IrcMessage>(1)) {

src/test/kotlin/com/dmdirc/ktirc/io/MessageParserTest.kt

 package com.dmdirc.ktirc.io
 
+import com.dmdirc.ktirc.model.MessageTag
 import org.junit.jupiter.api.Assertions.*
 import org.junit.jupiter.api.Test
 import org.junit.jupiter.params.ParameterizedTest
         @JvmStatic
         @Suppress("unused")
         fun ircMessageArgumentsProvider(): Stream<Arguments> = Stream.of(
-                arguments("test", null, null, "test", emptyList<String>()),
-                arguments("test 1 2", null, null, "test", listOf("1", "2")),
-                arguments("test    1     2     ", null, null, "test", listOf("1", "2")),
-                arguments("test :1 2", null, null, "test", listOf("1 2")),
-                arguments("test :1 2    ", null, null, "test", listOf("1 2    ")),
-                arguments("123 :1 2    ", null, null, "123", listOf("1 2    ")),
-                arguments(":test abc 1 2    ", null, "test", "abc", listOf("1", "2")),
-                arguments("@tags :test abc 1 2 :three four", "tags", "test", "abc", listOf("1", "2", "three four")),
-                arguments("@tags abc 1 2 : three four ", "tags", null, "abc", listOf("1", "2", " three four "))
+                arguments("test", null, "test", emptyList<String>()),
+                arguments("test 1 2", null, "test", listOf("1", "2")),
+                arguments("test    1     2     ", null, "test", listOf("1", "2")),
+                arguments("test :1 2", null, "test", listOf("1 2")),
+                arguments("test :1 2    ", null, "test", listOf("1 2    ")),
+                arguments("123 :1 2    ", null, "123", listOf("1 2    ")),
+                arguments(":test abc 1 2    ", "test", "abc", listOf("1", "2")),
+                arguments("@tags :test abc 1 2 :three four", "test", "abc", listOf("1", "2", "three four")),
+                arguments("@tags abc 1 2 : three four ", null, "abc", listOf("1", "2", " three four "))
         )
     }
 
     @ParameterizedTest
     @MethodSource("ircMessageArgumentsProvider")
-    fun `Parses IRC messages`(input: String, tags: String?, prefix: String?, command: String, params: List<String>) {
+    fun `Parses basic IRC messages`(input: String, prefix: String?, command: String, params: List<String>) {
         val parsed = MessageParser().parse(input.toByteArray())
 
-        assertEquals(tags, parsed.tags?.let { String(it) }) { "Expected '$input' to have tags '$tags'" }
         assertEquals(prefix, parsed.prefix?.let { String(it) }) { "Expected '$input' to have prefix '$prefix'" }
         assertEquals(command, parsed.command) { "Expected '$input' to have command '$command'" }
         assertEquals(params, parsed.params.map { String(it) }) { "Expected '$input' to have params '$params'" }
     }
 
+    @Test
+    fun `Parses tags without values`() {
+        val parsed = MessageParser().parse("@time;account= :zeroCool!dade@root.localhost PRIVMSG #chat :Hack the planet!".toByteArray())
+
+        assertEquals(2, parsed.tags.size)
+        assertEquals("", parsed.tags[MessageTag.ServerTime])
+        assertEquals("", parsed.tags[MessageTag.AccountName])
+    }
+
+    @Test
+    fun `Parses tags with values`() {
+        val parsed = MessageParser().parse("@time=2011-10-19T16:40:51.620Z;account=zeroCool :zeroCool!dade@root.localhost PRIVMSG #chat :Hack the planet!".toByteArray())
+
+        assertEquals(2, parsed.tags.size)
+        assertEquals("2011-10-19T16:40:51.620Z", parsed.tags[MessageTag.ServerTime])
+        assertEquals("zeroCool", parsed.tags[MessageTag.AccountName])
+    }
+
+    @Test
+    fun `Parses tags with escape sequences`() {
+        val parsed = MessageParser().parse("""@account=\\hack\sthe\r\nplanet\: :zeroCool!dade@root.localhost PRIVMSG #chat :Hack the planet!""".toByteArray())
+
+        assertEquals(1, parsed.tags.size)
+        assertEquals("\\hack the\r\nplanet;", parsed.tags[MessageTag.AccountName])
+    }
+
 }
 
 internal class CursorByteArrayTest {

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

 import com.dmdirc.ktirc.events.ServerCapabilitiesAcknowledged
 import com.dmdirc.ktirc.events.ServerCapabilitiesFinished
 import com.dmdirc.ktirc.events.ServerCapabilitiesReceived
-import com.dmdirc.ktirc.io.IrcMessage
 import com.dmdirc.ktirc.model.Capability
+import com.dmdirc.ktirc.model.IrcMessage
 import org.junit.jupiter.api.Assertions.assertEquals
 import org.junit.jupiter.api.Assertions.assertTrue
 import org.junit.jupiter.api.Test
 
     @Test
     fun `CapabilityProcessor does nothing for unknown subcommand`() {
-        val events = processor.process(IrcMessage(null, "the.gibson".toByteArray(), "CAP", listOf("*".toByteArray(), "FOO".toByteArray())))
+        val events = processor.process(IrcMessage(emptyMap(), "the.gibson".toByteArray(), "CAP", listOf("*".toByteArray(), "FOO".toByteArray())))
 
         assertTrue(events.isEmpty())
     }
 
     @Test
     fun `CapabilityProcessor raises ServerCapabilitiesReceived event with known capabilities`() {
-        val events = processor.process(IrcMessage(null, "the.gibson".toByteArray(), "CAP", listOf("*", "LS", "chghost extended-join invalid").map { it.toByteArray() }))
+        val events = processor.process(IrcMessage(emptyMap(), "the.gibson".toByteArray(), "CAP", listOf("*", "LS", "chghost extended-join invalid").map { it.toByteArray() }))
 
         val receivedEvent = events.filterIsInstance<ServerCapabilitiesReceived>()[0]
         assertEquals(2, receivedEvent.capabilities.size)
 
     @Test
     fun `CapabilityProcessor raises ServerCapabilitiesReceived event with values for capabilities`() {
-        val events = processor.process(IrcMessage(null, "the.gibson".toByteArray(), "CAP", listOf("*", "LS", "chghost=test123 extended-join=abc=def invalid").map { it.toByteArray() }))
+        val events = processor.process(IrcMessage(emptyMap(), "the.gibson".toByteArray(), "CAP", listOf("*", "LS", "chghost=test123 extended-join=abc=def invalid").map { it.toByteArray() }))
 
         val receivedEvent = events.filterIsInstance<ServerCapabilitiesReceived>()[0]
         assertEquals(2, receivedEvent.capabilities.size)
 
     @Test
     fun `CapabilityProcessor overwrites earlier values with later ones for identical capabilities`() {
-        val events = processor.process(IrcMessage(null, "the.gibson".toByteArray(), "CAP", listOf("*", "LS", "chghost=test123 chghost chghost=456").map { it.toByteArray() }))
+        val events = processor.process(IrcMessage(emptyMap(), "the.gibson".toByteArray(), "CAP", listOf("*", "LS", "chghost=test123 chghost chghost=456").map { it.toByteArray() }))
 
         val receivedEvent = events.filterIsInstance<ServerCapabilitiesReceived>()[0]
         assertEquals(1, receivedEvent.capabilities.size)
 
     @Test
     fun `CapabilityProcessor raises ServerCapabilitiesReceived event with known capabilities for multi-line responses`() {
-        val events = processor.process(IrcMessage(null, "the.gibson".toByteArray(), "CAP", listOf("*", "LS", "*", "chghost extended-join invalid").map { it.toByteArray() }))
+        val events = processor.process(IrcMessage(emptyMap(), "the.gibson".toByteArray(), "CAP", listOf("*", "LS", "*", "chghost extended-join invalid").map { it.toByteArray() }))
 
         val receivedEvent = events.filterIsInstance<ServerCapabilitiesReceived>()[0]
         assertEquals(2, receivedEvent.capabilities.size)
 
     @Test
     fun `CapabilityProcessor raises ServerCapabilitiesFinished event for final LS responses`() {
-        val events = processor.process(IrcMessage(null, "the.gibson".toByteArray(), "CAP", listOf("*", "LS", "chghost extended-join invalid").map { it.toByteArray() }))
+        val events = processor.process(IrcMessage(emptyMap(), "the.gibson".toByteArray(), "CAP", listOf("*", "LS", "chghost extended-join invalid").map { it.toByteArray() }))
 
         assertEquals(2, events.size)
         assertTrue(events[1] is ServerCapabilitiesFinished)
 
     @Test
     fun `CapabilityProcessor raises ServerCapabilitiesAcknowledged event`() {
-        val events = processor.process(IrcMessage(null, "the.gibson".toByteArray(), "CAP", listOf("*", "ACK", "chghost=test123 extended-join=abc=def invalid").map { it.toByteArray() }))
+        val events = processor.process(IrcMessage(emptyMap(), "the.gibson".toByteArray(), "CAP", listOf("*", "ACK", "chghost=test123 extended-join=abc=def invalid").map { it.toByteArray() }))
 
         val receivedEvent = events.filterIsInstance<ServerCapabilitiesAcknowledged>()[0]
         assertEquals(2, receivedEvent.capabilities.size)

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

 package com.dmdirc.ktirc.messages
 
 import com.dmdirc.ktirc.io.CaseMapping
-import com.dmdirc.ktirc.io.IrcMessage
+import com.dmdirc.ktirc.model.IrcMessage
 import com.dmdirc.ktirc.model.ModePrefixMapping
 import com.dmdirc.ktirc.model.ServerFeature
 import com.dmdirc.ktirc.model.ServerFeatureMap
 
     @Test
     fun `ISupportProcessor handles multiple numeric arguments`() {
-        val events = processor.process(IrcMessage(null, "server.com".toByteArray(), "005",
+        val events = processor.process(IrcMessage(emptyMap(), "server.com".toByteArray(), "005",
                 listOf("nickname", "MAXCHANNELS=123", "CHANNELLEN=456", "are supported blah blah").map { it.toByteArray() }))
 
         assertEquals(123, events[0].serverFeatures[ServerFeature.MaximumChannels])
 
     @Test
     fun `ISupportProcessor handles string arguments`() {
-        val events = processor.process(IrcMessage(null, "server.com".toByteArray(), "005",
+        val events = processor.process(IrcMessage(emptyMap(), "server.com".toByteArray(), "005",
                 listOf("nickname", "CHANMODES=abcd", "are supported blah blah").map { it.toByteArray() }))
 
         assertEquals("abcd", events[0].serverFeatures[ServerFeature.ChannelModes])
 
     @Test
     fun `ISupportProcessor handles resetting arguments`() {
-        val events = processor.process(IrcMessage(null, "server.com".toByteArray(), "005",
+        val events = processor.process(IrcMessage(emptyMap(), "server.com".toByteArray(), "005",
                 listOf("nickname", "-CHANMODES", "are supported blah blah").map { it.toByteArray() }))
 
         val oldFeatures = ServerFeatureMap()
 
     @Test
     fun `ISupportProcessor handles case mapping arguments`() {
-        val events = processor.process(IrcMessage(null, "server.com".toByteArray(), "005",
+        val events = processor.process(IrcMessage(emptyMap(), "server.com".toByteArray(), "005",
                 listOf("nickname", "CASEMAPPING=rfc1459-strict", "are supported blah blah").map { it.toByteArray() }))
 
         assertEquals(CaseMapping.RfcStrict, events[0].serverFeatures[ServerFeature.ServerCaseMapping])
 
     @Test
     fun `ISupportProcessor handles mode prefix arguments`() {
-        val events = processor.process(IrcMessage(null, "server.com".toByteArray(), "005",
+        val events = processor.process(IrcMessage(emptyMap(), "server.com".toByteArray(), "005",
                 listOf("nickname", "PREFIX=(ovd)@+%", "are supported blah blah").map { it.toByteArray() }))
 
         assertEquals(ModePrefixMapping("ovd", "@+%"), events[0].serverFeatures[ServerFeature.ModePrefixes])
 
     @Test
     fun `ISupportProcessor handles boolean features with no arguments`() {
-        val events = processor.process(IrcMessage(null, "server.com".toByteArray(), "005",
+        val events = processor.process(IrcMessage(emptyMap(), "server.com".toByteArray(), "005",
                 listOf("nickname", "WHOX", "are supported blah blah").map { it.toByteArray() }))
 
         assertEquals(true, events[0].serverFeatures[ServerFeature.WhoxSupport])

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

 package com.dmdirc.ktirc.messages
 
 import com.dmdirc.ktirc.events.ChannelJoined
-import com.dmdirc.ktirc.io.IrcMessage
+import com.dmdirc.ktirc.model.IrcMessage
 import com.dmdirc.ktirc.model.User
 import org.junit.jupiter.api.Assertions.assertEquals
 import org.junit.jupiter.api.Test
     @Test
     fun `JoinProcessor raises join event`() {
         val events = JoinProcessor().process(
-                IrcMessage(null, "acidburn!libby@root.localhost".toByteArray(), "JOIN", listOf("#crashandburn".toByteArray())))
+                IrcMessage(emptyMap(), "acidburn!libby@root.localhost".toByteArray(), "JOIN", listOf("#crashandburn".toByteArray())))
         assertEquals(1, events.size)
         assertEquals(ChannelJoined(User("acidburn", "libby", "root.localhost"), "#crashandburn"), events[0])
     }
     @Test
     fun `JoinProcessor does nothing if prefix missing`() {
         val events = JoinProcessor().process(
-                IrcMessage(null, null, "JOIN", listOf("#crashandburn".toByteArray())))
+                IrcMessage(emptyMap(), null, "JOIN", listOf("#crashandburn".toByteArray())))
         assertEquals(0, events.size)
     }
 

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

 
 import com.dmdirc.ktirc.events.ChannelNamesFinished
 import com.dmdirc.ktirc.events.ChannelNamesReceived
-import com.dmdirc.ktirc.io.IrcMessage
+import com.dmdirc.ktirc.model.IrcMessage
 import org.junit.jupiter.api.Assertions.assertEquals
 import org.junit.jupiter.api.Test
 
 
     @Test
     fun `NamesProcessor handles end of names reply`() {
-        val events = processor.process(IrcMessage(null, ":the.gibson".toByteArray(), "366", listOf("AcidBurn", "#root", "End of /NAMES list").map { it.toByteArray() }))
+        val events = processor.process(IrcMessage(emptyMap(), ":the.gibson".toByteArray(), "366", listOf("AcidBurn", "#root", "End of /NAMES list").map { it.toByteArray() }))
 
         assertEquals(1, events.size)
         assertEquals("#root", (events[0] as ChannelNamesFinished).channel)
 
     @Test
     fun `NamesProcessor handles names reply`() {
-        val events = processor.process(IrcMessage(null, ":the.gibson".toByteArray(), "353", listOf("AcidBurn", "@", "#root", "AcidBurn @ZeroCool +ThePlague").map { it.toByteArray() }))
+        val events = processor.process(IrcMessage(emptyMap(), ":the.gibson".toByteArray(), "353", listOf("AcidBurn", "@", "#root", "AcidBurn @ZeroCool +ThePlague").map { it.toByteArray() }))
 
         assertEquals(1, events.size)
         val event = events[0] as ChannelNamesReceived

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

 package com.dmdirc.ktirc.messages
 
 import com.dmdirc.ktirc.events.ChannelParted
-import com.dmdirc.ktirc.io.IrcMessage
+import com.dmdirc.ktirc.model.IrcMessage
 import com.dmdirc.ktirc.model.User
 import org.junit.jupiter.api.Assertions
 import org.junit.jupiter.api.Test
     @Test
     fun `PartProcessor raises part event without message`() {
         val events = PartProcessor().process(
-                IrcMessage(null, "acidburn!libby@root.localhost".toByteArray(), "PART", listOf("#crashandburn".toByteArray())))
+                IrcMessage(emptyMap(), "acidburn!libby@root.localhost".toByteArray(), "PART", listOf("#crashandburn".toByteArray())))
         Assertions.assertEquals(1, events.size)
         Assertions.assertEquals(ChannelParted(User("acidburn", "libby", "root.localhost"), "#crashandburn"), events[0])
     }
     @Test
     fun `PartProcessor raises part event with message`() {
         val events = PartProcessor().process(
-                IrcMessage(null, "acidburn!libby@root.localhost".toByteArray(), "PART", listOf("#crashandburn".toByteArray(), "Hack the planet!".toByteArray())))
+                IrcMessage(emptyMap(), "acidburn!libby@root.localhost".toByteArray(), "PART", listOf("#crashandburn".toByteArray(), "Hack the planet!".toByteArray())))
         Assertions.assertEquals(1, events.size)
         Assertions.assertEquals(ChannelParted(User("acidburn", "libby", "root.localhost"), "#crashandburn", "Hack the planet!"), events[0])
     }
     @Test
     fun `PartProcessor does nothing if prefix missing`() {
         val events = JoinProcessor().process(
-                IrcMessage(null, null, "PART", listOf("#crashandburn".toByteArray())))
+                IrcMessage(emptyMap(), null, "PART", listOf("#crashandburn".toByteArray())))
         Assertions.assertEquals(0, events.size)
     }
 

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

 package com.dmdirc.ktirc.messages
 
 import com.dmdirc.ktirc.events.MessageReceived
-import com.dmdirc.ktirc.io.IrcMessage
+import com.dmdirc.ktirc.model.IrcMessage
 import com.dmdirc.ktirc.model.User
 import org.junit.jupiter.api.Assertions
 import org.junit.jupiter.api.Test
     @Test
     fun `PrivsgProcessor raises message received event`() {
         val events = PrivmsgProcessor().process(
-                IrcMessage(null, "acidburn!libby@root.localhost".toByteArray(), "PRIVMSG", listOf("#crashandburn".toByteArray(), "hack the planet!".toByteArray())))
+                IrcMessage(emptyMap(), "acidburn!libby@root.localhost".toByteArray(), "PRIVMSG", listOf("#crashandburn".toByteArray(), "hack the planet!".toByteArray())))
         Assertions.assertEquals(1, events.size)
         Assertions.assertEquals(MessageReceived(User("acidburn", "libby", "root.localhost"), "#crashandburn", "hack the planet!"), events[0])
     }
     @Test
     fun `PrivsgProcessor does nothing if prefix missing`() {
         val events = PrivmsgProcessor().process(
-                IrcMessage(null, null, "PRIVMSG", listOf("#crashandburn".toByteArray(), "hack the planet!".toByteArray())))
+                IrcMessage(emptyMap(), null, "PRIVMSG", listOf("#crashandburn".toByteArray(), "hack the planet!".toByteArray())))
         Assertions.assertEquals(0, events.size)
     }
 }

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

 package com.dmdirc.ktirc.messages
 
 import com.dmdirc.ktirc.events.UserQuit
-import com.dmdirc.ktirc.io.IrcMessage
+import com.dmdirc.ktirc.model.IrcMessage
 import com.dmdirc.ktirc.model.User
 import org.junit.jupiter.api.Assertions
 import org.junit.jupiter.api.Test
     @Test
     fun `QuitProcessor raises quit event without message`() {
         val events = QuitProcessor().process(
-                IrcMessage(null, "acidburn!libby@root.localhost".toByteArray(), "QUIT", emptyList()))
+                IrcMessage(emptyMap(), "acidburn!libby@root.localhost".toByteArray(), "QUIT", emptyList()))
         Assertions.assertEquals(1, events.size)
         Assertions.assertEquals(UserQuit(User("acidburn", "libby", "root.localhost")), events[0])
     }
     @Test
     fun `QuitProcessor raises quit event with message`() {
         val events = QuitProcessor().process(
-                IrcMessage(null, "acidburn!libby@root.localhost".toByteArray(), "QUIT", listOf("Hack the planet!".toByteArray())))
+                IrcMessage(emptyMap(), "acidburn!libby@root.localhost".toByteArray(), "QUIT", listOf("Hack the planet!".toByteArray())))
         Assertions.assertEquals(1, events.size)
         Assertions.assertEquals(UserQuit(User("acidburn", "libby", "root.localhost"), "Hack the planet!"), events[0])
     }
     @Test
     fun `QuitProcessor does nothing if prefix missing`() {
         val events = QuitProcessor().process(
-                IrcMessage(null, null, "QUIT", listOf("Hack the planet!".toByteArray())))
+                IrcMessage(emptyMap(), null, "QUIT", listOf("Hack the planet!".toByteArray())))
         Assertions.assertEquals(0, events.size)
     }
 

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

 
 import com.dmdirc.ktirc.events.IrcEvent
 import com.dmdirc.ktirc.events.ServerWelcome
-import com.dmdirc.ktirc.io.IrcMessage
+import com.dmdirc.ktirc.model.IrcMessage
 import org.junit.jupiter.api.Assertions.assertEquals
 import org.junit.jupiter.api.Assertions.assertTrue
 import org.junit.jupiter.api.Test
 
     @Test
     fun `WelcomeProcessor returns server welcome event`() {
-        val events = processor.process(IrcMessage(null, ":thegibson.com".toByteArray(), "001", listOf(
+        val events = processor.process(IrcMessage(emptyMap(), ":thegibson.com".toByteArray(), "001", listOf(
                 "acidBurn".toByteArray(),
                 "Welcome to the Internet Relay Network, acidBurn!burn@hacktheplanet.com".toByteArray())))
         assertEquals(listOf<IrcEvent>(ServerWelcome("acidBurn")), events)