Add BoundKMapper.

build.gradle.kts

@@ -6,7 +6,7 @@ plugins {
 }
 
 group = "com.mapk"
-version = "0.19"
+version = "0.20"
 
 java {
     sourceCompatibility = JavaVersion.VERSION_1_8

src/main/kotlin/com/mapk/kmapper/BoundKMapper.kt

@@ -0,0 +1,69 @@
+package com.mapk.kmapper
+
+import com.mapk.annotations.KGetterAlias
+import com.mapk.annotations.KGetterIgnore
+import com.mapk.core.ArgumentBucket
+import com.mapk.core.KFunctionForCall
+import com.mapk.core.getAliasOrName
+import com.mapk.core.isUseDefaultArgument
+import com.mapk.core.toKConstructor
+import java.lang.IllegalArgumentException
+import kotlin.reflect.KClass
+import kotlin.reflect.KFunction
+import kotlin.reflect.KParameter
+import kotlin.reflect.KProperty1
+import kotlin.reflect.KVisibility
+import kotlin.reflect.full.findAnnotation
+import kotlin.reflect.full.memberProperties
+import kotlin.reflect.jvm.jvmName
+
+class BoundKMapper<S : Any, D : Any> private constructor(
+    private val function: KFunctionForCall<D>,
+    src: KClass<S>,
+    parameterNameConverter: (String) -> String = { it }
+) {
+    constructor(function: KFunction<D>, src: KClass<S>, parameterNameConverter: (String) -> String = { it }) : this(
+        KFunctionForCall(function), src, parameterNameConverter
+    )
+
+    constructor(clazz: KClass<D>, src: KClass<S>, parameterNameConverter: (String) -> String = { it }) : this(
+        clazz.toKConstructor(), src, parameterNameConverter
+    )
+
+    private val parameters: List<BoundParameterForMap<S>>
+
+    init {
+        val srcPropertiesMap: Map<String, KProperty1<S, *>> =
+            src.memberProperties
+                .filter {
+                    // アクセス可能かつignoreされてないもののみ抽出
+                    !(it.visibility != KVisibility.PUBLIC) &&
+                            it.getter.annotations.none { annotation -> annotation is KGetterIgnore }
+                }.associateBy { it.getter.findAnnotation<KGetterAlias>()?.value ?: it.name }
+
+        parameters = function.parameters
+            .filter { it.kind != KParameter.Kind.INSTANCE && !it.isUseDefaultArgument() }
+            .mapNotNull {
+                val temp = srcPropertiesMap[parameterNameConverter(it.getAliasOrName()!!)]?.let { property ->
+                    BoundParameterForMap(it, property)
+                }
+
+                // 必須引数に対応するプロパティがsrcに定義されていない場合エラー
+                if (temp == null && !it.isOptional) {
+                    throw IllegalArgumentException("Property ${it.name!!} is not declared in ${src.jvmName}.")
+                }
+
+                temp
+            }
+    }
+
+    fun map(src: S): D {
+        val bucket: ArgumentBucket = function.getArgumentBucket()
+
+        parameters.forEach {
+            bucket.putIfAbsent(it.param, it.map(src))
+        }
+
+        return function.call(bucket)
+    }
+}

src/main/kotlin/com/mapk/kmapper/BoundParameterForMap.kt

@@ -0,0 +1,44 @@
+package com.mapk.kmapper
+
+import com.mapk.core.EnumMapper
+import java.lang.IllegalArgumentException
+import kotlin.reflect.KClass
+import kotlin.reflect.KParameter
+import kotlin.reflect.KProperty1
+import kotlin.reflect.full.isSubclassOf
+import kotlin.reflect.jvm.javaGetter
+
+@Suppress("UNCHECKED_CAST")
+internal class BoundParameterForMap<S : Any>(val param: KParameter, property: KProperty1<S, *>) {
+    val map: (S) -> Any?
+
+    init {
+        // ゲッターが無いならエラー
+        val propertyGetter = property.javaGetter
+            ?: throw IllegalArgumentException("${property.name} does not have getter.")
+        propertyGetter.isAccessible = true
+
+        val paramClazz = param.type.classifier as KClass<*>
+        val propertyClazz = property.returnType.classifier as KClass<*>
+
+        val converter = (convertersFromConstructors(paramClazz) +
+                convertersFromStaticMethods(paramClazz) +
+                convertersFromCompanionObject(paramClazz))
+            .filter { (key, _) -> propertyClazz.isSubclassOf(key) }
+            .let {
+                if (1 < it.size) throw IllegalArgumentException("${param.name} has multiple converter. $it")
+
+                it.singleOrNull()?.second
+            }
+
+        map = when {
+            converter != null -> { { converter.call(propertyGetter.invoke(it)) } }
+            paramClazz.isSubclassOf(propertyClazz) -> { { propertyGetter.invoke(it) } }
+            paramClazz.java.isEnum && propertyClazz == String::class -> { {
+                EnumMapper.getEnum(paramClazz.java, propertyGetter.invoke(it) as String)
+            } }
+            paramClazz == String::class -> { { propertyGetter.invoke(it).toString() } }
+            else -> throw IllegalArgumentException("Can not convert $propertyClazz to $paramClazz")
+        }
+    }
+}

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

@@ -1,15 +1,9 @@
 package com.mapk.kmapper
 
-import com.mapk.annotations.KConverter
-import com.mapk.core.KFunctionWithInstance
 import kotlin.reflect.KClass
 import kotlin.reflect.KFunction
 import kotlin.reflect.KParameter
-import kotlin.reflect.full.companionObjectInstance
-import kotlin.reflect.full.functions
 import kotlin.reflect.full.isSubclassOf
-import kotlin.reflect.full.staticFunctions
-import kotlin.reflect.jvm.isAccessible
 
 internal class ParameterForMap<T : Any> private constructor(val param: KParameter, val clazz: KClass<T>) {
     val javaClazz: Class<T> by lazy {
@@ -30,39 +24,3 @@ internal class ParameterForMap<T : Any> private constructor(val param: KParamete
         }
     }
 }
-
-private fun <T> Collection<KFunction<T>>.getConverterMapFromFunctions(): Set<Pair<KClass<*>, KFunction<T>>> {
-    return filter { it.annotations.any { annotation -> annotation is KConverter } }
-        .map { func ->
-            func.isAccessible = true
-
-            (func.parameters.single().type.classifier as KClass<*>) to func
-        }.toSet()
-}
-
-private fun <T : Any> convertersFromConstructors(clazz: KClass<T>): Set<Pair<KClass<*>, KFunction<T>>> {
-    return clazz.constructors.getConverterMapFromFunctions()
-}
-
-@Suppress("UNCHECKED_CAST")
-private fun <T : Any> convertersFromStaticMethods(clazz: KClass<T>): Set<Pair<KClass<*>, KFunction<T>>> {
-    val staticFunctions: Collection<KFunction<T>> = clazz.staticFunctions as Collection<KFunction<T>>
-
-    return staticFunctions.getConverterMapFromFunctions()
-}
-
-@Suppress("UNCHECKED_CAST")
-private fun <T : Any> convertersFromCompanionObject(clazz: KClass<T>): Set<Pair<KClass<*>, KFunction<T>>> {
-    return clazz.companionObjectInstance?.let { companionObject ->
-        companionObject::class.functions
-            .filter { it.annotations.any { annotation -> annotation is KConverter } }
-            .map { function ->
-                val func: KFunction<T> = KFunctionWithInstance(
-                    function,
-                    companionObject
-                ) as KFunction<T>
-
-                (func.parameters.single().type.classifier as KClass<*>) to func
-            }.toSet()
-    } ?: emptySet()
-}

src/main/kotlin/com/mapk/kmapper/ParameterUtils.kt

@@ -0,0 +1,46 @@
+package com.mapk.kmapper
+
+import com.mapk.annotations.KConverter
+import com.mapk.core.KFunctionWithInstance
+import kotlin.reflect.KClass
+import kotlin.reflect.KFunction
+import kotlin.reflect.full.companionObjectInstance
+import kotlin.reflect.full.functions
+import kotlin.reflect.full.staticFunctions
+import kotlin.reflect.jvm.isAccessible
+
+internal fun <T> Collection<KFunction<T>>.getConverterMapFromFunctions(): Set<Pair<KClass<*>, KFunction<T>>> {
+    return filter { it.annotations.any { annotation -> annotation is KConverter } }
+        .map { func ->
+            func.isAccessible = true
+
+            (func.parameters.single().type.classifier as KClass<*>) to func
+        }.toSet()
+}
+
+internal fun <T : Any> convertersFromConstructors(clazz: KClass<T>): Set<Pair<KClass<*>, KFunction<T>>> {
+    return clazz.constructors.getConverterMapFromFunctions()
+}
+
+@Suppress("UNCHECKED_CAST")
+internal fun <T : Any> convertersFromStaticMethods(clazz: KClass<T>): Set<Pair<KClass<*>, KFunction<T>>> {
+    val staticFunctions: Collection<KFunction<T>> = clazz.staticFunctions as Collection<KFunction<T>>
+
+    return staticFunctions.getConverterMapFromFunctions()
+}
+
+@Suppress("UNCHECKED_CAST")
+internal fun <T : Any> convertersFromCompanionObject(clazz: KClass<T>): Set<Pair<KClass<*>, KFunction<T>>> {
+    return clazz.companionObjectInstance?.let { companionObject ->
+        companionObject::class.functions
+            .filter { it.annotations.any { annotation -> annotation is KConverter } }
+            .map { function ->
+                val func: KFunction<T> = KFunctionWithInstance(
+                    function,
+                    companionObject
+                ) as KFunction<T>
+
+                (func.parameters.single().type.classifier as KClass<*>) to func
+            }.toSet()
+    } ?: emptySet()
+}

src/test/kotlin/com/mapk/kmapper/ConverterKMapperTest.kt

@@ -25,6 +25,10 @@ class CompanionConverter private constructor(val arg: String) {
 
 private data class StaticMethodConverterDst(val argument: StaticMethodConverter)
 
+private data class BoundConstructorConverterSrc(val argument: Int)
+private data class BoundCompanionConverterSrc(val argument: String)
+private data class BoundStaticMethodConverterSrc(val argument: String)
+
 @DisplayName("コンバータ有りでのマッピングテスト")
 class ConverterKMapperTest {
     @Nested
@@ -57,4 +61,35 @@ class ConverterKMapperTest {
             assertTrue(intArrayOf(1, 2, 3) contentEquals result.argument.arg)
         }
     }
+
+    @Nested
+    @DisplayName("BoundKMapper")
+    inner class BoundKMapperTest {
+        @Test
+        @DisplayName("コンストラクターでのコンバートテスト")
+        fun constructorConverterTest() {
+            val mapper = BoundKMapper(::ConstructorConverterDst, BoundConstructorConverterSrc::class)
+            val result = mapper.map(BoundConstructorConverterSrc(1))
+
+            assertEquals(ConstructorConverter(1), result.argument)
+        }
+
+        @Test
+        @DisplayName("コンパニオンオブジェクトに定義したコンバータでのコンバートテスト")
+        fun companionConverterTest() {
+            val mapper = BoundKMapper(::CompanionConverterDst, BoundCompanionConverterSrc::class)
+            val result = mapper.map(BoundCompanionConverterSrc("arg"))
+
+            assertEquals("arg", result.argument.arg)
+        }
+
+        @Test
+        @DisplayName("スタティックメソッドに定義したコンバータでのコンバートテスト")
+        fun staticMethodConverterTest() {
+            val mapper = BoundKMapper(::StaticMethodConverterDst, BoundStaticMethodConverterSrc::class)
+            val result = mapper.map(BoundStaticMethodConverterSrc("1,2,3"))
+
+            assertTrue(intArrayOf(1, 2, 3) contentEquals result.argument.arg)
+        }
+    }
 }

src/test/kotlin/com/mapk/kmapper/DefaultArgumentTest.kt

@@ -11,15 +11,25 @@ class DefaultArgumentTest {
     data class Dst(val fooArgument: Int, @param:KUseDefaultArgument val barArgument: String = "default")
     data class Src(val fooArgument: Int, val barArgument: String)
 
+    private val src = Src(1, "src")
+
     @Nested
     @DisplayName("KMapper")
     inner class KMapperTest {
         @Test
         fun test() {
-            val src = Src(1, "src")
-
             val result = KMapper(::Dst).map(src)
             assertEquals(Dst(1, "default"), result)
         }
     }
+
+    @Nested
+    @DisplayName("BoundKMapper")
+    inner class BoundKMapperTest {
+        @Test
+        fun test() {
+            val result = BoundKMapper(::Dst, Src::class).map(src)
+            assertEquals(Dst(1, "default"), result)
+        }
+    }
 }

src/test/kotlin/com/mapk/kmapper/EnumMappingTest.kt

@@ -29,4 +29,20 @@ class EnumMappingTest {
             assertEquals(language, result.language)
         }
     }
+
+    data class BoundSrc(val language: String)
+
+    @Nested
+    @DisplayName("BoundKMapper")
+    inner class BoundKMapperTest {
+        private val mapper = BoundKMapper(::EnumMappingDst, BoundSrc::class)
+
+        @ParameterizedTest(name = "Non-Null要求")
+        @EnumSource(value = JvmLanguage::class)
+        fun test(language: JvmLanguage) {
+            val result = mapper.map(BoundSrc(language.name))
+
+            assertEquals(language, result.language)
+        }
+    }
 }

src/test/kotlin/com/mapk/kmapper/KGetterIgnoreTest.kt

@@ -31,4 +31,21 @@ class KGetterIgnoreTest {
             assertEquals(Dst(1, "2-1", 32, "4"), dst1)
         }
     }
+
+    data class BoundSrc(val arg1: Int, val arg2: Short, @get:KGetterIgnore val arg3: String)
+    data class BoundDst(val arg1: Int, val arg2: Short, val arg3: String = "default")
+
+    @Nested
+    @DisplayName("BoundKMapper")
+    inner class BoundKMapperTest {
+        @Test
+        @DisplayName("フィールドを無視するテスト")
+        fun test() {
+            val mapper = BoundKMapper(::BoundDst, BoundSrc::class)
+
+            val result = mapper.map(BoundSrc(1, 2, "arg3"))
+
+            assertEquals(BoundDst(1, 2, "default"), result)
+        }
+    }
 }

src/test/kotlin/com/mapk/kmapper/ParameterNameConverterTest.kt

@@ -6,7 +6,8 @@ import org.junit.jupiter.api.DisplayName
 import org.junit.jupiter.api.Nested
 import org.junit.jupiter.api.Test
 
-private class CamelCaseDst(val camelCase: String)
+private data class CamelCaseDst(val camelCase: String)
+private data class BoundSrc(val camel_case: String)
 
 @DisplayName("パラメータ名変換のテスト")
 class ParameterNameConverterTest {
@@ -20,14 +21,27 @@ class ParameterNameConverterTest {
             val src = mapOf("camel_case" to expected)
 
             val mapper = KMapper(CamelCaseDst::class) {
-                CaseFormat.LOWER_CAMEL.to(
-                    CaseFormat.LOWER_UNDERSCORE,
-                    it
-                )
+                CaseFormat.LOWER_CAMEL.to(CaseFormat.LOWER_UNDERSCORE, it)
             }
             val result = mapper.map(src)
 
             assertEquals(expected, result.camelCase)
         }
     }
+
+    @Nested
+    @DisplayName("BoundKMapper")
+    inner class BoundKMapperTest {
+        @Test
+        @DisplayName("スネークケースsrc -> キャメルケースdst")
+        fun test() {
+
+            val mapper = BoundKMapper(::CamelCaseDst, BoundSrc::class) {
+                CaseFormat.LOWER_CAMEL.to(CaseFormat.LOWER_UNDERSCORE, it)
+            }
+            val result = mapper.map(BoundSrc("snakeCase"))
+
+            assertEquals(CamelCaseDst("snakeCase"), result)
+        }
+    }
 }