Support "custom types"

[config4k]

Support "custom types"

[jbunting]

And for reference, this is the sort of thing that I'm wanting to implement. I make some very opinionated decisions in this code and wouldn't really see fit to put it into the library:

package com.example.extensibleConfig

import com.typesafe.config.Config
import com.typesafe.config.ConfigFactory
import com.typesafe.config.ConfigValue
import io.github.config4k.ClassContainer
import io.github.config4k.CustomType
import io.github.config4k.readers.SelectReader
import io.github.config4k.toConfig
import javax.inject.Named
import kotlin.reflect.KClass
import kotlin.reflect.full.findAnnotation
import kotlin.reflect.full.isSubclassOf
import kotlin.reflect.full.memberProperties
import kotlin.reflect.full.primaryConstructor

class SubclassingType<T: Any>(private val parentType: KClass<T>): CustomType {
    private val mappedTypes: Map<String, KClass<*>>
    init {
        val mutableMap = mutableMapOf<String, KClass<*>>()

        parentType.nestedClasses
                .filter { nc -> nc.isSubclassOf(parentType) }
                .forEach { nc ->
                    val typeName = nc.findAnnotation<Named>()?.value ?: throw IllegalStateException("Config Subtype must have @Named annotation.")
                    mutableMap.put(typeName, nc)
                }

        mappedTypes = mutableMap
    }

    override fun parse(clazz: ClassContainer, config: Config, name: String): Any? {
        val type = config.getConfig(name).getString("type")
        val kType = mappedTypes.get(type) ?: throw IllegalArgumentException("'$type' is not an allowable type for $name")

        val reader = SelectReader.getReader(ClassContainer(kType)) ?: throw IllegalStateException("Could not select reader for type $kType")
        return reader.invoke(config, name)
    }

    override fun testParse(clazz: ClassContainer): Boolean {
        return clazz.mapperClass == parentType
    }

    private fun findMappedType(obj: Any): Pair<String, KClass<*>>? {
        return mappedTypes.entries.filter { (_, v) -> v.isInstance(obj) }.singleOrNull()?.toPair()
    }

    override fun testToConfig(obj: Any): Boolean {
        return findMappedType(obj) != null
    }

    override fun toConfig(obj: Any, name: String): Config {
        val (typeName, cl) = findMappedType(obj) ?: throw IllegalStateException("toConfig should not be called if testToConfig is false")

        return ConfigFactory.parseMap(getConfigMap(obj, typeName, cl as KClass<Any>))

    }

    private fun Any.toConfigValue(): ConfigValue {
        val name = "dummy"
        return this.toConfig(name).root()[name]!!
    }

    private fun getConfigMap(receiver: Any, typeName: String,
                              clazz: KClass<Any>): Map<String, *> =
            clazz.primaryConstructor!!.parameters.mapNotNull {
                val parameterName = it.name!!
                clazz.memberProperties
                        .find { it.name == parameterName }!!
                        .get(receiver)
                        ?.let {parameterValue  ->
                            parameterName to parameterValue.toConfigValue()
                        }

            }.toMap().plus("type" to typeName)
}

[mmorihiro]

I agree that adding the ability to register custom types is useful. So, could you give an example(like test snippet) in order to make the design clearer?

[jbunting]

I added a pull request with the idea plus a test case. It is simple static registration which I felt went with the existing pattern of the library. However things like dynamic registration or local registration might be useful as well. I'm not crazy about the "static state" thing.