Part handling

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

     override suspend fun processEvent(client: IrcClient, event: IrcEvent) {
         when (event) {
             is ChannelJoined -> handleJoin(client, event)
+            is ChannelParted -> handlePart(client, event)
             is ChannelNamesReceived -> handleNamesReceived(client, event)
             is ChannelNamesFinished -> handleNamesFinished(client, event)
         }
         client.channelState[event.channel]?.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
+        } else {
+            client.channelState[event.channel]?.let {
+                it.users -= event.user.nickname
+            }
+        }
+    }
+
     private fun handleNamesReceived(client: IrcClient, event: ChannelNamesReceived) {
         val channel = client.channelState[event.channel] ?: return
 

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

 /** Raised when a user joins a channel. */
 data class ChannelJoined(val user: User, val channel: String) : IrcEvent()
 
+/** Raised when a user leaves a channel. */
+data class ChannelParted(val user: User, val channel: String, val reason: String = "") : IrcEvent()
+
 /** Raised when a batch of the channel's member list has been received. More batches may follow. */
 data class ChannelNamesReceived(val channel: String, val names: List<String>) : IrcEvent()
 

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

         ISupportProcessor(),
         JoinProcessor(),
         NamesProcessor(),
+        PartProcessor(),
         PingProcessor(),
         WelcomeProcessor()
 )

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.asUser
+
+class PartProcessor : MessageProcessor {
+
+    override val commands = arrayOf("PART")
+
+    override fun process(message: IrcMessage) = message.prefix?.let {
+        listOf(ChannelParted(it.asUser(), message.channel, message.reason))
+    } ?: emptyList()
+
+    private val IrcMessage.channel
+        get() = String(params[0])
+
+    private val IrcMessage.reason
+        get() = if (params.size > 1) String(params[1]) else ""
+
+}

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

         values.add(value)
     }
 
-    operator fun minusAssign(state: T) {
-        values.removeIf { caseMappingProvider().areEquivalent(nameOf(it), nameOf(state)) }
+    operator fun minusAssign(name: String) {
+        values.removeIf { caseMappingProvider().areEquivalent(nameOf(it), name) }
     }
 
     operator fun contains(name: String) = get(name) != null

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

         assertEquals("", channel.users["cerealKiller"]?.modes)
     }
 
+    @Test
+    fun `ChannelStateHandler removes state object for local parts`() = runBlocking {
+        val channel = ChannelState("#thegibson") { CaseMapping.Rfc }
+        channelStateMap += channel
+
+        handler.processEvent(ircClient, ChannelParted(User("acidburn", "libby", "root.localhost"), "#thegibson"))
+
+        assertFalse("#thegibson" in channelStateMap)
+    }
+
+    @Test
+    fun `ChannelStateHandler removes user from channel member list for remote parts`() = runBlocking {
+        val channel = ChannelState("#thegibson") { CaseMapping.Rfc }
+        channel.users += ChannelUser("ZeroCool")
+        channelStateMap += channel
+
+        handler.processEvent(ircClient, ChannelParted(User("zerocool", "dade", "root.localhost"), "#thegibson"))
+
+        assertFalse("zerocool" in channel.users)
+    }
+
 }

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.User
+import org.junit.jupiter.api.Assertions
+import org.junit.jupiter.api.Test
+
+internal class PartProcessorTest {
+
+    @Test
+    fun `PartProcessor raises part event without message`() {
+        val events = PartProcessor().process(
+                IrcMessage(null, "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())))
+        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())))
+        Assertions.assertEquals(0, events.size)
+    }
+
+}

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

 
 internal class CaseInsensitiveMapTest {
 
+    private data class Wrapper(val name: String)
+
     private var caseMapping = CaseMapping.Rfc
-    private val map = object : CaseInsensitiveMap<String>({ caseMapping }, { str -> str.substring(0, 4) }) {}
+    private val map = object : CaseInsensitiveMap<Wrapper>({ caseMapping }, { it -> it.name }) {}
 
     @Test
     fun `CaseInsensitiveMap stores values`() {
-        val value = "acidBurn"
+        val value = Wrapper("acidBurn")
 
         map += value
 
-        assertSame(value, map["acid"])
+        assertSame(value, map["acidBurn"])
     }
 
     @Test
     fun `CaseInsensitiveMap disallows the same value twice`() {
-        val value = "acidBurn"
+        val value = Wrapper("acidBurn")
 
         map += value
 
 
     @Test
     fun `CaseInsensitiveMap retrieves values using differently cased keys`() {
-        val value = "[acidBurn]"
+        val value = Wrapper("[acidBurn]")
         map += value
 
-        assertSame(value, map["{ACI"])
+        assertSame(value, map["{ACIDBURN}"])
     }
 
     @Test
     fun `CaseInsensitiveMap retrieves values if the casemapping changes`() {
-        val value = "[acidBurn]"
+        val value = Wrapper("[acidBurn]")
         map += value
 
         caseMapping = CaseMapping.Ascii
 
-        assertSame(value, map["[ACI"])
-        assertNull(map["{aci"])
+        assertSame(value, map["[ACIDBURN]"])
+        assertNull(map["{acidburn}"])
     }
 
     @Test
     fun `CaseInsensitiveMap retrieves null if value not found`() {
-        val value = "[acidBurn]"
+        val value = Wrapper("[acidBurn]")
         map += value
 
         assertNull(map["acidBurn"])
 
     @Test
     fun `CaseInsensitiveMap removes values`() {
-        map += "acidBurn"
+        map += Wrapper("acidBurn")
         map -= "ACIDburn"
 
         assertNull(map["acidBurn"])
-        assertNull(map["ACIDburn"])
     }
 
     @Test
     fun `CaseInsensitiveMap can be iterated`() {
-        map += "acidBurn"
-        map += "zeroCool"
+        map += Wrapper("acidBurn")
+        map += Wrapper("zeroCool")
 
-        val names = map.toList()
+        val names = map.map { it.name }.toList()
         assertEquals(2, names.size)
         assertTrue(names.contains("acidBurn"))
         assertTrue(names.contains("zeroCool"))
 
     @Test
     fun `ChannelInsensitiveMap indicates if it contains a value or not`() {
-        map += "acidBurn"
+        map += Wrapper("acidBurn")
 
-        assertTrue("acid" in map)
-        assertFalse("theP" in map)
+        assertTrue("acidBurn" in map)
+        assertFalse("thePlague" in map)
     }
 
     @Test
     fun `ChannelInsensitiveMap can be cleared`() {
-        map += "acidBurn"
-        map += "zeroCool"
+        map += Wrapper("acidBurn")
+        map += Wrapper("zeroCool")
 
         map.clear()
 
-        assertFalse("acid" in map)
-        assertFalse("zero" in map)
+        assertFalse("acidBurn" in map)
+        assertFalse("zeroCool" in map)
         assertEquals(0, map.count())
     }