Merge branch 'master' into auto-generate-operation-id

Conflicts:
	modules/swagger-codegen/src/main/resources/Java/libraries/okhttp-gson/api.mustache

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

@@ -46,4 +46,6 @@ public class CodegenConstants {
     public static final String PACKAGE_NAME = "packageName";
     public static final String PACKAGE_VERSION = "packageVersion";
     public static final String POD_VERSION = "podVersion";
+
+    public static final String OPTIONAL_METHOD_ARGUMENT = "optionalMethodArgument";
 }

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

@@ -45,13 +45,15 @@ public class InlineModelResolver {
                                 if (bp.getSchema() != null) {
                                     Model model = bp.getSchema();
                                     if(model instanceof ModelImpl) {
-                                        String modelName = uniqueName(bp.getName());
                                         ModelImpl obj = (ModelImpl) model;
-                                        flattenProperties(obj.getProperties(), pathname);
+                                        if (obj.getType() == null || "object".equals(obj.getType())) {
+                                            String modelName = uniqueName(bp.getName());
+                                            flattenProperties(obj.getProperties(), pathname);
 
-                                        bp.setSchema(new RefModel(modelName));
-                                        addGenerated(modelName, model);
-                                        swagger.addDefinition(modelName, model);
+                                            bp.setSchema(new RefModel(modelName));
+                                            addGenerated(modelName, model);
+                                            swagger.addDefinition(modelName, model);
+                                        }
                                     }
                                     else if (model instanceof ArrayModel) {
                                         ArrayModel am = (ArrayModel) model;

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

@@ -25,6 +25,7 @@ import org.slf4j.LoggerFactory;
 
 public class CSharpClientCodegen extends DefaultCodegen implements CodegenConfig {
     private static final Logger LOGGER = LoggerFactory.getLogger(CSharpClientCodegen.class);
+    protected boolean optionalMethodArgumentFlag = true;
     protected String packageName = "IO.Swagger";
     protected String packageVersion = "1.0.0";
     protected String clientPackage = "IO.Swagger.Client";
@@ -91,6 +92,7 @@ public class CSharpClientCodegen extends DefaultCodegen implements CodegenConfig
                 .defaultValue("IO.Swagger"));
         cliOptions.add(new CliOption(CodegenConstants.PACKAGE_VERSION, "C# package version.").defaultValue("1.0.0"));
         cliOptions.add(new CliOption(CodegenConstants.SORT_PARAMS_BY_REQUIRED_FLAG, CodegenConstants.SORT_PARAMS_BY_REQUIRED_FLAG_DESC));
+        cliOptions.add(new CliOption(CodegenConstants.OPTIONAL_METHOD_ARGUMENT, "C# Optional method argument, e.g. void square(int x=10) (.net 4.0+ only). Default: false").defaultValue("false"));
     }
 
     @Override
@@ -113,6 +115,12 @@ public class CSharpClientCodegen extends DefaultCodegen implements CodegenConfig
         }
 
         additionalProperties.put("clientPackage", clientPackage);
+
+        if (additionalProperties.containsKey(CodegenConstants.OPTIONAL_METHOD_ARGUMENT)) {
+            setOptionalMethodArgumentFlag(Boolean.valueOf(additionalProperties
+                    .get(CodegenConstants.OPTIONAL_METHOD_ARGUMENT).toString()));
+        }
+        additionalProperties.put("optionalMethodArgument", optionalMethodArgumentFlag);
         
         supportingFiles.add(new SupportingFile("Configuration.mustache",
                 sourceFolder + File.separator + clientPackage.replace(".", java.io.File.separator), "Configuration.cs"));
@@ -261,6 +269,10 @@ public class CSharpClientCodegen extends DefaultCodegen implements CodegenConfig
         return camelize(sanitizeName(operationId));
     }
 
+    public void setOptionalMethodArgumentFlag(boolean flag) {
+        this.optionalMethodArgumentFlag = flag;
+    }
+
     public void setPackageName(String packageName) {
         this.packageName = packageName;
     }

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

@@ -232,6 +232,8 @@ public class JavaClientCodegen extends DefaultCodegen implements CodegenConfig {
         if ("okhttp-gson".equals(getLibrary())) {
             // the "okhttp-gson" library template requires "ApiCallback.mustache" for async call
             supportingFiles.add(new SupportingFile("ApiCallback.mustache", invokerFolder, "ApiCallback.java"));
+            supportingFiles.add(new SupportingFile("ProgressRequestBody.mustache", invokerFolder, "ProgressRequestBody.java"));
+            supportingFiles.add(new SupportingFile("ProgressResponseBody.mustache", invokerFolder, "ProgressResponseBody.java"));
             // "build.sbt" is for development with SBT
             supportingFiles.add(new SupportingFile("build.sbt.mustache", "", "build.sbt"));
         } else if ("retrofit".equals(getLibrary()) || "retrofit2".equals(getLibrary())) {

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

@@ -0,0 +1,221 @@
+package io.swagger.codegen.languages;
+
+import io.swagger.codegen.CodegenConfig;
+import io.swagger.codegen.CodegenConstants;
+import io.swagger.codegen.CodegenType;
+import io.swagger.codegen.DefaultCodegen;
+import io.swagger.codegen.SupportingFile;
+import io.swagger.models.properties.ArrayProperty;
+import io.swagger.models.properties.MapProperty;
+import io.swagger.models.properties.Property;
+import io.swagger.models.properties.RefProperty;
+
+import java.io.File;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.HashSet;
+
+public class SlimFrameworkServerCodegen extends DefaultCodegen implements CodegenConfig {
+    protected String invokerPackage;
+    protected String groupId = "io.swagger";
+    protected String artifactId = "swagger-server";
+    protected String artifactVersion = "1.0.0";
+    private String variableNamingConvention = "camelCase";
+
+    public SlimFrameworkServerCodegen() {
+        super();
+
+        invokerPackage = camelize("SwaggerServer");
+
+        String packagePath = "SwaggerServer";
+
+        modelPackage = packagePath + "\\lib\\Models";
+        apiPackage = packagePath + "\\lib";
+        outputFolder = "generated-code" + File.separator + "slim";
+        modelTemplateFiles.put("model.mustache", ".php");
+
+        // no api files
+        apiTemplateFiles.clear();
+
+        embeddedTemplateDir = templateDir = "slim";
+
+        reservedWords = new HashSet<String>(
+                Arrays.asList(
+                        "__halt_compiler", "abstract", "and", "array", "as", "break", "callable", "case", "catch", "class", "clone", "const", "continue", "declare", "default", "die", "do", "echo", "else", "elseif", "empty", "enddeclare", "endfor", "endforeach", "endif", "endswitch", "endwhile", "eval", "exit", "extends", "final", "for", "foreach", "function", "global", "goto", "if", "implements", "include", "include_once", "instanceof", "insteadof", "interface", "isset", "list", "namespace", "new", "or", "print", "private", "protected", "public", "require", "require_once", "return", "static", "switch", "throw", "trait", "try", "unset", "use", "var", "while", "xor")
+        );
+
+        additionalProperties.put(CodegenConstants.INVOKER_PACKAGE, invokerPackage);
+        additionalProperties.put(CodegenConstants.GROUP_ID, groupId);
+        additionalProperties.put(CodegenConstants.ARTIFACT_ID, artifactId);
+        additionalProperties.put(CodegenConstants.ARTIFACT_VERSION, artifactVersion);
+
+        // ref: http://php.net/manual/en/language.types.intro.php
+        languageSpecificPrimitives = new HashSet<String>(
+                Arrays.asList(
+                        "boolean",
+                        "int",
+                        "integer",
+                        "double",
+                        "float",
+                        "string",
+                        "object",
+                        "DateTime",
+                        "mixed",
+                        "number")
+        );
+
+        instantiationTypes.put("array", "array");
+        instantiationTypes.put("map", "map");
+
+        // ref: https://github.com/swagger-api/swagger-spec/blob/master/versions/2.0.md#data-types
+        typeMapping = new HashMap<String, String>();
+        typeMapping.put("integer", "int");
+        typeMapping.put("long", "int");
+        typeMapping.put("float", "float");
+        typeMapping.put("double", "double");
+        typeMapping.put("string", "string");
+        typeMapping.put("byte", "int");
+        typeMapping.put("boolean", "bool");
+        typeMapping.put("date", "\\DateTime");
+        typeMapping.put("datetime", "\\DateTime");
+        typeMapping.put("file", "\\SplFileObject");
+        typeMapping.put("map", "map");
+        typeMapping.put("array", "array");
+        typeMapping.put("list", "array");
+        typeMapping.put("object", "object");
+
+        supportingFiles.add(new SupportingFile("README.mustache", packagePath.replace('/', File.separatorChar), "README.md"));
+        supportingFiles.add(new SupportingFile("composer.json", packagePath.replace('/', File.separatorChar), "composer.json"));
+        supportingFiles.add(new SupportingFile("index.mustache", packagePath.replace('/', File.separatorChar), "index.php"));
+        supportingFiles.add(new SupportingFile(".htaccess", packagePath.replace('/', File.separatorChar), ".htaccess"));
+    }
+
+    public CodegenType getTag() {
+        return CodegenType.SERVER;
+    }
+
+    public String getName() {
+        return "slim";
+    }
+
+    public String getHelp() {
+        return "Generates a Slim Framework server library.";
+    }
+
+    @Override
+    public String escapeReservedWord(String name) {
+        return "_" + name;
+    }
+
+    @Override
+    public String apiFileFolder() {
+        return (outputFolder + "/" + apiPackage()).replace('/', File.separatorChar);
+    }
+
+    public String modelFileFolder() {
+        return (outputFolder + "/" + modelPackage()).replace('/', File.separatorChar);
+    }
+
+    @Override
+    public String getTypeDeclaration(Property p) {
+        if (p instanceof ArrayProperty) {
+            ArrayProperty ap = (ArrayProperty) p;
+            Property inner = ap.getItems();
+            return getTypeDeclaration(inner) + "[]";
+        } else if (p instanceof MapProperty) {
+            MapProperty mp = (MapProperty) p;
+            Property inner = mp.getAdditionalProperties();
+            return getSwaggerType(p) + "[string," + getTypeDeclaration(inner) + "]";
+        } else if (p instanceof RefProperty) {
+            String type = super.getTypeDeclaration(p);
+            return (!languageSpecificPrimitives.contains(type))
+                    ? "\\" + modelPackage + "\\" + type : type;
+        }
+        return super.getTypeDeclaration(p);
+    }
+
+    @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 type;
+            } else if (instantiationTypes.containsKey(type)) {
+                return type;
+            }
+        } else {
+            type = swaggerType;
+        }
+        if (type == null) {
+            return null;
+        }
+        return toModelName(type);
+    }
+
+    @Override
+    public String getTypeDeclaration(String name) {
+        if (!languageSpecificPrimitives.contains(name)) {
+            return "\\" + modelPackage + "\\" + name;
+        }
+        return super.getTypeDeclaration(name);
+    }
+
+    public String toDefaultValue(Property p) {
+        return "null";
+    }
+
+    public void setParameterNamingConvention(String variableNamingConvention) {
+        this.variableNamingConvention = variableNamingConvention;
+    }
+
+    @Override
+    public String toVarName(String name) {
+        // sanitize name
+        name = sanitizeName(name);
+
+        if ("camelCase".equals(variableNamingConvention)) {
+            // return the name in camelCase style
+            // phone_number => phoneNumber
+            name =  camelize(name, true);
+        } else { // default to snake case
+            // return the name in underscore style
+            // PhoneNumber => phone_number
+            name =  underscore(name);
+        }
+
+        // parameter name starting with number won't compile
+        // need to escape it by appending _ at the beginning
+        if (name.matches("^\\d.*")) {
+            name = "_" + name;
+        }
+
+        return name;
+    }
+
+    @Override
+    public String toParamName(String name) {
+        // should be the same as variable name
+        return toVarName(name);
+    }
+
+    @Override
+    public String toModelName(String name) {
+        // model name cannot use reserved keyword
+        if (reservedWords.contains(name)) {
+            escapeReservedWord(name); // e.g. return => _return
+        }
+
+        // camelize the model name
+        // phone_number => PhoneNumber
+        return camelize(name);
+    }
+
+    @Override
+    public String toModelFilename(String name) {
+        // should be the same as the model name
+        return toModelName(name);
+    }
+
+}