Merge pull request #14 from k163377/feature

Support for mapping to nested classes.

Author: k163377

build.gradle.kts

@@ -6,7 +6,7 @@ plugins {
 }
 
 group = "com.mapk"
-version = "0.9"
+version = "0.10"
 
 java {
     sourceCompatibility = JavaVersion.VERSION_1_8
@@ -30,7 +30,7 @@ repositories {
 dependencies {
     implementation("org.jetbrains.kotlin:kotlin-stdlib-jdk8")
     implementation(kotlin("reflect"))
-    api("com.github.ProjectMapK:Shared:0.11")
+    api("com.github.ProjectMapK:Shared:0.12")
     // 使うのはRowMapperのみなため他はexclude、またバージョンそのものは使う相手に合わせるためcompileOnly
     compileOnly(group = "org.springframework", name = "spring-jdbc", version = "5.2.4.RELEASE") {
         exclude(module = "spring-beans")

src/main/kotlin/com/mapk/krowmapper/KRowMapper.kt

@@ -1,37 +1,30 @@
 package com.mapk.krowmapper
 
 import com.mapk.core.KFunctionForCall
-import com.mapk.core.isUseDefaultArgument
 import com.mapk.core.toKConstructor
 import java.sql.ResultSet
 import kotlin.reflect.KClass
 import kotlin.reflect.KFunction
-import kotlin.reflect.KParameter
 import org.springframework.jdbc.core.RowMapper
 
 class KRowMapper<T : Any> private constructor(
-    private val function: KFunctionForCall<T>,
-    parameterNameConverter: (String) -> String
+    private val function: KFunctionForCall<T>
 ) : RowMapper<T> {
-    constructor(function: KFunction<T>, propertyNameConverter: (String) -> String = { it }) : this(
-        KFunctionForCall(function), propertyNameConverter
+    constructor(function: KFunction<T>, parameterNameConverter: (String) -> String = { it }) : this(
+        KFunctionForCall(function, parameterNameConverter)
     )
 
-    constructor(clazz: KClass<T>, propertyNameConverter: (String) -> String = { it }) : this(
-        clazz.toKConstructor(), propertyNameConverter
+    constructor(clazz: KClass<T>, parameterNameConverter: (String) -> String = { it }) : this(
+        clazz.toKConstructor(parameterNameConverter)
     )
 
-    private val parameters: List<ParameterForMap> = function.parameters
-        .filter { it.kind != KParameter.Kind.INSTANCE && !it.isUseDefaultArgument() }
-        .map { ParameterForMap.newInstance(it, parameterNameConverter) }
+    private val parameters: List<ParameterForMap> = function.requiredParameters.map { ParameterForMap.newInstance(it) }
 
     override fun mapRow(rs: ResultSet, rowNum: Int): T {
-        val argumentBucket = function.getArgumentBucket()
+        val adaptor = function.getArgumentAdaptor()
 
-        parameters.forEach { param ->
-            argumentBucket.putIfAbsent(param.param, param.getObject(rs))
-        }
+        parameters.forEach { adaptor.putIfAbsent(it.name, it.getObject(rs)) }
 
-        return function.call(argumentBucket)
+        return function.call(adaptor)
     }
 }

src/main/kotlin/com/mapk/krowmapper/ParameterForMap.kt

@@ -3,14 +3,13 @@ package com.mapk.krowmapper
 import com.mapk.annotations.KColumnDeserializer
 import com.mapk.core.EnumMapper
 import com.mapk.core.KFunctionWithInstance
-import com.mapk.core.getAliasOrName
+import com.mapk.core.ValueParameter
 import com.mapk.deserialization.AbstractKColumnDeserializer
 import com.mapk.deserialization.KColumnDeserializeBy
 import java.lang.IllegalArgumentException
 import java.sql.ResultSet
 import kotlin.reflect.KClass
 import kotlin.reflect.KFunction
-import kotlin.reflect.KParameter
 import kotlin.reflect.full.companionObjectInstance
 import kotlin.reflect.full.findAnnotation
 import kotlin.reflect.full.functions
@@ -20,78 +19,70 @@ import kotlin.reflect.jvm.isAccessible
 import kotlin.reflect.jvm.jvmName
 
 internal sealed class ParameterForMap {
-    abstract val param: KParameter
     abstract val name: String
     abstract val clazz: Class<*>
     abstract fun getObject(rs: ResultSet): Any?
 
     private class Plain(
-        override val param: KParameter,
         override val name: String,
         override val clazz: Class<*>
     ) : ParameterForMap() {
         override fun getObject(rs: ResultSet): Any? = rs.getObject(name, clazz)
     }
 
     private class Enum(
-        override val param: KParameter,
         override val name: String,
         override val clazz: Class<*>
     ) : ParameterForMap() {
         override fun getObject(rs: ResultSet): Any? = EnumMapper.getEnum(clazz, rs.getString(name))
     }
 
     private class Deserializer(
-        override val param: KParameter,
         override val name: String,
         override val clazz: Class<*>,
         private val deserializer: KFunction<*>
     ) : ParameterForMap() {
         constructor(
-            param: KParameter,
             name: String,
             deserializer: AbstractKColumnDeserializer<*, *, *>
-        ) : this(param, name, deserializer.srcClass, deserializer::deserialize)
+        ) : this(name, deserializer.srcClass, deserializer::deserialize)
 
         override fun getObject(rs: ResultSet): Any? = deserializer.call(rs.getObject(name, clazz))
     }
 
     companion object {
-        fun newInstance(param: KParameter, parameterNameConverter: (String) -> String): ParameterForMap {
-            val name = parameterNameConverter(param.getAliasOrName()!!)
-
+        fun <T : Any> newInstance(param: ValueParameter<T>): ParameterForMap {
             param.getDeserializer()?.let {
-                return Deserializer(param, name, it)
+                return Deserializer(param.name, it)
             }
 
-            val parameterKClazz = param.type.classifier as KClass<*>
-
-            parameterKClazz.getDeserializer()?.let {
+            param.requiredClazz.getDeserializer()?.let {
                 val targetClass = (it.parameters.single().type.classifier as KClass<*>).javaObjectType
-                return Deserializer(param, name, targetClass, it)
+                return Deserializer(param.name, targetClass, it)
             }
 
-            return parameterKClazz.javaObjectType.let {
+            return param.requiredClazz.javaObjectType.let {
                 when (it.isEnum) {
-                    true -> Enum(param, name, it)
-                    false -> Plain(param, name, it)
+                    true -> Enum(param.name, it)
+                    false -> Plain(param.name, it)
                 }
             }
         }
     }
 }
 
-private fun KParameter.getDeserializer(): AbstractKColumnDeserializer<*, *, *>? {
+@Suppress("UNCHECKED_CAST")
+private fun <T : Any> ValueParameter<T>.getDeserializer(): AbstractKColumnDeserializer<*, *, T>? {
     val deserializers = this.annotations.mapNotNull { paramAnnotation ->
         paramAnnotation.annotationClass
             .findAnnotation<KColumnDeserializeBy>()
             ?.let { it.deserializer.primaryConstructor!!.call(paramAnnotation) }
     }
 
     if (1 < deserializers.size)
-        throw IllegalArgumentException("Find multiple deserializer from ${(this.type.classifier as KClass<*>).jvmName}")
+        throw IllegalArgumentException("Find multiple deserializer from ${(this.requiredClazz).jvmName}")
 
-    return deserializers.singleOrNull()
+    return deserializers.singleOrNull() as AbstractKColumnDeserializer<*, *, T>?
 }
 
 private fun <T : Any> KClass<T>.getDeserializer(): KFunction<T>? {

src/test/kotlin/com/mapk/krowmapper/KParameterFlattenTest.kt

@@ -0,0 +1,43 @@
+package com.mapk.krowmapper
+
+import com.google.common.base.CaseFormat
+import com.mapk.annotations.KParameterFlatten
+import com.mapk.core.NameJoiner
+import io.mockk.every
+import io.mockk.mockk
+import io.mockk.verify
+import java.sql.ResultSet
+import java.time.LocalDateTime
+import org.junit.jupiter.api.Assertions.assertEquals
+import org.junit.jupiter.api.DisplayName
+import org.junit.jupiter.api.Test
+
+@DisplayName("KParameterFlattenテスト")
+class KParameterFlattenTest {
+    data class InnerDst(val fooFoo: Int, val barBar: String)
+    data class Dst(
+        @KParameterFlatten(nameJoiner = NameJoiner.Snake::class) val bazBaz: InnerDst,
+        val quxQux: LocalDateTime
+    )
+
+    private fun camelToSnake(camel: String): String = CaseFormat.LOWER_CAMEL.to(CaseFormat.LOWER_UNDERSCORE, camel)
+
+    private val expected = Dst(InnerDst(1, "str"), LocalDateTime.MIN)
+
+    @Test
+    @DisplayName("スネークケースsrc -> キャメルケースdst")
+    fun test() {
+        val resultSet = mockk<ResultSet>() {
+            every { getObject("baz_baz_foo_foo", any<Class<*>>()) } returns 1
+            every { getObject("baz_baz_bar_bar", any<Class<*>>()) } returns "str"
+            every { getObject("qux_qux", any<Class<*>>()) } returns LocalDateTime.MIN
+        }
+
+        val result = KRowMapper(::Dst, this::camelToSnake).mapRow(resultSet, 0)
+        assertEquals(expected, result)
+
+        verify(exactly = 1) { resultSet.getObject("baz_baz_foo_foo", Integer::class.java) }
+        verify(exactly = 1) { resultSet.getObject("baz_baz_bar_bar", String::class.java) }
+        verify(exactly = 1) { resultSet.getObject("qux_qux", LocalDateTime::class.java) }
+    }
+}