Merge remote-tracking branch 'refs/remotes/swagger-api/master' into fix-java-warnings

# Conflicts:

#	modules/swagger-codegen/src/main/java/io/swagger/codegen/languages/JavascriptClientCodegen.java

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

@@ -640,41 +640,7 @@ public class DefaultCodegen {
      */
     @SuppressWarnings("static-method")
     public String toDefaultValueWithParam(String name, Property p) {
-        if (p instanceof StringProperty) {
-            return " = data." + name + ";";
-        } else if (p instanceof BooleanProperty) {
-            return " = data." + name + ";";
-        } else if (p instanceof DateProperty) {
-            return " = data." + name + ";";
-        } else if (p instanceof DateTimeProperty) {
-            return " = data." + name + ";";
-        } else if (p instanceof DoubleProperty) {
-            DoubleProperty dp = (DoubleProperty) p;
-            if (dp.getDefault() != null) {
-                return dp.getDefault().toString();
-            }
-            return " = data." + name + ";";
-        } else if (p instanceof FloatProperty) {
-            FloatProperty dp = (FloatProperty) p;
-            if (dp.getDefault() != null) {
-                return dp.getDefault().toString();
-            }
-            return " = data." + name + ";";
-        } else if (p instanceof IntegerProperty) {
-            IntegerProperty dp = (IntegerProperty) p;
-            if (dp.getDefault() != null) {
-                return dp.getDefault().toString();
-            }
-            return " = data." + name + ";";
-        } else if (p instanceof LongProperty) {
-            LongProperty dp = (LongProperty) p;
-            if (dp.getDefault() != null) {
-                return dp.getDefault().toString();
-            }
-            return " = data." + name + ";";
-        } else {
-            return " = data." + name + ";";
-        }
+        return " = data." + name + ";";
     }
 
     /**

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

@@ -0,0 +1,283 @@
+package io.swagger.codegen.languages;
+
+import io.swagger.codegen.*;
+import io.swagger.models.properties.ArrayProperty;
+import io.swagger.models.properties.MapProperty;
+import io.swagger.models.properties.Property;
+
+import java.io.File;
+import java.util.*;
+
+import org.apache.commons.lang.StringUtils;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class GoClientCodegen extends DefaultCodegen implements CodegenConfig {
+    static Logger LOGGER = LoggerFactory.getLogger(GoClientCodegen.class);
+
+    protected String packageName = "swagger";
+    protected String packageVersion = "1.0.0";
+
+    public CodegenType getTag() {
+        return CodegenType.CLIENT;
+    }
+
+    public String getName() {
+        return "go";
+    }
+
+    public String getHelp() {
+        return "Generates a Go client library (beta).";
+    }
+
+    public GoClientCodegen() {
+        super();
+        outputFolder = "generated-code/go";
+        modelTemplateFiles.put("model.mustache", ".go");
+        apiTemplateFiles.put("api.mustache", ".go");
+        templateDir = "go";
+
+        reservedWords = new HashSet<String> (
+            Arrays.asList(
+                "break", "default", "func", "interface", "select",
+                "case", "defer", "go", "map", "struct",
+                "chan", "else", "goto", "package", "switch",
+                "const", "fallthrough", "if", "range", "type",
+                "continue", "for", "import", "return", "var")
+        );
+
+        defaultIncludes = new HashSet<String>(
+                Arrays.asList(
+                    "map",
+                    "array")
+                );
+
+        languageSpecificPrimitives = new HashSet<String>(
+            Arrays.asList(
+                "string",
+                "bool",
+                "uint",
+                "uint32",
+                "uint64",
+                "int",
+                "int32",
+                "int64",
+                "float32",
+                "float64",
+                "complex64",
+                "complex128",
+                "rune",
+                "byte")
+            );
+
+        instantiationTypes.clear();
+        /*instantiationTypes.put("array", "GoArray");
+        instantiationTypes.put("map", "GoMap");*/
+
+        typeMapping.clear();
+        typeMapping.put("integer", "int32");
+        typeMapping.put("long", "int64");
+        typeMapping.put("float", "float32");
+        typeMapping.put("double", "float64");
+        typeMapping.put("boolean", "bool");
+        typeMapping.put("string", "string");
+        typeMapping.put("Date", "time.Time");
+        typeMapping.put("DateTime", "time.Time");
+        typeMapping.put("password", "string");
+        typeMapping.put("File", "*os.File");
+        typeMapping.put("file", "*os.File");
+        // map binary to string as a workaround
+        // the correct solution is to use []byte
+        typeMapping.put("binary", "string");
+
+        importMapping = new HashMap<String, String>();
+        importMapping.put("time.Time", "time");
+        importMapping.put("*os.File", "os");
+
+        cliOptions.clear();
+        cliOptions.add(new CliOption(CodegenConstants.PACKAGE_NAME, "Go package name (convention: lowercase).")
+                .defaultValue("swagger"));
+        cliOptions.add(new CliOption(CodegenConstants.PACKAGE_VERSION, "Go package version.")
+                .defaultValue("1.0.0"));
+   
+    }
+
+    @Override
+    public void processOpts() {
+        //super.processOpts();
+
+        if (additionalProperties.containsKey(CodegenConstants.PACKAGE_NAME)) {
+            setPackageName((String) additionalProperties.get(CodegenConstants.PACKAGE_NAME));
+        }
+        else {
+            setPackageName("swagger");
+        }
+
+        if (additionalProperties.containsKey(CodegenConstants.PACKAGE_VERSION)) {
+            setPackageVersion((String) additionalProperties.get(CodegenConstants.PACKAGE_VERSION));
+        }
+        else {
+            setPackageVersion("1.0.0");
+        }
+
+        additionalProperties.put(CodegenConstants.PACKAGE_NAME, packageName);
+        additionalProperties.put(CodegenConstants.PACKAGE_VERSION, packageVersion);
+
+        modelPackage = packageName;
+        apiPackage = packageName;
+
+        supportingFiles.add(new SupportingFile("README.mustache", "", "README.md"));
+    }    
+
+    @Override
+    public String escapeReservedWord(String name) {
+        return "_" + name;
+    }
+
+    @Override
+    public String apiFileFolder() {
+        return outputFolder + File.separator + packageName;
+    }
+
+    public String modelFileFolder() {
+        return outputFolder + File.separator + packageName;
+    }
+
+    @Override
+    public String toVarName(String name) {
+        // replace - with _ e.g. created-at => created_at
+        name = name.replaceAll("-", "_");
+
+        // if it's all uppper case, do nothing
+        if (name.matches("^[A-Z_]*$"))
+            return name;
+
+        // camelize (lower first character) the variable name
+        // pet_id => PetId
+        name = camelize(name);
+
+        // for reserved word or word starting with number, append _
+        if(reservedWords.contains(name) || name.matches("^\\d.*"))
+            name = escapeReservedWord(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, e.g. return
+        if(reservedWords.contains(name))
+            throw new RuntimeException(name + " (reserved word) cannot be used as a model name");
+
+        // 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);
+    }
+
+    @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);
+        }
+        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
+            type = swaggerType;
+        return type;
+    }
+
+    @Override
+    public String toOperationId(String operationId) {
+        // method name cannot use reserved keyword, e.g. return
+        if(reservedWords.contains(operationId))
+            throw new RuntimeException(operationId + " (reserved word) cannot be used as method name");
+
+        return camelize(operationId);
+    }
+
+    @Override
+    public Map<String, Object> postProcessOperations(Map<String, Object> objs) {
+        @SuppressWarnings("unchecked")
+        Map<String, Object> objectMap = (Map<String, Object>) objs.get("operations");
+        @SuppressWarnings("unchecked")
+        List<CodegenOperation> operations = (List<CodegenOperation>) objectMap.get("operation");
+        for (CodegenOperation operation : operations) {
+            // http method verb conversion (e.g. PUT => Put)
+            operation.httpMethod = camelize(operation.httpMethod.toLowerCase());
+        }
+
+        // remove model imports to avoid error
+        List<Map<String, String>> imports = (List<Map<String, String>>) objs.get("imports");
+        if (imports == null)
+            return objs;
+
+        Iterator<Map<String, String>> iterator = imports.iterator();
+        while (iterator.hasNext()) {
+            String _import = iterator.next().get("import");
+            if (_import.startsWith(apiPackage()))
+                iterator.remove();
+        }
+
+        return objs;
+    }
+
+    @Override
+    public Map<String, Object> postProcessModels(Map<String, Object> objs) {
+        // remove model imports to avoid error
+        List<Map<String, String>> imports = (List<Map<String, String>>) objs.get("imports");
+        final String prefix = modelPackage();
+        Iterator<Map<String, String>> iterator = imports.iterator();
+        while (iterator.hasNext()) {
+            String _import = iterator.next().get("import");
+            if (_import.startsWith(prefix))
+                iterator.remove();
+        }
+        return objs;
+    }
+
+    @Override
+    protected boolean needToImport(String type) {
+        return !defaultIncludes.contains(type)
+            && !languageSpecificPrimitives.contains(type);
+    }
+
+    public void setPackageName(String packageName) {
+        this.packageName = packageName;
+    }
+
+    public void setPackageVersion(String packageVersion) {
+        this.packageVersion = packageVersion;
+    }
+
+}

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

@@ -13,7 +13,6 @@ import io.swagger.codegen.DefaultCodegen;
 import io.swagger.codegen.SupportingFile;
 import io.swagger.models.*;
 import io.swagger.models.properties.ArrayProperty;
-import io.swagger.models.properties.LongProperty;
 import io.swagger.models.properties.MapProperty;
 import io.swagger.models.properties.Property;
 import io.swagger.models.properties.RefProperty;
@@ -229,7 +228,7 @@ public class JavascriptClientCodegen extends DefaultCodegen implements CodegenCo
     @Override
     public String toVarName(String name) {
         // sanitize name
-        name = sanitizeName(name); // FIXME: a parameter should not be assigned. Also declare the methods parameters as 'final'.
+        name = sanitizeName(name);  // FIXME parameter should not be assigned. Also declare it as "final"
 
         if("_".equals(name)) {
           name = "_u";
@@ -260,7 +259,7 @@ public class JavascriptClientCodegen extends DefaultCodegen implements CodegenCo
 
     @Override
     public String toModelName(String name) {
-        name = sanitizeName(name); // FIXME: a parameter should not be assigned. Also declare the methods parameters as 'final'.
+        name = sanitizeName(name);  // FIXME parameter should not be assigned. Also declare it as "final"
 
         // model name cannot use reserved keyword, e.g. return
         if (reservedWords.contains(name)) {
@@ -280,7 +279,7 @@ public class JavascriptClientCodegen extends DefaultCodegen implements CodegenCo
 
     @Override
     public String toModelImport(String name) {
-        return name;
+        return toModelName(name);
     }
 
     @Override
@@ -291,8 +290,8 @@ public class JavascriptClientCodegen extends DefaultCodegen implements CodegenCo
     @Override
     public String getTypeDeclaration(Property p) {
         if (p instanceof ArrayProperty) {
-          //  ArrayProperty ap = (ArrayProperty) p;
-          // Property inner = ap.getItems();
+        //    ArrayProperty ap = (ArrayProperty) p;
+       //     Property inner = ap.getItems();
             return getSwaggerType(p); // TODO: + "/* <" + getTypeDeclaration(inner) + "> */";
         } else if (p instanceof MapProperty) {
             MapProperty mp = (MapProperty) p;
@@ -309,40 +308,22 @@ public class JavascriptClientCodegen extends DefaultCodegen implements CodegenCo
             return "[]";
         } else if (p instanceof MapProperty) {
             return "{}";
-        } else if (p instanceof LongProperty) {
-            LongProperty dp = (LongProperty) p;
-            if (dp.getDefault() != null) {
-                return dp.getDefault().toString()+"l";
-            }
-           return "null";
-
-           // added for Javascript
         } else if (p instanceof RefProperty) {
-            RefProperty rp = (RefProperty)p;
-            return "new " +rp.getSimpleRef()  + "()";
+            return "new " + getTypeDeclaration(p) + "()";
         }
 
         return super.toDefaultValue(p);
     }
 
-
     @Override
     public String toDefaultValueWithParam(String name, Property p) {
-        if (p instanceof ArrayProperty) {
-            return  " = new Array();";
-        } else if (p instanceof MapProperty) {
-            return " = {}";
-        } else if (p instanceof LongProperty) {
-            return " = data." + name + ";";
-
-           // added for Javascript
-        } else if (p instanceof RefProperty) {
+        if (p instanceof RefProperty) {
             return ".constructFromObject(data." + name + ");";
         }
+
         return super.toDefaultValueWithParam(name, p);
     }
 
-
     @Override
     public String getSwaggerType(Property p) {
         String swaggerType = super.getSwaggerType(p);
@@ -383,7 +364,7 @@ public class JavascriptClientCodegen extends DefaultCodegen implements CodegenCo
         if (allDefinitions != null && codegenModel != null && codegenModel.parent != null && codegenModel.hasEnums) {
             final Model parentModel = allDefinitions.get(toModelName(codegenModel.parent));
             final CodegenModel parentCodegenModel = super.fromModel(codegenModel.parent, parentModel);
-            codegenModel = this.reconcileInlineEnums(codegenModel, parentCodegenModel);
+            codegenModel = JavascriptClientCodegen.reconcileInlineEnums(codegenModel, parentCodegenModel);
         }
 
         return codegenModel;
@@ -530,12 +511,13 @@ public class JavascriptClientCodegen extends DefaultCodegen implements CodegenCo
         return codegenModel;
     }
 
-    private static String sanitizePackageName(String packageName) {
-        packageName = packageName.trim(); // FIXME: a parameter should not be assigned. Also declare the methods parameters as 'final'.
+    private static String sanitizePackageName(String packageName) { // FIXME parameter should not be assigned. Also declare it as "final"
+        packageName = packageName.trim();
         packageName = packageName.replaceAll("[^a-zA-Z0-9_\\.]", "_");
         if(Strings.isNullOrEmpty(packageName)) {
             return "invalidPackageName";
         }
         return packageName;
     }
+
 }