Reformat code to align with code style standard

Author: timward60

src/main/kotlin/graphql/kickstart/tools/SchemaParserOptions.kt

@@ -19,18 +19,18 @@ import kotlin.coroutines.CoroutineContext
 import kotlin.reflect.KClass
 
 data class SchemaParserOptions internal constructor(
-        val contextClass: Class<*>?,
-        val genericWrappers: List<GenericWrapper>,
-        val missingFieldResolverHandler: MissingFieldResolverHandler?,
-        val allowUnimplementedResolvers: Boolean,
-        val objectMapperProvider: PerFieldObjectMapperProvider,
-        val proxyHandlers: List<ProxyHandler>,
-        val inputArgumentOptionalDetectOmission: Boolean,
-        val preferGraphQLResolver: Boolean,
-        val introspectionEnabled: Boolean,
-        val coroutineContextProvider: CoroutineContextProvider,
-        val typeDefinitionFactories: List<TypeDefinitionFactory>,
-        val fieldVisibility: GraphqlFieldVisibility?
+    val contextClass: Class<*>?,
+    val genericWrappers: List<GenericWrapper>,
+    val missingFieldResolverHandler: MissingFieldResolverHandler?,
+    val allowUnimplementedResolvers: Boolean,
+    val objectMapperProvider: PerFieldObjectMapperProvider,
+    val proxyHandlers: List<ProxyHandler>,
+    val inputArgumentOptionalDetectOmission: Boolean,
+    val preferGraphQLResolver: Boolean,
+    val introspectionEnabled: Boolean,
+    val coroutineContextProvider: CoroutineContextProvider,
+    val typeDefinitionFactories: List<TypeDefinitionFactory>,
+    val fieldVisibility: GraphqlFieldVisibility?
 ) {
     companion object {
         @JvmStatic

src/main/kotlin/graphql/kickstart/tools/resolver/MissingFieldResolver.kt

@@ -8,8 +8,8 @@ import graphql.schema.DataFetcher
 import graphql.schema.DataFetchingEnvironment
 
 internal class MissingFieldResolver(
-        field: FieldDefinition,
-        options: SchemaParserOptions
+    field: FieldDefinition,
+    options: SchemaParserOptions
 ) : FieldResolver(field, FieldResolverScanner.Search(Any::class.java, MissingResolverInfo(), null), options, Any::class.java) {
 
     override fun scanForMatches(): List<TypeClassMatcher.PotentialMatch> = listOf()
@@ -18,13 +18,13 @@ internal class MissingFieldResolver(
         return MissingFieldDataFetcher(handler)
     }
 
-    class MissingFieldDataFetcher(private val handler: MissingFieldResolverHandler): DataFetcher<Any?> {
+    class MissingFieldDataFetcher(private val handler: MissingFieldResolverHandler) : DataFetcher<Any?> {
         override fun get(p0: DataFetchingEnvironment?): Any? {
             return handler.resolve(p0)
         }
     }
 
-    class NotImplementedMissingFieldDataFetcher: DataFetcher<Any?> {
+    class NotImplementedMissingFieldDataFetcher : DataFetcher<Any?> {
         override fun get(p0: DataFetchingEnvironment?): Any? {
             TODO("Schema resolver not implemented")
         }

src/test/kotlin/graphql/kickstart/tools/MissingFieldResolverTest.kt

@@ -13,61 +13,61 @@ class MissingFieldResolverTest {
     @Test(expected = FieldResolverError::class)
     fun `should throw error`() {
         SchemaParser.newParser()
-                .schemaString("""
+            .schemaString("""
                     type Query {
                         implementedField(input: String): String
                         missingField(input: Int): Int
                     }
                     """
-                )
-                .resolvers(object : GraphQLQueryResolver {
-                    fun implementedField(input: Optional<String>) = input.toString()
-                })
-                .build()
-                .makeExecutableSchema()
+            )
+            .resolvers(object : GraphQLQueryResolver {
+                fun implementedField(input: Optional<String>) = input.toString()
+            })
+            .build()
+            .makeExecutableSchema()
     }
 
     @Test
     fun `should call missing field resolver handler if provided`() {
         val schema = SchemaParser.newParser()
-                .schemaString("""
+            .schemaString("""
                     type Query {
                         implementedField(input: String): String
                         missingField(input: Int): Int
                     }
                     """
-                )
-                .resolvers(object : GraphQLQueryResolver {
-                    fun implementedField(input: Optional<String>) = input.toString()
-                })
-                .options(SchemaParserOptions.newOptions()
-                        .missingFieldResolverHandler(TestMissingFieldResolverHandler())
-                        .build())
-                .build()
-                .makeExecutableSchema()
+            )
+            .resolvers(object : GraphQLQueryResolver {
+                fun implementedField(input: Optional<String>) = input.toString()
+            })
+            .options(SchemaParserOptions.newOptions()
+                .missingFieldResolverHandler(TestMissingFieldResolverHandler())
+                .build())
+            .build()
+            .makeExecutableSchema()
 
         val gql = GraphQL.newGraphQL(schema).build()
 
         val result = gql
-                .execute(ExecutionInput.newExecutionInput()
-                        .query("""
+            .execute(ExecutionInput.newExecutionInput()
+                .query("""
                             query {
                                 implementedField(input: "test-value")
                                 missingField(input: 1)
                             }
                             """)
-                        .context(Object())
-                        .root(Object()))
+                .context(Object())
+                .root(Object()))
 
         val expected = mapOf(
-                "implementedField" to "Optional[test-value]",
-                "missingField" to 1
+            "implementedField" to "Optional[test-value]",
+            "missingField" to 1
         )
 
         Assert.assertEquals(expected, result.getData())
     }
 
-    class TestMissingFieldResolverHandler: MissingFieldResolverHandler {
+    class TestMissingFieldResolverHandler : MissingFieldResolverHandler {
         override fun resolve(env: DataFetchingEnvironment?): Any? {
             return env?.getArgument("input");
         }