Add missing description & deprecation annotation processing for enum classes and values. (#77)

Closes #76

Author: d4rken

detekt_baseline.xml

@@ -6,5 +6,6 @@
     <ID>MethodOverloading:SchemaGeneratorTest.kt$SchemaGeneratorTest</ID>
     <ID>TooManyFunctions:SchemaGenerator.kt$SchemaGenerator</ID>
     <ID>ComplexInterface:SchemaGeneratorHooks.kt$SchemaGeneratorHooks</ID>
+    <ID>TooManyFunctions:annotationExtensions.kt$com.expedia.graphql.schema.extensions.annotationExtensions.kt</ID>
   </Whitelist>
 </SmellBaseline>

src/main/kotlin/com/expedia/graphql/schema/extensions/annotationExtensions.kt

@@ -10,26 +10,33 @@ import com.google.common.base.CaseFormat
 import graphql.schema.GraphQLArgument
 import graphql.schema.GraphQLDirective
 import graphql.schema.GraphQLInputType
+import java.lang.reflect.Field
 import kotlin.reflect.KAnnotatedElement
 import kotlin.reflect.KParameter
 import kotlin.reflect.full.findAnnotation
 import com.expedia.graphql.annotations.GraphQLDirective as DirectiveAnnotation
 
 internal fun KAnnotatedElement.graphQLDescription(): String? {
     val directiveNames = listOfDirectives().map { it.normalizeDirectiveName() }
-
     val description = this.findAnnotation<GraphQLDescription>()?.value
+    return formatGraphQLDescription(description, directiveNames)
+}
+
+internal fun Field.graphQLDescription(): String? {
+    val directiveNames = listOfDirectives().map { it.normalizeDirectiveName() }
+    val description = this.getAnnotation(GraphQLDescription::class.java)?.value
+    return formatGraphQLDescription(description, directiveNames)
+}
 
-    return when {
-        description != null && directiveNames.isNotEmpty() ->
-            """$description
+private fun formatGraphQLDescription(description: String?, directiveNames: List<String>): String? = when {
+    description != null && directiveNames.isNotEmpty() ->
+        """$description
             |
             |Directives: ${directiveNames.joinToString(", ")}
             """.trimMargin()
-        description == null && directiveNames.isNotEmpty() ->
-            "Directives: ${directiveNames.joinToString(", ")}"
-        else -> description
-    }
+    description == null && directiveNames.isNotEmpty() ->
+        "Directives: ${directiveNames.joinToString(", ")}"
+    else -> description
 }
 
 private fun KAnnotatedElement.listOfDirectives(): List<String> {
@@ -48,13 +55,32 @@ private fun KAnnotatedElement.listOfDirectives(): List<String> {
         .toList()
 }
 
-internal fun KAnnotatedElement.getDeprecationReason(): String? {
-    val annotation = this.findAnnotation<Deprecated>() ?: return null
+private fun Field.listOfDirectives(): List<String> {
+    val deprecationReason: String? = this.getDeprecationReason()?.let { "deprecated" }
+
+    return this.declaredAnnotations.asSequence()
+        .mapNotNull { it.getDirectiveInfo() }
+        .map {
+            when {
+                it.effectiveName.isNullOrEmpty().not() -> "@${it.effectiveName}"
+                else -> null
+            }
+        }
+        .plus(deprecationReason)
+        .filterNotNull()
+        .toList()
+}
+
+internal fun KAnnotatedElement.getDeprecationReason(): String? = this.findAnnotation<Deprecated>()?.getReason()
+
+internal fun Field.getDeprecationReason(): String? = this.getDeclaredAnnotation(Deprecated::class.java)?.getReason()
+
+internal fun Deprecated.getReason(): String? {
     val builder = StringBuilder()
-    builder.append(annotation.message)
-    if (!annotation.replaceWith.expression.isBlank()) {
+    builder.append(this.message)
+    if (!this.replaceWith.expression.isBlank()) {
         builder.append(", replace with ")
-        builder.append(annotation.replaceWith.expression)
+        builder.append(this.replaceWith.expression)
     }
     return builder.toString()
 }

src/main/kotlin/com/expedia/graphql/schema/generator/types/enumType.kt

@@ -1,15 +1,29 @@
 package com.expedia.graphql.schema.generator.types
 
+import com.expedia.graphql.schema.extensions.getDeprecationReason
+import com.expedia.graphql.schema.extensions.graphQLDescription
 import graphql.schema.GraphQLEnumType
+import graphql.schema.GraphQLEnumValueDefinition
 import kotlin.reflect.KClass
 
 internal fun enumType(kClass: KClass<out Enum<*>>): GraphQLEnumType {
-    val builder = GraphQLEnumType.newEnum()
+    val enumBuilder = GraphQLEnumType.newEnum()
+
+    enumBuilder.name(kClass.simpleName)
+    enumBuilder.description(kClass.graphQLDescription())
 
     kClass.java.enumConstants.forEach {
-        builder.value(it.name)
+        val valueBuilder = GraphQLEnumValueDefinition.newEnumValueDefinition()
+
+        valueBuilder.name(it.name)
+        valueBuilder.value(it.name)
+
+        val valueField = kClass.java.getField(it.name)
+        valueBuilder.description(valueField.graphQLDescription())
+        valueBuilder.deprecationReason(valueField.getDeprecationReason())
+
+        enumBuilder.value(valueBuilder.build())
     }
 
-    builder.name(kClass.simpleName)
-    return builder.build()
+    return enumBuilder.build()
 }

src/test/kotlin/com/expedia/graphql/schema/generator/types/EnumTypeTest.kt

@@ -1,12 +1,20 @@
 package com.expedia.graphql.schema.generator.types
 
+import com.expedia.graphql.annotations.GraphQLDescription
 import org.junit.jupiter.api.Test
 import kotlin.test.assertEquals
+import kotlin.test.assertFalse
+import kotlin.test.assertNotNull
+import kotlin.test.assertNull
+import kotlin.test.assertTrue
 
 internal class EnumTypeTest {
-
+    @GraphQLDescription("MyTestEnum description")
     private enum class MyTestEnum {
+        @GraphQLDescription("enum 'ONE' description")
         ONE,
+
+        @Deprecated("Deprecated enum value")
         TWO
     }
 
@@ -18,4 +26,26 @@ internal class EnumTypeTest {
         assertEquals(expected = "ONE", actual = actual.values[0].value)
         assertEquals(expected = "TWO", actual = actual.values[1].value)
     }
+
+    @Test
+    fun `Description on enum class and values`() {
+        val gqlEnum = assertNotNull(enumType(MyTestEnum::class))
+        assertEquals("MyTestEnum description", gqlEnum.description)
+
+        val one = assertNotNull(gqlEnum.getValue("ONE"))
+        assertEquals("enum 'ONE' description", one.description)
+    }
+
+    @Test
+    fun `Deprecation on enum values`() {
+        val gqlEnum = assertNotNull(enumType(MyTestEnum::class))
+
+        val one = assertNotNull(gqlEnum.getValue("ONE"))
+        assertFalse(one.isDeprecated)
+        assertNull(one.deprecationReason)
+
+        val two = assertNotNull(gqlEnum.getValue("TWO"))
+        assertTrue(two.isDeprecated)
+        assertEquals("Deprecated enum value", two.deprecationReason)
+    }
 }