Rename MissingFieldHandler to MissingFieldResolverHandler.

Author: timward60

src/main/kotlin/graphql/kickstart/tools/MissingFieldHandler.kt renamed to src/main/kotlin/graphql/kickstart/tools/MissingFieldResolverHandler.kt

@@ -2,6 +2,6 @@ package graphql.kickstart.tools
 
 import graphql.schema.DataFetchingEnvironment
 
-interface MissingFieldHandler {
+interface MissingFieldResolverHandler {
     fun resolve(env: DataFetchingEnvironment?): Any?
 }

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

@@ -21,7 +21,7 @@ import kotlin.reflect.KClass
 data class SchemaParserOptions internal constructor(
         val contextClass: Class<*>?,
         val genericWrappers: List<GenericWrapper>,
-        val missingFieldHandler: MissingFieldHandler?,
+        val missingFieldResolverHandler: MissingFieldResolverHandler?,
         val allowUnimplementedResolvers: Boolean,
         val objectMapperProvider: PerFieldObjectMapperProvider,
         val proxyHandlers: List<ProxyHandler>,
@@ -48,7 +48,7 @@ data class SchemaParserOptions internal constructor(
         private var contextClass: Class<*>? = null
         private val genericWrappers: MutableList<GenericWrapper> = mutableListOf()
         private var useDefaultGenericWrappers = true
-        private var missingFieldHandler: MissingFieldHandler? = null
+        private var missingFieldResolverHandler: MissingFieldResolverHandler? = null
         private var allowUnimplementedResolvers = false
         private var objectMapperProvider: PerFieldObjectMapperProvider = PerFieldConfiguringObjectMapperProvider()
         private val proxyHandlers: MutableList<ProxyHandler> = mutableListOf(Spring4AopProxyHandler(), GuiceAopProxyHandler(), JavassistProxyHandler(), WeldProxyHandler())
@@ -79,8 +79,8 @@ data class SchemaParserOptions internal constructor(
             this.useDefaultGenericWrappers = useDefaultGenericWrappers
         }
 
-        fun missingFieldHandler(missingFieldHandler: MissingFieldHandler?) = this.apply {
-            this.missingFieldHandler = missingFieldHandler
+        fun missingFieldResolverHandler(missingFieldResolverHandler: MissingFieldResolverHandler?) = this.apply {
+            this.missingFieldResolverHandler = missingFieldResolverHandler
         }
 
         fun allowUnimplementedResolvers(allowUnimplementedResolvers: Boolean) = this.apply {
@@ -160,7 +160,7 @@ data class SchemaParserOptions internal constructor(
             return SchemaParserOptions(
                 contextClass,
                 wrappers,
-                missingFieldHandler,
+                missingFieldResolverHandler,
                 allowUnimplementedResolvers,
                 objectMapperProvider,
                 proxyHandlers,

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

@@ -64,7 +64,7 @@ internal class FieldResolverScanner(val options: SchemaParserOptions) {
     }
 
     private fun missingFieldResolver(field: FieldDefinition, searches: List<Search>, scanProperties: Boolean): FieldResolver {
-        return if (options.allowUnimplementedResolvers || options.missingFieldHandler != null) {
+        return if (options.allowUnimplementedResolvers || options.missingFieldResolverHandler != null) {
             if (options.allowUnimplementedResolvers) {
                 log.warn("Missing resolver for field: $field")
             }

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

@@ -14,11 +14,11 @@ internal class MissingFieldResolver(
 
     override fun scanForMatches(): List<TypeClassMatcher.PotentialMatch> = listOf()
     override fun createDataFetcher(): DataFetcher<*> {
-        val handler = options.missingFieldHandler ?: return NotImplementedMissingFieldDataFetcher()
+        val handler = options.missingFieldResolverHandler ?: return NotImplementedMissingFieldDataFetcher()
         return MissingFieldDataFetcher(handler)
     }
 
-    class MissingFieldDataFetcher(private val handler: MissingFieldHandler): DataFetcher<Any?> {
+    class MissingFieldDataFetcher(private val handler: MissingFieldResolverHandler): DataFetcher<Any?> {
         override fun get(p0: DataFetchingEnvironment?): Any? {
             return handler.resolve(p0)
         }

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

@@ -41,7 +41,7 @@ class MissingFieldResolverTest {
                     fun implementedField(input: Optional<String>) = input.toString()
                 })
                 .options(SchemaParserOptions.newOptions()
-                        .missingFieldHandler(TestMissingFieldHandler())
+                        .missingFieldResolverHandler(TestMissingFieldResolverHandler())
                         .build())
                 .build()
                 .makeExecutableSchema()
@@ -67,7 +67,7 @@ class MissingFieldResolverTest {
         Assert.assertEquals(expected, result.getData())
     }
 
-    class TestMissingFieldHandler: MissingFieldHandler {
+    class TestMissingFieldResolverHandler: MissingFieldResolverHandler {
         override fun resolve(env: DataFetchingEnvironment?): Any? {
             return env?.getArgument("input");
         }