Add user state

src/main/kotlin/com/dmdirc/ktirc/IrcClient.kt

 
     val serverState: ServerState
     val channelState: ChannelStateMap
+    val userState: UserState
 
     val caseMapping: CaseMapping
         get() = serverState.features[ServerFeature.ServerCaseMapping] ?: CaseMapping.Rfc
 
     override val serverState = ServerState(profile.initialNick)
     override val channelState = ChannelStateMap { caseMapping }
+    override val userState = UserState { caseMapping }
 
     override var eventHandler: EventHandler? = null
         set(value) {

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

 }
 
 enum class CapabilitiesNegotiationState {
-
     AWAITING_LIST,
     AWAITING_ACK,
     FINISHED
-
 }
 
 @Suppress("unused")

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

 
 class ChannelStateMap(caseMappingProvider: () -> CaseMapping) : CaseInsensitiveMap<ChannelState>(caseMappingProvider, ChannelState::name)
 class ChannelUserMap(caseMappingProvider: () -> CaseMapping) : CaseInsensitiveMap<ChannelUser>(caseMappingProvider, ChannelUser::nickname)
+class UserMap(caseMappingProvider: () -> CaseMapping) : CaseInsensitiveMap<KnownUser>(caseMappingProvider, { it.details.nickname })

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

         var account: String? = null,
         var realName: String? = null,
         var awayMessage: String? = null
-)
+) {
+    fun updateFrom(other: User) {
+        nickname = other.nickname
+        other.ident?.let { ident = it }
+        other.hostname?.let { hostname = it }
+        other.account?.let { account = it }
+        other.realName?.let { realName = it }
+        other.awayMessage?.let { awayMessage = it }
+    }
+}
 
 fun ByteArray.asUser(): User {
     val string = String(this)

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

+package com.dmdirc.ktirc.model
+
+import com.dmdirc.ktirc.io.CaseMapping
+
+class UserState(caseMappingProvider: () -> CaseMapping) {
+
+    private val users = UserMap(caseMappingProvider)
+
+    operator fun get(nickname: String) = users[nickname]
+    operator fun plusAssign(details: User) { users += KnownUser(details) }
+    operator fun minusAssign(details: User) { users -= details.nickname }
+
+    fun update(details: User, oldNick: String = details.nickname) {
+        users[oldNick]?.details?.updateFrom(details)
+    }
+
+}
+
+class KnownUser(val details: User) {
+
+    val channels = mutableListOf<String>()
+
+    operator fun plusAssign(channel: String) { channels += channel }
+    operator fun minusAssign(channel: String) { channels -= channel }
+    operator fun contains(channel: String) = channel in channels
+
+}

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

+package com.dmdirc.ktirc.model
+
+import org.junit.jupiter.api.Assertions.*
+import org.junit.jupiter.api.Test
+
+internal class KnownUserTest {
+
+    @Test
+    fun `KnownUser can add channels`() {
+        val user = KnownUser(User("acidBurn"))
+        user += "#thegibson"
+        user += "#dumpsterdiving"
+
+        assertEquals(2, user.channels.size)
+        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"))
+        user -= "#thegibson"
+
+        assertEquals(1, user.channels.size)
+        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"))
+
+        assertTrue("#thegibson" in user)
+        assertFalse("#dumpsterdiving" in user)
+    }
+
+}

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

         assertFalse("zerocool" in channelUserMap)
     }
 
+}
+
+internal class UserMapTest {
+
+    @Test
+    fun `UserMap maps users on nickname`() {
+        val userMap = UserMap { CaseMapping.Rfc }
+        userMap += KnownUser(User("acidBurn"))
+        assertTrue("acidBurn" in userMap)
+        assertTrue("acidburn" in userMap)
+        assertFalse("zerocool" in userMap)
+    }
+
 }

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

+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 UserStateTest {
+
+    private val userState = UserState { CaseMapping.Rfc }
+
+    @Test
+    fun `UserState adds and gets new users`() {
+        userState += User("acidBurn", "libby", "root.localhost")
+        val user = userState["acidburn"]
+        assertNotNull(user)
+        assertEquals("acidBurn", user?.details?.nickname)
+        assertEquals("libby", user?.details?.ident)
+        assertEquals("root.localhost", user?.details?.hostname)
+    }
+
+    @Test
+    fun `UserState removes users`() {
+        userState += User("acidBurn", "libby", "root.localhost")
+        userState -= User("ACIDBURN")
+        assertNull(userState["acidburn"])
+    }
+
+    @Test
+    fun `UserState updates existing user with same nickname`() {
+        userState += User("acidBurn", "libby", "root.localhost")
+        userState.update(User("acidBurn", realName = "Libby", awayMessage = "Hacking"))
+
+        val user = userState["acidburn"]!!
+        assertEquals("acidBurn", user.details.nickname)
+        assertEquals("libby", user.details.ident)
+        assertEquals("root.localhost", user.details.hostname)
+        assertEquals("Libby", user.details.realName)
+        assertEquals("Hacking", user.details.awayMessage)
+    }
+
+    @Test
+    fun `UserState updates existing user with new nickname`() {
+        userState += User("acidBurn", "libby", "root.localhost")
+        userState.update(User("acidBurn2", realName = "Libby", awayMessage = "Hacking"), "acidBurn")
+
+        val user = userState["acidburn2"]!!
+        assertEquals("acidBurn2", user.details.nickname)
+        assertEquals("libby", user.details.ident)
+        assertEquals("root.localhost", user.details.hostname)
+        assertEquals("Libby", user.details.realName)
+        assertEquals("Hacking", user.details.awayMessage)
+
+        assertNull(userState["acidBurn"])
+    }
+
+}

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

         assertEquals("root.localhost", user.hostname)
     }
 
+    @Test
+    fun `User updates non-null fields from other instance`() {
+        val user1 = User("acidBurn", "libby", awayMessage = "Hacking the planet")
+        user1.updateFrom(User("acidBurn", null, "root.localhost", "acidBurn", "Libby"))
+
+        assertEquals("acidBurn", user1.nickname)
+        assertEquals("libby", user1.ident)
+        assertEquals("root.localhost", user1.hostname)
+        assertEquals("acidBurn", user1.account)
+        assertEquals("Libby", user1.realName)
+        assertEquals("Hacking the planet", user1.awayMessage)
+
+        val user2 = User("acidBurn", null, "root.localhost", "acidBurn", "Libby")
+        user2.updateFrom(User("acidBurn", "libby", awayMessage = "Hacking the planet"))
+
+        assertEquals("acidBurn", user2.nickname)
+        assertEquals("libby", user2.ident)
+        assertEquals("root.localhost", user2.hostname)
+        assertEquals("acidBurn", user2.account)
+        assertEquals("Libby", user2.realName)
+        assertEquals("Hacking the planet", user2.awayMessage)
+    }
+
 }