Add channel join handling, basic channel state

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

@@ -4,14 +4,9 @@ import com.dmdirc.ktirc.events.EventHandler
 import com.dmdirc.ktirc.events.IrcEvent
 import com.dmdirc.ktirc.events.ServerWelcome
 import com.dmdirc.ktirc.events.eventHandlers
-import com.dmdirc.ktirc.io.KtorLineBufferedSocket
-import com.dmdirc.ktirc.io.LineBufferedSocket
-import com.dmdirc.ktirc.io.MessageHandler
-import com.dmdirc.ktirc.io.MessageParser
+import com.dmdirc.ktirc.io.*
 import com.dmdirc.ktirc.messages.*
-import com.dmdirc.ktirc.model.Profile
-import com.dmdirc.ktirc.model.Server
-import com.dmdirc.ktirc.model.ServerState
+import com.dmdirc.ktirc.model.*
 import kotlinx.coroutines.channels.map
 import kotlinx.coroutines.coroutineScope
 import kotlinx.coroutines.runBlocking
@@ -24,6 +19,12 @@ interface IrcClient {
     suspend fun send(message: String)
 
     val serverState: ServerState
+    val channelState: ChannelStateMap
+
+    val caseMapping: CaseMapping
+        get() = serverState.features[ServerFeature.ServerCaseMapping] ?: CaseMapping.Rfc
+
+    fun isLocalUser(user: User): Boolean = caseMapping.areEquivalent(user.nickname, serverState.localNickname)
 
 }
 
@@ -35,6 +36,7 @@ class IrcClientImpl(private val server: Server, private val profile: Profile) :
     var socketFactory: (String, Int) -> LineBufferedSocket = ::KtorLineBufferedSocket
 
     override val serverState = ServerState(profile.initialNick)
+    override val channelState = ChannelStateMap { caseMapping }
 
     private val messageHandler = MessageHandler(messageProcessors, eventHandlers + object : EventHandler {
         override suspend fun processEvent(client: IrcClient, event: IrcEvent) {

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

@@ -0,0 +1,25 @@
+package com.dmdirc.ktirc.events
+
+import com.dmdirc.ktirc.IrcClient
+import com.dmdirc.ktirc.model.ChannelState
+import com.dmdirc.ktirc.util.logger
+
+class ChannelStateHandler : EventHandler {
+
+    private val log by logger()
+
+    override suspend fun processEvent(client: IrcClient, event: IrcEvent) {
+        when (event) {
+            is ChannelJoined -> handleJoin(client, event)
+        }
+    }
+
+    private fun handleJoin(client: IrcClient, event: ChannelJoined) {
+        if (client.isLocalUser(event.user)) {
+            log.info { "Joined new channel: ${event.channel}" }
+            client.channelState += ChannelState(event.channel)
+        }
+        // TODO: Add user to channel
+    }
+
+}

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

@@ -3,6 +3,7 @@
 package com.dmdirc.ktirc.events
 
 import com.dmdirc.ktirc.model.ServerFeatureMap
+import com.dmdirc.ktirc.model.User
 
 sealed class IrcEvent
 
@@ -25,4 +26,9 @@ object ServerConnected : IrcEvent()
 /**
  * Raised whenever a PING is received from the server.
  */
-data class PingReceived(val nonce: ByteArray): IrcEvent()
+data class PingReceived(val nonce: ByteArray): IrcEvent()
+
+/**
+ * Raised when a user joins a channel.
+ */
+data class ChannelJoined(val user: User, val channel: String): IrcEvent()

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

@@ -0,0 +1,13 @@
+package com.dmdirc.ktirc.messages
+
+import com.dmdirc.ktirc.events.ChannelJoined
+import com.dmdirc.ktirc.io.IrcMessage
+import com.dmdirc.ktirc.model.asUser
+
+class JoinProcessor : MessageProcessor {
+
+    override val commands = arrayOf("JOIN")
+
+    override fun process(message: IrcMessage) = message.prefix?.let { listOf(ChannelJoined(it.asUser(), String(message.params[0]))) } ?: emptyList()
+
+}

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

@@ -19,6 +19,7 @@ interface MessageProcessor {
 
 val messageProcessors = setOf(
         ISupportProcessor(),
+        JoinProcessor(),
         PingProcessor(),
         WelcomeProcessor()
 )

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

@@ -0,0 +1,3 @@
+package com.dmdirc.ktirc.model
+
+class ChannelState(val name: String)

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

@@ -0,0 +1,24 @@
+package com.dmdirc.ktirc.model
+
+import com.dmdirc.ktirc.io.CaseMapping
+
+class ChannelStateMap(private val caseMappingProvider: () -> CaseMapping) : Iterable<ChannelState> {
+
+    private val channels = HashSet<ChannelState>()
+
+    operator fun get(name: String) = channels.find { caseMappingProvider().areEquivalent(it.name, name) }
+
+    operator fun plusAssign(state: ChannelState) {
+        require(get(state.name) == null) { "Channel state already registered: ${state.name}"}
+        channels.add(state)
+    }
+
+    operator fun minusAssign(state: ChannelState) {
+        channels.removeIf { caseMappingProvider().areEquivalent(it.name, state.name) }
+    }
+
+    operator fun contains(name: String) = get(name) != null
+
+    override fun iterator() = channels.iterator()
+
+}

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

@@ -0,0 +1,18 @@
+package com.dmdirc.ktirc.model
+
+data class User(val nickname: String, val ident: String? = null, val hostname: String? = null)
+
+fun ByteArray.asUser(): User {
+    val string = String(this)
+    val identOffset = string.indexOf('!')
+    return if (identOffset >= 0) {
+        val hostOffset = string.indexOf('@', identOffset)
+        if (hostOffset >= 0) {
+            User(string.substring(0 until identOffset), string.substring(identOffset + 1 until hostOffset), string.substring(hostOffset + 1))
+        } else {
+            User(string.substring(0 until identOffset), string.substring(identOffset + 1))
+        }
+    } else {
+        User(string)
+    }
+}

src/test/kotlin/com/dmdirc/ktirc/IrcClientImplTest.kt → src/test/kotlin/com/dmdirc/ktirc/IrcClientTest.kt

@@ -1,11 +1,15 @@
 package com.dmdirc.ktirc
 
+import com.dmdirc.ktirc.io.CaseMapping
 import com.dmdirc.ktirc.io.LineBufferedSocket
 import com.dmdirc.ktirc.model.Profile
 import com.dmdirc.ktirc.model.Server
+import com.dmdirc.ktirc.model.ServerFeature
+import com.dmdirc.ktirc.model.User
 import com.nhaarman.mockitokotlin2.*
 import kotlinx.coroutines.channels.Channel
 import kotlinx.coroutines.runBlocking
+import org.junit.jupiter.api.Assertions.*
 import org.junit.jupiter.api.Test
 import org.junit.jupiter.api.assertThrows
 
@@ -92,4 +96,28 @@ internal class IrcClientImplTest {
         }
     }
 
+    @Test
+    fun `IrcClient gets case mapping from server features`() {
+        val client = IrcClientImpl(Server(HOST, PORT), Profile(NICK, REAL_NAME, USER_NAME))
+        client.serverState.features[ServerFeature.ServerCaseMapping] = CaseMapping.RfcStrict
+        assertEquals(CaseMapping.RfcStrict, client.caseMapping)
+    }
+
+    @Test
+    fun `IrcClient indicates if user is local user or not`() {
+        val client = IrcClientImpl(Server(HOST, PORT), Profile(NICK, REAL_NAME, USER_NAME))
+        client.serverState.localNickname = "[acidBurn]"
+
+        assertTrue(client.isLocalUser(User("{acidBurn}", "libby", "root.localhost")))
+        assertFalse(client.isLocalUser(User("acid-Burn", "libby", "root.localhost")))
+    }
+
+    @Test
+    fun `IrcClient uses current case mapping to check local user`() {
+        val client = IrcClientImpl(Server(HOST, PORT), Profile(NICK, REAL_NAME, USER_NAME))
+        client.serverState.localNickname = "[acidBurn]"
+        client.serverState.features[ServerFeature.ServerCaseMapping] = CaseMapping.Ascii
+        assertFalse(client.isLocalUser(User("{acidBurn}", "libby", "root.localhost")))
+    }
+
 }

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

@@ -0,0 +1,36 @@
+package com.dmdirc.ktirc.events
+
+import com.dmdirc.ktirc.IrcClient
+import com.dmdirc.ktirc.io.CaseMapping
+import com.dmdirc.ktirc.model.ChannelStateMap
+import com.dmdirc.ktirc.model.User
+import com.nhaarman.mockitokotlin2.doReturn
+import com.nhaarman.mockitokotlin2.mock
+import kotlinx.coroutines.runBlocking
+import org.junit.jupiter.api.Assertions.assertFalse
+import org.junit.jupiter.api.Assertions.assertTrue
+import org.junit.jupiter.api.Test
+
+internal class ChannelStateHandlerTest {
+
+    private val channelStateMap = ChannelStateMap { CaseMapping.Rfc }
+    private val ircClient = mock<IrcClient> {
+        on { channelState } doReturn channelStateMap
+        on { isLocalUser(User("acidburn", "libby", "root.localhost")) } doReturn true
+    }
+
+    @Test
+    fun `ChannelStateHandler creates new state object for local joins`() = runBlocking {
+        val handler = ChannelStateHandler()
+        handler.processEvent(ircClient, ChannelJoined(User("acidburn", "libby", "root.localhost"), "#newchannel"))
+        assertTrue("#newchannel" in channelStateMap)
+    }
+
+    @Test
+    fun `ChannelStateHandler does not create new state object for remote joins`() = runBlocking {
+        val handler = ChannelStateHandler()
+        handler.processEvent(ircClient, ChannelJoined(User("zerocool", "dade", "root.localhost"), "#newchannel"))
+        assertFalse("#newchannel" in channelStateMap)
+    }
+
+}

src/test/kotlin/com/dmdirc/ktirc/messages/JoinProcessorTest.kt

@@ -0,0 +1,26 @@
+package com.dmdirc.ktirc.messages
+
+import com.dmdirc.ktirc.events.ChannelJoined
+import com.dmdirc.ktirc.io.IrcMessage
+import com.dmdirc.ktirc.model.User
+import org.junit.jupiter.api.Assertions.assertEquals
+import org.junit.jupiter.api.Test
+
+internal class JoinProcessorTest {
+
+    @Test
+    fun `JoinProcessor raises join event`() {
+        val events = JoinProcessor().process(
+                IrcMessage(null, "acidburn!libby@root.localhost".toByteArray(), "JOIN", listOf("#crashandburn".toByteArray())))
+        assertEquals(1, events.size)
+        assertEquals(ChannelJoined(User("acidburn", "libby", "root.localhost"), "#crashandburn"), events[0])
+    }
+
+    @Test
+    fun `JoinProcessor does nothing if prefix missing`() {
+        val events = JoinProcessor().process(
+                IrcMessage(null, null, "JOIN", listOf("#crashandburn".toByteArray())))
+        assertEquals(0, events.size)
+    }
+
+}

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

@@ -0,0 +1,78 @@
+package com.dmdirc.ktirc.model
+
+import com.dmdirc.ktirc.io.CaseMapping
+import org.junit.jupiter.api.Assertions.*
+import org.junit.jupiter.api.Test
+import org.junit.jupiter.api.assertThrows
+
+internal class ChannelStateMapTest {
+
+    @Test
+    fun `ChannelStateMap stores channel state`() {
+        val channelStateMap = ChannelStateMap { CaseMapping.Rfc }
+        val channelState = ChannelState("#dumpsterdiving")
+        channelStateMap += channelState
+
+        assertSame(channelState, channelStateMap["#dumpsterdiving"])
+    }
+
+    @Test
+    fun `ChannelStateMap disallows setting the same channel twice`() {
+        val channelStateMap = ChannelStateMap { CaseMapping.Rfc }
+        channelStateMap += ChannelState("#dumpsterdiving")
+
+        assertThrows<IllegalArgumentException> {
+            channelStateMap += ChannelState("#DumpsterDiving")
+        }
+    }
+
+    @Test
+    fun `ChannelStateMap retrieves channels in different cases`() {
+        val channelStateMap = ChannelStateMap { CaseMapping.Rfc }
+        val channelState = ChannelState("#dumpsterdiving[]")
+        channelStateMap += channelState
+
+        assertSame(channelState, channelStateMap["#dumpsterdiving{}"])
+    }
+
+    @Test
+    fun `ChannelStateMap returns null if channel not found`() {
+        val channelStateMap = ChannelStateMap { CaseMapping.Ascii }
+        val channelState = ChannelState("#dumpsterdiving[]")
+        channelStateMap += channelState
+
+        assertNull(channelStateMap["#dumpsterdiving{}"])
+    }
+
+    @Test
+    fun `ChannelStateMap removes channels`() {
+        val channelStateMap = ChannelStateMap { CaseMapping.Rfc }
+        val channelState = ChannelState("#dumpsterdiving")
+        channelStateMap += channelState
+        channelStateMap -= ChannelState("#dumpsterDIVING")
+
+        assertNull(channelStateMap["#dumpsterdiving"])
+    }
+
+    @Test
+    fun `ChannelStateMap can be iterated`() {
+        val channelStateMap = ChannelStateMap { CaseMapping.Rfc }
+        channelStateMap += ChannelState("#dumpsterdiving")
+        channelStateMap += ChannelState("#gibson")
+
+        val names = channelStateMap.map { it.name }.toList()
+        assertEquals(2, names.size)
+        assertTrue(names.contains("#dumpsterdiving"))
+        assertTrue(names.contains("#gibson"))
+    }
+
+    @Test
+    fun `ChannelStateMap indicates if it contains a channel or not`() {
+        val channelStateMap = ChannelStateMap { CaseMapping.Rfc }
+        channelStateMap += ChannelState("#dumpsterdiving")
+
+        assertTrue("#dumpsterDIVING" in channelStateMap)
+        assertFalse("#crashandburn" in channelStateMap)
+    }
+
+}

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

@@ -0,0 +1,33 @@
+package com.dmdirc.ktirc.model
+
+import org.junit.jupiter.api.Assertions.assertEquals
+import org.junit.jupiter.api.Assertions.assertNull
+import org.junit.jupiter.api.Test
+
+internal class UserTest {
+
+    @Test
+    fun `ByteArray asUser returns user with just nickname`() {
+        val user = "acidBurn".toByteArray().asUser()
+        assertEquals("acidBurn", user.nickname)
+        assertNull(user.ident)
+        assertNull(user.hostname)
+    }
+
+    @Test
+    fun `ByteArray asUser returns user and ident`() {
+        val user = "acidBurn!libby".toByteArray().asUser()
+        assertEquals("acidBurn", user.nickname)
+        assertEquals("libby", user.ident)
+        assertNull(user.hostname)
+    }
+
+    @Test
+    fun `ByteArray asUser returns user ident and host`() {
+        val user = "acidBurn!libby@root.localhost".toByteArray().asUser()
+        assertEquals("acidBurn", user.nickname)
+        assertEquals("libby", user.ident)
+        assertEquals("root.localhost", user.hostname)
+    }
+
+}