Add TargetedEvent class, fix caps negotiation

After allowing multiple names we started ACKing only the preferred
name, even if the server hadn't advertised it.

CHANGELOG

  * Batch start and end events are no longer included in BatchReceived events
  * Batches now expose complete metadata from their start event
  * Added support for labelled-replies capability and label message tags
+ * Added support for message-tags capability after it moved from draft
  * Added new methods for sending raw lines to the IRC server
    * send(tagMap(...), command, arguments) replaces send(line)
    * send(command, arguments) is available if no tags are to be sent
    * send(line) is deprecated and will be removed after v1.0.0
  * Add 'alwaysEchoMessages' behaviour that makes it easier to deal with servers
    that don't support the echo message capability
+ * Added TargetedEvent, a subclass of IrcEvent, for all events that are
+   targeted to a user or channel
  * (Internal) Added annotation to track removal of deprecated methods
 
 v0.9.0

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

 package com.dmdirc.ktirc.events
 
-import com.dmdirc.ktirc.model.Capability
 import com.dmdirc.ktirc.model.ConnectionError
 import com.dmdirc.ktirc.model.ServerFeatureMap
 import com.dmdirc.ktirc.model.User
 
 }
 
+/**
+ * Base class for events that are targeted to a channel or user.
+ */
+sealed class TargetedEvent(metadata: EventMetadata, val target: String) : IrcEvent(metadata) {
+
+    /** The channel (or user!) this event was targeted at. */
+    @Deprecated("Use target instead", replaceWith = ReplaceWith("target"))
+    @RemoveIn("2.0.0")
+    val channel: String
+        get() = target
+
+}
+
 /** Raised when a connection to the server is being established. */
 class ServerConnecting(metadata: EventMetadata) : IrcEvent(metadata)
 
 class PingReceived(metadata: EventMetadata, val nonce: ByteArray) : IrcEvent(metadata)
 
 /** Raised when a user joins a channel. */
-class ChannelJoined(metadata: EventMetadata, val user: User, val channel: String) : IrcEvent(metadata)
+class ChannelJoined(metadata: EventMetadata, val user: User, channel: String) : TargetedEvent(metadata, channel)
 
 /** Raised when a user leaves a channel. */
-class ChannelParted(metadata: EventMetadata, val user: User, val channel: String, val reason: String = "") : IrcEvent(metadata)
+class ChannelParted(metadata: EventMetadata, val user: User, channel: String, val reason: String = "") : TargetedEvent(metadata, channel)
 
 /** Raised when a [victim] is kicked from a channel. */
-class ChannelUserKicked(metadata: EventMetadata, val user: User, val channel: String, val victim: String, val reason: String = "") : IrcEvent(metadata)
+class ChannelUserKicked(metadata: EventMetadata, val user: User, channel: String, val victim: String, val reason: String = "") : TargetedEvent(metadata, channel)
 
 /** Raised when a user quits, and is in a channel. */
-class ChannelQuit(metadata: EventMetadata, val user: User, val channel: String, val reason: String = "") : IrcEvent(metadata)
+class ChannelQuit(metadata: EventMetadata, val user: User, channel: String, val reason: String = "") : TargetedEvent(metadata, channel)
 
 /** Raised when a user changes nickname, and is in a channel. */
-class ChannelNickChanged(metadata: EventMetadata, val user: User, val channel: String, val newNick: String) : IrcEvent(metadata)
+class ChannelNickChanged(metadata: EventMetadata, val user: User, channel: String, val newNick: String) : TargetedEvent(metadata, channel)
 
 /** Raised when a batch of the channel's member list has been received. More batches may follow. */
-class ChannelNamesReceived(metadata: EventMetadata, val channel: String, val names: List<String>) : IrcEvent(metadata)
+class ChannelNamesReceived(metadata: EventMetadata, channel: String, val names: List<String>) : TargetedEvent(metadata, channel)
 
 /** Raised when the entirety of the channel's member list has been received. */
-class ChannelNamesFinished(metadata: EventMetadata, val channel: String) : IrcEvent(metadata)
+class ChannelNamesFinished(metadata: EventMetadata, channel: String) : TargetedEvent(metadata, channel)
 
 /** Raised when a channel topic is discovered (not changed). Usually followed by [ChannelTopicMetadataDiscovered] if the [topic] is non-null. */
-class ChannelTopicDiscovered(metadata: EventMetadata, val channel: String, val topic: String?) : IrcEvent(metadata)
+class ChannelTopicDiscovered(metadata: EventMetadata, channel: String, val topic: String?) : TargetedEvent(metadata, channel)
 
 /** Raised when a channel topic's metadata is discovered. */
-class ChannelTopicMetadataDiscovered(metadata: EventMetadata, val channel: String, val user: User, val setTime: LocalDateTime) : IrcEvent(metadata)
+class ChannelTopicMetadataDiscovered(metadata: EventMetadata, channel: String, val user: User, val setTime: LocalDateTime) : TargetedEvent(metadata, channel)
 
 /**
  * Raised when a channel's topic is changed.
  *
  * If the topic has been unset (cleared), [topic] will be `null`
  */
-class ChannelTopicChanged(metadata: EventMetadata, val user: User, val channel: String, val topic: String?) : IrcEvent(metadata)
+class ChannelTopicChanged(metadata: EventMetadata, val user: User, channel: String, val topic: String?) : TargetedEvent(metadata, channel)
 
 /** Raised when a message is received. */
-class MessageReceived(metadata: EventMetadata, val user: User, val target: String, val message: String) : IrcEvent(metadata) {
+class MessageReceived(metadata: EventMetadata, val user: User, target: String, val message: String) : TargetedEvent(metadata, target) {
 
     /** The message ID of this message. */
     @Deprecated("Moved to metadata", replaceWith = ReplaceWith("metadata.messageId"))
  *
  * The [user] may in fact be a server, or have a nickname of `*` while connecting.
  */
-class NoticeReceived(metadata: EventMetadata, val user: User, val target: String, val message: String) : IrcEvent(metadata)
+class NoticeReceived(metadata: EventMetadata, val user: User, target: String, val message: String) : TargetedEvent(metadata, target)
 
 /** Raised when an action is received. */
-class ActionReceived(metadata: EventMetadata, val user: User, val target: String, val action: String) : IrcEvent(metadata) {
+class ActionReceived(metadata: EventMetadata, val user: User, target: String, val action: String) : TargetedEvent(metadata, target) {
 
     /** The message ID of this action. */
     @Deprecated("Moved to metadata", replaceWith = ReplaceWith("metadata.messageId"))
 }
 
 /** Raised when a CTCP is received. */
-class CtcpReceived(metadata: EventMetadata, val user: User, val target: String, val type: String, val content: String) : IrcEvent(metadata)
+class CtcpReceived(metadata: EventMetadata, val user: User, target: String, val type: String, val content: String) : TargetedEvent(metadata, target)
 
 /** Raised when a CTCP reply is received. */
-class CtcpReplyReceived(metadata: EventMetadata, val user: User, val target: String, val type: String, val content: String) : IrcEvent(metadata)
+class CtcpReplyReceived(metadata: EventMetadata, val user: User, target: String, val type: String, val content: String) : TargetedEvent(metadata, target)
 
 /** Raised when a user quits. */
 class UserQuit(metadata: EventMetadata, val user: User, val reason: String = "") : IrcEvent(metadata)
 class UserAccountChanged(metadata: EventMetadata, val user: User, val newAccount: String?) : IrcEvent(metadata)
 
 /** Raised when available server capabilities are received. More batches may follow. */
-class ServerCapabilitiesReceived(metadata: EventMetadata, val capabilities: Map<Capability, String>) : IrcEvent(metadata)
+class ServerCapabilitiesReceived(metadata: EventMetadata, val capabilities: Map<String, String>) : IrcEvent(metadata)
 
 /** Raised when our requested capabilities are acknowledged. More batches may follow. */
-class ServerCapabilitiesAcknowledged(metadata: EventMetadata, val capabilities: Map<Capability, String>) : IrcEvent(metadata)
+class ServerCapabilitiesAcknowledged(metadata: EventMetadata, val capabilities: Map<String, String>) : IrcEvent(metadata)
 
 /** Raised when the server has finished sending us capabilities. */
 class ServerCapabilitiesFinished(metadata: EventMetadata) : IrcEvent(metadata)
  * and the given modes are thus exhaustive. Otherwise, the modes are a sequence of changes to apply to the existing
  * state.
  */
-class ModeChanged(metadata: EventMetadata, val target: String, val modes: String, val arguments: Array<String>, val discovered: Boolean = false) : IrcEvent(metadata)
+class ModeChanged(metadata: EventMetadata, target: String, val modes: String, val arguments: Array<String>, val discovered: Boolean = false) : TargetedEvent(metadata, target)
 
 /** Raised when an AUTHENTICATION message is received. [argument] is `null` if the server sent an empty reply ("+") */
 class AuthenticationMessage(metadata: EventMetadata, val argument: String?) : IrcEvent(metadata)

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

 import com.dmdirc.ktirc.model.CapabilitiesNegotiationState
 import com.dmdirc.ktirc.model.CapabilitiesState
 import com.dmdirc.ktirc.model.Capability
+import com.dmdirc.ktirc.model.capabilities
 import com.dmdirc.ktirc.sasl.fromBase64
 import com.dmdirc.ktirc.util.logger
 
         }
     }
 
-    private fun handleCapabilitiesReceived(state: CapabilitiesState, capabilities: Map<Capability, String>) {
+    private fun handleCapabilitiesReceived(state: CapabilitiesState, capabilities: Map<String, String>) {
         state.advertisedCapabilities.putAll(capabilities)
     }
 
                 client.sendCapabilityEnd()
             } else {
                 negotiationState = CapabilitiesNegotiationState.AWAITING_ACK
-                advertisedCapabilities.keys.map { it.names[0] }.let {
+                advertisedCapabilities.keys.let {
                     log.info { "Requesting capabilities: ${it.toList()}" }
                     client.sendCapabilityRequest(it)
                 }
         }
     }
 
-    private fun handleCapabilitiesAcknowledged(client: IrcClient, capabilities: Map<Capability, String>) {
+    private fun handleCapabilitiesAcknowledged(client: IrcClient, ackedCapabilities: Map<String, String>) {
         // TODO: Check if everything we wanted is enabled
         with(client.serverState.capabilities) {
-            log.info { "Acknowledged capabilities: ${capabilities.keys.map { it::class.simpleName }.toList()}" }
-            enabledCapabilities.putAll(capabilities)
+            log.info { "Acknowledged capabilities: ${ackedCapabilities.keys.toList()}" }
+            ackedCapabilities.forEach { n, v ->
+                capabilities[n]?.let {
+                    enabledCapabilities[it] = v
+                }
+            }
 
             if (client.serverState.sasl.mechanisms.isNotEmpty()) {
-                advertisedCapabilities[Capability.SaslAuthentication]?.let { serverCaps ->
+                // TODO: Icky. What if SASL had multiple names?
+                advertisedCapabilities[Capability.SaslAuthentication.names[0]]?.let { serverCaps ->
                     if (startSaslAuth(client, if (serverCaps.isEmpty()) emptyList() else serverCaps.split(','))) {
                         return
                     }

src/main/kotlin/com/dmdirc/ktirc/events/handlers/ChannelStateHandler.kt

 
     private fun handleJoin(client: IrcClient, event: ChannelJoined) {
         if (client.isLocalUser(event.user)) {
-            log.info { "Joined new channel: ${event.channel}" }
-            client.channelState += ChannelState(event.channel) { client.caseMapping }
+            log.info { "Joined new channel: ${event.target}" }
+            client.channelState += ChannelState(event.target) { client.caseMapping }
         }
 
-        client.channelState[event.channel]?.let { it.users += ChannelUser(event.user.nickname) }
+        client.channelState[event.target]?.let { it.users += ChannelUser(event.user.nickname) }
     }
 
     private fun handlePart(client: IrcClient, event: ChannelParted) {
         if (client.isLocalUser(event.user)) {
-            log.info { "Left channel: ${event.channel}" }
-            client.channelState -= event.channel
+            log.info { "Left channel: ${event.target}" }
+            client.channelState -= event.target
         } else {
-            client.channelState[event.channel]?.let {
+            client.channelState[event.target]?.let {
                 it.users -= event.user.nickname
             }
         }
 
     private fun handleKick(client: IrcClient, event: ChannelUserKicked) {
         if (client.isLocalUser(event.victim)) {
-            log.info { "Kicked from channel: ${event.channel}" }
-            client.channelState -= event.channel
+            log.info { "Kicked from channel: ${event.target}" }
+            client.channelState -= event.target
         } else {
-            client.channelState[event.channel]?.let {
+            client.channelState[event.target]?.let {
                 it.users -= event.victim
             }
         }
     }
 
     private fun handleNamesReceived(client: IrcClient, event: ChannelNamesReceived) {
-        val channel = client.channelState[event.channel] ?: return
+        val channel = client.channelState[event.target] ?: return
 
         if (!channel.receivingUserList) {
             log.finer { "Started receiving names list for ${channel.name}" }
     }
 
     private fun handleNamesFinished(client: IrcClient, event: ChannelNamesFinished) {
-        client.channelState[event.channel]?.let {
+        client.channelState[event.target]?.let {
             it.receivingUserList = false
-            log.finest { "Finished receiving names in ${event.channel}. Users: ${it.users.toList()}" }
+            log.finest { "Finished receiving names in ${event.target}. Users: ${it.users.toList()}" }
             if (client.behaviour.requestModesOnJoin && !it.modesDiscovered) {
                 client.sendModeRequest(it.name)
             }
     }
 
     private fun handleTopicDiscovered(client: IrcClient, event: ChannelTopicDiscovered) {
-        client.channelState[event.channel]?.let {
+        client.channelState[event.target]?.let {
             if (!it.topicDiscovered) {
                 it.topic = ChannelTopic(event.topic)
                 if (event.topic == null) {
     }
 
     private fun handleTopicMetadata(client: IrcClient, event: ChannelTopicMetadataDiscovered) {
-        client.channelState[event.channel]?.let {
+        client.channelState[event.target]?.let {
             if (!it.topicDiscovered) {
                 it.topic = ChannelTopic(it.topic.topic, event.user, event.setTime)
                 it.topicDiscovered = true
     }
 
     private fun handleTopicChanged(client: IrcClient, event: ChannelTopicChanged) {
-        client.channelState[event.channel]?.let {
+        client.channelState[event.target]?.let {
             it.topic = ChannelTopic(event.topic, event.user, event.metadata.time)
         }
     }
     }
 
     private fun handleQuit(client: IrcClient, event: ChannelQuit) {
-        client.channelState[event.channel]?.let {
+        client.channelState[event.target]?.let {
             it.users -= event.user.nickname
         }
     }
 
     private fun handleNickChanged(client: IrcClient, event: ChannelNickChanged) {
-        client.channelState[event.channel]?.let {
+        client.channelState[event.target]?.let {
             it.users[event.user.nickname]?.let { chanUser ->
                 chanUser.nickname = event.newNick
             }

src/main/kotlin/com/dmdirc/ktirc/events/handlers/UserStateHandler.kt

     }
 
     private fun handleJoin(state: UserState, event: ChannelJoined) {
-        state.addToChannel(event.user, event.channel)
+        state.addToChannel(event.user, event.target)
         state.update(event.user)
     }
 
     private fun handlePart(client: IrcClient, event: ChannelParted) {
         if (client.isLocalUser(event.user)) {
             // Remove channel from all users
-            client.userState.forEach { it.channels -= event.channel }
+            client.userState.forEach { it.channels -= event.target }
             client.userState.removeIf { it.channels.isEmpty() && !client.isLocalUser(it.details) }
         } else {
             client.userState[event.user]?.channels?.let {
-                it -= event.channel
+                it -= event.target
                 if (it.isEmpty()) {
                     client.userState -= event.user
                 }
     private fun handleKick(client: IrcClient, event: ChannelUserKicked) {
         if (client.isLocalUser(event.victim)) {
             // Remove channel from all users
-            client.userState.forEach { it.channels -= event.channel }
+            client.userState.forEach { it.channels -= event.target }
             client.userState.removeIf { it.channels.isEmpty() && !client.isLocalUser(it.details) }
         } else {
             client.userState[event.victim]?.channels?.let {
-                it -= event.channel
+                it -= event.target
                 if (it.isEmpty()) {
                     client.userState -= event.victim
                 }
 
     private fun handleNamesReceived(client: IrcClient, event: ChannelNamesReceived) {
         event.toModesAndUsers(client).forEach { (_, user) ->
-            client.userState.addToChannel(user, event.channel)
+            client.userState.addToChannel(user, event.target)
             client.userState.update(user)
         }
     }

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

             val index = cap.indexOf('=')
             val name = if (index == -1) cap else cap.substring(0 until index)
             val value = if (index == -1) "" else cap.substring(index + 1)
-            capabilities[name]?.let { yield(it to value) } ?: log.info { "Unknown capability: $name (value: $value)" }
+            capabilities[name]?.let { yield(name to value) } ?: log.info { "Unknown capability: $name (value: $value)" }
         }
     }.toMap()
 

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

 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(" "))
+internal fun IrcClient.sendCapabilityRequest(capabilities: Collection<String>) = send("CAP", "REQ", capabilities.joinToString(" "))
 
 /** Sends a request to join the given channel. */
 fun IrcClient.sendJoin(channel: String) = send("JOIN", channel)

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

 
     // TODO: These should only be mutable internally
     /** The capabilities that were advertised by the server. */
-    val advertisedCapabilities = HashMap<Capability, String>()
+    val advertisedCapabilities = HashMap<String, String>()
     /** The capabilities that we have agreed to enable. */
     val enabledCapabilities = HashMap<Capability, String>()
 

src/test/kotlin/com/dmdirc/ktirc/events/handlers/CapabilitiesHandlerTest.kt

     @Test
     fun `adds new capabilities to the state`() {
         handler.processEvent(ircClient, ServerCapabilitiesReceived(EventMetadata(TestConstants.time), hashMapOf(
-                Capability.EchoMessages to "",
-                Capability.HostsInNamesReply to "123"
+                Capability.EchoMessages.names[0] to "",
+                Capability.HostsInNamesReply.names[0] to "123"
         )))
 
         assertEquals(2, serverState.capabilities.advertisedCapabilities.size)
-        assertEquals("", serverState.capabilities.advertisedCapabilities[Capability.EchoMessages])
-        assertEquals("123", serverState.capabilities.advertisedCapabilities[Capability.HostsInNamesReply])
+        assertEquals("", serverState.capabilities.advertisedCapabilities[Capability.EchoMessages.names[0]])
+        assertEquals("123", serverState.capabilities.advertisedCapabilities[Capability.HostsInNamesReply.names[0]])
     }
 
     @Test
     fun `updates negotiation state when capabilities finished`() {
-        serverState.capabilities.advertisedCapabilities[Capability.EchoMessages] = ""
+        serverState.capabilities.advertisedCapabilities[Capability.EchoMessages.names[0]] = ""
 
         handler.processEvent(ircClient, ServerCapabilitiesFinished(EventMetadata(TestConstants.time)))
 
 
     @Test
     fun `sends REQ when capabilities received`() {
-        serverState.capabilities.advertisedCapabilities[Capability.EchoMessages] = ""
-        serverState.capabilities.advertisedCapabilities[Capability.AccountChangeMessages] = ""
+        serverState.capabilities.advertisedCapabilities[Capability.EchoMessages.names[0]] = ""
+        serverState.capabilities.advertisedCapabilities[Capability.AccountChangeMessages.names[0]] = ""
 
         handler.processEvent(ircClient, ServerCapabilitiesFinished(EventMetadata(TestConstants.time)))
 
     @Test
     fun `sends END when capabilities acknowledged and no enabled mechanisms`() {
         handler.processEvent(ircClient, ServerCapabilitiesAcknowledged(EventMetadata(TestConstants.time), hashMapOf(
-                Capability.EchoMessages to "",
-                Capability.HostsInNamesReply to ""
+                Capability.EchoMessages.names[0] to "",
+                Capability.HostsInNamesReply.names[0] to ""
         )))
 
         verify(ircClient).send("CAP", "END")
     fun `sends END when capabilities acknowledged and no sasl state`() {
         serverState.sasl.mechanisms.addAll(listOf(saslMech1, saslMech2, saslMech3))
         handler.processEvent(ircClient, ServerCapabilitiesAcknowledged(EventMetadata(TestConstants.time), hashMapOf(
-                Capability.EchoMessages to "",
-                Capability.HostsInNamesReply to ""
+                Capability.EchoMessages.names[0] to "",
+                Capability.HostsInNamesReply.names[0] to ""
         )))
 
         verify(ircClient).send("CAP", "END")
     @Test
     fun `sends END when capabilities acknowledged and no shared mechanism`() {
         serverState.sasl.mechanisms.addAll(listOf(saslMech1, saslMech2, saslMech3))
-        serverState.capabilities.advertisedCapabilities[Capability.SaslAuthentication] = "fake1,fake2"
+        serverState.capabilities.advertisedCapabilities[Capability.SaslAuthentication.names[0]] = "fake1,fake2"
         handler.processEvent(ircClient, ServerCapabilitiesAcknowledged(EventMetadata(TestConstants.time), hashMapOf(
-                Capability.SaslAuthentication to "",
-                Capability.HostsInNamesReply to ""
+                Capability.SaslAuthentication.names[0] to "",
+                Capability.HostsInNamesReply.names[0] to ""
         )))
 
         verify(ircClient).send("CAP", "END")
     @Test
     fun `sets current SASL mechanism when capabilities acknowledged with shared mechanism`() {
         serverState.sasl.mechanisms.addAll(listOf(saslMech1, saslMech2, saslMech3))
-        serverState.capabilities.advertisedCapabilities[Capability.SaslAuthentication] = "mech1,fake2"
+        serverState.capabilities.advertisedCapabilities[Capability.SaslAuthentication.names[0]] = "mech1,fake2"
         handler.processEvent(ircClient, ServerCapabilitiesAcknowledged(EventMetadata(TestConstants.time), hashMapOf(
-                Capability.SaslAuthentication to "",
-                Capability.HostsInNamesReply to ""
+                Capability.SaslAuthentication.names[0] to "",
+                Capability.HostsInNamesReply.names[0] to ""
         )))
 
         assertSame(saslMech1, serverState.sasl.currentMechanism)
     @Test
     fun `sets current SASL mechanism when capabilities acknowledged with no declared mechanisms`() {
         serverState.sasl.mechanisms.addAll(listOf(saslMech1, saslMech2, saslMech3))
-        serverState.capabilities.advertisedCapabilities[Capability.SaslAuthentication] = ""
+        serverState.capabilities.advertisedCapabilities[Capability.SaslAuthentication.names[0]] = ""
         handler.processEvent(ircClient, ServerCapabilitiesAcknowledged(EventMetadata(TestConstants.time), hashMapOf(
-                Capability.SaslAuthentication to "",
-                Capability.HostsInNamesReply to ""
+                Capability.SaslAuthentication.names[0] to "",
+                Capability.HostsInNamesReply.names[0] to ""
         )))
 
         assertSame(saslMech3, serverState.sasl.currentMechanism)
     @Test
     fun `sends authenticate when capabilities acknowledged with shared mechanism`() {
         serverState.sasl.mechanisms.addAll(listOf(saslMech1, saslMech2, saslMech3))
-        serverState.capabilities.advertisedCapabilities[Capability.SaslAuthentication] = "mech1,fake2"
+        serverState.capabilities.advertisedCapabilities[Capability.SaslAuthentication.names[0]] = "mech1,fake2"
         handler.processEvent(ircClient, ServerCapabilitiesAcknowledged(EventMetadata(TestConstants.time), hashMapOf(
-                Capability.SaslAuthentication to "",
-                Capability.HostsInNamesReply to ""
+                Capability.SaslAuthentication.names[0] to "",
+                Capability.HostsInNamesReply.names[0] to ""
         )))
 
         verify(ircClient).send("AUTHENTICATE", "mech1")
     @Test
     fun `sends authenticate when capabilities acknowledged with no declared mechanisms`() {
         serverState.sasl.mechanisms.addAll(listOf(saslMech1, saslMech2, saslMech3))
-        serverState.capabilities.advertisedCapabilities[Capability.SaslAuthentication] = ""
+        serverState.capabilities.advertisedCapabilities[Capability.SaslAuthentication.names[0]] = ""
         handler.processEvent(ircClient, ServerCapabilitiesAcknowledged(EventMetadata(TestConstants.time), hashMapOf(
-                Capability.SaslAuthentication to "",
-                Capability.HostsInNamesReply to ""
+                Capability.SaslAuthentication.names[0] to "",
+                Capability.HostsInNamesReply.names[0] to ""
         )))
 
         verify(ircClient).send("AUTHENTICATE", "mech3")
     @Test
     fun `updates negotiation state when capabilities acknowledged with shared mechanism`() {
         serverState.sasl.mechanisms.addAll(listOf(saslMech1, saslMech2, saslMech3))
-        serverState.capabilities.advertisedCapabilities[Capability.SaslAuthentication] = "mech1,fake2"
+        serverState.capabilities.advertisedCapabilities[Capability.SaslAuthentication.names[0]] = "mech1,fake2"
         handler.processEvent(ircClient, ServerCapabilitiesAcknowledged(EventMetadata(TestConstants.time), hashMapOf(
-                Capability.SaslAuthentication to "",
-                Capability.HostsInNamesReply to ""
+                Capability.SaslAuthentication.names[0] to "",
+                Capability.HostsInNamesReply.names[0] to ""
         )))
 
         assertEquals(CapabilitiesNegotiationState.AUTHENTICATING, serverState.capabilities.negotiationState)
     @Test
     fun `updates negotiation state when capabilities acknowledged`() {
         handler.processEvent(ircClient, ServerCapabilitiesAcknowledged(EventMetadata(TestConstants.time), hashMapOf(
-                Capability.EchoMessages to "",
-                Capability.HostsInNamesReply to "123"
+                Capability.EchoMessages.names[0] to "",
+                Capability.HostsInNamesReply.names[0] to "123"
         )))
 
         assertEquals(CapabilitiesNegotiationState.FINISHED, serverState.capabilities.negotiationState)
     @Test
     fun `stores enabled caps when capabilities acknowledged`() {
         handler.processEvent(ircClient, ServerCapabilitiesAcknowledged(EventMetadata(TestConstants.time), hashMapOf(
-                Capability.EchoMessages to "",
-                Capability.HostsInNamesReply to "123"
+                Capability.EchoMessages.names[0] to "",
+                Capability.HostsInNamesReply.names[0] to "123"
         )))
 
         assertEquals(2, serverState.capabilities.enabledCapabilities.size)

src/test/kotlin/com/dmdirc/ktirc/events/mutators/ChannelFanOutMutatorTest.kt

                 Assertions.assertEquals(TestConstants.time, it.metadata.time)
                 Assertions.assertEquals("zerocool", it.user.nickname)
                 Assertions.assertEquals("Hack the planet!", it.reason)
-                names.add(it.channel)
+                names.add(it.target)
             }
         }
 
                 Assertions.assertEquals(TestConstants.time, it.metadata.time)
                 Assertions.assertEquals("zerocool", it.user.nickname)
                 Assertions.assertEquals("zer0c00l", it.newNick)
-                names.add(it.channel)
+                names.add(it.target)
             }
         }
 

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.model.Capability
 import com.dmdirc.ktirc.model.IrcMessage
 import com.dmdirc.ktirc.params
 import org.junit.jupiter.api.Assertions.assertEquals
 
         val receivedEvent = events.filterIsInstance<ServerCapabilitiesReceived>()[0]
         assertEquals(2, receivedEvent.capabilities.size)
-        assertTrue(Capability.HostChangeMessages in receivedEvent.capabilities)
-        assertTrue(Capability.AccountAndRealNameInJoinMessages in receivedEvent.capabilities)
+        assertTrue("chghost" in receivedEvent.capabilities)
+        assertTrue("extended-join" in receivedEvent.capabilities)
     }
 
     @Test
 
         val receivedEvent = events.filterIsInstance<ServerCapabilitiesReceived>()[0]
         assertEquals(2, receivedEvent.capabilities.size)
-        assertEquals("test123", receivedEvent.capabilities[Capability.HostChangeMessages])
-        assertEquals("abc=def", receivedEvent.capabilities[Capability.AccountAndRealNameInJoinMessages])
+        assertEquals("test123", receivedEvent.capabilities["chghost"])
+        assertEquals("abc=def", receivedEvent.capabilities["extended-join"])
     }
 
     @Test
 
         val receivedEvent = events.filterIsInstance<ServerCapabilitiesReceived>()[0]
         assertEquals(1, receivedEvent.capabilities.size)
-        assertEquals("456", receivedEvent.capabilities[Capability.HostChangeMessages])
+        assertEquals("456", receivedEvent.capabilities["chghost"])
     }
 
 
 
         val receivedEvent = events.filterIsInstance<ServerCapabilitiesReceived>()[0]
         assertEquals(2, receivedEvent.capabilities.size)
-        assertTrue(Capability.HostChangeMessages in receivedEvent.capabilities)
-        assertTrue(Capability.AccountAndRealNameInJoinMessages in receivedEvent.capabilities)
+        assertTrue("chghost" in receivedEvent.capabilities)
+        assertTrue("extended-join" in receivedEvent.capabilities)
     }
 
     @Test
 
         val receivedEvent = events.filterIsInstance<ServerCapabilitiesAcknowledged>()[0]
         assertEquals(2, receivedEvent.capabilities.size)
-        assertEquals("test123", receivedEvent.capabilities[Capability.HostChangeMessages])
-        assertEquals("abc=def", receivedEvent.capabilities[Capability.AccountAndRealNameInJoinMessages])
+        assertEquals("test123", receivedEvent.capabilities["chghost"])
+        assertEquals("abc=def", receivedEvent.capabilities["extended-join"])
     }
 
 }

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

 
         assertEquals(TestConstants.time, events[0].metadata.time)
         assertEquals(User("acidburn", "libby", "root.localhost"), events[0].user)
-        assertEquals("#crashandburn", events[0].channel)
+        assertEquals("#crashandburn", events[0].target)
     }
 
     @Test
 
         assertEquals(TestConstants.time, events[0].metadata.time)
         assertEquals(User("acidburn", "libby", "root.localhost", account = "acidBurn", realName = "Libby"), events[0].user)
-        assertEquals("#crashandburn", events[0].channel)
+        assertEquals("#crashandburn", events[0].target)
     }
 
     @Test
 
         assertEquals(TestConstants.time, events[0].metadata.time)
         assertEquals(User("acidburn", "libby", "root.localhost", realName = "Libby"), events[0].user)
-        assertEquals("#crashandburn", events[0].channel)
+        assertEquals("#crashandburn", events[0].target)
     }
 
 }

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

 
         assertEquals(TestConstants.time, events[0].metadata.time)
         assertEquals(User("acidburn", "libby", "root.localhost"), events[0].user)
-        assertEquals("#crashandburn", events[0].channel)
+        assertEquals("#crashandburn", events[0].target)
         assertEquals("zeroCool", events[0].victim)
         assertEquals("", events[0].reason)
     }
 
         assertEquals(TestConstants.time, events[0].metadata.time)
         assertEquals(User("acidburn", "libby", "root.localhost"), events[0].user)
-        assertEquals("#crashandburn", events[0].channel)
+        assertEquals("#crashandburn", events[0].target)
         assertEquals("zeroCool", events[0].victim)
         assertEquals("Hack the planet!", events[0].reason)
     }

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

         val events = processor.process(IrcMessage(emptyMap(), ":the.gibson".toByteArray(), "366", params("AcidBurn", "#root", "End of /NAMES list")))
 
         assertEquals(1, events.size)
-        assertEquals("#root", (events[0] as ChannelNamesFinished).channel)
+        assertEquals("#root", (events[0] as ChannelNamesFinished).target)
     }
 
     @Test
 
         assertEquals(1, events.size)
         val event = events[0] as ChannelNamesReceived
-        assertEquals("#root", event.channel)
+        assertEquals("#root", event.target)
         assertEquals(listOf("AcidBurn", "@ZeroCool", "+ThePlague"), event.names)
     }
 

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

 
         assertEquals(TestConstants.time, events[0].metadata.time)
         assertEquals(User("acidburn", "libby", "root.localhost"), events[0].user)
-        assertEquals("#crashandburn", events[0].channel)
+        assertEquals("#crashandburn", events[0].target)
         assertEquals("", events[0].reason)
     }
 
 
         assertEquals(TestConstants.time, events[0].metadata.time)
         assertEquals(User("acidburn", "libby", "root.localhost"), events[0].user)
-        assertEquals("#crashandburn", events[0].channel)
+        assertEquals("#crashandburn", events[0].target)
         assertEquals("Hack the planet!", events[0].reason)
     }
 

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

 
         val event = events[0] as ChannelTopicDiscovered
         assertEquals(TestConstants.time, event.metadata.time)
-        assertEquals("#thegibson", event.channel)
+        assertEquals("#thegibson", event.target)
         assertEquals("Hack the planet!", event.topic)
     }
 
 
         val event = events[0] as ChannelTopicDiscovered
         assertEquals(TestConstants.time, event.metadata.time)
-        assertEquals("#thegibson", event.channel)
+        assertEquals("#thegibson", event.target)
         assertNull(event.topic)
     }
 
 
         val event = events[0] as ChannelTopicMetadataDiscovered
         assertEquals(TestConstants.time, event.metadata.time)
-        assertEquals("#thegibson", event.channel)
+        assertEquals("#thegibson", event.target)
         assertEquals("zeroCool", event.user.nickname)
         assertEquals(TestConstants.otherTime, event.setTime)
     }
         val event = events[0] as ChannelTopicChanged
         assertEquals(TestConstants.time, event.metadata.time)
         assertEquals(User("acidBurn", "acidB", "the.gibson"), event.user)
-        assertEquals("#thegibson", event.channel)
+        assertEquals("#thegibson", event.target)
         assertEquals("Hack the planet!", event.topic)
     }
 

src/test/kotlin/com/dmdirc/ktirc/model/CapabilitiesStateTest.kt

 
     @Test
     fun `reset clears all state`() = with(CapabilitiesState()) {
-        advertisedCapabilities[Capability.SaslAuthentication] = "foo"
+        advertisedCapabilities["sasl"] = "foo"
         enabledCapabilities[Capability.SaslAuthentication] = "foo"
         negotiationState = CapabilitiesNegotiationState.FINISHED
 

src/test/kotlin/com/dmdirc/ktirc/model/ServerStateTest.kt

         localNickname = "acidBurn3"
         serverName = "root.the.gibson"
         features[ServerFeature.Network] = "gibson"
-        capabilities.advertisedCapabilities[Capability.SaslAuthentication] = "sure"
+        capabilities.advertisedCapabilities["sasl"] = "sure"
         sasl.saslBuffer = "in progress"
         batches["batch"] = Batch("type", emptyList(), EventMetadata(TestConstants.time))
         labelCounter.set(100)