Merge pull request #70 from hauner/mapping-reader

mapping yaml is easier to understand with a java mapping

Author: hauner

build.gradle

@@ -9,6 +9,7 @@ plugins {
 group 'com.github.hauner.openapi'
 version '1.0.0.M5'
 
+sourceCompatibility = JavaVersion.VERSION_1_8
 targetCompatibility = JavaVersion.VERSION_1_8
 
 ext {
@@ -35,7 +36,7 @@ check.dependsOn testInt
 dependencies {
     implementation 'org.codehaus.groovy:groovy:2.5.4'
     implementation 'io.swagger.parser.v3:swagger-parser:2.0.12'
-    implementation 'org.yaml:snakeyaml:1.25'
+    implementation 'com.fasterxml.jackson.dataformat:jackson-dataformat-yaml:2.9.8'
     implementation 'com.google.googlejavaformat:google-java-format:1.7'
     compileOnly "com.github.hauner.openapi:openapi-generatr-api:$generatrApiVersion"
 

src/main/groovy/com/github/hauner/openapi/spring/generatr/TypeMappingReader.groovy

@@ -16,13 +16,26 @@
 
 package com.github.hauner.openapi.spring.generatr
 
+import com.fasterxml.jackson.databind.DeserializationFeature
+import com.fasterxml.jackson.databind.ObjectMapper
+import com.fasterxml.jackson.databind.PropertyNamingStrategy
+import com.fasterxml.jackson.databind.module.SimpleModule
+import com.fasterxml.jackson.dataformat.yaml.YAMLFactory
 import com.github.hauner.openapi.spring.converter.mapping.AddParameterTypeMapping
 import com.github.hauner.openapi.spring.converter.mapping.EndpointTypeMapping
 import com.github.hauner.openapi.spring.converter.mapping.ParameterTypeMapping
 import com.github.hauner.openapi.spring.converter.mapping.ResponseTypeMapping
 import com.github.hauner.openapi.spring.converter.mapping.TypeMapping
 import com.github.hauner.openapi.spring.converter.mapping.Mapping
-import org.yaml.snakeyaml.Yaml
+import com.github.hauner.openapi.spring.generatr.mapping.AdditionalParameter
+import com.github.hauner.openapi.spring.generatr.mapping.Mapping as YamlMapping
+import com.github.hauner.openapi.spring.generatr.mapping.Parameter
+import com.github.hauner.openapi.spring.generatr.mapping.Parameter as YamlParameter
+import com.github.hauner.openapi.spring.generatr.mapping.ParameterDeserializer
+import com.github.hauner.openapi.spring.generatr.mapping.Path as YamlPath
+import com.github.hauner.openapi.spring.generatr.mapping.RequestParameter
+import com.github.hauner.openapi.spring.generatr.mapping.Response as YamlResponse
+import com.github.hauner.openapi.spring.generatr.mapping.Type as YamlType
 
 import java.util.regex.Matcher
 import java.util.regex.Pattern
@@ -36,7 +49,7 @@ class TypeMappingReader {
     private Pattern GENERIC_INLINE = ~/(.+?)<(.+?)>/
 
     List<Mapping> read (String typeMappings) {
-        if (typeMappings == null) {
+        if (typeMappings == null || typeMappings.empty) {
             return []
         }
 
@@ -45,90 +58,91 @@ class TypeMappingReader {
             mapping = new File(typeMappings).text
         }
 
-        Yaml yaml = new Yaml()
-        Map props = yaml.load (mapping)
+        def mapper = createYamlParser()
+        def props = mapper.readValue (mapping, YamlMapping)
 
-        if (props == null) {
-            return null
-        }
-
-        parse (props)
+        convert (props)
     }
 
-    private List<Mapping> parse (Map<String, ?> props) {
-        //def version = props.get ('openapi-generatr-spring')
+    private List<Mapping> convert (YamlMapping source) {
+        def result = new ArrayList<Mapping>()
 
-        def root = props.get ('map') as Map<String, ?>
+        source.map.types.each {
+            result.add (convert (it))
+        }
 
-        def mappings = readTypeMappings (root)
+        source.map.parameters.each {
+            result.add (convert (it))
+        }
 
-        def paths = root.get ('paths') as Map<String, ?>
-        paths.each {
-            def epm = new EndpointTypeMapping(path: it.key)
-            def types = readTypeMappings (it.value as Map<String, ?>)
-            epm.typeMappings = types
-            mappings.add (epm)
+        source.map.responses.each {
+            result.add (convert (it))
         }
 
-        mappings
+        source.map.paths.each {
+            result.add(convert (it.key, it.value))
+        }
+
+        result
     }
 
-    private List<Mapping> readTypeMappings (Map<String, ?> root) {
-        def mappings = []
+    private EndpointTypeMapping convert (String path, YamlPath source) {
+        def result = new ArrayList<Mapping>()
 
-        def types = root.get ('types') as List<Map<String, ?> >
-        types.each { Map<String, ?> it ->
-            mappings.add (readTypMapping (it))
+        source.types.each {
+            result.add (convert (it))
         }
 
-        def responses = root.get ('responses') as List<Map<String, ?> >
-        responses.each {
-            mappings.add (readResponseTypeMapping (it))
+        source.parameters.each {
+            result.add (convert (it))
         }
 
-        def parameters = root.get ('parameters') as List<Map<String, ?> >
-        parameters.each {
-            mappings.add (readParameterTypeMapping (it))
+        source.responses.each {
+            result.add (convert (it))
         }
 
-        return mappings
+        new EndpointTypeMapping(path: path, typeMappings: result)
     }
 
-    private Mapping readParameterTypeMapping (Map<String, ?> source) {
-        if (isParameterMappings (source)) {
+    private Mapping convert (YamlParameter source) {
+        if (source instanceof RequestParameter) {
             def name = source.name
-            def mapping = readTypMapping (source)
+            def mapping = convert (new YamlType(
+                from: null,
+                to: source.to,
+                generics: source.generics
+            ))
             new ParameterTypeMapping (parameterName: name, mapping: mapping)
 
-        } else if (isParameterAddition (source)) {
+        } else if (source instanceof  AdditionalParameter) {
             def name = source.add
-            def mapping = readTypMapping (source, 'as')
+            def mapping = convert (new YamlType(
+                from: null,
+                to: source.to,
+                generics: source.generics
+            ))
             new AddParameterTypeMapping (parameterName: name, mapping: mapping)
 
         } else {
             throw new Exception("unknown parameter mapping $source")
         }
     }
 
-    private boolean isParameterAddition (Map<String, ?> source) {
-        source.containsKey ('add') && source.containsKey ('as')
-    }
-
-    private boolean isParameterMappings (Map<String, ?> source) {
-        source.containsKey ('name') && source.containsKey ('to')
-    }
-
-    private ResponseTypeMapping readResponseTypeMapping (Map<String, ?> source) {
+    private ResponseTypeMapping convert (YamlResponse source) {
         def content = source.content
-        def mapping = readTypMapping (source)
+        def mapping = convert (new YamlType(
+            from: null,
+            to: source.to,
+            generics: source.generics
+        ))
         new ResponseTypeMapping(contentType: content, mapping: mapping)
     }
 
-    private TypeMapping readTypMapping (Map<String, ?> source, String target = 'to') {
-        Matcher matcher = source.to =~ GENERIC_INLINE
+    private TypeMapping convert (YamlType type) {
+        Matcher matcher = type.to =~ GENERIC_INLINE
 
-        def (from, format) = source.from ? (source.from as String).tokenize (':') : [null,  null]
-        String to = source[target]
+        def (from, format) = type.from ? (type.from as String).tokenize (':') : [null,  null]
+        String to = type.to
         List<String> generics = []
 
         // has inline generics
@@ -140,15 +154,25 @@ class TypeMappingReader {
                 .collect { it.trim () }
 
         // has explicit generic list
-        } else if (source.containsKey ('generics')) {
-            generics = source.generics as List
+        } else if (type.generics) {
+            generics = type.generics
         }
 
         new TypeMapping (
             sourceTypeName: from, sourceTypeFormat: format,
             targetTypeName: to, genericTypeNames: generics)
     }
 
+    private ObjectMapper createYamlParser () {
+        SimpleModule module = new SimpleModule ()
+        module.addDeserializer (Parameter, new ParameterDeserializer ())
+
+        new ObjectMapper (new YAMLFactory ())
+            .configure (DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false)
+            .setPropertyNamingStrategy (PropertyNamingStrategy.KEBAB_CASE)
+            .registerModule (module)
+    }
+
     private boolean isFileName (String name) {
         name.endsWith ('.yaml') || name.endsWith ('.yml')
     }

src/main/groovy/com/github/hauner/openapi/spring/generatr/mapping/AdditionalParameter.groovy

@@ -0,0 +1,43 @@
+/*
+ * Copyright 2020 the original authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.github.hauner.openapi.spring.generatr.mapping
+
+import com.fasterxml.jackson.annotation.JsonProperty
+
+/**
+ * a "parameters:" add parameter entry in the mapping yaml
+ *
+ *  @author Martin Hauner
+ */
+class AdditionalParameter extends Parameter {
+
+    /**
+     * name of the additional parameter
+     */
+    String add
+
+    /**
+     * target java type
+     */
+    String to
+
+    /**
+     * (optional) generic parameters of {@link #to}
+     */
+    List<String> generics
+    
+}

src/main/groovy/com/github/hauner/openapi/spring/generatr/mapping/Map.groovy

@@ -0,0 +1,48 @@
+/*
+ * Copyright 2020 the original authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.github.hauner.openapi.spring.generatr.mapping
+
+/**
+ * the "map:" entry in the mapping yaml
+ *
+ *  @author Martin Hauner
+ */
+class Map {
+
+    /**
+     * global type mappings
+     */
+    List<Type> types
+    
+    /**
+     * global parameter mappings
+     */
+    List<Parameter> parameters
+
+    /**
+     * global response mappings
+     */
+    List<Response> responses
+
+    /**
+     * endpoint mappings
+     * 
+     * the LinkedHashMap preserves order
+     */
+    LinkedHashMap<String, Path> paths
+    
+}

src/main/groovy/com/github/hauner/openapi/spring/generatr/mapping/Mapping.groovy

@@ -0,0 +1,36 @@
+/*
+ * Copyright 2020 the original authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.github.hauner.openapi.spring.generatr.mapping
+
+/**
+ * *the* Schema of the mapping yaml
+ *
+ *  @author Martin Hauner
+ */
+class Mapping {
+
+    /**
+     * version (currently optional)
+     */
+    String openapiGeneratrSpring
+
+    /**
+     * the mappings
+     */
+    Map map
+
+}

src/main/groovy/com/github/hauner/openapi/spring/generatr/mapping/Parameter.groovy

@@ -0,0 +1,25 @@
+/*
+ * Copyright 2020 the original authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.github.hauner.openapi.spring.generatr.mapping
+
+/**
+ * a "parameters:" entry in the mapping yaml
+ *
+ *  @author Martin Hauner
+ */
+class Parameter {
+}