Add support for channel modes

Closes #5

CHANGELOG

     * CHANMODES feature is now stored as an array, not a single comma-separated string
     * Added ChanModeType enum, and method in ServerState to get the type of a mode
     * Added ModeChanged event, for user and channel mode changes and discovery
+    * Added modes and modesDiscovered to ChannelState
  * Other new events:
     * Added MotdFinished event
     * Added UserAccountChanged event

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

             is ChannelParted -> handlePart(client, event)
             is ChannelNamesReceived -> handleNamesReceived(client, event)
             is ChannelNamesFinished -> handleNamesFinished(client, event)
+            is ModeChanged -> handleModeChanged(client, event)
             is UserQuit -> return handleQuit(client, event)
         }
         return emptyList()
         }
     }
 
+    private fun handleModeChanged(client: IrcClient, event: ModeChanged) {
+        val chan =  client.channelState[event.target] ?: return
+        if (event.discovered) {
+            chan.modesDiscovered = true
+            chan.modes.clear()
+        }
+
+        var adding = true
+        var argumentOffset = 0
+        for (char in event.modes) {
+            when (char) {
+                '+' -> adding = true
+                '-' -> adding = false
+                else -> argumentOffset += adjustMode(client, chan, char, event.arguments, argumentOffset, adding)
+            }
+        }
+    }
+
+    private fun adjustMode(client: IrcClient, chan: ChannelState, mode: Char, arguments: Array<String>, argumentOffset: Int, adding: Boolean): Int {
+        val type = client.serverState.channelModeType(mode)
+        val takesParam = if (adding) type.needsParameterToSet else type.needsParameterToUnset
+        val param = if (takesParam) arguments[argumentOffset] else ""
+        if (adding) {
+            chan.modes[mode] = param
+        } else {
+            chan.modes.remove(mode)
+        }
+        return if (takesParam) 1 else 0
+    }
+
     private fun handleQuit(client: IrcClient, event: UserQuit) = sequence {
         client.channelState.forEach {
             if (it.users.contains(event.user.nickname)) {

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

     var receivingUserList = false
         internal set
 
+    /**
+     * Whether or not we have discovered the full set of modes for the channel.
+     */
+    var modesDiscovered = false
+        internal set
+
     /**
      * A map of all users in the channel to their current modes.
      */
     val users = ChannelUserMap(caseMappingProvider)
 
+    /**
+     * A map of modes set on the channel, and their values (if any).
+     *
+     * If [modesDiscovered] is false, this map may be missing modes that the server hasn't told us about.
+     */
+    var modes = HashMap<Char, String>()
 }
 
 /**

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

 import com.dmdirc.ktirc.model.*
 import com.nhaarman.mockitokotlin2.doReturn
 import com.nhaarman.mockitokotlin2.mock
-import kotlinx.coroutines.runBlocking
 import org.junit.jupiter.api.Assertions.*
 import org.junit.jupiter.api.Test
 
     }
 
     @Test
-    fun `ChannelStateHandler creates new state object for local joins`() = runBlocking {
+    fun `ChannelStateHandler creates new state object for local joins`() {
         handler.processEvent(ircClient, ChannelJoined(TestConstants.time, User("acidburn", "libby", "root.localhost"), "#thegibson"))
         assertTrue("#thegibson" in channelStateMap)
     }
 
     @Test
-    fun `ChannelStateHandler does not create new state object for remote joins`() = runBlocking {
+    fun `ChannelStateHandler does not create new state object for remote joins`() {
         handler.processEvent(ircClient, ChannelJoined(TestConstants.time, User("zerocool", "dade", "root.localhost"), "#thegibson"))
         assertFalse("#thegibson" in channelStateMap)
     }
 
     @Test
-    fun `ChannelStateHandler adds joiners to channel state`() = runBlocking {
+    fun `ChannelStateHandler adds joiners to channel state`() {
         channelStateMap += ChannelState("#thegibson") { CaseMapping.Rfc }
 
         handler.processEvent(ircClient, ChannelJoined(TestConstants.time, User("zerocool", "dade", "root.localhost"), "#thegibson"))
     }
 
     @Test
-    fun `ChannelStateHandler clears existing users when getting a new list`() = runBlocking {
+    fun `ChannelStateHandler clears existing users when getting a new list`() {
         val channel = ChannelState("#thegibson") { CaseMapping.Rfc }
         channel.users += ChannelUser("acidBurn")
         channel.users += ChannelUser("thePlague")
     }
 
     @Test
-    fun `ChannelStateHandler adds users from multiple name received events`() = runBlocking {
+    fun `ChannelStateHandler adds users from multiple name received events`() {
         val channel = ChannelState("#thegibson") { CaseMapping.Rfc }
         channelStateMap += channel
 
     }
 
     @Test
-    fun `ChannelStateHandler clears and readds users on additional names received`() = runBlocking {
+    fun `ChannelStateHandler clears and readds users on additional names received`() {
         val channel = ChannelState("#thegibson") { CaseMapping.Rfc }
         channelStateMap += channel
 
     }
 
     @Test
-    fun `ChannelStateHandler adds users with mode prefixes`() = runBlocking {
+    fun `ChannelStateHandler adds users with mode prefixes`() {
         val channel = ChannelState("#thegibson") { CaseMapping.Rfc }
         channelStateMap += channel
         serverState.features[ServerFeature.ModePrefixes] = ModePrefixMapping("ov", "@+")
     }
 
     @Test
-    fun `ChannelStateHandler adds users with full hosts`() = runBlocking {
+    fun `ChannelStateHandler adds users with full hosts`() {
         val channel = ChannelState("#thegibson") { CaseMapping.Rfc }
         channelStateMap += channel
         serverState.features[ServerFeature.ModePrefixes] = ModePrefixMapping("ov", "@+")
     }
 
     @Test
-    fun `ChannelStateHandler removes state object for local parts`() = runBlocking {
+    fun `ChannelStateHandler removes state object for local parts`() {
         val channel = ChannelState("#thegibson") { CaseMapping.Rfc }
         channelStateMap += channel
 
     }
 
     @Test
-    fun `ChannelStateHandler removes user from channel member list for remote parts`() = runBlocking {
+    fun `ChannelStateHandler removes user from channel member list for remote parts`() {
         val channel = ChannelState("#thegibson") { CaseMapping.Rfc }
         channel.users += ChannelUser("ZeroCool")
         channelStateMap += channel
     }
 
     @Test
-    fun `ChannelStateHandler removes user from all channel member lists for quits`() = runBlocking {
+    fun `ChannelStateHandler removes user from all channel member lists for quits`() {
         with (ChannelState("#thegibson") { CaseMapping.Rfc }) {
             users += ChannelUser("ZeroCool")
             channelStateMap += this
 
 
     @Test
-    fun `ChannelStateHandler raises ChannelQuit event for each channel a user quits from`() = runBlocking {
+    fun `ChannelStateHandler raises ChannelQuit event for each channel a user quits from`() {
         with (ChannelState("#thegibson") { CaseMapping.Rfc }) {
             users += ChannelUser("ZeroCool")
             channelStateMap += this
         assertTrue("#dumpsterdiving" in names)
     }
 
+    @Test
+    fun `sets mode discovered flag when discovered mode event received`() {
+        val channel = ChannelState("#thegibson") { CaseMapping.Rfc }
+        channelStateMap += channel
+        serverState.features[ServerFeature.ChannelModes] = arrayOf("ab", "cd", "ef", "gh")
+
+        handler.processEvent(ircClient, ModeChanged(TestConstants.time, "#thegibson", "+", emptyArray(), true))
+
+        assertTrue(channel.modesDiscovered)
+    }
+
+    @Test
+    fun `adds modes when discovered mode event received`() {
+        val channel = ChannelState("#thegibson") { CaseMapping.Rfc }
+        channelStateMap += channel
+        serverState.features[ServerFeature.ChannelModes] = arrayOf("ab", "cd", "ef", "gh")
+
+        handler.processEvent(ircClient, ModeChanged(TestConstants.time, "#thegibson", "+ceg", arrayOf("CCC", "EEE"), true))
+
+        assertEquals("CCC", channel.modes['c'])
+        assertEquals("EEE", channel.modes['e'])
+        assertEquals("", channel.modes['g'])
+    }
+
+    @Test
+    fun `adjusts complex modes when mode change event received`() {
+        val channel = ChannelState("#thegibson") { CaseMapping.Rfc }
+        channel.modes['c'] = "CCC"
+        channel.modes['e'] = "EEE"
+        channel.modes['h'] = ""
+        channelStateMap += channel
+        serverState.features[ServerFeature.ChannelModes] = arrayOf("ab", "cd", "ef", "gh")
+
+        handler.processEvent(ircClient, ModeChanged(TestConstants.time, "#thegibson", "-c+d-eh+fg", arrayOf("CCC", "DDD", "FFF"), true))
+
+        assertNull(channel.modes['c'])
+        assertEquals("DDD", channel.modes['d'])
+        assertNull(channel.modes['e'])
+        assertEquals("FFF", channel.modes['f'])
+        assertEquals("", channel.modes['g'])
+        assertNull(channel.modes['h'])
+    }
+
+
 }