Merge remote-tracking branch 'origin/master' into 2.3.0

modules/swagger-codegen/src/main/java/io/swagger/codegen/CodegenConstants.java

@@ -96,6 +96,7 @@ public class CodegenConstants {
     public static final String ENSURE_UNIQUE_PARAMS = "ensureUniqueParams";
     public static final String ENSURE_UNIQUE_PARAMS_DESC = "Whether to ensure parameter names are unique in an operation (rename parameters that are not).";
 
+    public static final String PROJECT_NAME = "projectName";
     public static final String PACKAGE_NAME = "packageName";
     public static final String PACKAGE_VERSION = "packageVersion";
 

modules/swagger-codegen/src/main/java/io/swagger/codegen/CodegenOperation.java

@@ -118,7 +118,7 @@ public class CodegenOperation {
      * @return true if act as Restful show method, false otherwise
      */
     public boolean isRestfulShow() {
-        return "GET".equals(httpMethod) && isMemberPath();
+        return "GET".equalsIgnoreCase(httpMethod) && isMemberPath();
     }
 
     /**
@@ -127,7 +127,7 @@ public class CodegenOperation {
      * @return true if act as Restful create method, false otherwise
      */
     public boolean isRestfulCreate() {
-        return "POST".equals(httpMethod) && "".equals(pathWithoutBaseName());
+        return "POST".equalsIgnoreCase(httpMethod) && "".equals(pathWithoutBaseName());
     }
 
     /**
@@ -136,7 +136,7 @@ public class CodegenOperation {
      * @return true if act as Restful update method, false otherwise
      */
     public boolean isRestfulUpdate() {
-        return Arrays.asList("PUT", "PATCH").contains(httpMethod) && isMemberPath();
+        return Arrays.asList("PUT", "PATCH").contains(httpMethod.toUpperCase()) && isMemberPath();
     }
 
     /**
@@ -145,7 +145,7 @@ public class CodegenOperation {
      * @return true if act as Restful destroy method, false otherwise
      */
     public boolean isRestfulDestroy() {
-        return "DELETE".equals(httpMethod) && isMemberPath();
+        return "DELETE".equalsIgnoreCase(httpMethod) && isMemberPath();
     }
 
     /**
@@ -173,7 +173,6 @@ public class CodegenOperation {
      */
     private boolean isMemberPath() {
         if (pathParams.size() != 1) return false;
-
         String id = pathParams.get(0).baseName;
         return ("/{" + id + "}").equals(pathWithoutBaseName());
     }

modules/swagger-codegen/src/main/java/io/swagger/codegen/languages/FlaskConnexionCodegen.java

@@ -141,6 +141,8 @@ public class FlaskConnexionCodegen extends DefaultCodegen implements CodegenConf
                 defaultValue("default_controller"));
         cliOptions.add(new CliOption(SUPPORT_PYTHON2, "support python2").
                 defaultValue("false"));
+        cliOptions.add(new CliOption("serverPort", "TCP port to listen to in app.run").
+                defaultValue("8080"));
     }
 
     @Override

modules/swagger-codegen/src/main/java/io/swagger/codegen/languages/JavascriptClosureAngularClientCodegen.java

@@ -3,6 +3,7 @@ package io.swagger.codegen.languages;
 import io.swagger.codegen.CodegenModel;
 import io.swagger.codegen.*;
 import io.swagger.models.properties.*;
+import io.swagger.models.Swagger;
 
 import java.util.TreeSet;
 import java.util.*;
@@ -11,8 +12,14 @@ import java.io.File;
 import org.apache.commons.lang3.StringUtils;
 
 public class JavascriptClosureAngularClientCodegen extends DefaultCodegen implements CodegenConfig {
+
+    public static final String USE_ES6 = "useEs6";
+
+    protected boolean useEs6;
+
     public JavascriptClosureAngularClientCodegen() {
         super();
+        outputFolder = "generated-code/javascript-closure-angular";
 
         supportsInheritance = false;
         setReservedWordsLowerCase(Arrays.asList("abstract",
@@ -64,15 +71,11 @@ public class JavascriptClosureAngularClientCodegen extends DefaultCodegen implem
 
         typeMapping.put("binary", "string");
 
-        outputFolder = "generated-code/javascript-closure-angular";
-        modelTemplateFiles.put("model.mustache", ".js");
-        apiTemplateFiles.put("api.mustache", ".js");
-        embeddedTemplateDir = templateDir = "Javascript-Closure-Angular";
-        apiPackage = "API.Client";
-        modelPackage = "API.Client";
-
         cliOptions.add(new CliOption(CodegenConstants.HIDE_GENERATION_TIMESTAMP, "hides the timestamp when files were generated")
                 .defaultValue(Boolean.TRUE.toString()));
+        cliOptions.add(new CliOption(USE_ES6,
+                "use ES6 templates")
+                .defaultValue(Boolean.FALSE.toString()));
     }
 
     @Override
@@ -83,6 +86,28 @@ public class JavascriptClosureAngularClientCodegen extends DefaultCodegen implem
         if (!additionalProperties.containsKey(CodegenConstants.HIDE_GENERATION_TIMESTAMP)) {
             additionalProperties.put(CodegenConstants.HIDE_GENERATION_TIMESTAMP, Boolean.TRUE.toString());
         }
+
+        if (additionalProperties.containsKey(USE_ES6)) {
+            setUseEs6(convertPropertyToBooleanAndWriteBack(USE_ES6));
+        }
+    }
+
+    @Override
+    public void preprocessSwagger(Swagger swagger) {
+        super.preprocessSwagger(swagger);
+
+        if (useEs6) {
+            embeddedTemplateDir = templateDir = "Javascript-Closure-Angular/es6";
+            apiPackage = "resources";
+            apiTemplateFiles.put("api.mustache", ".js");
+            supportingFiles.add(new SupportingFile("module.mustache", "", "module.js"));
+        } else {
+            modelTemplateFiles.put("model.mustache", ".js");
+            apiTemplateFiles.put("api.mustache", ".js");
+            embeddedTemplateDir = templateDir = "Javascript-Closure-Angular";
+            apiPackage = "API.Client";
+            modelPackage = "API.Client";
+        }
     }
 
     @Override
@@ -102,7 +127,7 @@ public class JavascriptClosureAngularClientCodegen extends DefaultCodegen implem
     }
 
     @Override
-    public String escapeReservedWord(String name) {           
+    public String escapeReservedWord(String name) {
         if(this.reservedWordsMappings().containsKey(name)) {
             return this.reservedWordsMappings().get(name);
         }
@@ -121,7 +146,7 @@ public class JavascriptClosureAngularClientCodegen extends DefaultCodegen implem
     @Override
     public String toVarName(String name) {
         // sanitize name
-        name = sanitizeName(name); 
+        name = sanitizeName(name);
 
         // replace - with _ e.g. created-at => created_at
         name = name.replaceAll("-", "_");
@@ -273,4 +298,7 @@ public class JavascriptClosureAngularClientCodegen extends DefaultCodegen implem
         return input.replace("*/", "*_/").replace("/*", "/_*");
     }
 
+    public void setUseEs6(boolean useEs6) {
+        this.useEs6 = useEs6;
+    }
 }

modules/swagger-codegen/src/main/java/io/swagger/codegen/languages/PistacheServerCodegen.java

@@ -0,0 +1,409 @@
+package io.swagger.codegen.languages;
+
+
+import io.swagger.codegen.*;
+import io.swagger.models.Model;
+import io.swagger.models.Operation;
+import io.swagger.models.Response;
+import io.swagger.models.Swagger;
+import io.swagger.models.properties.*;
+
+import javax.validation.constraints.Null;
+import java.io.File;
+import java.util.*;
+
+public class PistacheServerCodegen extends DefaultCodegen implements CodegenConfig {
+    protected String implFolder = "impl";
+
+    @Override
+    public CodegenType getTag() {
+        return CodegenType.SERVER;
+    }
+
+    @Override
+    public String getName() {
+        return "pistache-server";
+    }
+
+    @Override
+    public String getHelp() {
+        return "Generates a C++ API server (based on Pistache)";
+    }
+
+    public PistacheServerCodegen() {
+        super();
+
+        apiPackage = "io.swagger.server.api";
+        modelPackage = "io.swagger.server.model";
+
+        modelTemplateFiles.put("model-header.mustache", ".h");
+        modelTemplateFiles.put("model-source.mustache", ".cpp");
+
+        apiTemplateFiles.put("api-header.mustache", ".h");
+        apiTemplateFiles.put("api-source.mustache", ".cpp");
+        apiTemplateFiles.put("api-impl-header.mustache", ".h");
+        apiTemplateFiles.put("api-impl-source.mustache", ".cpp");
+        apiTemplateFiles.put("main-api-server.mustache", ".cpp");
+
+        embeddedTemplateDir = templateDir = "pistache-server";
+
+        cliOptions.clear();
+
+        reservedWords = new HashSet<>();
+
+        supportingFiles.add(new SupportingFile("modelbase-header.mustache", "model", "ModelBase.h"));
+        supportingFiles.add(new SupportingFile("modelbase-source.mustache", "model", "ModelBase.cpp"));
+        supportingFiles.add(new SupportingFile("cmake.mustache", "", "CMakeLists.txt"));
+        supportingFiles.add(new SupportingFile("README.mustache", "", "README.md"));
+
+        languageSpecificPrimitives = new HashSet<String>(
+                Arrays.asList("int", "char", "bool", "long", "float", "double", "int32_t", "int64_t"));
+
+        typeMapping = new HashMap<String, String>();
+        typeMapping.put("date", "std::string");
+        typeMapping.put("DateTime", "std::string");
+        typeMapping.put("string", "std::string");
+        typeMapping.put("integer", "int32_t");
+        typeMapping.put("long", "int64_t");
+        typeMapping.put("boolean", "bool");
+        typeMapping.put("array", "std::vector");
+        typeMapping.put("map", "std::map");
+        typeMapping.put("file", "std::string");
+        typeMapping.put("object", "Object");
+        typeMapping.put("binary", "std::string");
+        typeMapping.put("number", "double");
+        typeMapping.put("UUID", "std::string");
+
+        super.importMapping = new HashMap<String, String>();
+        importMapping.put("std::vector", "#include <vector>");
+        importMapping.put("std::map", "#include <map>");
+        importMapping.put("std::string", "#include <string>");
+        importMapping.put("Object", "#include \"Object.h\"");
+    }
+
+    @Override
+    public void processOpts() {
+        super.processOpts();
+
+        additionalProperties.put("modelNamespaceDeclarations", modelPackage.split("\\."));
+        additionalProperties.put("modelNamespace", modelPackage.replaceAll("\\.", "::"));
+        additionalProperties.put("apiNamespaceDeclarations", apiPackage.split("\\."));
+        additionalProperties.put("apiNamespace", apiPackage.replaceAll("\\.", "::"));
+    }
+
+    /**
+     * Escapes a reserved word as defined in the `reservedWords` array. Handle
+     * escaping those terms here. This logic is only called if a variable
+     * matches the reseved words
+     *
+     * @return the escaped term
+     */
+    @Override
+    public String escapeReservedWord(String name) {
+        return "_" + name; // add an underscore to the name
+    }
+
+    @Override
+    public String toModelImport(String name) {
+        if (importMapping.containsKey(name)) {
+            return importMapping.get(name);
+        } else {
+            return "#include \"" + name + ".h\"";
+        }
+    }
+
+    @Override
+    public CodegenModel fromModel(String name, Model model, Map<String, Model> allDefinitions) {
+        CodegenModel codegenModel = super.fromModel(name, model, allDefinitions);
+
+        Set<String> oldImports = codegenModel.imports;
+        codegenModel.imports = new HashSet<>();
+        for (String imp : oldImports) {
+            String newImp = toModelImport(imp);
+            if (!newImp.isEmpty()) {
+                codegenModel.imports.add(newImp);
+            }
+        }
+
+        return codegenModel;
+    }
+
+    @Override
+    public CodegenOperation fromOperation(String path, String httpMethod, Operation operation,
+                                          Map<String, Model> definitions, Swagger swagger) {
+        CodegenOperation op = super.fromOperation(path, httpMethod, operation, definitions, swagger);
+
+        if (operation.getResponses() != null && !operation.getResponses().isEmpty()) {
+            Response methodResponse = findMethodResponse(operation.getResponses());
+
+            if (methodResponse != null) {
+                if (methodResponse.getSchema() != null) {
+                    CodegenProperty cm = fromProperty("response", methodResponse.getSchema());
+                    op.vendorExtensions.put("x-codegen-response", cm);
+                    if(cm.datatype == "HttpContent") {
+                        op.vendorExtensions.put("x-codegen-response-ishttpcontent", true);
+                    }
+                }
+            }
+        }
+
+        String pathForPistache = path.replaceAll("\\{(.*?)}", ":$1");
+        op.vendorExtensions.put("x-codegen-pistache-path", pathForPistache);
+
+        return op;
+    }
+
+    @SuppressWarnings("unchecked")
+    @Override
+    public Map<String, Object> postProcessOperations(Map<String, Object> objs) {
+        Map<String, Object> operations = (Map<String, Object>) objs.get("operations");
+        String classname = (String) operations.get("classname");
+        operations.put("classnameSnakeUpperCase", DefaultCodegen.underscore(classname).toUpperCase());
+        operations.put("classnameSnakeLowerCase", DefaultCodegen.underscore(classname).toLowerCase());
+
+        List<CodegenOperation> operationList = (List<CodegenOperation>) operations.get("operation");
+        for (CodegenOperation op : operationList) {
+            boolean consumeJson = false;
+            boolean isParsingSupported = true;
+            if (op.bodyParam != null) {
+                if (op.bodyParam.vendorExtensions == null) {
+                    op.bodyParam.vendorExtensions = new HashMap<>();
+                }
+
+                op.bodyParam.vendorExtensions.put("x-codegen-pistache-isStringOrDate", op.bodyParam.isString || op.bodyParam.isDate);
+            }
+            if(op.consumes != null) {
+                for (Map<String, String> consume : op.consumes) {
+                    if (consume.get("mediaType") != null && consume.get("mediaType").equals("application/json")) {
+                        consumeJson = true;
+                    }
+                }
+            }
+
+            op.httpMethod = op.httpMethod.substring(0, 1).toUpperCase() + op.httpMethod.substring(1).toLowerCase();
+
+            for(CodegenParameter param : op.allParams){
+                if (param.isFormParam) isParsingSupported=false;
+                if (param.isFile) isParsingSupported=false;
+                if (param.isCookieParam) isParsingSupported=false;
+
+                //TODO: This changes the info about the real type but it is needed to parse the header params
+                if (param.isHeaderParam) {
+                    param.dataType = "Optional<Net::Http::Header::Raw>";
+                    param.baseType = "Optional<Net::Http::Header::Raw>";
+                } else if(param.isQueryParam){
+                    if(param.isPrimitiveType) {
+                        param.dataType = "Optional<" + param.dataType + ">";
+                    } else {
+                        param.dataType = "Optional<" + param.baseType + ">";
+                        param.baseType = "Optional<" + param.baseType + ">";
+                    }
+                }
+            }
+
+            if (op.vendorExtensions == null) {
+                op.vendorExtensions = new HashMap<>();
+            }
+            op.vendorExtensions.put("x-codegen-pistache-consumesJson", consumeJson);
+            op.vendorExtensions.put("x-codegen-pistache-isParsingSupported", isParsingSupported);
+        }
+
+        return objs;
+    }
+
+    @Override
+    public String toModelFilename(String name) {
+        return initialCaps(name);
+    }
+
+    @Override
+    public String apiFilename(String templateName, String tag) {
+        String result = super.apiFilename(templateName, tag);
+
+        if ( templateName.endsWith("impl-header.mustache") ) {
+            int ix = result.lastIndexOf('/');
+            result = result.substring(0, ix) + result.substring(ix, result.length() - 2) + "Impl.h";
+            result = result.replace(apiFileFolder(), implFileFolder());
+        } else if ( templateName.endsWith("impl-source.mustache") ) {
+            int ix = result.lastIndexOf('/');
+            result = result.substring(0, ix) + result.substring(ix, result.length() - 4) + "Impl.cpp";
+            result = result.replace(apiFileFolder(), implFileFolder());
+        } else if ( templateName.endsWith("api-server.mustache") ) {
+            int ix = result.lastIndexOf('/');
+            result = result.substring(0, ix) + result.substring(ix, result.length() - 4) + "MainServer.cpp";
+            result = result.replace(apiFileFolder(), outputFolder);
+        }
+        return result;
+    }
+
+    @Override
+    public String toApiFilename(String name) {
+        return initialCaps(name) + "Api";
+    }
+
+    /**
+     * Optional - type declaration. This is a String which is used by the
+     * templates to instantiate your types. There is typically special handling
+     * for different property types
+     *
+     * @return a string value used as the `dataType` field for model templates,
+     *         `returnType` for api templates
+     */
+    @Override
+    public String getTypeDeclaration(Property p) {
+        String swaggerType = getSwaggerType(p);
+
+        if (p instanceof ArrayProperty) {
+            ArrayProperty ap = (ArrayProperty) p;
+            Property inner = ap.getItems();
+            return getSwaggerType(p) + "<" + getTypeDeclaration(inner) + ">";
+        }
+        if (p instanceof MapProperty) {
+            MapProperty mp = (MapProperty) p;
+            Property inner = mp.getAdditionalProperties();
+            return getSwaggerType(p) + "<std::string, " + getTypeDeclaration(inner) + ">";
+        }
+        if (p instanceof StringProperty || p instanceof DateProperty
+                || p instanceof DateTimeProperty || p instanceof FileProperty
+                || languageSpecificPrimitives.contains(swaggerType)) {
+            return toModelName(swaggerType);
+        }
+
+        return "std::shared_ptr<" + swaggerType + ">";
+    }
+
+    @Override
+    public String toDefaultValue(Property p) {
+        if (p instanceof StringProperty) {
+            return "\"\"";
+        } else if (p instanceof BooleanProperty) {
+            return "false";
+        } else if (p instanceof DateProperty) {
+            return "\"\"";
+        } else if (p instanceof DateTimeProperty) {
+            return "\"\"";
+        } else if (p instanceof DoubleProperty) {
+            return "0.0";
+        } else if (p instanceof FloatProperty) {
+            return "0.0f";
+        } else if (p instanceof IntegerProperty || p instanceof BaseIntegerProperty) {
+            return "0";
+        } else if (p instanceof LongProperty) {
+            return "0L";
+        } else if (p instanceof DecimalProperty) {
+            return "0.0";
+        } else if (p instanceof MapProperty) {
+            MapProperty ap = (MapProperty) p;
+            String inner = getSwaggerType(ap.getAdditionalProperties());
+            return "std::map<std::string, " + inner + ">()";
+        } else if (p instanceof ArrayProperty) {
+            ArrayProperty ap = (ArrayProperty) p;
+            String inner = getSwaggerType(ap.getItems());
+            if (!languageSpecificPrimitives.contains(inner)) {
+                inner = "std::shared_ptr<" + inner + ">";
+            }
+            return "std::vector<" + inner + ">()";
+        } else if (p instanceof RefProperty) {
+            RefProperty rp = (RefProperty) p;
+            return "new " + toModelName(rp.getSimpleRef()) + "()";
+        }
+        return "nullptr";
+    }
+
+    @Override
+    public void postProcessParameter(CodegenParameter parameter) {
+        super.postProcessParameter(parameter);
+
+        boolean isPrimitiveType = parameter.isPrimitiveType == Boolean.TRUE;
+        boolean isListContainer = parameter.isListContainer == Boolean.TRUE;
+        boolean isString = parameter.isString == Boolean.TRUE;
+
+        if (!isPrimitiveType && !isListContainer && !isString && !parameter.dataType.startsWith("std::shared_ptr")) {
+            parameter.dataType = "std::shared_ptr<" + parameter.dataType + ">";
+        }
+    }
+
+    /**
+     * Location to write model files. You can use the modelPackage() as defined
+     * when the class is instantiated
+     */
+    public String modelFileFolder() {
+        return (outputFolder + "/model").replace("/", File.separator);
+    }
+
+    /**
+     * Location to write api files. You can use the apiPackage() as defined when
+     * the class is instantiated
+     */
+    @Override
+    public String apiFileFolder() {
+        return (outputFolder + "/api").replace("/", File.separator);
+    }
+
+    private String implFileFolder() {
+        return (outputFolder + "/" + implFolder).replace("/", File.separator);
+    }
+
+    /**
+     * Optional - swagger type conversion. This is used to map swagger types in
+     * a `Property` into either language specific types via `typeMapping` or
+     * into complex models if there is not a mapping.
+     *
+     * @return a string value of the type or complex model for this property
+     * @see io.swagger.models.properties.Property
+     */
+    @Override
+    public String getSwaggerType(Property p) {
+        String swaggerType = super.getSwaggerType(p);
+        String type = null;
+        if (typeMapping.containsKey(swaggerType)) {
+            type = typeMapping.get(swaggerType);
+            if (languageSpecificPrimitives.contains(type))
+                return toModelName(type);
+        } else
+            type = swaggerType;
+        return toModelName(type);
+    }
+
+    @Override
+    public String toModelName(String type) {
+        if (typeMapping.keySet().contains(type) || typeMapping.values().contains(type)
+                || importMapping.values().contains(type) || defaultIncludes.contains(type)
+                || languageSpecificPrimitives.contains(type)) {
+            return type;
+        } else {
+            return Character.toUpperCase(type.charAt(0)) + type.substring(1);
+        }
+    }
+
+    @Override
+    public String toVarName(String name) {
+        if (typeMapping.keySet().contains(name) || typeMapping.values().contains(name)
+                || importMapping.values().contains(name) || defaultIncludes.contains(name)
+                || languageSpecificPrimitives.contains(name)) {
+            return name;
+        }
+
+        if (name.length() > 1) {
+            return Character.toUpperCase(name.charAt(0)) + name.substring(1);
+        }
+
+        return name;
+    }
+
+    @Override
+    public String toApiName(String type) {
+        return Character.toUpperCase(type.charAt(0)) + type.substring(1) + "Api";
+    }
+
+    @Override
+    public String escapeQuotationMark(String input) {
+        // remove " to avoid code injection
+        return input.replace("\"", "");
+    }
+
+    @Override
+    public String escapeUnsafeCharacters(String input) {
+        return input.replace("*/", "*_/").replace("/*", "/_*");
+    }
+}

modules/swagger-codegen/src/main/java/io/swagger/codegen/languages/PythonClientCodegen.java

@@ -24,8 +24,9 @@ import org.apache.commons.lang3.StringUtils;
 public class PythonClientCodegen extends DefaultCodegen implements CodegenConfig {
     public static final String PACKAGE_URL = "packageUrl";
 
-    protected String packageName;
+    protected String packageName; // e.g. petstore_api
     protected String packageVersion;
+    protected String projectName; // for setup.py, e.g. petstore-api
     protected String packageUrl;
     protected String apiDocPath = "docs/";
     protected String modelDocPath = "docs/";
@@ -114,6 +115,7 @@ public class PythonClientCodegen extends DefaultCodegen implements CodegenConfig
         cliOptions.clear();
         cliOptions.add(new CliOption(CodegenConstants.PACKAGE_NAME, "python package name (convention: snake_case).")
                 .defaultValue("swagger_client"));
+        cliOptions.add(new CliOption(CodegenConstants.PROJECT_NAME, "python project name in setup.py (e.g. petstore-api)."));
         cliOptions.add(new CliOption(CodegenConstants.PACKAGE_VERSION, "python package version.")
                 .defaultValue("1.0.0"));
         cliOptions.add(new CliOption(PACKAGE_URL, "python package URL."));
@@ -139,6 +141,15 @@ public class PythonClientCodegen extends DefaultCodegen implements CodegenConfig
             setPackageName("swagger_client");
         }
 
+        if (additionalProperties.containsKey(CodegenConstants.PROJECT_NAME)) {
+            setProjectName((String) additionalProperties.get(CodegenConstants.PROJECT_NAME));
+        }
+        else {
+            // default: set project based on package name
+            // e.g. petstore_api (package name) => petstore-api (project name)
+            setProjectName(packageName.replaceAll("_", "-"));
+        }
+
         if (additionalProperties.containsKey(CodegenConstants.PACKAGE_VERSION)) {
             setPackageVersion((String) additionalProperties.get(CodegenConstants.PACKAGE_VERSION));
         }
@@ -154,6 +165,7 @@ public class PythonClientCodegen extends DefaultCodegen implements CodegenConfig
                     Boolean.valueOf(additionalProperties().get(CodegenConstants.HIDE_GENERATION_TIMESTAMP).toString()));
         }
 
+        additionalProperties.put(CodegenConstants.PROJECT_NAME, projectName);
         additionalProperties.put(CodegenConstants.PACKAGE_NAME, packageName);
         additionalProperties.put(CodegenConstants.PACKAGE_VERSION, packageVersion);
 
@@ -201,7 +213,7 @@ public class PythonClientCodegen extends DefaultCodegen implements CodegenConfig
         // process enum in models
         return postProcessModelsEnum(objs);
     }
-    
+
     @Override
     public void postProcessParameter(CodegenParameter parameter){
         postProcessPattern(parameter.pattern, parameter.vendorExtensions);
@@ -493,6 +505,10 @@ public class PythonClientCodegen extends DefaultCodegen implements CodegenConfig
         this.packageName = packageName;
     }
 
+    public void setProjectName(String projectName) {
+        this.projectName= projectName;
+    }
+
     public void setPackageVersion(String packageVersion) {
         this.packageVersion = packageVersion;
     }

modules/swagger-codegen/src/main/java/io/swagger/codegen/languages/RestbedCodegen.java

@@ -1,5 +1,6 @@
 package io.swagger.codegen.languages;
 
+import java.io.File;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.HashMap;
@@ -181,7 +182,7 @@ public class RestbedCodegen extends DefaultCodegen implements CodegenConfig {
    * when the class is instantiated
    */
   public String modelFileFolder() {
-      return outputFolder + "/model";
+      return (outputFolder + "/model").replace("/", File.separator);
   }
 
   /**
@@ -190,7 +191,7 @@ public class RestbedCodegen extends DefaultCodegen implements CodegenConfig {
    */
   @Override
   public String apiFileFolder() {
-      return outputFolder + "/api";
+      return (outputFolder + "/api").replace("/", File.separator);
   }
 
   @Override

modules/swagger-codegen/src/main/java/io/swagger/codegen/languages/StaticHtml2Generator.java

@@ -1,14 +1,7 @@
 package io.swagger.codegen.languages;
 
-import io.swagger.codegen.CliOption;
-import io.swagger.codegen.CodegenConfig;
-import io.swagger.codegen.CodegenConstants;
-import io.swagger.codegen.CodegenOperation;
-import io.swagger.codegen.CodegenParameter;
-import io.swagger.codegen.CodegenResponse;
-import io.swagger.codegen.CodegenType;
-import io.swagger.codegen.DefaultCodegen;
-import io.swagger.codegen.SupportingFile;
+import com.samskivert.mustache.Mustache;
+import io.swagger.codegen.*;
 import io.swagger.models.Info;
 import org.yaml.snakeyaml.error.Mark;
 import io.swagger.codegen.utils.Markdown;
@@ -129,6 +122,7 @@ public class StaticHtml2Generator extends DefaultCodegen implements CodegenConfi
                     response.code = "default";
                 }
             }
+            op.formParams = postProcessParameterEnum(op.formParams);
         }
         return objs;
     }
@@ -215,6 +209,30 @@ public class StaticHtml2Generator extends DefaultCodegen implements CodegenConfi
         }
     }
 
+    /**
+     * Format to HTML the enums contained in every operations
+     *
+     * @param parameterList The whole parameters contained in one operation
+     * @return String | Html formated enum
+     */
+    public List<CodegenParameter> postProcessParameterEnum(List<CodegenParameter> parameterList) {
+        String enumFormatted = "";
+        for(CodegenParameter parameter : parameterList) {
+            if (parameter.isEnum) {
+                for (int i = 0; i < parameter._enum.size(); i++) {
+                    String spacer = (i == (parameter._enum.size() - 1)) ? " " : ", ";
+
+                    if (parameter._enum.get(i) != null)
+                        enumFormatted += "`" + parameter._enum.get(i) + "`" + spacer;
+                }
+                Markdown markInstance = new Markdown();
+                if (!enumFormatted.isEmpty())
+                    parameter.vendorExtensions.put("x-eumFormatted", markInstance.toHtml(enumFormatted));
+            }
+        }
+        return parameterList;
+    }
+
     private String sanitizePath(String p) {
         //prefer replace a ', instead of a fuLL URL encode for readability
         return p.replaceAll("'", "%27");