close io

Author: fractalwrench

TODO.md

@@ -10,6 +10,7 @@ Ordered roughly in priority:
 
 - Make website tool prettier
 - Throttle website tool/prepare for HN
+- Code style check
 - Docs + writeup
 
 - Unit tests for individual methods (once codebase a bit less volatile)

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

@@ -70,7 +70,7 @@ internal class ClassTypeHolder(val delegate: SourceBuildDelegate, groupingStrate
     }
 
     private fun buildClass(commonElements: List<TypedJsonElement>, fields: Collection<String>): TypeSpec.Builder {
-        val identifier = commonElements.last().kotlinIdentifier // FIXME should only pass in one if that's all that's needed!
+        val identifier = commonElements.last().kotlinIdentifier
         val classBuilder = TypeSpec.classBuilder(identifier.capitalize())
         val constructor = FunSpec.constructorBuilder()
 

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

@@ -1,3 +1,3 @@
 package com.fractalwrench.json2kotlin
 
-class ConversionArgs(val rootClassName: String = "Example", val packageName: String? = null)
+data class ConversionArgs(val rootClassName: String = "Example", val packageName: String? = null)

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

@@ -18,13 +18,14 @@ class JsonReader(private val jsonParser: JsonParser) {
      * Reads a JSON string using GSON.
      */
     internal fun readJsonTree(input: InputStream, args: ConversionArgs): JsonObject {
-        // TODO check IO is closed properly everywhere!
 
-        with(jsonParser.parse(BufferedReader(InputStreamReader(input)))) {
-            return when {
-                isJsonObject -> asJsonObject
-                isJsonArray -> addRootWrapper(asJsonArray, args.rootClassName)
-                else -> throw IllegalStateException("Failed to read json object")
+        BufferedReader(InputStreamReader(input)).use {
+            with(jsonParser.parse(it)) {
+                return when {
+                    isJsonObject -> asJsonObject
+                    isJsonArray -> addRootWrapper(asJsonArray, args.rootClassName)
+                    else -> throw IllegalStateException("Failed to read json object")
+                }
             }
         }
     }

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

@@ -9,7 +9,9 @@ import java.util.HashSet
 
 internal class JsonTypeDetector {
 
-    internal fun typeForJsonField(jsonElement: JsonElement, key: String, jsonElementMap: Map<JsonElement, TypeSpec>): TypeName {
+    internal fun typeForJsonField(jsonElement: JsonElement,
+                                  key: String,
+                                  jsonElementMap: Map<JsonElement, TypeSpec>): TypeName {
         with(jsonElement) {
             return when {
                 isJsonPrimitive -> typeForJsonPrimitive(asJsonPrimitive)
@@ -21,7 +23,7 @@ internal class JsonTypeDetector {
         }
     }
 
-    internal fun typeForJsonPrimitive(primitive: JsonPrimitive): TypeName {
+    private fun typeForJsonPrimitive(primitive: JsonPrimitive): TypeName {
         return when {
             primitive.isBoolean -> Boolean::class
             primitive.isNumber -> Number::class
@@ -30,41 +32,48 @@ internal class JsonTypeDetector {
         }.asTypeName()
     }
 
-
-    // FIXME feels really messy from here on out
-
-
-    internal fun typeForJsonObject(jsonObject: JsonObject, key: String, jsonElementMap: Map<JsonElement, TypeSpec>): TypeName {
+    private fun typeForJsonObject(jsonObject: JsonObject,
+                                   key: String,
+                                   jsonElementMap: Map<JsonElement, TypeSpec>): TypeName {
         val existingTypeName = jsonElementMap[jsonObject]
-        if (existingTypeName != null) {
-            return ClassName.bestGuess(existingTypeName.name!!)
-        }
-
-        val identifier = key.toKotlinIdentifier().capitalize()
+        val identifier = existingTypeName?.name ?: key.toKotlinIdentifier().capitalize()
         return ClassName.bestGuess(identifier)
     }
 
-    internal fun typeForJsonArray(jsonArray: JsonArray, key: String, jsonElementMap: Map<JsonElement, TypeSpec>): TypeName {
+    private fun typeForJsonArray(jsonArray: JsonArray,
+                                  key: String,
+                                  jsonElementMap: Map<JsonElement, TypeSpec>): TypeName {
+        val pair = findAllArrayTypes(jsonArray, key, jsonElementMap)
+        val arrayTypes = pair.first
+        val nullable = pair.second
+        val arrayType = deduceArrayType(arrayTypes, nullable)
+        return ParameterizedTypeName.get(Array<Any>::class.asClassName(), arrayType)
+    }
+
+    private fun findAllArrayTypes(jsonArray: JsonArray,
+                                  key: String,
+                                  jsonElementMap: Map<JsonElement, TypeSpec>): Pair<HashSet<TypeName>, Boolean> {
         val arrayTypes = HashSet<TypeName>()
         var nullable = false
 
         jsonArray.withIndex().forEach {
             val sanitisedName = key.toKotlinIdentifier()
+            val fieldKey = nameForArrayField(it.index, sanitisedName)
+
             with(it.value) {
                 when {
                     isJsonPrimitive -> arrayTypes.add(typeForJsonPrimitive(asJsonPrimitive))
-                    isJsonArray -> arrayTypes.add(typeForJsonArray(asJsonArray, nameForArrayField(it.index, sanitisedName), jsonElementMap))
-                    isJsonObject -> arrayTypes.add(typeForJsonObject(asJsonObject, nameForArrayField(it.index, sanitisedName), jsonElementMap))
+                    isJsonArray -> arrayTypes.add(typeForJsonArray(asJsonArray, fieldKey, jsonElementMap))
+                    isJsonObject -> arrayTypes.add(typeForJsonObject(asJsonObject, fieldKey, jsonElementMap))
                     isJsonNull -> nullable = true
                     else -> throw IllegalStateException("Unexpected state in array")
                 }
             }
         }
-        val arrayType = deduceArrayType(arrayTypes, nullable)
-        return ParameterizedTypeName.get(Array<Any>::class.asClassName(), arrayType)
+        return Pair(arrayTypes, nullable)
     }
 
-    internal fun deduceArrayType(arrayTypes: HashSet<TypeName>, nullable: Boolean): TypeName {
+    private fun deduceArrayType(arrayTypes: HashSet<TypeName>, nullable: Boolean): TypeName {
         val hasMultipleType = arrayTypes.size > 1 || arrayTypes.isEmpty()
         val arrayTypeName = when {
             hasMultipleType -> Any::class.asTypeName()

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

@@ -23,9 +23,11 @@ internal class SourceFileWriter {
             sourceFile.addType(stack.pop())
         }
 
-        val bufferedWriter = BufferedWriter(OutputStreamWriter(output))
-        sourceFile.build().writeTo(bufferedWriter)
-        bufferedWriter.flush()
+        BufferedWriter(OutputStreamWriter(output)).use {
+            sourceFile.build().writeTo(it)
+            it.flush()
+        }
+
     }
 
 }