Move messageId to metadata

CHANGELOG

    * requestModesOnJoin - automatically sends a MODE request when joining a channel
  * Events now have a `metadata` property instead of a `time` (and time is available in metadata)
    * IrcEvent.time is now deprecated but will remain until after v1.0.0.
+   * Metadata now contains the message ID, if any.
+     * ActionReceived.messageId and MessageReceived.messageId are now deprecated, to be removed after v1.0.0.
    * Metadata now contains the event's batch ID, if any.
  * Added support for batches
    * All events in a batch are buffered until the batch is finished

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

  */
 fun IrcClient.reply(message: MessageReceived, response: String, prefixWithNickname: Boolean = false) {
     if (isToMe(message)) {
-        sendMessage(message.user.nickname, response, message.messageId)
+        sendMessage(message.user.nickname, response, message.metadata.messageId)
     } else {
-        sendMessage(message.target, if (prefixWithNickname) "${message.user.nickname}: $response" else response, message.messageId)
+        sendMessage(message.target, if (prefixWithNickname) "${message.user.nickname}: $response" else response, message.metadata.messageId)
     }
 }
 
 fun IrcClient.react(message: MessageReceived, reaction: String) = sendTagMessage(
         if (isToMe(message)) message.user.nickname else message.target,
         mapOf(MessageTag.React to reaction),
-        message.messageId)
+        message.metadata.messageId)
 
 /**
  * Utility to determine whether the given message is to our local user or not.

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

  *
  * @param time The best-guess time at which the event occurred.
  * @param batchId The ID of the batch this event is part of, if any.
+ * @param messageId The unique ID of this message, if any.
  */
-data class EventMetadata(val time: LocalDateTime, val batchId: String? = null)
+data class EventMetadata(val time: LocalDateTime, val batchId: String? = null, val messageId: String? = null)
 
 /** Base class for all events. */
 sealed class IrcEvent(val metadata: EventMetadata) {
 
     /** The time at which the event occurred. */
-    @Deprecated("Only for backwards compatibility; to be removed post-1.0.0", replaceWith = ReplaceWith("metadata.time"))
+    @Deprecated("Moved to metadata; to be removed post-1.0.0", replaceWith = ReplaceWith("metadata.time"))
     val time: LocalDateTime
         get() = metadata.time
 
 class ChannelTopicChanged(metadata: EventMetadata, val user: User, val channel: String, val topic: String?) : IrcEvent(metadata)
 
 /** Raised when a message is received. */
-class MessageReceived(metadata: EventMetadata, val user: User, val target: String, val message: String, val messageId: String? = null) : IrcEvent(metadata)
+class MessageReceived(metadata: EventMetadata, val user: User, val target: String, val message: String) : IrcEvent(metadata) {
+
+    /** The message ID of this message. */
+    @Deprecated("Moved to metadata; to be removed post-1.0.0", replaceWith = ReplaceWith("metadata.messageId"))
+    val messageId: String?
+        get() = metadata.messageId
+
+}
 
 /**
  * Raised when a notice is received.
 class NoticeReceived(metadata: EventMetadata, val user: User, val target: String, val message: String) : IrcEvent(metadata)
 
 /** Raised when an action is received. */
-class ActionReceived(metadata: EventMetadata, val user: User, val target: String, val action: String, val messageId: String? = null) : IrcEvent(metadata)
+class ActionReceived(metadata: EventMetadata, val user: User, val target: String, val action: String) : IrcEvent(metadata) {
+
+    /** The message ID of this action. */
+    @Deprecated("Moved to metadata; to be removed post-1.0.0", replaceWith = ReplaceWith("metadata.messageId"))
+    val messageId: String?
+        get() = metadata.messageId
+
+}
 
 /** Raised when a CTCP is received. */
 class CtcpReceived(metadata: EventMetadata, val user: User, val target: String, val type: String, val content: String) : IrcEvent(metadata)

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

 import com.dmdirc.ktirc.events.IrcEvent
 import com.dmdirc.ktirc.events.MessageReceived
 import com.dmdirc.ktirc.model.IrcMessage
-import com.dmdirc.ktirc.model.MessageTag
 import com.dmdirc.ktirc.model.User
 
 internal class PrivmsgProcessor : MessageProcessor {
     override fun process(message: IrcMessage) = message.sourceUser?.let { user ->
         listOf(when {
             message.isCtcp() -> handleCtcp(message, user)
-            else -> MessageReceived(message.metadata, user, String(message.params[0]), String(message.params[1]), message.messageId)
+            else -> MessageReceived(message.metadata, user, String(message.params[0]), String(message.params[1]))
         })
     } ?: emptyList()
 
         val parts = content.split(' ', limit=2)
         val body = if (parts.size == 2) parts[1] else ""
         return when (parts[0].toUpperCase()) {
-            "ACTION" -> ActionReceived(message.metadata, user, String(message.params[0]), body, message.messageId)
+            "ACTION" -> ActionReceived(message.metadata, user, String(message.params[0]), body)
             else -> CtcpReceived(message.metadata, user, String(message.params[0]), parts[0], body)
         }
     }
 
     private fun IrcMessage.isCtcp() = params[1].size > 2 && params[1][0] == CTCP_BYTE && params[1][params[1].size - 1] == CTCP_BYTE
 
-    private val IrcMessage.messageId
-        get() = tags[MessageTag.MessageId]
-
 }

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

 internal class IrcMessage(val tags: Map<MessageTag, String>, val prefix: ByteArray?, val command: String, val params: List<ByteArray>) {
 
     /** The time at which the message was sent, or our best guess at it. */
-    val metadata = EventMetadata(time, batchId)
+    val metadata = EventMetadata(time, batchId, messageId)
 
     /** The user that generated the message, if any. */
     val sourceUser by lazy {
     }
 
     private val time
-        get() = if (MessageTag.ServerTime in tags) {
-            LocalDateTime.ofInstant(Instant.parse(tags[MessageTag.ServerTime]), currentTimeZoneProvider())
-        } else {
-            currentTimeProvider()
+        get() = when (MessageTag.ServerTime in tags) {
+            true -> LocalDateTime.ofInstant(Instant.parse(tags[MessageTag.ServerTime]), currentTimeZoneProvider())
+            false -> currentTimeProvider()
         }
 
     private val batchId
         get() = tags[MessageTag.Batch]
 
+    private val messageId
+        get() = tags[MessageTag.MessageId]
+
 }
 
 /**

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

     @Test
     fun `reply sends response with message ID to user when message is private`() {
         serverState.localNickname = "zeroCool"
-        val message = MessageReceived(EventMetadata(TestConstants.time), User("acidBurn"), "Zerocool", "Hack the planet!", "abc123")
+        val message = MessageReceived(EventMetadata(TestConstants.time, messageId = "abc123"), User("acidBurn"), "Zerocool", "Hack the planet!")
 
         ircClient.reply(message, "OK")
         verify(ircClient).send("@+draft/reply=abc123 PRIVMSG acidBurn :OK")
 
     @Test
     fun `reply sends unprefixed response with message ID to user when message is in a channel`() {
-        val message = MessageReceived(EventMetadata(TestConstants.time), User("acidBurn"), "#TheGibson", "Hack the planet!", "abc123")
+        val message = MessageReceived(EventMetadata(TestConstants.time, messageId = "abc123"), User("acidBurn"), "#TheGibson", "Hack the planet!")
 
         ircClient.reply(message, "OK")
         verify(ircClient).send("@+draft/reply=abc123 PRIVMSG #TheGibson :OK")
 
     @Test
     fun `reply sends prefixed response with message ID to user when message is in a channel`() {
-        val message = MessageReceived(EventMetadata(TestConstants.time), User("acidBurn"), "#TheGibson", "Hack the planet!", "abc123")
+        val message = MessageReceived(EventMetadata(TestConstants.time, messageId = "abc123"), User("acidBurn"), "#TheGibson", "Hack the planet!")
 
         ircClient.reply(message, "OK", prefixWithNickname = true)
         verify(ircClient).send("@+draft/reply=abc123 PRIVMSG #TheGibson :acidBurn: OK")
     @Test
     fun `react sends response to user when message is private`() {
         serverState.localNickname = "zeroCool"
-        val message = MessageReceived(EventMetadata(TestConstants.time), User("acidBurn"), "Zerocool", "Hack the planet!", "msgId")
+        val message = MessageReceived(EventMetadata(TestConstants.time, messageId = "msgId"), User("acidBurn"), "Zerocool", "Hack the planet!")
 
         ircClient.react(message, ":P")
         verify(ircClient).send("@+draft/react=:P;+draft/reply=msgId TAGMSG acidBurn")
 
     @Test
     fun `react sends unprefixed response to user when message is in a channel`() {
-        val message = MessageReceived(EventMetadata(TestConstants.time), User("acidBurn"), "#TheGibson", "Hack the planet!", "msgId")
+        val message = MessageReceived(EventMetadata(TestConstants.time, messageId = "msgId"), User("acidBurn"), "#TheGibson", "Hack the planet!")
 
         ircClient.react(message, ":P")
         verify(ircClient).send("@+draft/react=:P;+draft/reply=msgId TAGMSG #TheGibson")

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

 import com.dmdirc.ktirc.events.CtcpReceived
 import com.dmdirc.ktirc.events.MessageReceived
 import com.dmdirc.ktirc.model.IrcMessage
-import com.dmdirc.ktirc.model.MessageTag
 import com.dmdirc.ktirc.model.User
 import com.dmdirc.ktirc.params
 import com.dmdirc.ktirc.util.currentTimeProvider
 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
 
     }
 
     @Test
-    fun `PrivsgProcessor raises message received event`() {
+    fun `raises message received event`() {
         val events = PrivmsgProcessor().process(
                 IrcMessage(emptyMap(), "acidburn!libby@root.localhost".toByteArray(), "PRIVMSG", params("#crashandburn", "hack the planet!")))
         assertEquals(1, events.size)
         assertEquals(User("acidburn", "libby", "root.localhost"), event.user)
         assertEquals("#crashandburn", event.target)
         assertEquals("hack the planet!", event.message)
-        assertNull(event.messageId)
     }
 
     @Test
-    fun `PrivsgProcessor raises message received event with message ID`() {
-        val events = PrivmsgProcessor().process(
-                IrcMessage(mapOf(MessageTag.MessageId to "abc123"), "acidburn!libby@root.localhost".toByteArray(), "PRIVMSG", params("#crashandburn", "hack the planet!")))
-        assertEquals(1, events.size)
-
-        val event = events[0] as MessageReceived
-        assertEquals(TestConstants.time, event.metadata.time)
-        assertEquals(User("acidburn", "libby", "root.localhost"), event.user)
-        assertEquals("#crashandburn", event.target)
-        assertEquals("hack the planet!", event.message)
-        assertEquals("abc123", event.messageId)
-    }
-
-    @Test
-    fun `PrivsgProcessor raises action received event with content`() {
+    fun `raises action received event with content`() {
         val events = PrivmsgProcessor().process(
                 IrcMessage(emptyMap(), "acidburn!libby@root.localhost".toByteArray(), "PRIVMSG", params("#crashandburn", "\u0001ACTION hacks the planet\u0001")))
         assertEquals(1, events.size)
         assertEquals(User("acidburn", "libby", "root.localhost"), event.user)
         assertEquals("#crashandburn", event.target)
         assertEquals("hacks the planet", event.action)
-        assertNull(event.messageId)
-    }
-
-    @Test
-    fun `PrivsgProcessor raises action received event with message ID`() {
-        val events = PrivmsgProcessor().process(
-                IrcMessage(mapOf(MessageTag.MessageId to "abc123"), "acidburn!libby@root.localhost".toByteArray(), "PRIVMSG", params("#crashandburn", "\u0001ACTION hacks the planet\u0001")))
-        assertEquals(1, events.size)
-
-        val event = events[0] as ActionReceived
-        assertEquals(TestConstants.time, event.metadata.time)
-        assertEquals(User("acidburn", "libby", "root.localhost"), event.user)
-        assertEquals("#crashandburn", event.target)
-        assertEquals("hacks the planet", event.action)
-        assertEquals("abc123", event.messageId)
     }
 
     @Test
-    fun `PrivsgProcessor raises action received event without content`() {
+    fun `raises action received event without content`() {
         val events = PrivmsgProcessor().process(
                 IrcMessage(emptyMap(), "acidburn!libby@root.localhost".toByteArray(), "PRIVMSG", params("#crashandburn", "\u0001ACTION\u0001")))
         assertEquals(1, events.size)
         assertEquals(User("acidburn", "libby", "root.localhost"), event.user)
         assertEquals("#crashandburn", event.target)
         assertEquals("", event.action)
-        assertNull(event.messageId)
     }
 
     @Test
-    fun `PrivsgProcessor raises action received event with lowercase type`() {
+    fun `raises action received event with lowercase type`() {
         val events = PrivmsgProcessor().process(
                 IrcMessage(emptyMap(), "acidburn!libby@root.localhost".toByteArray(), "PRIVMSG", params("#crashandburn", "\u0001action hacks the planet\u0001")))
         assertEquals(1, events.size)
         assertEquals(User("acidburn", "libby", "root.localhost"), event.user)
         assertEquals("#crashandburn", event.target)
         assertEquals("hacks the planet", event.action)
-        assertNull(event.messageId)
     }
 
     @Test
-    fun `PrivsgProcessor raises CTCP received event with content`() {
+    fun `raises CTCP received event with content`() {
         val events = PrivmsgProcessor().process(
                 IrcMessage(emptyMap(), "acidburn!libby@root.localhost".toByteArray(), "PRIVMSG", params("#crashandburn", "\u0001PING 12345\u0001")))
         assertEquals(1, events.size)
     }
 
     @Test
-    fun `PrivsgProcessor raises CTCP received event without content`() {
+    fun `raises CTCP received event without content`() {
         val events = PrivmsgProcessor().process(
                 IrcMessage(emptyMap(), "acidburn!libby@root.localhost".toByteArray(), "PRIVMSG", params("#crashandburn", "\u0001PING\u0001")))
         assertEquals(1, events.size)
     }
 
     @Test
-    fun `PrivsgProcessor does nothing if prefix missing`() {
+    fun `does nothing if prefix missing`() {
         val events = PrivmsgProcessor().process(
                 IrcMessage(emptyMap(), null, "PRIVMSG", params("#crashandburn", "hack the planet!")))
         assertEquals(0, events.size)
     }
-}
+}

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

         assertEquals("abc123", message.metadata.batchId)
     }
 
+    @Test
+    fun `populates message id if present`() {
+        currentTimeProvider = { TestConstants.time }
+        val message = IrcMessage(hashMapOf(MessageTag.MessageId to "abc123"), null, "", emptyList())
+        assertEquals("abc123", message.metadata.messageId)
+    }
+
     @Test
     fun `Can parse the prefix as a source user`() {
         val message = IrcMessage(emptyMap(), "acidBurn!libby@root.localhost".toByteArray(), "", emptyList())