#91, should be able to distinguish between name & type name

Author: hauner

src/main/kotlin/io/openapiprocessor/core/converter/ApiConverter.kt

@@ -186,7 +186,7 @@ class  ApiConverter(
         val addType = MappedDataType(
             tt.getName(),
             tt.getPkg(),
-            tt.genericNames,
+            tt.genericNames.map { DataTypeName(it) },
             null,
             false
         )

src/main/kotlin/io/openapiprocessor/core/converter/DataTypeConverter.kt

@@ -85,7 +85,7 @@ class DataTypeConverter(
             return MappedDataType(
                 targetType.getName(),
                 targetType.getPkg(),
-                targetType.genericNames,
+                targetType.genericNames.map { DataTypeName(it) },
                 null,
                 schemaInfo.getDeprecated()
             )
@@ -203,14 +203,14 @@ class DataTypeConverter(
                     return MappedMapDataType(
                         targetType.getName(),
                         targetType.getPkg(),
-                        targetType.genericNames,
+                        targetType.genericNames.map { DataTypeName(it) },
                         null,
                         schemaInfo.getDeprecated())
                 else -> {
                     return MappedDataType(
                         targetType.getName(),
                         targetType.getPkg(),
-                        targetType.genericNames,
+                        targetType.genericNames.map { DataTypeName(it) },
                         null,
                         schemaInfo.getDeprecated()
                     )
@@ -247,7 +247,7 @@ class DataTypeConverter(
             return MappedDataType (
                 targetType.getName(),
                 targetType.getPkg(),
-                targetType.genericNames,
+                targetType.genericNames.map { DataTypeName(it) },
                 null,
                 schemaInfo.getDeprecated(),
                 true

src/main/kotlin/io/openapiprocessor/core/model/DataTypeCollector.kt

@@ -30,9 +30,9 @@ class DataTypeCollector(
             }
             is MappedDataType -> {
                 dataType.genericTypes
-                    .filter { it.startsWith(generatedPackageName) }
+                    .filter { it.id.startsWith(generatedPackageName) }
                     .forEach {
-                        val name = it.substringAfterLast(".")
+                        val name = it.id.substringAfterLast(".")
                         val found = dataTypes.find(name)
                         if (found != null) {
                             collect(found)

src/main/kotlin/io/openapiprocessor/core/model/datatypes/MappedDataType.kt

@@ -9,10 +9,9 @@ package io.openapiprocessor.core.model.datatypes
  * OpenAPI schema mapped to a java type.
  */
 open class MappedDataType(
-
     private val type: String,
     private val pkg: String,
-    /*private*/ val genericTypes: List<String> = emptyList(),
+    val genericTypes: List<DataTypeName> = emptyList(),
     override val constraints: DataTypeConstraints? = null,
     override val deprecated: Boolean = false,
     val simpleDataType: Boolean = false
@@ -23,7 +22,7 @@ open class MappedDataType(
         return if (genericTypes.isEmpty()) {
             type
         } else {
-            "${type}<${getGenericTypeNames().joinToString(", ")}>"
+            "${type}<${genericTypeNames.joinToString(", ")}>"
         }
     }
 
@@ -32,17 +31,18 @@ open class MappedDataType(
     }
 
     override fun getImports(): Set<String> {
-        return setOf("${getPackageName()}.$type") + genericTypes.filter { it != "?" }
+        return setOf("${getPackageName()}.$type") + genericTypes.map { it.type }.filter { it != "?" }
     }
 
-    private fun getGenericTypeNames(): List<String> {
-        return genericTypes.map {
-            getClassName (it)
+    private val genericTypeNames: List<String>
+        get() {
+            return genericTypes.map {
+                getClassName(it.type)
+            }
         }
-    }
 
-    private fun getClassName(ref: String): String {
-        return ref.substring(ref.lastIndexOf('.') + 1)
+    private fun getClassName(type: String): String {
+        return type.substringAfterLast('.')
     }
 
 }

src/main/kotlin/io/openapiprocessor/core/model/datatypes/MappedMapDataType.kt

@@ -28,7 +28,7 @@ package io.openapiprocessor.core.model.datatypes
 class MappedMapDataType(
     type: String,
     pkg: String,
-    genericTypes: List<String> = emptyList(),
+    genericTypes: List<DataTypeName> = emptyList(),
     constraints: DataTypeConstraints? = null,
     deprecated: Boolean = false
 ) : MappedDataType(type, pkg, genericTypes, constraints, deprecated)

src/test/groovy/com/github/hauner/openapi/core/model/datatypes/MappedDataTypeSpec.groovy

@@ -0,0 +1,53 @@
+/*
+ * Copyright 2019 https://github.com/openapi-processor/openapi-processor-core
+ * PDX-License-Identifier: Apache-2.0
+ */
+
+package io.openapiprocessor.core.model.datatypes
+
+import io.kotest.core.spec.style.StringSpec
+import io.kotest.datatest.withData
+import io.kotest.matchers.shouldBe
+
+class MappedDataTypeSpec: StringSpec ({
+
+    "get name of type with (optional) generic parameters" {
+        class TypeName (val generics: List<String>, val typeName: String)
+
+        withData(
+            TypeName(emptyList(), "Foo"),
+            TypeName(listOf("?"), "Foo<?>"),
+            TypeName(listOf("java.lang.String"), "Foo<String>"),
+            TypeName(listOf("java.lang.String", "java.lang.String"), "Foo<String, String>")
+        ) { data ->
+            val type = MappedDataType(
+                "Foo",
+                "model",
+                data.generics.map { DataTypeName(it) })
+
+            type.getTypeName() shouldBe data.typeName
+        }
+    }
+
+    "get imports of type with (optional) generic parameters" {
+        class TypeImports (val generics: List<String>, val imports: List<String>)
+
+        withData(
+            TypeImports(emptyList(), listOf("model.Foo")),
+            TypeImports(listOf("?"), listOf("model.Foo")),
+            TypeImports(
+                listOf("java.lang.String"),
+                listOf("model.Foo", "java.lang.String")),
+            TypeImports(
+                listOf("java.lang.String", "java.lang.String"),
+                listOf("model.Foo", "java.lang.String"))
+        ) { data ->
+            val type = MappedDataType(
+                "Foo",
+                "model",
+                data.generics.map { DataTypeName(it) })
+
+            type.getImports() shouldBe data.imports
+        }
+    }
+})