address most warnings

Author: fractalwrench

core/src/main/kotlin/com/fractalwrench/json2kotlin/JsonProcessor.kt

@@ -0,0 +1,70 @@
+package com.fractalwrench.json2kotlin
+
+import com.google.gson.JsonElement
+import com.squareup.kotlinpoet.*
+import java.util.*
+
+/**
+ * Finds distinct types for a collection of fields.
+ */
+internal class TypeReducer(private val typeDetector: JsonTypeDetector) {
+
+    fun findDistinctTypes(fields: Collection<String>,
+                          commonElements: List<TypedJsonElement>,
+                          jsonElementMap: HashMap<JsonElement, TypeSpec>): Map<String, TypeName> {
+        val fieldMap = HashMap<String, TypeName>()
+
+        fields.forEach {
+            val distinctTypes = findDistinctTypesForField(commonElements, it, jsonElementMap)
+            fieldMap.put(it, reduceToSingleType(distinctTypes))
+        }
+        return fieldMap
+    }
+
+    private fun findDistinctTypesForField(commonElements: List<TypedJsonElement>,
+                                          key: String,
+                                          jsonElementMap: HashMap<JsonElement, TypeSpec>): List<TypeName?> {
+        return commonElements.map {
+            val fieldValue = it.asJsonObject.get(key)
+            if (fieldValue != null) {
+                typeDetector.typeForJsonElement(fieldValue, key, jsonElementMap)
+            } else {
+                null
+            }
+        }.distinct()
+    }
+
+    /**
+     * Determines a single type which fits multiple types.
+     */
+    private fun reduceToSingleType(types: List<TypeName?>): TypeName {
+        val anyClz = Any::class.asTypeName()
+        val nullableClassName = anyClz.asNullable()
+        val nullable = types.contains(nullableClassName) || types.contains(null)
+        val nonNullTypes = types.filterNotNull().filter { it != nullableClassName }
+
+        val typeName: TypeName = when {
+            nonNullTypes.size == 1 -> nonNullTypes[0]
+            nonNullTypes.size == 2 -> reduceMultipleTypes(nonNullTypes, anyClz)
+            else -> anyClz
+        }
+        return if (nullable) typeName.asNullable() else typeName
+    }
+
+    private fun reduceMultipleTypes(nonNullTypes: List<TypeName>, anyClz: ClassName): TypeName {
+        val parameterizedTypeName
+                = nonNullTypes.filterIsInstance(ParameterizedTypeName::class.java).firstOrNull()
+
+        return when {
+            parameterizedTypeName != null -> { // handle type params (recursive)
+                val rawType = parameterizedTypeName.rawType
+                parameterizedTypeName.typeArguments
+                ParameterizedTypeName.get(rawType, reduceToSingleType(parameterizedTypeName.typeArguments))
+            }
+            nonNullTypes.contains(anyClz) -> // Any will be an empty/missing object
+                nonNullTypes.filterNot { it == anyClz }.first()
+            else -> anyClz
+        }
+    }
+
+}

core/src/main/kotlin/com/fractalwrench/json2kotlin/TypeReducer.kt

@@ -1,5 +1,6 @@
 package com.fractalwrench.json2kotlin
 
+import com.google.gson.JsonElement
 import com.squareup.kotlinpoet.*
 import java.util.*
 
@@ -9,7 +10,8 @@ import java.util.*
 internal class TypeSpecGenerator(private val delegate: SourceBuildDelegate,
                                  groupingStrategy: GroupingStrategy) {
 
-    private val jsonProcessor = JsonProcessor(JsonTypeDetector())
+    private val jsonElementMap = HashMap<JsonElement, TypeSpec>()
+    private val typeReducer = TypeReducer(JsonTypeDetector())
     private val jsonFieldGrouper = JsonFieldGrouper(groupingStrategy)
 
     /**
@@ -69,11 +71,9 @@ internal class TypeSpecGenerator(private val delegate: SourceBuildDelegate,
             it.toKotlinIdentifier().toLowerCase()
         }).build()
 
-        // FIXME encapsulation broken from this point
-        return commonElements.filterNot {
-            // reuse any types which already exist in the map
-            val containsValue = jsonProcessor.jsonElementMap.containsValue(classType)
-            jsonProcessor.jsonElementMap.put(it.jsonElement, classType)
+        return commonElements.filterNot { // reuse any types which already exist in the map
+            val containsValue = jsonElementMap.containsValue(classType)
+            jsonElementMap.put(it.jsonElement, classType)
             containsValue
         }.map { classType }
     }
@@ -87,7 +87,7 @@ internal class TypeSpecGenerator(private val delegate: SourceBuildDelegate,
         val constructor = FunSpec.constructorBuilder()
 
         if (fields.isNotEmpty()) {
-            val fieldTypeMap = jsonProcessor.findDistinctTypesForFields(fields, commonElements)
+            val fieldTypeMap = typeReducer.findDistinctTypes(fields, commonElements, jsonElementMap)
             fields.forEach {
                 buildProperty(it, fieldTypeMap, commonElements, classBuilder, constructor)
             }