First pass at user state processing

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

@@ -3,7 +3,6 @@ package com.dmdirc.ktirc.events
 import com.dmdirc.ktirc.IrcClient
 import com.dmdirc.ktirc.model.ChannelState
 import com.dmdirc.ktirc.model.ChannelUser
-import com.dmdirc.ktirc.model.ServerFeature
 import com.dmdirc.ktirc.util.logger
 
 class ChannelStateHandler : EventHandler {
@@ -49,11 +48,8 @@ class ChannelStateHandler : EventHandler {
             channel.receivingUserList = true
         }
 
-        val modePrefixes = client.serverState.features[ServerFeature.ModePrefixes]!!
-        for (user in event.names) {
-            user.takeWhile { modePrefixes.isPrefix(it) }.let { prefix ->
-                channel.users += ChannelUser(user.nickname(prefix.length), modePrefixes.getModes(prefix))
-            }
+        event.toModesAndUsers(client).forEach { (modes, user) ->
+            channel.users += ChannelUser(user.nickname, modes)
         }
     }
 

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

@@ -8,9 +8,10 @@ interface EventHandler {
 
 }
 
-val eventHandlers = setOf(
+val eventHandlers = listOf(
         CapabilitiesHandler(),
         ChannelStateHandler(),
         PingHandler(),
-        ServerStateHandler()
+        ServerStateHandler(),
+        UserStateHandler()
 )

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

@@ -0,0 +1,14 @@
+package com.dmdirc.ktirc.events
+
+import com.dmdirc.ktirc.IrcClient
+import com.dmdirc.ktirc.model.ServerFeature
+import com.dmdirc.ktirc.model.asUser
+
+fun ChannelNamesReceived.toModesAndUsers(client: IrcClient) = sequence {
+    val modePrefixes = client.serverState.features[ServerFeature.ModePrefixes]!!
+    for (user in names) {
+        user.takeWhile { modePrefixes.isPrefix(it) }.let { prefix ->
+            yield(Pair(modePrefixes.getModes(prefix), user.substring(prefix.length).asUser()))
+        }
+    }
+}.toList()

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

@@ -0,0 +1,48 @@
+package com.dmdirc.ktirc.events
+
+import com.dmdirc.ktirc.IrcClient
+import com.dmdirc.ktirc.model.UserState
+
+class UserStateHandler : EventHandler {
+
+    override suspend fun processEvent(client: IrcClient, event: IrcEvent) {
+        when (event) {
+            is ChannelJoined -> handleJoin(client.userState, event)
+            is ChannelParted -> handlePart(client, event)
+            is ChannelNamesReceived  -> handleNamesReceived(client, event)
+            is UserQuit -> handleQuit(client.userState, event)
+        }
+    }
+
+    private fun handleJoin(state: UserState, event: ChannelJoined) {
+        state.addToChannel(event.user, event.channel)
+        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.removeIf { it.channels.isEmpty() && !client.isLocalUser(it.details) }
+        } else {
+            client.userState[event.user]?.channels?.let {
+                it -= event.channel
+                if (it.isEmpty()) {
+                    client.userState -= event.user
+                }
+            }
+        }
+    }
+
+    private fun handleNamesReceived(client: IrcClient, event: ChannelNamesReceived) {
+        event.toModesAndUsers(client).forEach { (_, user) ->
+            client.userState.addToChannel(user, event.channel)
+            client.userState.update(user)
+        }
+    }
+
+    private fun handleQuit(state: UserState, event: UserQuit) {
+        state -= event.user
+    }
+
+}

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

@@ -0,0 +1,31 @@
+package com.dmdirc.ktirc.model
+
+import com.dmdirc.ktirc.io.CaseMapping
+
+/**
+ * Maintains a set of strings that are compared case-insensitively according to the provided [CaseMapping]
+ *
+ * If the case mapping changes during the lifetime of this set, it is presumed that all items will also be
+ * unique in the new case mapping. Otherwise, the behaviour of this class is undefined.
+ */
+class CaseInsensitiveSet(private val caseMappingProvider: () -> CaseMapping) : Iterable<String> {
+
+    private val items = HashSet<String>()
+
+    operator fun plusAssign(item: String) {
+        if (!contains(item)) {
+            items += item
+        }
+    }
+
+    operator fun minusAssign(item: String) {
+        items.removeIf { caseMappingProvider().areEquivalent(it, item) }
+    }
+
+    operator fun contains(item: String) = items.any { caseMappingProvider().areEquivalent(it, item) }
+
+    override operator fun iterator() = items.iterator()
+
+    fun isEmpty() = items.isEmpty()
+
+}

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

@@ -23,6 +23,8 @@ abstract class CaseInsensitiveMap<T>(private val caseMappingProvider: () -> Case
 
     fun clear() = values.clear()
 
+    fun removeIf(predicate: (T) -> Boolean) = values.removeIf(predicate)
+
 }
 
 class ChannelStateMap(caseMappingProvider: () -> CaseMapping) : CaseInsensitiveMap<ChannelState>(caseMappingProvider, ChannelState::name)

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

@@ -18,17 +18,18 @@ data class User(
     }
 }
 
-fun ByteArray.asUser(): User {
-    val string = String(this)
-    val identOffset = string.indexOf('!')
+fun ByteArray.asUser() = String(this).asUser()
+
+fun String.asUser(): User {
+    val identOffset = indexOf('!')
     return if (identOffset >= 0) {
-        val hostOffset = string.indexOf('@', identOffset)
+        val hostOffset = indexOf('@', identOffset)
         if (hostOffset >= 0) {
-            User(string.substring(0 until identOffset), string.substring(identOffset + 1 until hostOffset), string.substring(hostOffset + 1))
+            User(substring(0 until identOffset), substring(identOffset + 1 until hostOffset), substring(hostOffset + 1))
         } else {
-            User(string.substring(0 until identOffset), string.substring(identOffset + 1))
+            User(substring(0 until identOffset), substring(identOffset + 1))
         }
     } else {
-        User(string)
+        User(this)
     }
 }

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

@@ -2,23 +2,37 @@ package com.dmdirc.ktirc.model
 
 import com.dmdirc.ktirc.io.CaseMapping
 
-class UserState(caseMappingProvider: () -> CaseMapping) {
+class UserState(private val caseMappingProvider: () -> CaseMapping): Iterable<KnownUser> {
 
     private val users = UserMap(caseMappingProvider)
 
     operator fun get(nickname: String) = users[nickname]
-    operator fun plusAssign(details: User) { users += KnownUser(details) }
+    operator fun get(user: User) = users[user.nickname]
+
+    operator fun plusAssign(details: User) { users += KnownUser(caseMappingProvider, details) }
     operator fun minusAssign(details: User) { users -= details.nickname }
 
-    fun update(details: User, oldNick: String = details.nickname) {
-        users[oldNick]?.details?.updateFrom(details)
+    override operator fun iterator() = users.iterator()
+
+    fun removeIf(predicate: (KnownUser) -> Boolean) = users.removeIf(predicate)
+
+    fun update(user: User, oldNick: String = user.nickname) {
+        users[oldNick]?.details?.updateFrom(user)
+    }
+
+    fun addToChannel(user: User, channel: String) {
+        users[user.nickname]?.let {
+            it += channel
+        } ?: run {
+            users += KnownUser(caseMappingProvider, user).apply { channels += channel }
+        }
     }
 
 }
 
-class KnownUser(val details: User) {
+class KnownUser(caseMappingProvider: () -> CaseMapping, val details: User) {
 
-    val channels = mutableListOf<String>()
+    val channels = CaseInsensitiveSet(caseMappingProvider)
 
     operator fun plusAssign(channel: String) { channels += channel }
     operator fun minusAssign(channel: String) { channels -= channel }

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

@@ -0,0 +1,66 @@
+package com.dmdirc.ktirc.events
+
+import com.dmdirc.ktirc.IrcClient
+import com.dmdirc.ktirc.TestConstants
+import com.dmdirc.ktirc.model.ModePrefixMapping
+import com.dmdirc.ktirc.model.ServerFeature
+import com.dmdirc.ktirc.model.ServerState
+import com.nhaarman.mockitokotlin2.doReturn
+import com.nhaarman.mockitokotlin2.mock
+import org.junit.jupiter.api.Assertions.assertEquals
+import org.junit.jupiter.api.BeforeEach
+import org.junit.jupiter.api.Test
+
+internal class EventUtilsTest {
+
+    private val serverState = ServerState("")
+    private val ircClient = mock<IrcClient> {
+        on { serverState } doReturn serverState
+    }
+
+    @BeforeEach
+    fun setUp() {
+        serverState.features[ServerFeature.ModePrefixes] = ModePrefixMapping("ov", "@+")
+    }
+
+    @Test
+    fun `ChannelNamesReceived#toModesAndUsers parses nicknames and mode prefixes`() {
+        val event = ChannelNamesReceived(TestConstants.time, "#thegibson", listOf(
+                "@+acidBurn", "@zeroCool", "thePlague"
+        ))
+
+        val result = event.toModesAndUsers(ircClient)
+        assertEquals(3, result.size)
+
+        assertEquals("ov", result[0].first)
+        assertEquals("acidBurn", result[0].second.nickname)
+
+        assertEquals("o", result[1].first)
+        assertEquals("zeroCool", result[1].second.nickname)
+
+        assertEquals("", result[2].first)
+        assertEquals("thePlague", result[2].second.nickname)
+    }
+
+    @Test
+    fun `ChannelNamesReceived#toModesAndUsers parses extended joins with prefixes`() {
+        val event = ChannelNamesReceived(TestConstants.time, "#thegibson", listOf(
+                "@+acidBurn!libby@root.localhost", "zeroCool!dade@root.localhost"
+        ))
+
+        val result = event.toModesAndUsers(ircClient)
+        assertEquals(2, result.size)
+
+        assertEquals("ov", result[0].first)
+        assertEquals("acidBurn", result[0].second.nickname)
+        assertEquals("libby", result[0].second.ident)
+        assertEquals("root.localhost", result[0].second.hostname)
+
+        assertEquals("", result[1].first)
+        assertEquals("zeroCool", result[1].second.nickname)
+        assertEquals("dade", result[1].second.ident)
+        assertEquals("root.localhost", result[1].second.hostname)
+    }
+
+
+}

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

@@ -0,0 +1,161 @@
+package com.dmdirc.ktirc.events
+
+import com.dmdirc.ktirc.IrcClient
+import com.dmdirc.ktirc.TestConstants
+import com.dmdirc.ktirc.io.CaseMapping
+import com.dmdirc.ktirc.model.*
+import com.nhaarman.mockitokotlin2.argForWhich
+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.BeforeEach
+import org.junit.jupiter.api.Test
+
+internal class UserStateHandlerTest {
+
+    private val serverState = ServerState("")
+    private val userState = UserState { CaseMapping.Rfc }
+
+    private val ircClient = mock<IrcClient> {
+        on { serverState } doReturn serverState
+        on { userState } doReturn userState
+        on { isLocalUser(argForWhich { nickname == "zeroCool" }) } doReturn true
+    }
+
+    private val handler = UserStateHandler()
+
+    @BeforeEach
+    fun setUp() {
+        serverState.features[ServerFeature.ModePrefixes] = ModePrefixMapping("ov", "@+")
+    }
+
+    @Test
+    fun `adds channel to user on join`() {
+        runBlocking {
+            userState += User("acidBurn")
+
+            handler.processEvent(ircClient, ChannelJoined(TestConstants.time, User("acidBurn", "libby", "root.localhost"), "#thegibson"))
+
+            assertEquals(listOf("#thegibson"), userState["acidBurn"]?.channels?.toList())
+        }
+    }
+
+    @Test
+    fun `updates user info on join`() {
+        runBlocking {
+            userState += User("acidBurn")
+
+            handler.processEvent(ircClient, ChannelJoined(TestConstants.time, User("acidBurn", "libby", "root.localhost"), "#thegibson"))
+
+            val details = userState["acidBurn"]?.details!!
+            assertEquals("libby", details.ident)
+            assertEquals("root.localhost", details.hostname)
+        }
+    }
+
+    @Test
+    fun `removes channel from user on part`() {
+        runBlocking {
+            userState += User("acidBurn")
+            userState.addToChannel(User("acidBurn"), "#thegibson")
+            userState.addToChannel(User("acidBurn"), "#dumpsterdiving")
+
+            handler.processEvent(ircClient, ChannelParted(TestConstants.time, User("acidBurn", "libby", "root.localhost"), "#dumpsterdiving"))
+
+            assertEquals(listOf("#thegibson"), userState["acidBurn"]?.channels?.toList())
+        }
+    }
+
+    @Test
+    fun `removes user on part from last channel`() {
+        runBlocking {
+            userState += User("acidBurn")
+            userState.addToChannel(User("acidBurn"), "#dumpsterdiving")
+
+            handler.processEvent(ircClient, ChannelParted(TestConstants.time, User("acidBurn", "libby", "root.localhost"), "#dumpsterdiving"))
+
+            assertNull(userState["acidBurn"])
+        }
+    }
+
+    @Test
+    fun `removes channel from all users on local part`() {
+        runBlocking {
+            userState += User("acidBurn")
+            userState.addToChannel(User("acidBurn"), "#dumpsterdiving")
+            userState.addToChannel(User("acidBurn"), "#thegibson")
+
+            userState += User("zeroCool")
+            userState.addToChannel(User("zeroCool"), "#dumpsterdiving")
+            userState.addToChannel(User("zeroCool"), "#thegibson")
+
+            handler.processEvent(ircClient, ChannelParted(TestConstants.time, User("zeroCool", "dade", "root.localhost"), "#dumpsterdiving"))
+
+            assertEquals(listOf("#thegibson"), userState["acidBurn"]?.channels?.toList())
+            assertEquals(listOf("#thegibson"), userState["zeroCool"]?.channels?.toList())
+        }
+    }
+
+    @Test
+    fun `removes remote users with no remaining channels on local part`() {
+        runBlocking {
+            userState += User("acidBurn")
+            userState.addToChannel(User("acidBurn"), "#dumpsterdiving")
+
+            handler.processEvent(ircClient, ChannelParted(TestConstants.time, User("zeroCool", "dade", "root.localhost"), "#dumpsterdiving"))
+
+            assertNull(userState["acidBurn"])
+        }
+    }
+
+    @Test
+    fun `keeps local user with no remaining channels after local part`() {
+        runBlocking {
+            userState += User("zeroCool")
+            userState.addToChannel(User("zeroCool"), "#dumpsterdiving")
+
+            handler.processEvent(ircClient, ChannelParted(TestConstants.time, User("zeroCool", "dade", "root.localhost"), "#dumpsterdiving"))
+
+            assertNotNull(userState["zeroCool"])
+        }
+    }
+
+    @Test
+    fun `removes user entirely on quit`() {
+        runBlocking {
+            userState += User("acidBurn")
+            userState.addToChannel(User("acidBurn"), "#dumpsterdiving")
+
+            handler.processEvent(ircClient, UserQuit(TestConstants.time, User("acidBurn", "libby", "root.localhost")))
+
+            assertNull(userState["acidBurn"])
+        }
+    }
+
+    @Test
+    fun `adds users to channels on names received`() {
+        runBlocking {
+            userState += User("acidBurn")
+            userState.addToChannel(User("acidBurn"), "#dumpsterdiving")
+
+            handler.processEvent(ircClient, ChannelNamesReceived(TestConstants.time, "#thegibson", listOf("@acidBurn")))
+
+            assertEquals(listOf("#dumpsterdiving", "#thegibson"), userState["acidBurn"]?.channels?.toList())
+        }
+    }
+
+    @Test
+    fun `updates user details on names received`() {
+        runBlocking {
+            userState += User("acidBurn")
+            userState.addToChannel(User("acidBurn"), "#dumpsterdiving")
+
+            handler.processEvent(ircClient, ChannelNamesReceived(TestConstants.time, "#thegibson", listOf("@acidBurn!libby@root.localhost")))
+
+            val details = userState["acidBurn"]?.details!!
+            assertEquals("libby", details.ident)
+            assertEquals("root.localhost", details.hostname)
+        }
+    }
+}

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

@@ -0,0 +1,64 @@
+package com.dmdirc.ktirc.model
+
+import com.dmdirc.ktirc.io.CaseMapping
+import org.junit.jupiter.api.Assertions.*
+import org.junit.jupiter.api.Test
+
+internal class CaseInsensitiveSetTest {
+
+    val set = CaseInsensitiveSet { CaseMapping.Rfc }
+
+    @Test
+    fun `isEmpty returns true when there are no items`() {
+        assertTrue(set.isEmpty())
+
+        set += "gibson"
+        assertFalse(set.isEmpty())
+
+        set -= "gibson"
+        assertTrue(set.isEmpty())
+    }
+
+    @Test
+    fun `items can be added to the set`() {
+        set += "libby"
+        assertEquals(setOf("libby"), set.toSet())
+
+        set += "dade"
+        assertEquals(setOf("libby", "dade"), set.toSet())
+    }
+
+    @Test
+    fun `items can be removed from the set`() {
+        set += "acidBurn"
+        set += "zeroCool"
+        set -= "acidBurn"
+        assertEquals(setOf("zeroCool"), set.toSet())
+    }
+
+    @Test
+    fun `items can be removed from the set using a different case`() {
+        set += "acidBurn"
+        set += "zeroCool"
+        set -= "ACIDburn"
+        assertEquals(setOf("zeroCool"), set.toSet())
+    }
+
+    @Test
+    fun `adding the same item in a different case has no effect`() {
+        set += "acidBurn[]"
+        set += "Acidburn[]"
+        set += "acidBurn{}"
+        assertEquals(1, set.count())
+    }
+
+    @Test
+    fun `contains indicates if a case-insensitive match is in the set`() {
+        set += "acidBurn[]"
+        assertTrue("acidBurn[]" in set)
+        assertTrue("AcidBurn[]" in set)
+        assertTrue("acidBurn{}" in set)
+        assertFalse("zeroCool" in set)
+    }
+
+}

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

@@ -1,5 +1,6 @@
 package com.dmdirc.ktirc.model
 
+import com.dmdirc.ktirc.io.CaseMapping
 import org.junit.jupiter.api.Assertions.*
 import org.junit.jupiter.api.Test
 
@@ -7,30 +8,31 @@ internal class KnownUserTest {
 
     @Test
     fun `KnownUser can add channels`() {
-        val user = KnownUser(User("acidBurn"))
+        val user = KnownUser({ CaseMapping.Rfc }, User("acidBurn"))
         user += "#thegibson"
         user += "#dumpsterdiving"
 
-        assertEquals(2, user.channels.size)
+        assertEquals(2, user.channels.count())
         assertTrue("#thegibson" in user.channels)
         assertTrue("#dumpsterdiving" in user.channels)
     }
 
     @Test
     fun `KnownUser can remove channels`() {
-        val user = KnownUser(User("acidBurn"))
-        user.channels.addAll(listOf("#thegibson", "#dumpsterdiving"))
+        val user = KnownUser({ CaseMapping.Rfc }, User("acidBurn"))
+        user.channels += "#thegibson"
+        user.channels += "#dumpsterdiving"
         user -= "#thegibson"
 
-        assertEquals(1, user.channels.size)
+        assertEquals(1, user.channels.count())
         assertFalse("#thegibson" in user.channels)
         assertTrue("#dumpsterdiving" in user.channels)
     }
 
     @Test
     fun `KnownUser indicates if a channel is known`() {
-        val user = KnownUser(User("acidBurn"))
-        user.channels.addAll(listOf("#thegibson"))
+        val user = KnownUser({ CaseMapping.Rfc }, User("acidBurn"))
+        user.channels += "#thegibson"
 
         assertTrue("#thegibson" in user)
         assertFalse("#dumpsterdiving" in user)

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

@@ -99,6 +99,18 @@ internal class CaseInsensitiveMapTest {
         assertEquals(0, map.count())
     }
 
+    @Test
+    fun `removeIf removes matching items`() {
+        map += Wrapper("acidBurn")
+        map += Wrapper("zeroCool")
+        map += Wrapper("thePlague")
+
+        map.removeIf { it.name.length == 8 }
+
+        assertEquals(1, map.count())
+        assertTrue("thePlague" in map)
+    }
+
 }
 
 internal class ChannelStateMapTest {
@@ -132,7 +144,7 @@ internal class UserMapTest {
     @Test
     fun `UserMap maps users on nickname`() {
         val userMap = UserMap { CaseMapping.Rfc }
-        userMap += KnownUser(User("acidBurn"))
+        userMap += KnownUser({ CaseMapping.Rfc }, User("acidBurn"))
         assertTrue("acidBurn" in userMap)
         assertTrue("acidburn" in userMap)
         assertFalse("zerocool" in userMap)

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

@@ -53,4 +53,39 @@ internal class UserStateTest {
         assertNull(userState["acidBurn"])
     }
 
+    @Test
+    fun `addToChannel adds new user if not known`() {
+        userState.addToChannel(User("acidBurn", "libby", "root.localhost"), "#thegibson")
+
+        val user = userState["acidburn"]!!
+        assertEquals("acidBurn", user.details.nickname)
+        assertEquals("libby", user.details.ident)
+        assertEquals("root.localhost", user.details.hostname)
+
+        assertEquals(1, user.channels.count())
+        assertTrue("#thegibson" in user.channels)
+    }
+
+    @Test
+    fun `addToChannel appends channel to existing user`() {
+        userState += User("acidBurn", "libby", "root.localhost")
+        userState.addToChannel(User("acidBurn"), "#thegibson")
+
+        val user = userState["acidburn"]!!
+        assertEquals(1, user.channels.count())
+        assertTrue("#thegibson" in user.channels)
+    }
+
+    @Test
+    fun `removeIf deletes all matching users`() {
+        userState += User("acidBurn", "libby", "root.localhost")
+        userState += User("zeroCool", "dade", "root.localhost")
+        userState += User("acidBurn2", "libby", "root.localhost")
+
+        userState.removeIf { it.details.nickname.startsWith("acidBurn") }
+
+        assertEquals(1, userState.count())
+        assertNotNull(userState["zeroCool"])
+    }
+
 }