Simplify how event handlers are exposed

CHANGELOG

@@ -1,4 +1,5 @@
 v0.2.0 [in development]
 
   * Added support for connecting over TLS
+  * Simplified how event handlers are registered
   * (Internal) Upgraded to Gradle 5.1.1

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

@@ -19,11 +19,11 @@ interface IrcClient {
     val channelState: ChannelStateMap
     val userState: UserState
 
+    fun onEvent(handler: (IrcEvent) -> Unit)
+
     val caseMapping: CaseMapping
         get() = serverState.features[ServerFeature.ServerCaseMapping] ?: CaseMapping.Rfc
 
-    var eventHandler: EventHandler?
-
     fun isLocalUser(user: User): Boolean = caseMapping.areEquivalent(user.nickname, serverState.localNickname)
 
 }
@@ -39,18 +39,12 @@ class IrcClientImpl(private val server: Server, private val profile: Profile) :
     override val channelState = ChannelStateMap { caseMapping }
     override val userState = UserState { caseMapping }
 
-    override var eventHandler: EventHandler? = null
-        set(value) {
-            field?.let { messageHandler.handlers.remove(it) }
-            field = value
-            field?.let { messageHandler.handlers.add(it) }
-        }
-
     private val messageHandler = MessageHandler(messageProcessors.toList(), eventHandlers.toMutableList())
 
     private val parser = MessageParser()
     private var socket: LineBufferedSocket? = null
 
+    // TODO: It would be cleaner if this didn't suspend but returned immediately
     override suspend fun send(message: String) {
         socket?.sendLine(message)
     }
@@ -77,28 +71,32 @@ class IrcClientImpl(private val server: Server, private val profile: Profile) :
         socket?.disconnect()
     }
 
-    companion object {
-        @JvmStatic
-        fun main(args: Array<String>) {
-            val rootLogger = LogManager.getLogManager().getLogger("")
-            rootLogger.level = Level.FINEST
-            for (h in rootLogger.handlers) {
-                h.level = Level.FINEST
+    override fun onEvent(handler: (IrcEvent) -> Unit) {
+        messageHandler.handlers.add(object : EventHandler {
+            override suspend fun processEvent(client: IrcClient, event: IrcEvent) {
+                handler(event)
             }
+        })
+    }
+}
+
+fun main() {
+    val rootLogger = LogManager.getLogManager().getLogger("")
+    rootLogger.level = Level.FINEST
+    for (h in rootLogger.handlers) {
+        h.level = Level.FINEST
+    }
 
+    runBlocking {
+        val client = IrcClientImpl(Server("testnet.inspircd.org", 6667), Profile("KtIrc", "Kotlin!", "kotlin"))
+        client.onEvent { event ->
             runBlocking {
-                val client = IrcClientImpl(Server("testnet.inspircd.org", 6667), Profile("KtIrc", "Kotlin!", "kotlin"))
-                client.eventHandler = object : EventHandler {
-                    override suspend fun processEvent(client: IrcClient, event: IrcEvent) {
-                        when (event) {
-                            is ServerWelcome -> client.send(joinMessage("#ktirc"))
-                            is MessageReceived -> if (event.message == "!test") client.send(privmsgMessage(event.target, "Test successful!"))
-                        }
-                    }
+                when (event) {
+                    is ServerWelcome -> client.send(joinMessage("#ktirc"))
+                    is MessageReceived -> if (event.message == "!test") client.send(privmsgMessage(event.target, "Test successful!"))
                 }
-                client.connect()
             }
         }
+        client.connect()
     }
-
 }

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

@@ -2,6 +2,7 @@ package com.dmdirc.ktirc.events
 
 import com.dmdirc.ktirc.IrcClient
 
+@FunctionalInterface
 interface EventHandler {
 
     suspend fun processEvent(client: IrcClient, event: IrcEvent)

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

@@ -1,6 +1,6 @@
 package com.dmdirc.ktirc
 
-import com.dmdirc.ktirc.events.EventHandler
+import com.dmdirc.ktirc.events.IrcEvent
 import com.dmdirc.ktirc.events.ServerWelcome
 import com.dmdirc.ktirc.io.CaseMapping
 import com.dmdirc.ktirc.io.LineBufferedSocket
@@ -35,7 +35,7 @@ internal class IrcClientImplTest {
         on { invoke(eq(HOST), eq(PORT), any()) } doReturn mockSocket
     }
 
-    private val mockEventHandler = mock<EventHandler>()
+    private val mockEventHandler = mock<(IrcEvent) -> Unit>()
 
     @BeforeEach
     fun setUp() {
@@ -124,7 +124,7 @@ internal class IrcClientImplTest {
         runBlocking {
             val client = IrcClientImpl(Server(HOST, PORT, password = PASSWORD), Profile(NICK, REAL_NAME, USER_NAME))
             client.socketFactory = mockSocketFactory
-            client.eventHandler = mockEventHandler
+            client.onEvent(mockEventHandler)
 
             launch {
                 readLineChannel.send(":the.gibson 001 acidBurn :Welcome to the IRC!".toByteArray())
@@ -133,45 +133,7 @@ internal class IrcClientImplTest {
 
             client.connect()
 
-            verify(mockEventHandler).processEvent(same(client), isA<ServerWelcome>())
-        }
-    }
-
-    @Test
-    fun `IrcClientImpl removes old event handlers when new one is added`() {
-        runBlocking {
-            val client = IrcClientImpl(Server(HOST, PORT, password = PASSWORD), Profile(NICK, REAL_NAME, USER_NAME))
-            client.socketFactory = mockSocketFactory
-            client.eventHandler = mockEventHandler
-            client.eventHandler = mock()
-
-            launch {
-                readLineChannel.send(":the.gibson 001 acidBurn :Welcome to the IRC!".toByteArray())
-                readLineChannel.close()
-            }
-
-            client.connect()
-
-            verify(mockEventHandler, never()).processEvent(client, ServerWelcome(TestConstants.time, "acidBurn"))
-        }
-    }
-
-    @Test
-    fun `IrcClientImpl removes old event handlers when it is set to null`() {
-        runBlocking {
-            val client = IrcClientImpl(Server(HOST, PORT, password = PASSWORD), Profile(NICK, REAL_NAME, USER_NAME))
-            client.socketFactory = mockSocketFactory
-            client.eventHandler = mockEventHandler
-            client.eventHandler = null
-
-            launch {
-                readLineChannel.send(":the.gibson 001 acidBurn :Welcome to the IRC!".toByteArray())
-                readLineChannel.close()
-            }
-
-            client.connect()
-
-            verify(mockEventHandler, never()).processEvent(client, ServerWelcome(TestConstants.time, "acidBurn"))
+            verify(mockEventHandler).invoke(isA<ServerWelcome>())
         }
     }