Topic support

CHANGELOG

 
  * Added support for SCRAM-SHA-1 and SCRAM-SHA-256 SASL mechanisms
  * Added MotdLineReceived event
+ * Added topic events and state
  * (Internal) Move event handlers into their own package
 
 v0.7.0

gradle/wrapper/gradle-wrapper.properties

 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-5.2-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-5.2.1-bin.zip
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists

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

 /** Raised when the entirety of the channel's member list has been received. */
 class ChannelNamesFinished(time: LocalDateTime, val channel: String) : IrcEvent(time)
 
-/** Raised when a channel topic is discovered (not changed). Usually followed by [ChannelTopicMetadataDiscovered]. */
-class ChannelTopicDiscovered(time: LocalDateTime, val channel: String, val topic: String) : IrcEvent(time)
+/** Raised when a channel topic is discovered (not changed). Usually followed by [ChannelTopicMetadataDiscovered] if the [topic] is non-null. */
+class ChannelTopicDiscovered(time: LocalDateTime, val channel: String, val topic: String?) : IrcEvent(time)
 
 /** Raised when a channel topic's metadata is discovered. */
 class ChannelTopicMetadataDiscovered(time: LocalDateTime, val channel: String, val user: User, val setTime: LocalDateTime) : IrcEvent(time)
 
+/**
+ * Raised when a channel's topic is changed.
+ *
+ * If the topic has been unset (cleared), [topic] will be `null`
+ */
+class ChannelTopicChanged(time: LocalDateTime, val user: User, val channel: String, val topic: String?) : IrcEvent(time)
+
 /** Raised when a message is received. */
 class MessageReceived(time: LocalDateTime, val user: User, val target: String, val message: String, val messageId: String? = null) : IrcEvent(time)
 

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

 import com.dmdirc.ktirc.IrcClient
 import com.dmdirc.ktirc.events.*
 import com.dmdirc.ktirc.model.ChannelState
+import com.dmdirc.ktirc.model.ChannelTopic
 import com.dmdirc.ktirc.model.ChannelUser
 import com.dmdirc.ktirc.util.logger
 
             is ChannelNamesReceived -> handleNamesReceived(client, event)
             is ChannelNamesFinished -> handleNamesFinished(client, event)
             is ChannelUserKicked -> handleKick(client, event)
+            is ChannelTopicDiscovered -> handleTopicDiscovered(client, event)
+            is ChannelTopicMetadataDiscovered -> handleTopicMetadata(client, event)
+            is ChannelTopicChanged -> handleTopicChanged(client, event)
             is ModeChanged -> handleModeChanged(client, event)
             is UserQuit -> return handleQuit(client, event)
             is UserNickChanged -> return handleNickChanged(client, event)
         }
     }
 
+    private fun handleTopicDiscovered(client: IrcClient, event: ChannelTopicDiscovered) {
+        client.channelState[event.channel]?.let {
+            if (!it.topicDiscovered) {
+                it.topic = ChannelTopic(event.topic)
+                if (event.topic == null) {
+                    it.topicDiscovered = true
+                }
+            }
+        }
+    }
+
+    private fun handleTopicMetadata(client: IrcClient, event: ChannelTopicMetadataDiscovered) {
+        client.channelState[event.channel]?.let {
+            if (!it.topicDiscovered) {
+                it.topic = ChannelTopic(it.topic.topic, event.user, event.setTime)
+                it.topicDiscovered = true
+            }
+        }
+    }
+
+    private fun handleTopicChanged(client: IrcClient, event: ChannelTopicChanged) {
+        client.channelState[event.channel]?.let {
+            it.topic = ChannelTopic(event.topic, event.user, event.time)
+        }
+    }
+
     private fun handleModeChanged(client: IrcClient, event: ModeChanged) {
         val chan = client.channelState[event.target] ?: return
         if (event.discovered) {

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

 internal const val RPL_UMODEIS = "221"
 
 internal const val RPL_CHANNELMODEIS = "324"
+internal const val RPL_NOTOPIC = "331"
 internal const val RPL_TOPIC = "332"
 internal const val RPL_TOPICWHOTIME = "333"
 internal const val RPL_MOTD = "372"

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

 package com.dmdirc.ktirc.messages
 
+import com.dmdirc.ktirc.events.ChannelTopicChanged
 import com.dmdirc.ktirc.events.ChannelTopicDiscovered
 import com.dmdirc.ktirc.events.ChannelTopicMetadataDiscovered
 import com.dmdirc.ktirc.model.IrcMessage
 
 internal class TopicProcessor : MessageProcessor {
 
-    override val commands = arrayOf(RPL_TOPIC, RPL_TOPICWHOTIME)
+    override val commands = arrayOf(RPL_TOPIC, RPL_TOPICWHOTIME, RPL_NOTOPIC, "TOPIC")
 
     override fun process(message: IrcMessage) = sequence {
         when (message.command) {
             RPL_TOPIC -> yield(ChannelTopicDiscovered(message.time, message.channel, String(message.params[2])))
+            RPL_NOTOPIC -> yield(ChannelTopicDiscovered(message.time, message.channel, null))
             RPL_TOPICWHOTIME -> yield(ChannelTopicMetadataDiscovered(
                     message.time, message.channel, message.params[2].asUser(), message.topicSetTime))
+            "TOPIC" -> message.sourceUser?.let { yield(ChannelTopicChanged(message.time, it, String(message.params[0]), String(message.params[1]))) }
         }
     }.toList()
 

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

 package com.dmdirc.ktirc.model
 
 import com.dmdirc.ktirc.io.CaseMapping
+import java.time.LocalDateTime
 
 /**
  * Describes the state of a channel that the client has joined.
     var modesDiscovered = false
         internal set
 
+    /**
+     * Whether or not we have discovered or seen a channel topic. Subsequent discoveries are ignored.
+     */
+    internal var topicDiscovered = false
+
+    /**
+     * The current channel topic.
+     */
+    var topic = ChannelTopic()
+        internal set
+
     /**
      * A map of all users in the channel to their current modes.
      */
     internal fun reset() {
         receivingUserList = false
         modesDiscovered = false
+        topic = ChannelTopic()
+        topicDiscovered = false
         users.clear()
         modes.clear()
     }
 }
 
+/**
+ * Describes a channel topic, and when and by whom it was set.
+ *
+ * [topic] may be null if there is no topic set.
+ *
+ * [user] and [time] may not be known if the topic was set before we joined the channel, depending on when it
+ * is checked and the exact behaviour of the IRC server.
+ *
+ * If the topic is cleared while we are present, then [topic] will be `null` but the [user] and [time] that it
+ * was cleared will still be recorded.
+ */
+data class ChannelTopic(val topic: String? = null, val user: User? = null, val time: LocalDateTime? = null)
+
 /**
  * Describes a user in a channel, and their modes.
  */

src/test/kotlin/com/dmdirc/ktirc/TestConstants.kt

 
 object TestConstants {
     val time: LocalDateTime = LocalDateTime.parse("1995-09-15T09:00:00")
+    val otherTime : LocalDateTime = LocalDateTime.parse("1996-05-03T13:00:00")
 }

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

         assertEquals("bbb", channelStateMap["#thegibson"]?.modes?.get('b'))
     }
 
+    @Test
+    fun `updates topic state when it's discovered for the first time`() {
+        val state = ChannelState("#thegibson") { CaseMapping.Rfc }
+        channelStateMap += state
+
+        handler.processEvent(ircClient, ChannelTopicDiscovered(TestConstants.time, "#thegibson", "Hack the planet!"))
+        handler.processEvent(ircClient, ChannelTopicMetadataDiscovered(TestConstants.time, "#thegibson", User("acidBurn"), TestConstants.otherTime))
+
+        assertTrue(state.topicDiscovered)
+        assertEquals(ChannelTopic("Hack the planet!", User("acidBurn"), TestConstants.otherTime), state.topic)
+    }
+
+    @Test
+    fun `updates topic state when no topic is discovered for the first time`() {
+        val state = ChannelState("#thegibson") { CaseMapping.Rfc }
+        channelStateMap += state
+
+        handler.processEvent(ircClient, ChannelTopicDiscovered(TestConstants.time, "#thegibson", null))
+
+        assertTrue(state.topicDiscovered)
+        assertEquals(ChannelTopic(), state.topic)
+    }
+
+    @Test
+    fun `leaves topic state when it's discovered for a second time`() {
+        val state = ChannelState("#thegibson") { CaseMapping.Rfc }
+        state.topic = ChannelTopic("Hack the planet!", User("acidBurn"), TestConstants.otherTime)
+        state.topicDiscovered = true
+        channelStateMap += state
+
+        handler.processEvent(ircClient, ChannelTopicDiscovered(TestConstants.time, "#thegibson", "Hack the planet"))
+        handler.processEvent(ircClient, ChannelTopicMetadataDiscovered(TestConstants.time, "#thegibson", User("zeroCool"), TestConstants.time))
+
+        assertTrue(state.topicDiscovered)
+        assertEquals(ChannelTopic("Hack the planet!", User("acidBurn"), TestConstants.otherTime), state.topic)
+    }
+
+    @Test
+    fun `updates topic state when the topic is changed`() {
+        val state = ChannelState("#thegibson") { CaseMapping.Rfc }
+        channelStateMap += state
+
+        handler.processEvent(ircClient, ChannelTopicChanged(TestConstants.time, User("acidBurn"), "#thegibson", "Hack the planet!"))
+
+        assertEquals(ChannelTopic("Hack the planet!", User("acidBurn"), TestConstants.time), state.topic)
+    }
+
+    @Test
+    fun `updates topic state when the topic is unset`() {
+        val state = ChannelState("#thegibson") { CaseMapping.Rfc }
+        channelStateMap += state
+
+        handler.processEvent(ircClient, ChannelTopicChanged(TestConstants.time, User("acidBurn"), "#thegibson", null))
+
+        assertEquals(ChannelTopic(null, User("acidBurn"), TestConstants.time), state.topic)
+    }
+
+    @Test
+    fun `ignores topic change when channel doesn't exist`() {
+        val state = ChannelState("#thegibson") { CaseMapping.Rfc }
+        channelStateMap += state
+
+        handler.processEvent(ircClient, ChannelTopicChanged(TestConstants.time, User("acidBurn"), "#dumpsterdiving", "Hack the planet!"))
+
+        assertEquals(ChannelTopic(), state.topic)
+    }
+
 }

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

 package com.dmdirc.ktirc.messages
 
 import com.dmdirc.ktirc.TestConstants
+import com.dmdirc.ktirc.events.ChannelTopicChanged
 import com.dmdirc.ktirc.events.ChannelTopicDiscovered
 import com.dmdirc.ktirc.events.ChannelTopicMetadataDiscovered
 import com.dmdirc.ktirc.model.IrcMessage
+import com.dmdirc.ktirc.model.User
 import com.dmdirc.ktirc.params
 import com.dmdirc.ktirc.util.currentTimeProvider
 import com.dmdirc.ktirc.util.currentTimeZoneProvider
 import org.junit.jupiter.api.Assertions.assertEquals
+import org.junit.jupiter.api.Assertions.assertNull
 import org.junit.jupiter.api.BeforeEach
 import org.junit.jupiter.api.Test
-import java.time.ZoneId
 
 internal class TopicProcessorTest {
 
     }
 
     @Test
-    fun `raises ChannelTopicMetadataDiscovered event when topic is supplied`() {
-        val events = processor.process(IrcMessage(emptyMap(), null, "333", params("acidBurn", "#thegibson", "zeroCool", unixtime(currentTimeZoneProvider()))))
+    fun `raises ChannelTopicDiscovered event when no topic is set`() {
+        val events = processor.process(IrcMessage(emptyMap(), null, "331", params("acidBurn", "#thegibson", "No topic set")))
+        assertEquals(1, events.size)
+
+        val event = events[0] as ChannelTopicDiscovered
+        assertEquals(TestConstants.time, event.time)
+        assertEquals("#thegibson", event.channel)
+        assertNull(event.topic)
+    }
+
+    @Test
+    fun `raises ChannelTopicMetadataDiscovered event when metadata is supplied`() {
+        val events = processor.process(IrcMessage(emptyMap(), null, "333", params("acidBurn", "#thegibson", "zeroCool", unixtime())))
         assertEquals(1, events.size)
 
         val event = events[0] as ChannelTopicMetadataDiscovered
         assertEquals(TestConstants.time, event.time)
         assertEquals("#thegibson", event.channel)
         assertEquals("zeroCool", event.user.nickname)
-        assertEquals(TestConstants.time, event.setTime)
+        assertEquals(TestConstants.otherTime, event.setTime)
+    }
+
+    @Test
+    fun `raises ChannelTopicChanged event when topic is changed`() {
+        val events = processor.process(IrcMessage(emptyMap(), "acidBurn!acidB@the.gibson".toByteArray(), "TOPIC", params("#thegibson", "Hack the planet!")))
+        assertEquals(1, events.size)
+
+        val event = events[0] as ChannelTopicChanged
+        assertEquals(TestConstants.time, event.time)
+        assertEquals(User("acidBurn", "acidB", "the.gibson"), event.user)
+        assertEquals("#thegibson", event.channel)
+        assertEquals("Hack the planet!", event.topic)
+    }
+
+    @Test
+    fun `does nothing when topic is changed with no source`() {
+        val events = processor.process(IrcMessage(emptyMap(), null, "TOPIC", params("#thegibson", "Hack the planet!")))
+        assertEquals(0, events.size)
     }
 
-    private fun unixtime(zoneId: ZoneId) = TestConstants.time.toEpochSecond(zoneId.rules.getOffset(TestConstants.time)).toString()
+    private fun unixtime() = TestConstants.otherTime.toEpochSecond(currentTimeZoneProvider().rules.getOffset(TestConstants.time)).toString()
 
 }

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

     fun `reset resets all state`() = with(ChannelState("#thegibson") { CaseMapping.Rfc }) {
         receivingUserList = true
         modesDiscovered = true
+        topicDiscovered = true
         modes['a'] = "b"
         users += ChannelUser("acidBurn")
+        topic = ChannelTopic("Hack the planet!")
 
         reset()
 
         assertFalse(receivingUserList)
         assertFalse(modesDiscovered)
+        assertFalse(topicDiscovered)
         assertTrue(modes.isEmpty())
         assertEquals(0, users.count())
+        assertEquals(ChannelTopic(), topic)
     }
 
 }