Store channel modes a bit nicer.

Groundwork for #5

CHANGELOG

  * Improved some documentation
  * Added ServerConnecting and ServerDisconnected events
  * Server status now starts as Disconnected rather than Connecting
+ * CHANMODES feature is now stored as an array, not a single comma-separated string
+ * Improved error message when features are of an unexpected type
 
 v0.4.0
 

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

             String::class -> this
             CaseMapping::class -> CaseMapping.fromName(this)
             ModePrefixMapping::class -> indexOf(')').let { ModePrefixMapping(substring(1 until it), substring(it + 1)) }
+            Array<String>::class -> split(',').toTypedArray()
             else -> TODO("not implemented")
         }
     }

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

     operator fun <T : Any> get(feature: ServerFeature<T>) = features.getOrDefault(feature, feature.default) as? T? ?: feature.default
 
     internal operator fun set(feature: ServerFeature<*>, value: Any) {
-        require(feature.type.isInstance(value))
+        require(feature.type.isInstance(value)) {
+            "Value given for feature ${feature::class} must be type ${feature.type} but was ${value::class}"
+        }
+
         features[feature] = value
     }
 
     /** The maximum number of channels a client may join. */
     object MaximumChannels : ServerFeature<Int>("MAXCHANNELS", Int::class) // TODO: CHANLIMIT also exists
     /** The modes supported in channels. */
-    object ChannelModes : ServerFeature<String>("CHANMODES", String::class)
+    object ChannelModes : ServerFeature<Array<String>>("CHANMODES", Array<String>::class)
     /** The maximum length of a channel name, defaulting to 200. */
     object MaximumChannelNameLength : ServerFeature<Int>("CHANNELLEN", Int::class, 200)
     /** Whether or not the server supports extended who. */

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

 import com.nhaarman.mockitokotlin2.doReturn
 import com.nhaarman.mockitokotlin2.mock
 import kotlinx.coroutines.runBlocking
-import org.junit.jupiter.api.Assertions.assertEquals
-import org.junit.jupiter.api.Assertions.assertTrue
+import org.junit.jupiter.api.Assertions.*
 import org.junit.jupiter.api.Test
 
 internal class ServerStateHandlerTest {
     @Test
     fun `ServerStateHandler updates features on features event`() = runBlocking {
         val features = ServerFeatureMap()
-        features[ServerFeature.ChannelModes] = "abc"
+        features[ServerFeature.ChannelModes] = arrayOf("abc", "def")
         features[ServerFeature.WhoxSupport] = true
 
         handler.processEvent(ircClient, ServerFeaturesUpdated(TestConstants.time, features))
 
-        assertEquals("abc", serverState.features[ServerFeature.ChannelModes])
+        assertArrayEquals(arrayOf("abc", "def"), serverState.features[ServerFeature.ChannelModes])
         assertEquals(true, serverState.features[ServerFeature.WhoxSupport])
     }
 

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

     @Test
     fun `ISupportProcessor handles string arguments`() {
         val events = processor.process(IrcMessage(emptyMap(), "server.com".toByteArray(), "005",
-                listOf("nickname", "CHANMODES=abcd", "are supported blah blah").map { it.toByteArray() }))
+                listOf("nickname", "NETWORK=abcd", "are supported blah blah").map { it.toByteArray() }))
 
-        assertEquals("abcd", events[0].serverFeatures[ServerFeature.ChannelModes])
+        assertEquals("abcd", events[0].serverFeatures[ServerFeature.Network])
+    }
+
+    @Test
+    fun `ISupportProcessor handles string array arguments`() {
+        val events = processor.process(IrcMessage(emptyMap(), "server.com".toByteArray(), "005",
+                listOf("nickname", "CHANMODES=abcd,efg,,hij", "are supported blah blah").map { it.toByteArray() }))
+
+        val modes = events[0].serverFeatures[ServerFeature.ChannelModes]!!
+        assertEquals("abcd", modes[0])
+        assertEquals("efg", modes[1])
+        assertEquals("", modes[2])
+        assertEquals("hij", modes[3])
     }
 
     @Test
                 listOf("nickname", "-CHANMODES", "are supported blah blah").map { it.toByteArray() }))
 
         val oldFeatures = ServerFeatureMap()
-        oldFeatures[ServerFeature.ChannelModes] = "abc"
+        oldFeatures[ServerFeature.ChannelModes] = arrayOf("abc")
         oldFeatures.setAll(events[0].serverFeatures)
         assertNull(oldFeatures[ServerFeature.ChannelModes])
     }

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

         val featureMap1 = ServerFeatureMap()
         val featureMap2 = ServerFeatureMap()
         featureMap2[ServerFeature.WhoxSupport] = true
-        featureMap2[ServerFeature.ChannelModes] = "abc"
+        featureMap2[ServerFeature.ChannelModes] = arrayOf("abc", "def")
         featureMap1.setAll(featureMap2)
 
         assertEquals(true, featureMap1[ServerFeature.WhoxSupport])
-        assertEquals("abc", featureMap1[ServerFeature.ChannelModes])
+        assertArrayEquals(arrayOf("abc", "def"), featureMap1[ServerFeature.ChannelModes])
     }