Merge pull request #5 from rschluesselbauer/bug/GAIA-1691

Support conversion of arrays nested in maps

Author: alberto-ls1

src/main/kotlin/implicit/Implicit.kt

@@ -122,20 +122,33 @@ class Implicit(val namingStrategy: (TypeDescription) -> CharSequence) {
     fun <T> setMapValueInInstance(instance: T, method: Method, fieldValue: Any?) {
         if (fieldValue != null) {
             val clazz = method.parameterTypes[0]
-            if (isNestedImplicitObject(clazz, fieldValue))
-                invoke(instance, method, instantiateNestedObject(clazz, fieldValue as Map<*, *>))
-            else
-                invoke(instance, method, TypeConversion.convert(fieldValue, method.parameterTypes[0]))
+            val convertedFieldValue = when {
+                isNestedImplicitObject(clazz, fieldValue) -> instantiateNestedObject(clazz, fieldValue as Map<*, *>)
+                isNestedMap(clazz, fieldValue) -> convertCollectionsInMaps(fieldValue as Map<*, *>)
+                else -> TypeConversion.convert(fieldValue, method.parameterTypes[0])
+            }
+            invoke(instance, method, convertedFieldValue)
         } else {
             initializeField(instance, method, method.parameterTypes[0])
         }
     }
 
+    private fun convertCollectionsInMaps(map: Map<*, *>): Map<*, *> {
+        return map.mapValues {
+            val valueAsCollection = convertToCollection(it.value)
+            when {
+                valueAsCollection != null -> return@mapValues valueAsCollection
+                it.value is Map<*, *> -> return@mapValues convertCollectionsInMaps(it.value as Map<*, *>)
+                else -> return@mapValues it.value
+            }
+        }
+    }
+
     private fun <T> handleGenerics(type: Class<T>, method: Method, value: Any?): Any? {
         val valuesInACollection = convertToCollection(value)
-        if (valuesInACollection!=null) {
+        if (valuesInACollection != null) {
             val genericType = getGenericType(type, method)
-            if(genericType!=null){
+            if (genericType != null) {
                 if (method.parameterTypes.first().isAssignableFrom(List::class.java)) {
                     return instantiateGenericNestedObject(valuesInACollection, genericType).toList()
                 }
@@ -147,8 +160,8 @@ class Implicit(val namingStrategy: (TypeDescription) -> CharSequence) {
         return value
     }
 
-    private fun convertToCollection(value: Any?) :  Collection<*>?{
-        if(value!=null){
+    private fun convertToCollection(value: Any?): Collection<*>? {
+        if (value != null) {
             if (value is Collection<*>)
                 return value
             else if (value is Array<*>)
@@ -157,7 +170,7 @@ class Implicit(val namingStrategy: (TypeDescription) -> CharSequence) {
         return null
     }
 
-    private fun instantiateGenericNestedObject(value : Collection<*>, clazz: KClass<*>)  = value.stream().map { instantiateNestedObject(clazz.java, it as Map<*, *>) }
+    private fun instantiateGenericNestedObject(value: Collection<*>, clazz: KClass<*>) = value.stream().map { instantiateNestedObject(clazz.java, it as Map<*, *>) }
 
     private fun <T> getGenericType(type: Class<T>, method: Method): KClass<*>? {
         return type.declaredMethods
@@ -169,6 +182,7 @@ class Implicit(val namingStrategy: (TypeDescription) -> CharSequence) {
 
     fun getFieldNameFromSetterMethod(setter: Method): String = setter.name.substring(3).decapitalize()
     fun isNestedImplicitObject(objClass: Class<*>, fieldValue: Any?): Boolean = objClass.isInterface && objClass != Map::class.java && fieldValue is Map<*, *>
+    fun isNestedMap(objClass: Class<*>, fieldValue: Any?): Boolean = objClass == Map::class.java && fieldValue is Map<*, *>
     fun isSetter(method: Method): Boolean = method.name.startsWith("set")
     fun isGetter(method: Method): Boolean = method.name.startsWith("get") || method.name.startsWith("is")
     fun <T> instantiateNestedObject(clazz: Class<T>, map: Map<*, *>) = instantiate(clazz, map)

src/test/kotlin/implicit/ImplicitTest.kt

@@ -18,6 +18,7 @@ package implicit;
 
 import org.junit.jupiter.api.Assertions
 import org.junit.jupiter.api.Assertions.assertNotNull
+import org.junit.jupiter.api.Assertions.assertTrue
 import org.junit.jupiter.api.Test
 import java.util.*
 
@@ -63,6 +64,19 @@ class ImplicitTest {
         assertNotNull(pojo.getLabelSet())
     }
 
+    @Test
+    fun `map initialization with array as value of map`() {
+        val factory = Implicit { "implicit.test.implicit.${it.simpleName}" }
+        val function = factory.getFunction(IPojo::class.java)
+
+        val pojo = function.apply(mapOf("utterances" to mapOf("de" to arrayOf("hello", "world"))))
+
+        assertNotNull(pojo.getUtterances())
+        assertNotNull(pojo.getUtterances()["de"])
+        assert(pojo.getUtterances()["de"] is List)
+        assertTrue(pojo.getUtterances()["de"] == listOf("hello", "world"))
+    }
+
     @Test
     fun `map initialization with list and set input`() {
         val factory = Implicit { "implicit.test.implicit.${it.simpleName}" }
@@ -111,5 +125,9 @@ class ImplicitTest {
 
         fun getLabelSet(): Set<String?>
         fun setLabelSet(labelList: Set<String?>)
+
+        fun getUtterances(): Map<String?, List<String?>>
+        fun setUtterances(utterances : Map<String?, List<String?>>)
+
     }
 }