Merge pull request #7881 from jmini/issue7845

[3.0.0] Modify 'meta' generator

Author: HugoMario

bin/meta-codegen.sh

@@ -0,0 +1,31 @@
+#!/bin/sh
+
+SCRIPT="$0"
+
+while [ -h "$SCRIPT" ] ; do
+  ls=`ls -ld "$SCRIPT"`
+  link=`expr "$ls" : '.*-> \(.*\)$'`
+  if expr "$link" : '/.*' > /dev/null; then
+    SCRIPT="$link"
+  else
+    SCRIPT=`dirname "$SCRIPT"`/"$link"
+  fi
+done
+
+if [ ! -d "${APP_DIR}" ]; then
+  APP_DIR=`dirname "$SCRIPT"`/..
+  APP_DIR=`cd "${APP_DIR}"; pwd`
+fi
+
+executable="./modules/swagger-codegen-cli/target/swagger-codegen-cli.jar"
+
+if [ ! -f "$executable" ]
+then
+  mvn clean package
+fi
+
+# if you've executed sbt assembly previously it will use that instead.
+export JAVA_OPTS="${JAVA_OPTS} -XX:MaxPermSize=256M -Xmx1024M -DloggerPath=conf/log4j.properties"
+ags="$@  meta -n myClientCodegen -p com.my.company.codegen -o samples/meta-codegen"
+
+java $JAVA_OPTS -jar $executable $ags

modules/swagger-codegen-cli/src/main/java/io/swagger/codegen/cmd/Meta.java

@@ -1,6 +1,5 @@
 package io.swagger.codegen.cmd;
 
-import ch.lambdaj.function.convert.Converter;
 import com.google.common.base.CaseFormat;
 import com.google.common.collect.ImmutableList;
 import com.google.common.collect.ImmutableMap;
@@ -17,17 +16,14 @@
 import java.util.List;
 import java.util.Map;
 
-import static ch.lambdaj.collection.LambdaCollections.with;
-import static com.google.common.base.Joiner.on;
-
 /**
  * User: lanwen Date: 24.03.15 Time: 20:22
  */
 public class Meta implements Runnable {
 
     private static final Logger LOGGER = LoggerFactory.getLogger(Meta.class);
 
-    private static final String TEMPLATE_DIR_CLASSPATH = "codegen";
+    private static final String TEMPLATE_DIR_CLASSPATH = "v2/codegen";
     private static final String MUSTACHE_EXTENSION = ".mustache";
 
     private String outputFolder = "";
@@ -56,27 +52,28 @@ public void run() {
         List<SupportingFile> supportingFiles =
                 ImmutableList
                         .of(new SupportingFile("pom.mustache", "", "pom.xml"),
-                                new SupportingFile("generatorClass.mustache", on(File.separator)
-                                        .join("src/main/java", asPath(targetPackage)), mainClass
-                                        .concat(".java")), new SupportingFile("README.mustache",
-                                        "", "README.md"), new SupportingFile("api.template",
-                                        "src/main/resources" + File.separator + name,
-                                        "api.mustache"), new SupportingFile("model.template",
-                                        "src/main/resources" + File.separator + name,
-                                        "model.mustache"), new SupportingFile("services.mustache",
-                                        "src/main/resources/META-INF/services",
-                                        "io.swagger.codegen.CodegenConfig"));
-
-        String swaggerVersion = Version.readVersionFromResources();
+                                new SupportingFile("generatorClass.mustache", 
+                                        String.join(File.separator, "src", "main", "java", asPath(targetPackage)), 
+                                        mainClass.concat(".java")), 
+                                new SupportingFile("README.mustache", "", "README.md"),
+                                new SupportingFile("api.template", String.join(File.separator, "src", "main", "resources", name), "api.mustache"),
+                                new SupportingFile("model.template", String.join(File.separator, "src", "main", "resources", name), "model.mustache"),
+                                new SupportingFile("myFile.template", String.join(File.separator, "src", "main", "resources", name), "myFile.mustache"),
+                                new SupportingFile("services.mustache", String.join(File.separator, "src", "main", "resources", "META-INF", "services"), "io.swagger.codegen.CodegenConfig"));
+
+        String swaggerCodegenVersion = Version.readVersionFromResources(Version.SWAGGER_CODEGEN_VERSION);
+        String swaggerCodegenGeneratorsVersion = Version.readVersionFromResources(Version.SWAGGER_CODEGEN_GENERATORS_VERSION);
 
         Map<String, Object> data =
                 new ImmutableMap.Builder<String, Object>().put("generatorPackage", targetPackage)
                         .put("generatorClass", mainClass).put("name", name)
                         .put("fullyQualifiedGeneratorClass", targetPackage + "." + mainClass)
-                        .put("swaggerCodegenVersion", swaggerVersion).build();
-
+                        .put("swaggerCodegenVersion", swaggerCodegenVersion)
+                        .put("swaggerCodegenGeneratorsVersion", swaggerCodegenGeneratorsVersion)
+                        .build();
 
-        with(supportingFiles).convert(processFiles(targetDir, data));
+        DefaultGenerator generator = new DefaultGenerator();
+        supportingFiles.stream().forEach(f -> processFiles(generator, f, targetDir, data));
     }
 
     /**
@@ -87,40 +84,27 @@ public void run() {
      * @param data - map with additional params needed to process templates
      * @return converter object to pass to lambdaj
      */
-    private static Converter<SupportingFile, File> processFiles(final File targetDir,
-            final Map<String, Object> data) {
-        return new Converter<SupportingFile, File>() {
-            private DefaultGenerator generator = new DefaultGenerator();
+    private static void processFiles(DefaultGenerator generator, SupportingFile support, final File targetDir, final Map<String, Object> data) {
+        try {
+            File destinationFolder = new File(new File(targetDir.getAbsolutePath()), support.folder);
+            File outputFile = new File(destinationFolder, support.destinationFilename);
 
-            @Override
-            public File convert(SupportingFile support) {
-                try {
-                    File destinationFolder =
-                            new File(new File(targetDir.getAbsolutePath()), support.folder);
-                    File outputFile = new File(destinationFolder, support.destinationFilename);
-
-                    String template =
-                            generator.readTemplate(new File(TEMPLATE_DIR_CLASSPATH,
-                                    support.templateFile).getPath());
-                    String formatted = template;
-
-                    if (support.templateFile.endsWith(MUSTACHE_EXTENSION)) {
-                        LOGGER.info("writing file to {}", outputFile.getAbsolutePath());
-                        formatted =
-                                Mustache.compiler().withLoader(loader(generator)).defaultValue("")
-                                        .compile(template).execute(data);
-                    } else {
-                        LOGGER.info("copying file to {}", outputFile.getAbsolutePath());
-                    }
-
-                    FileUtils.writeStringToFile(outputFile, formatted);
-                    return outputFile;
-
-                } catch (IOException e) {
-                    throw new RuntimeException("Can't generate project", e);
-                }
+            String template = generator.readTemplate(new File(TEMPLATE_DIR_CLASSPATH, support.templateFile).getPath());
+            String formatted = template;
+
+            if (support.templateFile.endsWith(MUSTACHE_EXTENSION)) {
+                LOGGER.info("writing file to {}", outputFile.getAbsolutePath());
+                formatted = Mustache.compiler().withLoader(loader(generator)).defaultValue("").compile(template).execute(data);
             }
-        };
+            else {
+                LOGGER.info("copying file to {}", outputFile.getAbsolutePath());
+            }
+
+            FileUtils.writeStringToFile(outputFile, formatted);
+        }
+        catch (IOException e) {
+            throw new RuntimeException("Can't generate project", e);
+        }
     }
 
     /**

modules/swagger-codegen-cli/src/main/java/io/swagger/codegen/cmd/Version.java

@@ -11,13 +11,20 @@ public class Version implements Runnable {
 
     private static final Logger LOGGER = LoggerFactory.getLogger(Meta.class);
 
+    public static final String SWAGGER_CODEGEN_VERSION = "swagger-codegen.version";
+    public static final String SWAGGER_CODEGEN_GENERATORS_VERSION = "swagger-codegen.generators.version";
+
     private static final String VERSION_PLACEHOLDER = "${project.version}";
 
     private static final String UNREADABLE_VERSION = "unreadable";
     private static final String UNSET_VERSION = "unset";
     private static final String UNKNOWN_VERSION = "unknown";
 
     public static String readVersionFromResources() {
+        return readVersionFromResources(SWAGGER_CODEGEN_VERSION);
+    }
+
+    public static String readVersionFromResources(String key) {
         Properties versionProperties = new Properties();
         try (InputStream is = Version.class.getResourceAsStream("/version.properties")) {
             versionProperties.load(is);
@@ -26,7 +33,7 @@ public static String readVersionFromResources() {
             return UNREADABLE_VERSION;
         }
 
-        String version = versionProperties.getProperty("version", UNKNOWN_VERSION).trim();
+        String version = versionProperties.getProperty(key, UNKNOWN_VERSION).trim();
         if (VERSION_PLACEHOLDER.equals(version)) {
             return UNSET_VERSION;
         } else {

modules/swagger-codegen-cli/src/main/resources/v2/codegen/README.mustache

@@ -0,0 +1,74 @@
+# Swagger Codegen for the {{name}} library
+
+## Overview
+This is a boiler-plate project to generate your own client library with Swagger.  Its goal is
+to get you started with the basic plumbing so you can put in your own logic.  It won't work without
+your changes applied.
+
+## What's Swagger?
+The goal of Swagger™ is to define a standard, language-agnostic interface to REST APIs which allows both humans and computers to discover and understand the capabilities of the service without access to source code, documentation, or through network traffic inspection. When properly defined via Swagger, a consumer can understand and interact with the remote service with a minimal amount of implementation logic. Similar to what interfaces have done for lower-level programming, Swagger removes the guesswork in calling the service.
+
+
+Check out [OpenAPI-Spec](https://github.com/OAI/OpenAPI-Specification) for additional information about the Swagger project, including additional libraries with support for other languages and more. 
+
+## How do I use this?
+At this point, you've likely generated a client setup.  It will include something along these lines:
+
+```
+.
+|- README.md    // this file
+|- pom.xml      // build script
+|-- src
+|--- main
+|---- java
+|----- {{generatorPackage}}.{{generatorClass}}.java // generator file
+|---- resources
+|----- {{name}} // template files
+|----- META-INF
+|------ services
+|------- io.swagger.codegen.CodegenConfig
+```
+
+You _will_ need to make changes in at least the following:
+
+`{{generatorClass}}.java`
+
+Templates in this folder:
+
+`src/main/resources/{{name}}`
+
+Once modified, you can run this:
+
+```
+mvn package
+```
+
+In your generator project.  A single jar file will be produced in `target`.  You can now use that with codegen:
+
+```
+java -cp /path/to/swagger-codegen-cli.jar:/path/to/your.jar io.swagger.codegen.Codegen -l {{name}} -i /path/to/swagger.yaml -o ./test
+```
+
+Now your templates are available to the client generator and you can write output values
+
+## But how do I modify this?
+The `{{generatorClass}}.java` has comments in it--lots of comments.  There is no good substitute
+for reading the code more, though.  See how the `{{generatorClass}}` implements `CodegenConfig`.
+That class has the signature of all values that can be overridden.
+
+For the templates themselves, you have a number of values available to you for generation.
+You can execute the `java` command from above while passing different debug flags to show
+the object you have available during client generation:
+
+```
+# The following additional debug options are available for all codegen targets:
+# -DdebugSwagger prints the OpenAPI Specification as interpreted by the codegen
+# -DdebugModels prints models passed to the template engine
+# -DdebugOperations prints operations passed to the template engine
+# -DdebugSupportingFiles prints additional data passed to the template engine
+
+java -DdebugOperations -cp /path/to/swagger-codegen-cli.jar:/path/to/your.jar io.swagger.codegen.Codegen -l {{name}} -i /path/to/swagger.yaml -o ./test
+```
+
+Will, for example, output the debug info for operations.  You can use this info
+in the `api.mustache` file.

modules/swagger-codegen-cli/src/main/resources/v2/codegen/api.template

@@ -0,0 +1,28 @@
+
+# This is a sample api mustache template.  It is representing a ficticous 
+# language and won't be usable or compile to anything without lots of changes.
+# Use it as an example.  You can access the variables in the generator object
+# like such:
+
+# use the package from the `apiPackage` variable
+package: {{package}}
+
+# operations block
+{{#operations}}
+classname: {{classname}}
+
+# loop over each operation in the API:
+{{#operation}}
+
+# each operation has an `operationId`:
+operationId: {{operationId}}
+
+# and parameters:
+{{#allParams}}
+{{paramName}}: {{dataType}}
+{{/allParams}}
+
+{{/operation}}
+
+# end of operations block
+{{/operations}}