generified, built and cleaned deep object builders

Author: Wicpar

build.gradle

@@ -18,13 +18,6 @@ dependencies {
     implementation "io.ktor:ktor-metrics:$ktor_version"
     implementation "io.ktor:ktor-server-sessions:$ktor_version"
 
-    // needed for oauth interop
-    implementation "io.ktor:ktor-auth:$ktor_version" 
-    implementation "io.ktor:ktor-client-core:$ktor_version"
-    implementation "io.ktor:ktor-client-core-jvm:$ktor_version"
-    implementation "io.ktor:ktor-client-apache:$ktor_version"
-    // ------------------------
-    
     implementation "io.ktor:ktor-jackson:$ktor_version" // needed for parameter parsing and multipart parsing
     implementation "com.fasterxml.jackson.datatype:jackson-datatype-jsr310:2.9.8" // needed for multipart parsing
     implementation 'org.webjars:swagger-ui:3.18.2'
@@ -37,10 +30,10 @@ dependencies {
 }
 
 compileKotlin {
-    kotlinOptions.jvmTarget = "1.8"
+    kotlinOptions.jvmTarget = "1.6"
 }
 compileTestKotlin {
-    kotlinOptions.jvmTarget = "1.8"
+    kotlinOptions.jvmTarget = "1.6"
 }
 
 wrapper {

gradle/wrapper/gradle-wrapper.properties

@@ -1,5 +1,6 @@
+#Mon Mar 02 14:17:20 CET 2020
+distributionUrl=https\://services.gradle.org/distributions/gradle-6.0.1-all.zip
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-6.0.1-bin.zip
-zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists
+zipStoreBase=GRADLE_USER_HOME

src/main/kotlin/com/papsign/ktor/openapigen/openapi/OpenAPIModels.kt

@@ -17,7 +17,7 @@ data class Parameter<T>(
     var schema: Schema<T>? = null,
     var example: T? = null,
     var examples: MutableMap<String, T>? = null,
-    var style: ParameterStyle? = null,
+    var style: ParameterStyle<*>? = null,
     var explode: Boolean = false
     // incomplete
 )

src/main/kotlin/com/papsign/ktor/openapigen/parameters/ParameterStyle.kt

@@ -1,5 +1,7 @@
 package com.papsign.ktor.openapigen.parameters
 
-interface ParameterStyle {
+import com.papsign.ktor.openapigen.parameters.parsers.generic.BuilderFactory
+
+interface ParameterStyle<S> where S: ParameterStyle<S>, S: Enum<S> {
     val name: String
 }

src/main/kotlin/com/papsign/ktor/openapigen/parameters/PathParamStyle.kt

@@ -1,5 +1,6 @@
 package com.papsign.ktor.openapigen.parameters
 
-enum class PathParamStyle: ParameterStyle {
+
+enum class PathParamStyle: ParameterStyle<PathParamStyle> {
     DEFAULT, simple, label, matrix
 }

src/main/kotlin/com/papsign/ktor/openapigen/parameters/QueryParamStyle.kt

@@ -1,5 +1,5 @@
 package com.papsign.ktor.openapigen.parameters
 
-enum class QueryParamStyle: ParameterStyle {
+enum class QueryParamStyle: ParameterStyle<QueryParamStyle> {
     DEFAULT, form, spaceDelimited, pipeDelimited, deepObject
 }

src/main/kotlin/com/papsign/ktor/openapigen/parameters/parsers/ObjectParameterParser.kt

@@ -1,11 +1,12 @@
 package com.papsign.ktor.openapigen.parameters.parsers
 
 import com.papsign.ktor.openapigen.parameters.QueryParamStyle
-import com.papsign.ktor.openapigen.parameters.parsers.deepobject.DeepBuilder.Companion.getBuilderForType
+import com.papsign.ktor.openapigen.parameters.parsers.deepobject.DeepBuilder
+import com.papsign.ktor.openapigen.parameters.parsers.deepobject.DeepBuilderFactory
 import com.papsign.ktor.openapigen.parameters.util.ParameterInfo
 import io.ktor.http.Parameters
+import io.ktor.util.toMap
 import kotlin.reflect.KType
-import kotlin.reflect.jvm.jvmErasure
 
 class ObjectParameterParser(info: ParameterInfo, type: KType) : InfoParameterParser(info, {
     when (it) {
@@ -15,28 +16,18 @@ class ObjectParameterParser(info: ParameterInfo, type: KType) : InfoParameterPar
     }
 }) {
 
-    private val cvt: (Parameters) -> Any?
-
-    init {
-        val kclass = type.jvmErasure
-        if (kclass.isData) {
-            cvt = when (queryStyle) {
-                QueryParamStyle.deepObject -> {
-                    val builder = getBuilderForType(type)
-                    ({ builder.build(key, it) })
-                }
+    private val cvt: (Parameters) -> Any? = when (queryStyle) {
+        QueryParamStyle.deepObject -> {
+            val builder = DeepBuilderFactory.buildBuilder(type, true)
+            ({ builder?.build(key, it.toMap()) })
+        }
 //                QueryParamStyle.form -> {
 //
 //                }
-                null -> error("Only query params can hold objects")
-                else -> error("Query param style $queryStyle is not supported")
-            }
-        } else {
-            error("Only data classes are currently supported as parameter objects")
-        }
+        null -> error("Only query params can hold objects")
+        else -> error("Query param style $queryStyle is not supported")
     }
 
-
     override fun parse(parameters: Parameters): Any? {
         return cvt(parameters)
     }

src/main/kotlin/com/papsign/ktor/openapigen/parameters/parsers/deepobject/ArrayBuilder.kt

@@ -0,0 +1,58 @@
+package com.papsign.ktor.openapigen.parameters.parsers.deepobject
+
+import com.papsign.kotlin.reflection.toKType
+import com.papsign.ktor.openapigen.parameters.parsers.generic.BuilderSelector
+import com.papsign.ktor.openapigen.parameters.util.primCVT
+import kotlin.reflect.KType
+import kotlin.reflect.jvm.jvmErasure
+
+class ArrayBuilder(val type: KType) : CollectionBuilder() {
+    private val componentType = type.jvmErasure.java.componentType
+    override val contentType = componentType.toKType()
+
+    override val builder by lazy { // must be lazy or it will recurse infinitely
+        DeepBuilderFactory.buildBuilderForced(contentType, exploded)
+    }
+
+    private fun cvt(list: List<Any?>): Any? {
+        val arr = java.lang.reflect.Array.newInstance(componentType, list.size)
+        list.forEachIndexed { index, elem ->
+            java.lang.reflect.Array.set(arr, index, elem)
+        }
+        return arr
+    }
+
+    override fun build(key: String, parameters: Map<String, List<String>>): Any? {
+        return cvt(super.build(key, parameters) as List<Any?>)
+    }
+
+    companion object : BuilderSelector<ArrayBuilder> {
+
+        private val primCVT = mapOf(
+            primCVT<Long> { it.toLongArray() },
+            primCVT<Int> { it.toIntArray() },
+            primCVT<Float> { it.toFloatArray() },
+            primCVT<Double> { it.toDoubleArray() },
+            primCVT<Boolean> { it.toBooleanArray() }
+        )
+
+        /**
+         * you may think it is redundant but it is not. Maybe the nullable types are useless though.
+         */
+        private val arrCVT = mapOf(
+            primCVT<Long> { it.toTypedArray() },
+            primCVT<Int> { it.toTypedArray() },
+            primCVT<Float> { it.toTypedArray() },
+            primCVT<Double> { it.toTypedArray() },
+            primCVT<Boolean> { it.toTypedArray() }
+        )
+
+        override fun canHandle(type: KType): Boolean {
+            return type.jvmErasure.java.isArray
+        }
+
+        override fun create(type: KType, exploded: Boolean): ArrayBuilder {
+            return ArrayBuilder(type)
+        }
+    }
+}

src/main/kotlin/com/papsign/ktor/openapigen/parameters/parsers/deepobject/CollectionBuilder.kt

@@ -0,0 +1,22 @@
+package com.papsign.ktor.openapigen.parameters.parsers.deepobject
+
+import kotlin.reflect.KType
+
+abstract class CollectionBuilder: DeepBuilder() {
+
+    protected abstract val contentType: KType
+    protected abstract val builder: DeepBuilder
+
+    override fun build(key: String, parameters: Map<String, List<String>>): Any? {
+        val names = parameters.filterKeys { it != key && it.startsWith(key) }
+        if (names.isEmpty()) { return listOf<Any?>() }
+        val indices =
+            names.entries.groupBy { (k, _) -> k.substring(key.length + 1, k.indexOf("]", key.length)).toInt() }
+        return indices.entries.fold(
+            ArrayList<Any?>((0..(indices.keys.max() ?: 0)).map { null })
+        ) { acc, (idx, params) ->
+            acc[idx] = builder.build("$key[$idx]", params.associate { (key, value) -> key to value })
+            acc
+        }
+    }
+}

src/main/kotlin/com/papsign/ktor/openapigen/parameters/parsers/deepobject/DeepBuilder.kt

@@ -1,28 +1,25 @@
 package com.papsign.ktor.openapigen.parameters.parsers.deepobject
 
+import com.papsign.ktor.openapigen.parameters.QueryParamStyle
+import com.papsign.ktor.openapigen.parameters.parsers.generic.Builder
+import com.papsign.ktor.openapigen.parameters.parsers.generic.BuilderFactory
+import com.papsign.ktor.openapigen.parameters.parsers.generic.BuilderSelector
+import com.papsign.ktor.openapigen.parameters.parsers.generic.SelectorFactory
 import com.papsign.ktor.openapigen.parameters.util.primitiveParsers
-import io.ktor.http.Parameters
 import kotlin.reflect.KType
 import kotlin.reflect.full.isSubclassOf
 import kotlin.reflect.jvm.jvmErasure
 
-interface DeepBuilder {
-    fun build(path: String, parameters: Parameters): Any?
-
-    companion object {
-        fun getBuilderForType(type: KType): DeepBuilder {
-            primitiveParsers[type]?.let {
-                return PrimitiveBuilder(it)
-            }
-            val clazz = type.jvmErasure
-            val jclazz = clazz.java
-            return when {
-                jclazz.isEnum -> EnumBuilder(jclazz.enumConstants.associateBy { it.toString() })
-                clazz.isSubclassOf(List::class) -> ListBuilder(type)
-                jclazz.isArray -> error("Nested array are not yet supported")
-                clazz.isSubclassOf(Map::class) -> MapBuilder(type)
-                else -> ObjectBuilder(type)
-            }
-        }
-    }
+abstract class DeepBuilder : Builder<QueryParamStyle> {
+    override val style: QueryParamStyle = QueryParamStyle.deepObject
+    override val exploded: Boolean = true
 }
+
+object DeepBuilderFactory : SelectorFactory<DeepBuilder, QueryParamStyle>(
+    PrimitiveBuilder,
+    EnumBuilder,
+    ListBuilder,
+    ArrayBuilder,
+    MapBuilder,
+    ObjectBuilder
+)