Fix handling of channel user modes

Closes #8

CHANGELOG

  * Changed USER command to not send the server name, per modern standards
  * Added support for SASL authentication (with PLAIN mechanism)
  * Removed some unused test code
+ * Fixed handling of user mode changes on channels (op/deop/etc)
  * Message extensions:
     * Added support for IRCv3 message tags v3.3
     * Exposed message IDs in MessageReceived and ActionReceived events

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

     }
 
     private fun handleModeChanged(client: IrcClient, event: ModeChanged) {
-        val chan =  client.channelState[event.target] ?: return
+        val chan = client.channelState[event.target] ?: return
         if (event.discovered) {
             chan.modesDiscovered = true
             chan.modes.clear()
     }
 
     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
+        return if (client.serverState.isChannelUserMode(mode)) {
+            adjustUserMode(client, chan, mode, adding, arguments[argumentOffset])
+            1
         } else {
-            chan.modes.remove(mode)
+            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)
+            }
+            if (takesParam) 1 else 0
+        }
+    }
+
+    private fun adjustUserMode(client: IrcClient, chan: ChannelState, mode: Char, adding: Boolean, user: String) {
+        chan.users[user]?.let { channelUser ->
+            // Filter from the master list of mode prefixes so that ordering is consistent
+            channelUser.modes = client.serverState.channelModePrefixes.modes.filter {
+                if (adding) {
+                    it == mode || it in channelUser.modes
+                } else {
+                    it != mode && it in channelUser.modes
+                }
+            }
         }
-        return if (takesParam) 1 else 0
     }
 
     private fun handleQuit(client: IrcClient, event: UserQuit) = sequence {

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

     /** The current state of SASL authentication. */
     internal val sasl = SaslState(saslMechanisms)
 
+    /**
+     * Convenience accessor for the [ServerFeature.ModePrefixes] feature, which will always have a value.
+     */
+    val channelModePrefixes
+        get() = features[ServerFeature.ModePrefixes] ?: throw IllegalStateException("lost mode prefixes")
+
+    /**
+     * Determines if the given mode is one applied to a user of a channel, such as 'o' for operator.
+     */
+    fun isChannelUserMode(mode: Char) = channelModePrefixes.isMode(mode)
+
     /**
      * Determines what type of channel mode the given character is, based on the server features.
      *
 
     /** Determines whether the given character is a mode prefix (e.g. "@", "+"). */
     fun isPrefix(char: Char) = prefixes.contains(char)
+    /** Determines whether the given character is a channel user mode (e.g. "o", "v"). */
+    fun isMode(char: Char) = modes.contains(char)
     /** Gets the mode corresponding to the given prefix (e.g. "@" -> "o"). */
     fun getMode(prefix: Char) = modes[prefixes.indexOf(prefix)]
     /** Gets the modes corresponding to the given prefixes (e.g. "@+" -> "ov"). */

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

         assertNull(channel.modes['h'])
     }
 
+    @Test
+    fun `handles unprivileged user gaining new mode`() {
+        with (ChannelState("#thegibson") { CaseMapping.Rfc }) {
+            users += ChannelUser("ZeroCool")
+            channelStateMap += this
+        }
+
+        handler.processEvent(ircClient, ModeChanged(TestConstants.time, "#thegibson", "+o", arrayOf("zeroCool")))
+
+        assertEquals("o", channelStateMap["#thegibson"]?.users?.get("zeroCool")?.modes)
+    }
+
+    @Test
+    fun `handles privileged user gaining lesser mode`() {
+        with (ChannelState("#thegibson") { CaseMapping.Rfc }) {
+            users += ChannelUser("ZeroCool", "o")
+            channelStateMap += this
+        }
+
+        handler.processEvent(ircClient, ModeChanged(TestConstants.time, "#thegibson", "+v", arrayOf("zeroCool")))
+
+        assertEquals("ov", channelStateMap["#thegibson"]?.users?.get("zeroCool")?.modes)
+    }
+
+    @Test
+    fun `handles privileged user gaining greater mode`() {
+        with (ChannelState("#thegibson") { CaseMapping.Rfc }) {
+            users += ChannelUser("ZeroCool", "v")
+            channelStateMap += this
+        }
+
+        handler.processEvent(ircClient, ModeChanged(TestConstants.time, "#thegibson", "+o", arrayOf("zeroCool")))
+
+        assertEquals("ov", channelStateMap["#thegibson"]?.users?.get("zeroCool")?.modes)
+    }
+
+    @Test
+    fun `handles user gaining multiple modes`() {
+        with (ChannelState("#thegibson") { CaseMapping.Rfc }) {
+            users += ChannelUser("ZeroCool")
+            channelStateMap += this
+        }
+
+        handler.processEvent(ircClient, ModeChanged(TestConstants.time, "#thegibson", "+vo", arrayOf("zeroCool", "zeroCool")))
+
+        assertEquals("ov", channelStateMap["#thegibson"]?.users?.get("zeroCool")?.modes)
+    }
+
+    @Test
+    fun `handles user losing multiple modes`() {
+        with (ChannelState("#thegibson") { CaseMapping.Rfc }) {
+            users += ChannelUser("ZeroCool", "ov")
+            channelStateMap += this
+        }
+
+        handler.processEvent(ircClient, ModeChanged(TestConstants.time, "#thegibson", "-vo", arrayOf("zeroCool", "zeroCool")))
+
+        assertEquals("", channelStateMap["#thegibson"]?.users?.get("zeroCool")?.modes)
+    }
+
+    @Test
+    fun `handles mixture of user modes and normal modes`() {
+        with (ChannelState("#thegibson") { CaseMapping.Rfc }) {
+            users += ChannelUser("ZeroCool", "v")
+            channelStateMap += this
+        }
+        serverState.features[ServerFeature.ChannelModes] = arrayOf("ab", "cd", "ef", "gh")
+
+        handler.processEvent(ircClient, ModeChanged(TestConstants.time, "#thegibson", "oa-v+b", arrayOf("zeroCool", "aaa", "zeroCool", "bbb")))
+
+        assertEquals("o", channelStateMap["#thegibson"]?.users?.get("zeroCool")?.modes)
+        assertEquals("aaa", channelStateMap["#thegibson"]?.modes?.get('a'))
+        assertEquals("bbb", channelStateMap["#thegibson"]?.modes?.get('b'))
+    }
 
-}
+}

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

         assertEquals(ChannelModeType.NoParameter, serverState.channelModeType('g'))
     }
 
+    @Test
+    fun `returns whether a mode is a channel user mode or not`() {
+        val serverState = ServerState("acidBurn", "")
+        serverState.features[ServerFeature.ModePrefixes] = ModePrefixMapping("oqv", "@~+")
+        assertTrue(serverState.isChannelUserMode('o'))
+        assertTrue(serverState.isChannelUserMode('q'))
+        assertTrue(serverState.isChannelUserMode('v'))
+        assertFalse(serverState.isChannelUserMode('@'))
+        assertFalse(serverState.isChannelUserMode('!'))
+        assertFalse(serverState.isChannelUserMode('z'))
+    }
+
     @Test
     fun `returns NoParameter for unknown channel mode`() {
         val serverState = ServerState("acidBurn", "")
         assertFalse(mapping.isPrefix('o'))
     }
 
+    @Test
+    fun `ModePrefixMapping identifies which chars are modes`() {
+        val mapping = ModePrefixMapping("oav", "+@-")
+        assertFalse(mapping.isMode('+'))
+        assertFalse(mapping.isMode('@'))
+        assertFalse(mapping.isMode('!'))
+        assertTrue(mapping.isMode('o'))
+    }
+
     @Test
     fun `ModePrefixMapping maps prefixes to modes`() {
         val mapping = ModePrefixMapping("oav", "+@-")