Merge pull request #12 from mstachniuk/ms

#11 Comments shouldn't start from space (by default)

Author: mstachniuk

core/src/main/kotlin/io/github/mstachniuk/graphqlschemafromintrospectiongenerator/Generator.kt

@@ -11,7 +11,7 @@ class Generator {
      * This function generate GraphQL schema language (also called Graphql DSL or SDL) from
      * <a href="https://graphql.org/learn/introspection/">introspection query</a> result.
      *
-     * Argument for this function should be in format returned by introspection query:
+     * Argument for this function should be in JSON format returned by introspection query:
      * ```
      * {
      *   "data": {
@@ -30,6 +30,18 @@ class Generator {
      * @return GraphQL Schema definition
      */
     fun generate(input: String): String {
-        return GeneratorImpl().generate(input)
+        return GeneratorImpl().generate(input, GeneratorSettings())
+    }
+
+    /**
+     * Another version of [generate] method with additional settings argument.
+     *
+     * @param input Introspection query result
+     * @param settings Settings how to generate Schema
+     * @return GraphQL Schema definition
+     * @since 0.2.0
+     */
+    fun generate(input: String, settings: GeneratorSettings): String {
+        return GeneratorImpl().generate(input, settings)
     }
 }

core/src/main/kotlin/io/github/mstachniuk/graphqlschemafromintrospectiongenerator/GeneratorSettings.kt

@@ -0,0 +1,8 @@
+package io.github.mstachniuk.graphqlschemafromintrospectiongenerator
+
+/**
+ * Class for Generator Settings
+ *
+ * @property trimStartComments Comments in GraphQL Schema usually start from leading space (between # and first letter). This lead that graphql-java will generate description field also with leading space what can lead to different generated schema. To avoid that this property is set to false by default.
+ */
+data class GeneratorSettings(val trimStartComments: Boolean = false)

core/src/main/kotlin/io/github/mstachniuk/graphqlschemafromintrospectiongenerator/internal/GeneratorImpl.kt

@@ -1,16 +1,20 @@
 package io.github.mstachniuk.graphqlschemafromintrospectiongenerator.internal
 
 import com.beust.klaxon.Klaxon
+import io.github.mstachniuk.graphqlschemafromintrospectiongenerator.GeneratorSettings
 
 class GeneratorImpl {
 
     val margin = "    "
     val primitiveScalars = listOf("Boolean", "Float", "ID", "Int", "String")
 
-    fun generate(input: String): String {
+    fun generate(
+        input: String,
+        settings: GeneratorSettings
+    ): String {
         val response = Klaxon().parse<IntrospectionResponse>(input) ?: return ""
 
-        val output = printSchema(response) + printTypes(response)
+        val output = printSchema(response) + printTypes(response, settings)
 
         return output.trimIndent().trimIndent()
     }
@@ -42,7 +46,7 @@ class GeneratorImpl {
     private fun isCustomSubscriptionType(response: IntrospectionResponse) =
         response.data.schema.subscriptionType != null && response.data.schema.subscriptionType.name != "Subscription"
 
-    private fun printTypes(response: IntrospectionResponse): String {
+    private fun printTypes(response: IntrospectionResponse, settings: GeneratorSettings): String {
         val types = response.data.schema.types!!
             .filter { !it.name.startsWith("__") }
             .filter { !primitiveScalars.contains(it.name) }
@@ -60,14 +64,14 @@ class GeneratorImpl {
                 else -> "UNKNOWN_TYPE"
             }
 
-            output += printDescription(it, false)
+            output += printDescription(it, settings, false)
             output += "$kind ${it.name}${printInterfaces(it.interfaces)}"
-            output += printBody(it)
+            output += printBody(it, settings)
         }
         return output
     }
 
-    private fun printBody(type: GraphQLType): String {
+    private fun printBody(type: GraphQLType, settings: GeneratorSettings): String {
         if (type.kind == "UNION") {
             return " = ${type.possibleTypes
                 .sortedBy { it.name }
@@ -79,23 +83,23 @@ class GeneratorImpl {
         var output = " {\n"
         type.fields.sortedBy { it.name }
             .forEach {
-                output += printField(it)
+                output += printField(it, settings)
             }
         type.inputFields.sortedBy { it.name }
             .forEach {
-                output += printField(it)
+                output += printField(it, settings)
             }
-        output += printEnumTypes(type.enumValues)
+        output += printEnumTypes(type.enumValues, settings)
 
         output += "}\n\n"
         return output
     }
 
-    private fun printEnumTypes(enumValues: List<GraphQLEnumType>): String {
+    private fun printEnumTypes(enumValues: List<GraphQLEnumType>, settings: GeneratorSettings): String {
         if (containsDescription(enumValues)) {
             val enums = enumValues
                 .sortedBy { it.name }
-                .map { "${printDescription(it)}$margin${it.name}" }
+                .map { "${printDescription(it, settings)}$margin${it.name}" }
                 .joinToString("\n")
             return "$enums\n"
         }
@@ -107,13 +111,17 @@ class GeneratorImpl {
         }
     }
 
-    private fun printDescription(it: Descriptable, addMargin: Boolean = true): String {
+    private fun printDescription(it: Descriptable, settings: GeneratorSettings, addMargin: Boolean = true): String {
         var output = ""
         if (it.description.isNotBlank()) {
             if (addMargin) {
                 output += margin
             }
-            output += "# ${it.description.trim().replace("\n", "\n$margin# ")}\n"
+            val desc = when {
+                settings.trimStartComments -> it.description.trim() // trim start and end
+                else -> it.description.trimEnd()                    // trim only end otherwise
+            }
+            output += "#${desc.replace("\n", "\n$margin#")}\n"
         }
         return output
     }
@@ -128,9 +136,9 @@ class GeneratorImpl {
         return type.name
     }
 
-    private fun printField(field: GraphQLField): String {
-        val arguments = printArguments(field.args.sortedBy { it.name })
-        return "${printDescription(field)}$margin${field.name}$arguments: ${printType(field.type)}" +
+    private fun printField(field: GraphQLField, settings: GeneratorSettings): String {
+        val arguments = printArguments(field.args.sortedBy { it.name }, settings)
+        return "${printDescription(field, settings)}$margin${field.name}$arguments: ${printType(field.type)}" +
                 "${printDefaultValue(field)}\n"
     }
 
@@ -152,11 +160,11 @@ class GeneratorImpl {
         }
     }
 
-    private fun printArguments(args: List<GraphQLField>): String {
+    private fun printArguments(args: List<GraphQLField>, settings: GeneratorSettings): String {
         if (containsDescription(args)) {
             val arguments = args
                 .map {
-                    "${printDescription(it)}$margin${it.name}: ${printType(it.type)}${printDefaultValue(it)}"
+                    "${printDescription(it, settings)}$margin${it.name}: ${printType(it.type)}${printDefaultValue(it)}"
                 }
                 .joinToString("\n")
             if (arguments.isNotBlank()) {

core/src/test/kotlin/io/github/mstachniuk/graphqlschemafromintrospectiongenerator/GeneratorTest.kt

@@ -1,6 +1,7 @@
 package io.github.mstachniuk.graphqlschemafromintrospectiongenerator
 
 import org.junit.jupiter.api.Assertions.assertEquals
+import org.junit.jupiter.api.Test
 import org.junit.jupiter.api.TestInstance
 import org.junit.jupiter.params.ParameterizedTest
 import org.junit.jupiter.params.provider.MethodSource
@@ -30,4 +31,28 @@ internal class GeneratorTest {
                         .replace(".json", ".graphqls")) }
         return list.stream()
     }
+
+    @Test
+    fun `should trim space in comments`() {
+        val path = System.getProperty("user.dir") + "/src/test/resources/testdata/input-6.json"
+        val input = File(path).readText().trimIndent()
+        val gen = Generator()
+
+        val result = gen.generate(input, GeneratorSettings(true))
+
+        val expectedResult = """#description of customer
+type Customer {
+    #unique id
+    id: ID!
+    #lastname comment with 5 leading spaces
+    lastname: String
+    #name comment without leading space
+    name: String
+}
+
+type Query {
+    customer(id: String): Customer
+}"""
+        assertEquals(expectedResult, result)
+    }
 }

core/src/test/kotlin/io/github/mstachniuk/graphqlschemafromintrospectiongenerator/SchemaToSchemaTest.kt

@@ -23,6 +23,7 @@ class SchemaToSchemaTest {
 
         // when
         val jsonString = graphql.runIntrospectionQuery()
+        // println(jsonString)
         val generatedSchema = generator.generate(jsonString)
 
         // then