Merge pull request #5 from k163377/feature

Add annotation that means "Use Non Null argument".

Author: k163377

build.gradle.kts

@@ -6,7 +6,7 @@ plugins {
 }
 
 group = "com.mapk"
-version = "0.3"
+version = "0.4"
 
 java {
     sourceCompatibility = JavaVersion.VERSION_1_8
@@ -30,25 +30,29 @@ repositories {
 dependencies {
     implementation("org.jetbrains.kotlin:kotlin-stdlib-jdk8")
     implementation(kotlin("reflect"))
+    api("com.github.ProjectMapK:Shared:0.8")
     // 使うのはRowMapperのみなため他はexclude、またバージョンそのものは使う相手に合わせるためcompileOnly
     compileOnly(group = "org.springframework", name = "spring-jdbc", version = "5.2.4.RELEASE") {
         exclude(module = "spring-beans")
         exclude(module = "spring-jcl")
         exclude(module = "spring-tx")
     }
-    api("com.github.ProjectMapK:Shared:0.7")
 
     // https://mvnrepository.com/artifact/org.junit.jupiter/junit-jupiter
     testImplementation(group = "org.junit.jupiter", name = "junit-jupiter", version = "5.6.0") {
         exclude(group = "org.junit.vintage", module = "junit-vintage-engine")
     }
     // https://mvnrepository.com/artifact/io.mockk/mockk
     testImplementation("io.mockk:mockk:1.9.3")
+
+    // テスト時には無いと困るため、別口でimplementation
+    testImplementation(group = "org.springframework", name = "spring-jdbc", version = "5.2.4.RELEASE")
+    // https://mvnrepository.com/artifact/com.h2database/h2
+    testImplementation(group = "com.h2database", name = "h2", version = "1.4.200")
+
     // 現状プロパティ名の変換はテストでしか使っていないのでtestImplementation
     // https://mvnrepository.com/artifact/com.google.guava/guava
     testImplementation(group = "com.google.guava", name = "guava", version = "28.2-jre")
-    // テスト時には無いと困るため、別口でimplementation
-    testImplementation(group = "org.springframework", name = "spring-jdbc", version = "5.2.4.RELEASE")
 }
 
 tasks {

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

@@ -17,32 +17,37 @@ import kotlin.reflect.jvm.jvmName
 
 class ParameterForMap private constructor(
     val param: KParameter,
-    private val name: String,
-    kClazz: KClass<*>
+    name: String,
+    parameterKClazz: KClass<*>
 ) {
-    private val javaClazz: Class<*> = kClazz.java
-    private val deserializer: KFunction<*>?
+    private val objectGetter: (ResultSet) -> Any?
 
     init {
-        val deserializers = deserializerFromConstructors(kClazz) +
-                deserializerFromStaticMethods(kClazz) +
-                deserializerFromCompanionObject(kClazz)
+        val deserializer = parameterKClazz.getDeserializer()
 
-        deserializer = when {
-            deserializers.isEmpty() -> null
-            deserializers.size == 1 -> deserializers.single()
-            else -> throw IllegalArgumentException("Find multiple deserializer from ${kClazz.jvmName}")
-        }
-    }
+        if (deserializer != null) {
+            val targetClass = deserializer.parameters.single().type.classifier as KClass<*>
 
-    fun getObject(rs: ResultSet): Any? = when {
-        javaClazz.isEnum -> EnumMapper.getEnum(javaClazz, rs.getString(name))
-        else -> {
-            val value: Any? = rs.getObject(name, javaClazz)
-            deserializer?.call(value) ?: value
+            objectGetter = {
+                deserializer.call(it.getObject(name, targetClass.javaObjectType))
+            }
+        } else {
+            val clazz = parameterKClazz.javaObjectType
+
+            objectGetter = if (clazz.isEnum) {
+                {
+                    EnumMapper.getEnum(clazz, it.getString(name))
+                }
+            } else {
+                {
+                    it.getObject(name, clazz)
+                }
+            }
         }
     }
 
+    fun getObject(rs: ResultSet): Any? = objectGetter(rs)
+
     companion object {
         fun newInstance(param: KParameter, propertyNameConverter: (String) -> String = { it }): ParameterForMap {
             return ParameterForMap(
@@ -54,6 +59,18 @@ class ParameterForMap private constructor(
     }
 }
 
+private fun <T : Any> KClass<T>.getDeserializer(): KFunction<T>? {
+    val deserializers = deserializerFromConstructors(this) +
+            deserializerFromStaticMethods(this) +
+            deserializerFromCompanionObject(this)
+
+    return when {
+        deserializers.isEmpty() -> null
+        deserializers.size == 1 -> deserializers.single()
+        else -> throw IllegalArgumentException("Find multiple deserializer from $jvmName")
+    }
+}
+
 private fun <T> Collection<KFunction<T>>.getDeserializerFromFunctions(): Collection<KFunction<T>> {
     return filter { it.annotations.any { annotation -> annotation is KColumnDeserializer } }
         .map { func ->

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

@@ -27,7 +27,7 @@ class DefaultValueTest {
         Assertions.assertEquals(1, result.fooId)
         Assertions.assertEquals("default", result.barValue)
 
-        verify(exactly = 1) { resultSet.getObject("foo_id", Int::class.java) }
+        verify(exactly = 1) { resultSet.getObject("foo_id", Integer::class.java) }
         verify(exactly = 0) { resultSet.getObject("bar_value", String::class.java) }
     }
 }

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

@@ -27,7 +27,7 @@ class SimpleMappingTest {
         assertEquals(1, result.fooId)
         assertEquals("str", result.strValue)
 
-        verify(exactly = 1) { resultSet.getObject("foo_id", Int::class.java) }
+        verify(exactly = 1) { resultSet.getObject("foo_id", Integer::class.java) }
         verify(exactly = 1) { resultSet.getObject("str_value", String::class.java) }
     }
 }

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

@@ -0,0 +1,88 @@
+package com.mapk.krowmapper
+
+import com.google.common.base.CaseFormat
+import javax.sql.DataSource
+import org.h2.jdbcx.JdbcDataSource
+import org.junit.jupiter.api.Assertions.assertEquals
+import org.junit.jupiter.api.BeforeAll
+import org.junit.jupiter.api.Test
+import org.junit.jupiter.api.TestInstance
+import org.springframework.jdbc.core.JdbcTemplate
+import org.springframework.jdbc.core.namedparam.BeanPropertySqlParameterSource
+import org.springframework.jdbc.core.simple.SimpleJdbcInsert
+
+@TestInstance(TestInstance.Lifecycle.PER_CLASS)
+class UseDBMappingTest {
+    enum class FooStatus {
+        active, archive, deleted
+    }
+
+    data class Foo(
+        val fooId: Int,
+        val fooName: String,
+        val fooStatus: FooStatus,
+        val isBar: Boolean,
+        val description: String?
+    ) {
+        companion object {
+            fun fooFactory(
+                fooId: Int,
+                fooName: String,
+                fooStatus: FooStatus,
+                isBar: String,
+                description: String?
+            ) = Foo(
+                fooId, fooName, fooStatus, isBar.toBoolean(), description
+            )
+        }
+    }
+
+    data class FooInsert(
+        val fooId: Int,
+        val fooName: String,
+        private val fooStatus: FooStatus,
+        private val isBar: Boolean,
+        val description: String?
+    ) {
+        fun getFooStatus(): String = fooStatus.name
+        fun getIsBar(): String = isBar.toString()
+    }
+
+    lateinit var jdbcTemplate: JdbcTemplate
+
+    @BeforeAll
+    fun beforeAll() {
+        val dataSource: DataSource = JdbcDataSource().apply {
+            setUrl("jdbc:h2:mem:testdb;DB_CLOSE_DELAY=-1;INIT=CREATE SCHEMA IF NOT EXISTS APP\\;SET SCHEMA APP;")
+        }
+
+        jdbcTemplate = JdbcTemplate(dataSource)
+
+        jdbcTemplate.execute("""
+            CREATE TABLE IF NOT EXISTS `foo_table` (
+              `foo_id` INT UNSIGNED NOT NULL AUTO_INCREMENT,
+              `foo_name` VARCHAR(255) NOT NULL,
+              `foo_status` ENUM('active', 'archive', 'deleted') NOT NULL,
+              `is_bar` ENUM('true', 'false') NOT NULL,
+              `description` VARCHAR(1023) NULL DEFAULT NULL,
+              PRIMARY KEY (`foo_id`)
+            );
+        """.trimIndent())
+
+        val data = FooInsert(10, "Foo", FooStatus.archive, false, null)
+
+        SimpleJdbcInsert(jdbcTemplate).withTableName("foo_table").execute(BeanPropertySqlParameterSource(data))
+    }
+
+    @Test
+    fun test() {
+        val result = jdbcTemplate.query("SELECT * FROM foo_table", KRowMapper((Foo)::fooFactory) {
+            CaseFormat.LOWER_CAMEL.to(CaseFormat.LOWER_UNDERSCORE, it)
+        }).single()
+
+        assertEquals(
+            Foo(10, "Foo", FooStatus.archive, false, null),
+            result
+        )
+    }
+}