fixed javadoc plugin

updated versions

.dockerignore

@@ -0,0 +1,47 @@
+*.iml
+out/
+*.ipr
+*.iws
+classpath.txt
+version.properties
+.project
+.classpath
+lib/*
+build/*
+generated-files/*
+generated-sources/*
+generated-code/*
+*.swp
+*.swo
+
+/target
+/generated-files
+/nbactions.xml
+*.pyc
+__pycache__
+samples/server-generator/scalatra/output
+samples/server-generator/node/output/node_modules
+samples/server-generator/scalatra/target
+samples/server-generator/scalatra/output/.history
+samples/client/petstore/qt5cpp/PetStore/moc_*
+samples/client/petstore/qt5cpp/PetStore/*.o
+samples/client/petstore/objc/PetstoreClient.xcworkspace/xcuserdata
+samples/client/petstore/qt5cpp/build-*
+samples/client/petstore/qt5cpp/PetStore/PetStore
+samples/client/petstore/qt5cpp/PetStore/Makefile
+samples/client/petstore/java/hello.txt
+samples/client/petstore/android/default/hello.txt
+samples/client/petstore/objc/Build
+samples/client/petstore/objc/Pods
+samples/server/petstore/nodejs/node_modules
+target
+.idea
+.lib
+atlassian-ide-plugin.xml
+.DS_Store
+
+samples/client/petstore/php/SwaggerClient-php/composer.lock
+samples/client/petstore/php/SwaggerClient-php/vendor/
+
+samples/client/petstore/silex/SwaggerServer/composer.lock
+samples/client/petstore/silex/SwaggerServer/venodr/

.gitignore

@@ -9,9 +9,11 @@ version.properties
 lib/*
 build/*
 generated-files/*
+generated-sources/*
 generated-code/*
 *.swp
 *.swo
+*.csproj.user
 
 /target
 /generated-files
@@ -29,15 +31,37 @@ samples/client/petstore/qt5cpp/build-*
 samples/client/petstore/qt5cpp/PetStore/PetStore
 samples/client/petstore/qt5cpp/PetStore/Makefile
 samples/client/petstore/java/hello.txt
-samples/client/petstore/android-java/hello.txt
-samples/client/petstore/objc/Build
-samples/client/petstore/objc/Pods
+samples/client/petstore/android/default/hello.txt
+samples/client/petstore/objc/SwaggerClientTests/Build
+samples/client/petstore/objc/SwaggerClientTests/Pods
+samples/client/petstore/objc/SwaggerClientTests/SwaggerClient.xcworkspace
+samples/client/petstore/objc/SwaggerClientTests/Podfile.lock
 samples/server/petstore/nodejs/node_modules
+samples/client/petstore/csharp/SwaggerClientTest/.vs
+samples/client/petstore/csharp/SwaggerClientTest/obj
+samples/client/petstore/csharp/SwaggerClientTest/bin
 target
 .idea
 .lib
 atlassian-ide-plugin.xml
 .DS_Store
+packages/
+.pub
+.packages
 
 samples/client/petstore/php/SwaggerClient-php/composer.lock
 samples/client/petstore/php/SwaggerClient-php/vendor/
+
+samples/client/petstore/silex/SwaggerServer/composer.lock
+samples/client/petstore/silex/SwaggerServer/venodr/
+
+samples/client/petstore/python/.projectile
+samples/client/petstore/python/.venv/
+
+.settings
+
+*.mustache~
+*.java~
+*.pm~
+*.xml~
+*.t~

.travis.yml

@@ -1,5 +1,22 @@
-sudo: false
+sudo: required
 language: java
-script: mvn verify
 jdk:
   - oraclejdk7
+
+services:
+  - docker
+
+before_install:
+  # required when sudo: required for the Ruby petstore tests
+  - gem install bundler
+
+install:
+  - docker login --email=$DOCKER_HUB_EMAIL --username=$DOCKER_HUB_USERNAME --password=$DOCKER_HUB_PASSWORD
+
+script:
+  - mvn verify -Psamples
+  - docker build -t $DOCKER_IMAGE_NAME ./modules/swagger-generator
+  - if [ ! -z "$TRAVIS_TAG" ]; then docker tag $DOCKER_IMAGE_NAME:latest $DOCKER_IMAGE_NAME:$TRAVIS_TAG; fi && docker push $DOCKER_IMAGE_NAME
+
+env:
+  - DOCKER_IMAGE_NAME=swaggerapi/swagger-generator

CONTRIBUTING.md

@@ -0,0 +1,62 @@
+# Guidelines For Contributing
+
+## Before submitting an issue
+
+ - Before submitting an issue, search the [open issue](https://github.com/swagger-api/swagger-codegen/issues) and [closed issue](https://github.com/swagger-api/swagger-codegen/issues?q=is%3Aissue+is%3Aclosed) to ensure no one else has reported something similar before.
+ - The issue should contain details on how to repeat the issue, e.g. 
+   - the OpenAPI Spec for reproducing the issue (:bulb: use [Gist](https://gist.github.com) to share). If the OpenAPI Spec cannot be shared publicly, it will be hard for the community to help
+   - version of Swagger Codegen
+   - language (`-l` in the command line, e.g. java, csharp, php)
+ - You can also make a suggestion or ask a question by opening an "issue"
+
+## Before submitting a PR
+
+ - Search the [open issue](https://github.com/swagger-api/swagger-codegen/issues) to ensure no one else has reported something similar and no one is actively working on similar proposed change.
+ - If no one has suggested something similar, open an ["issue"](https://github.com/swagger-api/swagger-codegen/issues) with your suggestion to gather feedback from the community.
+
+## How to contribute
+
+### Code generators
+
+All the code generators can be found in [modules/swagger-codegen/src/main/java/io/swagger/codegen/languages](https://github.com/swagger-api/swagger-codegen/tree/master/modules/swagger-codegen/src/main/java/io/swagger/codegen/languages)
+
+### Templates
+
+All the templates ([mustache](https://mustache.github.io/)) can be found in [modules/swagger-codegen/src/main/resources](https://github.com/swagger-api/swagger-codegen/tree/master/modules/swagger-codegen/src/main/resources).
+
+For a list of variables available in the template, please refer to this [page](https://github.com/swagger-api/swagger-codegen/wiki/Mustache-Template-Variables)
+
+
+### Style guide
+Code change should conform to the programming style guide of the respective langauages:
+- C#: https://msdn.microsoft.com/en-us/library/vstudio/ff926074.aspx
+- Java: https://google.github.io/styleguide/javaguide.html
+- ObjC: https://github.com/NYTimes/objective-c-style-guide
+- PHP: https://github.com/php-fig/fig-standards/blob/master/accepted/PSR-2-coding-style-guide.md
+- Python: https://www.python.org/dev/peps/pep-0008/
+- Ruby: https://github.com/bbatsov/ruby-style-guide
+- TypeScript: https://github.com/Microsoft/TypeScript/wiki/Coding-guidelines
+
+
+For other languages, feel free to suggest.
+
+You may find the current code base not 100% conform to the coding style and we welcome contributions to fix those.
+
+### Testing
+
+To add test cases (optional) covering the change in the code generator, please refer to [modules/swagger-codegen/src/test/java/io/swagger/codegen](https://github.com/swagger-api/swagger-codegen/tree/master/modules/swagger-codegen/src/test/java/io/swagger/codegen)
+
+To test the templates, please perform the following:
+- Update the [Petstore](http://petstore.swagger.io/) sample by running the shell script under `bin` folder. For example, run `./bin/ruby-petstore.sh` to update the Ruby PetStore API client under [`samples/client/petstore/ruby`](https://github.com/swagger-api/swagger-codegen/tree/master/samples/client/petstore/ruby) (For Windows, the batch files can be found under `bin\windows` folder)
+- Run the tests in the sample folder, e.g. in `samples/client/petstore/ruby`, run `mvn integration-test -rf :RubyPetstoreClientTests`. (some languages may not contain unit testing for Petstore and we're looking for contribution from the community to implement those tests)
+- Finally, git commit the updated samples files: `git commit -a`
+  (`git add -A` if added files with new test cases)
+
+To start the CI tests, you can run `mvn verify -Psamples` (assuming you've all the required tools installed to run tests for different languages) or you can leverage http://travis-ci.org to run the CI tests by adding your own Swagger-Codegen repository.
+
+### Tips
+- Smaller changes are easier to review
+- [Optional] For bug fixes, provide a OpenAPI Spec to repeat the issue so that the reviewer can use it to confirm the fix
+- Add test case(s) to cover the change
+- Document the fix in the code to make the code more readable
+- Make sure test cases passed after the change (one way is to leverage https://travis-ci.org/ to run the CI tests)

Dockerfile

@@ -0,0 +1,13 @@
+FROM maven:3.3-jdk-7
+
+WORKDIR /src
+VOLUME  /src
+VOLUME  /root/.m2/repository
+
+ADD . /opt/swagger-codegen
+
+RUN cd /opt/swagger-codegen && mvn package
+
+ENTRYPOINT ["java", "-jar", "/opt/swagger-codegen/modules/swagger-codegen-cli/target/swagger-codegen-cli.jar"]
+
+CMD ["help"]

README.md

@@ -1,47 +1,131 @@
 # Swagger Code Generator
 
 [![Build Status](https://travis-ci.org/swagger-api/swagger-codegen.png)](https://travis-ci.org/swagger-api/swagger-codegen)
+[![Maven Central](https://maven-badges.herokuapp.com/maven-central/io.swagger/swagger-codegen-project/badge.svg?style=plastic)](https://maven-badges.herokuapp.com/maven-central/io.swagger/swagger-codegen-project)
+
+:star::star::star: If you would like to contribute, please refer to [guidelines](https://github.com/swagger-api/swagger-codegen/blob/master/CONTRIBUTING.md) and a list of [open tasks](https://github.com/swagger-api/swagger-codegen/issues?q=is%3Aopen+is%3Aissue+label%3A%22Need+community+contribution%22).:star::star::star:
 
 ## Overview
 This is the swagger codegen project, which allows generation of client libraries automatically from a Swagger-compliant server.  
 
-Check out [Swagger-Spec](https://github.com/swagger-api/swagger-spec) for additional information about the Swagger project, including additional libraries with support for other languages and more. 
+Check out [Swagger-Spec](https://github.com/OAI/OpenAPI-Specification) for additional information about the Swagger project, including additional libraries with support for other languages and more.
+
+# Table of contents
+
+  - [Swagger Code Generator](#swagger-code-generator)
+  - [Overview](#overview)
+  - [Table of Contents](#table-of-contents)
+  - Installation
+    - [Compatibility](#compatibility)
+    - [Prerequisites](#prerequisites)
+      - [OS X Users](#os-x-users)
+    - [Building](#building)
+    - [Docker](#docker)
+      - [Build and run](#build-and-run-using-docker)
+      - [Build a Node.js server stub](#build-a-nodejs-server-stub)
+    - [Homebrew](#homebrew)
+  - Generators
+    - [To generate a sample client library](#to-generate-a-sample-client-library)
+    - [Generating libraries from your server](#generating-libraries-from-your-server)
+    - [Modifying the client library format](#modifying-the-client-library-format)
+    - [Making your own codegen modules](#making-your-own-codegen-modules)
+    - [Where is Javascript???](#where-is-javascript)
+    - [Generating a client from local files](#generating-a-client-from-local-files)
+    - [Customizing the generator](#customizing-the-generator)
+    - [Validating your OpenAPI Spec](#validating-your-swagger-spec)
+    - [Generating dynamic html api documentation](#generating-dynamic-html-api-documentation)
+    - [Generating static html api documentation](#generating-static-html-api-documentation)
+    - [To build a server stub](#to-build-a-server-stub)
+      - [Node.js](#nodejs)
+      - [PHP Silex](#php-silex)
+      - [Python Flask (Connexion)](#python-flask-connexion)
+      - [Ruby Sinatra](#ruby-sinatra)
+      - [Scala Scalatra](#scala-scalatra)
+      - [Java JAX-RS](#java-jax-rs)
+      - [Java Spring MVC](#java-spring-mvc)
+    - [To build the codegen library](#to-build-the-codegen-library)
+  - [Workflow Integration](#workflow-integration)
+  - [Online Generators](#online-generators)
+  - [Guidelines for Contribution](https://github.com/swagger-api/swagger-codegen/wiki/Guidelines-for-Contribution)
+  - [License](#license)
 
 
 ## Compatibility
-The Swagger Specification has undergone 3 revisions since initial creation in 2010.  The swagger-codegen project has the following compatibilies with the swagger specification:
+The OpenAPI Specification has undergone 3 revisions since initial creation in 2010.  The swagger-codegen project has the following compatibilies with the OpenAPI Specification:
 
-Swagger Codegen Version | Release Date | Swagger Spec compatibility | Notes
------------------------ | ------------ | -------------------------- | -----
-2.1.0                   | 2015-06-09   | 1.0, 1.1, 1.2, 2.0   | [master](https://github.com/swagger-api/swagger-codegen)
-2.0.17                  | 2014-08-22   | 1.1, 1.2      | [tag v2.0.17](https://github.com/swagger-api/swagger-codegen/tree/v2.0.17)
-1.0.4                   | 2012-04-12   | 1.0, 1.1      | [tag v1.0.4](https://github.com/swagger-api/swagger-codegen/tree/swagger-codegen_2.9.1-1.1)
+Swagger Codegen Version    | Release Date | OpenAPI Spec compatibility | Notes
+-------------------------- | ------------ | -------------------------- | -----
+2.1.6-SNAPSHOT             |              | 1.0, 1.1, 1.2, 2.0   | [master](https://github.com/swagger-api/swagger-codegen)
+2.1.5 (**current stable**) | 2015-01-06   | 1.0, 1.1, 1.2, 2.0   | [tag v2.1.5](https://github.com/swagger-api/swagger-codegen/tree/v2.1.4)
+2.0.17                     | 2014-08-22   | 1.1, 1.2             | [tag v2.0.17](https://github.com/swagger-api/swagger-codegen/tree/v2.0.17)
+1.0.4                      | 2012-04-12   | 1.0, 1.1             | [tag v1.0.4](https://github.com/swagger-api/swagger-codegen/tree/swagger-codegen_2.9.1-1.1)
 
 
 ### Prerequisites
-You need the following installed and available in your $PATH:
+If you're looking for the latest stable version, you can grab it directly from maven central (you'll need the java 7 runtime):
+
+```
+wget http://repo1.maven.org/maven2/io/swagger/swagger-codegen-cli/2.1.4/swagger-codegen-cli-2.1.4.jar swagger-codegen-cli.jar
+
+java -jar swagger-codegen-cli.jar help
+```
+
+On a mac, it's even easier with `brew`:
+```
+brew install swagger-codegen
+```
+
+To build from source, you need the following installed and available in your $PATH:
 
 * [Java 7](http://java.oracle.com)
 
 * [Apache maven 3.0.3 or greater](http://maven.apache.org/)
- 
+
 #### OS X Users
 Don't forget to install Java 7. You probably have 1.6 or 1.8.
 
-Export JAVA_HOME in order to user proper Java version:
+Export JAVA_HOME in order to use the supported Java version:
 ```
 export JAVA_HOME=`/usr/libexec/java_home -v 1.7`
 export PATH=${JAVA_HOME}/bin:$PATH
 ```
 
-#### Building
+### Building
 
 After cloning the project, you can build it from source with this command:
-
 ```
 mvn package
 ```
 
+### Docker
+#### Build and run using docker
+
+```
+git clone https://github.com/swagger-api/swagger-codegen
+
+cd swagger-codegen
+
+./run-in-docker.sh mvn package
+ ```
+
+#### Build a Node.js server stub
+
+ ```
+./run-in-docker.sh generate \
+  -i http://petstore.swagger.io/v2/swagger.json \
+  -l nodejs \
+  -o samples/server/petstore/nodejs
+ ```
+
+### Homebrew
+To install, run `brew install swagger-codegen`
+
+Here is an example usage:
+```
+swagger-codegen generate -i http://petstore.swagger.io/v2/swagger.json -l ruby -o /tmp/test/
+```
+
+
 ### To generate a sample client library
 You can build a client against the swagger sample [petstore](http://petstore.swagger.io) API as follows:
 
@@ -49,6 +133,8 @@ You can build a client against the swagger sample [petstore](http://petstore.swa
 ./bin/java-petstore.sh
 ```
 
+(On Windows, run `./bin/windows/java-petstore.bat` instead)
+
 This will run the generator with this command:
 
 ```
@@ -58,7 +144,7 @@ java -jar modules/swagger-codegen-cli/target/swagger-codegen-cli.jar generate \
   -o samples/client/petstore/java
 ```
 
-With a number of options.  You can get the options with the `help generate` command:
+with a number of options.  You can get the options with the `help generate` command:
 
 ```
 NAME
@@ -73,6 +159,7 @@ SYNOPSIS
                 [(-o <output directory> | --output <output directory>)]
                 [(-t <template directory> | --template-dir <template directory>)]
                 [(-v | --verbose)]
+                [(-s | --skip-overwrite)]
 
 OPTIONS
         -a <authorization>, --auth <authorization>
@@ -91,7 +178,7 @@ OPTIONS
             name=value,name=value
 
         -i <spec file>, --input-spec <spec file>
-            location of the swagger spec, as URL or file (required)
+            location of the OpenAPI Spec, as URL or file (required)
 
         -l <language>, --lang <language>
             client language to generate (maybe class name in classpath,
@@ -105,7 +192,11 @@ OPTIONS
 
         -v, --verbose
             verbose mode
- ```
+
+        -s , --skip-overwrite
+            specifies if the existing files should be overwritten during
+            the generation
+```
 
 You can then compile and run the client, as well as unit tests against it:
 
@@ -133,20 +224,37 @@ You can look at `modules/swagger-codegen/src/main/resources/${your-language}` fo
 If you're starting a project with a new language and don't see what you need, swagger-codegen can help you create a project to generate your own libraries:
 
 ```
-java -jar modules/swagger-codegen-distribution/target/swagger-codegen-cli.jar meta \
+java -jar modules/swagger-codegen-cli/target/swagger-codegen-cli.jar meta \
   -o output/myLibrary -n myClientCodegen -p com.my.company.codegen
 ```
 
 This will write, in the folder `output/myLibrary`, all the files you need to get started, including a README.md. Once modified and compiled, you can load your library with the codegen and generate clients with your own, custom-rolled logic.
 
+You would then compile your library in the `output/myLibrary` folder with `mvn package` and execute the codegen like such:
+
+
+```
+java -cp output/myLibrary/target/myClientCodegen-swagger-codegen-1.0.0.jar:modules/swagger-codegen-cli/target/swagger-codegen-cli.jar io.swagger.codegen.Codegen
+```
+
+Note the `myClientCodegen` is an option now, and you can use the usual arguments for generating your library:
+
+```
+java -cp output/myLibrary/target/myClientCodegen-swagger-codegen-1.0.0.jar:modules/swagger-codegen-cli/target/swagger-codegen-cli.jar \
+  io.swagger.codegen.Codegen generate -l myClientCodegen\
+  -i http://petstore.swagger.io/v2/swagger.json \
+  -o myClient
+```
+
 ### Where is Javascript???
 See our [javascript library](http://github.com/swagger-api/swagger-js)--it's completely dynamic and doesn't require
 static code generation.
-There is a third-party component called [swagger-js-codegen](https://github.com/wcandillon/swagger-js-codegen) that can generate angularjs or nodejs source code from a swagger specification.
+There is a third-party component called [swagger-js-codegen](https://github.com/wcandillon/swagger-js-codegen) that can generate angularjs or nodejs source code from a OpenAPI Specification.
 
+:exclamation: On Dec 7th 2015, a Javascript API client generator has been added by @jfiala.
 
-#### Generating a client from flat files (i.e. no remote server calls)
-If you don't want to call your server, you can save the swagger spec files into a directory and pass an argument
+### Generating a client from local files
+If you don't want to call your server, you can save the OpenAPI Spec files into a directory and pass an argument
 to the code generator like this:
 
 ```
@@ -155,36 +263,79 @@ to the code generator like this:
 
 Great for creating libraries on your ci server, from the [Swagger Editor](http://editor.swagger.io)... or while coding on an airplane.
 
+### Selective generation
+You may not want to generate *all* models in your project.  Likewise you may want just one or two apis to be written.  If that's the case, you can use system properties to control the output:
+
+The default is generate *everything* supported by the specific library.  Once you enable a feature, it will restrict the contents generated:
+
+```
+# generate only models
+java -Dmodels {opts}
+
+# generate only apis
+java -Dapis {opts}
+
+# generate only supporting files
+java -DsupportingFiles
+
+# generate models and supporting files
+java -Dmodels -DsupportingFiles
+```
+
+To control the specific files being generated, you can pass a CSV list of what you want:
+```
+# generate the User and Pet models only
+-Dmodels=User,Pet
+
+# generate the User model and the supportingFile `StringUtil.java`:
+-Dmodels=User -DsupportingFiles=StringUtil.java
+```
+
+When using selective generation, _only_ the templates needed for the specific generation will be used.
+
 ### Customizing the generator
 
 There are different aspects of customizing the code generator beyond just creating or modifying templates.  Each language has a supporting configuration file to handle different type mappings, etc:
 
 ```
 $ ls -1 modules/swagger-codegen/src/main/java/io/swagger/codegen/languages/
+AbstractTypeScriptClientCodegen.java
 AkkaScalaClientCodegen.java
 AndroidClientCodegen.java
+AndroidVolleyClientCodegen.java
 AsyncScalaClientCodegen.java
 CSharpClientCodegen.java
+ClojureClientCodegen.java
+CsharpDotNet2ClientCodegen.java
+DartClientCodegen.java
+FlashClientCodegen.java
+FlaskConnexionCodegen.java
 JavaClientCodegen.java
+JavaInflectorServerCodegen.java
+JavascriptClientCodegen.java
 JaxRSServerCodegen.java
+JMeterCodegen.java
 NodeJSServerCodegen.java
 ObjcClientCodegen.java
 PerlClientCodegen.java
 PhpClientCodegen.java
-Python3ClientCodegen.java
 PythonClientCodegen.java
 Qt5CPPGenerator.java
-RetrofitClientCodegen.java
 RubyClientCodegen.java
 ScalaClientCodegen.java
 ScalatraServerCodegen.java
+SilexServerCodegen.java
+SinatraServerCodegen.java
+SlimFrameworkServerCodegen.java
 SpringMVCServerCodegen.java
 StaticDocCodegen.java
 StaticHtmlGenerator.java
 SwaggerGenerator.java
 SwaggerYamlGenerator.java
-SwiftGenerator.java
+SwiftCodegen.java
 TizenClientCodegen.java
+TypeScriptAngularClientCodegen.java
+TypeScriptNodeClientCodegen.java
 ```
 
 Each of these files creates reasonable defaults so you can get running quickly.  But if you want to configure package names, prefixes, model folders, etc. you can use a json config file to pass the values.
@@ -196,10 +347,11 @@ java -jar modules/swagger-codegen-cli/target/swagger-codegen-cli.jar generate \
   -o samples/client/petstore/java \
   -c path/to/config.json
 ```
-Supported config options can be different per language. Running `config-help -l {lang}` will show available options.
+Supported config options can be different per language. Running `config-help -l {lang}` will show available options.  **These options are applied 
+by passing them with `-D{optionName}={optionValue}**.
 
 ```
-java -jar modules/swagger-codegen-cli/target/swagger-codegen-cli.jarr config-help -l java
+java -jar modules/swagger-codegen-cli/target/swagger-codegen-cli.jar config-help -l java
 ```
 
 Output
@@ -212,6 +364,9 @@ CONFIG OPTIONS
 	apiPackage
 	    package for generated api classes
 
+	sortParamsByRequiredFlag
+	    Sort method arguments to place required parameters before optional parameters. Default: true
+
 	invokerPackage
 	    root package for generated code
 
@@ -226,6 +381,21 @@ CONFIG OPTIONS
 
 	sourceFolder
 	    source folder for generated code
+
+	localVariablePrefix
+	    prefix for generated code members and local variables
+
+	serializableModel
+	    boolean - toggle "implements Serializable" for generated models
+
+	library
+	    library template (sub-template) to use:
+	    <default> - HTTP client: Jersey client 1.18. JSON processing: Jackson 2.4.2
+	    jersey2 - HTTP client: Jersey client 2.6
+	    feign - HTTP client: Netflix Feign 8.1.1.  JSON processing: Jackson 2.6.3
+	    okhttp-gson - HTTP client: OkHttp 2.4.0. JSON processing: Gson 2.3.1
+	    retrofit - HTTP client: OkHttp 2.4.0. JSON processing: Gson 2.3.1 (Retrofit 1.9.0)
+        retrofit2 - HTTP client: OkHttp 2.5.0. JSON processing: Gson 2.4 (Retrofit 2.0.0-beta2)
 ```
 
 Your config file for java can look like
@@ -234,13 +404,14 @@ Your config file for java can look like
 {
   "groupId":"com.my.company",
   "artifactId":"MyClent",
-  "artifactVersion":"1.2.0"
+  "artifactVersion":"1.2.0",
+  "library":"feign"
 }
 ```
 
 For all the unspecified options default values will be used.
 
-Another way to override default options is to extend config class for specific language.
+Another way to override default options is to extend the config class for the specific language.
 To change, for example, the prefix for the Objective-C generated files, simply subclass the ObjcClientCodegen.java:
 
 ```
@@ -263,7 +434,25 @@ and specify the `classname` when running the generator:
 
 Your subclass will now be loaded and overrides the `PREFIX` value in the superclass.
 
-### Validating your swagger spec
+### Bringing your own models
+
+Sometimes you don't want a model generated.  In this case, you can simply specify an import mapping to tell
+the codegen what _not_ to create.  When doing this, every location that references a specific model will
+refer back to your classes.  Note, this may not apply to all languages...
+
+To specify an import mapping, use the `--import-mappings` argument and specify the model-to-import logic as such:
+
+```
+--import-mappings Pet=my.models.MyPet
+```
+
+Or for multiple mappings:
+
+```
+Pet=my.models.MyPet,Order=my.models.MyOrder
+```
+
+### Validating your OpenAPI Spec
 
 You have options.  The easiest is to use our [online validator](https://github.com/swagger-api/validator-badge) which not only will let you validate your spec, but with the debug flag, you can see what's wrong with your spec.  For example:
 
@@ -296,7 +485,8 @@ open index.html
 
 You can also use the codegen to generate a server for a couple different frameworks.  Take a look here:
 
-### node.js
+### Node.js
+
 ```
 java -jar modules/swagger-codegen-cli/target/swagger-codegen-cli.jar generate \
   -i http://petstore.swagger.io/v2/swagger.json \
@@ -304,11 +494,34 @@ java -jar modules/swagger-codegen-cli/target/swagger-codegen-cli.jar generate \
   -o samples/server/petstore/nodejs
 ```
 
-### rails-grape
-#### Not yet migrated to this branch
+### PHP Silex
 
+```
+java -jar modules/swagger-codegen-cli/target/swagger-codegen-cli.jar generate \
+  -i http://petstore.swagger.io/v2/swagger.json \
+  -l silex \
+  -o samples/server/petstore/silex
+```
 
-### scala scalatra
+### Python Flask (Connexion)
+
+```
+java -jar modules/swagger-codegen-cli/target/swagger-codegen-cli.jar generate \
+  -i http://petstore.swagger.io/v2/swagger.json \
+  -l flaskConnexion \
+  -o samples/server/petstore/flaskConnexion
+```
+
+### Ruby Sinatra
+
+```
+java -jar modules/swagger-codegen-cli/target/swagger-codegen-cli.jar generate \
+  -i http://petstore.swagger.io/v2/swagger.json \
+  -l sinatra \
+  -o samples/server/petstore/sinatra
+```
+
+### Scala Scalatra
 ```
 java -jar modules/swagger-codegen-cli/target/swagger-codegen-cli.jar generate \
   -i http://petstore.swagger.io/v2/swagger.json \
@@ -316,7 +529,7 @@ java -jar modules/swagger-codegen-cli/target/swagger-codegen-cli.jar generate \
   -o samples/server/petstore/scalatra
 ```
 
-### java jax-rs
+### Java JAX-RS
 
 ```
 java -jar modules/swagger-codegen-cli/target/swagger-codegen-cli.jar generate \
@@ -325,7 +538,7 @@ java -jar modules/swagger-codegen-cli/target/swagger-codegen-cli.jar generate \
   -o samples/server/petstore/jaxrs
 ```
 
-### java spring-mvc
+### Java Spring MVC
 
 ```
 java -jar modules/swagger-codegen-cli/target/swagger-codegen-cli.jar generate \
@@ -333,6 +546,7 @@ java -jar modules/swagger-codegen-cli/target/swagger-codegen-cli.jar generate \
   -l spring-mvc \
   -o samples/server/petstore/spring-mvc
 ```
+
 ### To build the codegen library
 
 This will create the swagger-codegen library from source.  
@@ -343,6 +557,26 @@ mvn package
 
 Note!  The templates are included in the library generated.  If you want to modify the templates, you'll need to either repackage the library OR specify a path to your scripts
 
+## Workflow integration
+
+You can use the [swagger-codegen-maven-plugin](modules/swagger-codegen-maven-plugin/README.md) for integrating with your workflow, and generating any codegen target.
+
+
+## Online generators
+
+One can also generate API client or server using the online generators (https://generator.swagger.io)
+
+For example, to generate Ruby API client, simply send the following HTTP request using curl:
+```
+curl -X POST -H "content-type:application/json" -d '{"swaggerUrl":"http://petstore.swagger.io/v2/swagger.json"}' https://generator.swagger.io/api/gen/clients/ruby
+```
+Then you will receieve a JSON response with the URL to download the zipped code.
+
+Guidelines for Contribution
+---------------------------
+
+Please refer to this [page](https://github.com/swagger-api/swagger-codegen/blob/master/CONTRIBUTING.md)
+
 License
 -------
 

bin/all-petstore.sh

@@ -18,19 +18,33 @@ if [ ! -d "${APP_DIR}" ]; then
 fi
 
 cd $APP_DIR
-./bin/android-java-petstore.sh
+./bin/akka-scala-petstore.sh
+./bin/android-petstore.sh
+./bin/clojure-petstore.sh
 ./bin/csharp-petstore.sh
 ./bin/dynamic-html.sh
 ./bin/html-petstore.sh
-./bin/jaxrs-petstore-server.sh
 ./bin/java-petstore.sh
-./bin/qt5-petstore.sh
+./bin/java-petstore-jersey2.sh
+./bin/java-petstore-okhttp-gson.sh
+./bin/java-petstore-retrofit.sh
++./bin/java-petstore-retrofit2.sh
+./bin/jaxrs-petstore-server.sh
+./bin/nodejs-petstore-server.sh
+./bin/objc-petstore.sh
 ./bin/perl-petstore.sh
 ./bin/php-petstore.sh
 ./bin/python-petstore.sh
-./bin/retrofit-petstore.sh
+./bin/qt5-petstore.sh
 ./bin/ruby-petstore.sh
-./bin/objc-petstore.sh
+./bin/scala-async-petstore.sh
 ./bin/scala-petstore.sh
+./bin/scalatra-petstore-server.sh
+./bin/silex-petstore-server.sh
+./bin/slim-petstore-server.sh
 ./bin/spring-mvc-petstore-server.sh
+./bin/spring-mvc-petstore-j8-async-server.sh
+./bin/swift-petstore.sh
 ./bin/tizen-petstore.sh
+./bin/typescript-angular-petstore.sh
+./bin/typescript-node-petstore.sh

bin/android-petstore-volley.json

@@ -0,0 +1,4 @@
+{
+    "library": "volley",
+    "artifactId": "swagger-petstore-android-volley"
+}

bin/android-petstore-volley.sh

@@ -26,6 +26,6 @@ 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="$@ generate -t modules/swagger-codegen/src/main/resources/python3 -i modules/swagger-codegen/src/test/resources/2_0/petstore.json -l python3 -o samples/client/petstore/python3"
+ags="$@ generate -i modules/swagger-codegen/src/test/resources/2_0/petstore.json -l android -c bin/android-petstore-volley.json -o samples/client/petstore/android/volley"
 
 java $JAVA_OPTS -jar $executable $ags

bin/android-petstore.sh

@@ -26,6 +26,6 @@ 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="$@ generate -t modules/swagger-codegen/src/main/resources/android-java -i modules/swagger-codegen/src/test/resources/2_0/petstore.json -l android -o samples/client/petstore/android-java"
+ags="$@ generate -t modules/swagger-codegen/src/main/resources/android -i modules/swagger-codegen/src/test/resources/2_0/petstore.json -l android -o samples/client/petstore/android/default"
 
 java $JAVA_OPTS -jar $executable $ags

bin/clojure-petstore.sh

@@ -26,6 +26,6 @@ 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="$@ generate -t modules/swagger-codegen/src/main/resources/retrofit -i modules/swagger-codegen/src/test/resources/2_0/petstore.json -l retrofit -o samples/client/petstore/retrofit"
+ags="$@ generate -i modules/swagger-codegen/src/test/resources/2_0/petstore.json -l clojure -o samples/client/petstore/clojure"
 
 java $JAVA_OPTS -jar $executable $ags

bin/csharp-dotnet2-petstore.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="$@ generate -i modules/swagger-codegen/src/test/resources/2_0/petstore.json -l CsharpDotNet2 -o samples/client/petstore/csharp-dotnet2/SwaggerClientTest/Lib/SwaggerClient"
+
+java $JAVA_OPTS -jar $executable $ags

bin/csharp-petstore.sh

@@ -26,6 +26,6 @@ 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="$@ generate -i modules/swagger-codegen/src/test/resources/2_0/petstore.json -l csharp -o samples/client/petstore/csharp"
+ags="$@ generate -i modules/swagger-codegen/src/test/resources/2_0/petstore.json -l csharp -o samples/client/petstore/csharp/SwaggerClientTest/Lib/SwaggerClient"
 
 java $JAVA_OPTS -jar $executable $ags

bin/dart-petstore.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="$@ generate -i modules/swagger-codegen/src/test/resources/2_0/petstore.json -l dart -o samples/client/petstore/dart"
+
+java $JAVA_OPTS -jar $executable $ags

bin/flash-petstore.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="$@ generate -t modules/swagger-codegen/src/main/resources/flash -i modules/swagger-codegen/src/test/resources/2_0/petstore.json -l flash -o samples/client/petstore/flash"
+
+java $JAVA_OPTS -jar $executable $ags

bin/flaskConnexion.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="$@ generate -i modules/swagger-codegen/src/test/resources/2_0/petstore.json -l python-flask -o samples/server/petstore/flaskConnexion "
+
+java $JAVA_OPTS -Dservice -jar $executable $ags

bin/java-inflector-petstore-server.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="$@ generate -t modules/swagger-codegen/src/main/resources/JavaInflector -i modules/swagger-codegen/src/test/resources/2_0/petstore.json -l inflector -o samples/server/petstore/java-inflector"
+
+java $JAVA_OPTS -jar $executable $ags

bin/java-petstore-all.sh

@@ -0,0 +1,9 @@
+#!/bin/sh
+# update java petstore for all supported http libraries
+
+./bin/java-petstore.sh
+./bin/java-petstore-jersey2.sh
+./bin/java-petstore-feign.sh
+./bin/java-petstore-okhttp-gson.sh
+./bin/java-petstore-retrofit.sh
+./bin/java-petstore-retrofit2.sh

bin/java-petstore-feign.json

@@ -0,0 +1,4 @@
+{
+    "library": "feign",
+    "artifactId": "swagger-petstore-feign"
+}

bin/java-petstore-feign.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="$@ generate -i modules/swagger-codegen/src/test/resources/2_0/petstore.json -l java -c bin/java-petstore-feign.json -o samples/client/petstore/java/feign"
+
+java $JAVA_OPTS -jar $executable $ags

bin/java-petstore-jersey2.json

@@ -0,0 +1,4 @@
+{
+    "library": "jersey2",
+    "artifactId": "swagger-petstore-jersey2"
+}

bin/java-petstore-jersey2.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="$@ generate -i modules/swagger-codegen/src/test/resources/2_0/petstore.json -l java -c bin/java-petstore-jersey2.json -o samples/client/petstore/java/jersey2"
+
+java $JAVA_OPTS -jar $executable $ags

bin/java-petstore-okhttp-gson.json

@@ -0,0 +1,4 @@
+{
+    "library": "okhttp-gson",
+    "artifactId": "swagger-petstore-okhttp-gson"
+}

bin/java-petstore-okhttp-gson.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="$@ generate -i modules/swagger-codegen/src/test/resources/2_0/petstore.json -l java -c bin/java-petstore-okhttp-gson.json -o samples/client/petstore/java/okhttp-gson"
+
+java $JAVA_OPTS -jar $executable $ags

bin/java-petstore-retrofit.json

@@ -0,0 +1,4 @@
+{
+    "library": "retrofit",
+    "artifactId": "swagger-petstore-retrofit"
+}

bin/java-petstore-retrofit.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="$@ generate -i modules/swagger-codegen/src/test/resources/2_0/petstore.json -l java -c bin/java-petstore-retrofit.json -o samples/client/petstore/java/retrofit"
+
+java $JAVA_OPTS -jar $executable $ags

bin/java-petstore-retrofit2.json

@@ -0,0 +1,4 @@
+{
+    "library": "retrofit2",
+    "artifactId": "swagger-petstore-retrofit2"
+}

bin/java-petstore-retrofit2.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="$@ generate -i modules/swagger-codegen/src/test/resources/2_0/petstore.json -l java -c bin/java-petstore-retrofit2.json -o samples/client/petstore/java/retrofit2"
+
+java $JAVA_OPTS -jar $executable $ags

bin/java-petstore.sh

@@ -26,6 +26,6 @@ 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="$@ generate -i modules/swagger-codegen/src/test/resources/2_0/petstore.json -l java -o samples/client/petstore/java"
+ags="$@ generate -i modules/swagger-codegen/src/test/resources/2_0/petstore.json -l java -o samples/client/petstore/java/default"
 
 java $JAVA_OPTS -jar $executable $ags

bin/javascript-petstore.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="$@ generate -t modules/swagger-codegen/src/main/resources/javascript -i modules/swagger-codegen/src/test/resources/2_0/petstore.json -l javascript -o samples/client/petstore/javascript"
+
+java -DappName=PetstoreClient $JAVA_OPTS -jar $executable $ags

bin/jaxrs-petstore-server.sh

@@ -26,6 +26,6 @@ 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="$@ generate -t modules/swagger-codegen/src/main/resources/JavaJaxRS -i modules/swagger-codegen/src/test/resources/2_0/petstore.json -l jaxrs -o samples/server/petstore/jaxrs -Dswagger.codegen.jaxrs.impl.source=src/main/java"
+ags="$@ generate -t modules/swagger-codegen/src/main/resources/JavaJaxRS -i modules/swagger-codegen/src/test/resources/2_0/petstore.json -l jaxrs -o samples/server/petstore/jaxrs"
 
 java $JAVA_OPTS -jar $executable $ags

bin/ruby-petstore.json

@@ -0,0 +1,5 @@
+{
+  "gemName": "petstore",
+  "moduleName": "Petstore",
+  "gemVersion": "1.0.0"
+}

bin/ruby-petstore.sh

@@ -26,6 +26,6 @@ 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="$@ generate -t modules/swagger-codegen/src/main/resources/ruby -i modules/swagger-codegen/src/test/resources/2_0/petstore.json -l ruby -o samples/client/petstore/ruby"
+ags="$@ generate -t modules/swagger-codegen/src/main/resources/ruby -i modules/swagger-codegen/src/test/resources/2_0/petstore.json -l ruby -c bin/ruby-petstore.json -o samples/client/petstore/ruby"
 
 java $JAVA_OPTS -jar $executable $ags

bin/silex-petstore-server.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="$@ generate -t modules/swagger-codegen/src/main/resources/silex -i modules/swagger-codegen/src/test/resources/2_0/petstore.json -l silex -o samples/server/petstore/silex"
+
+java $JAVA_OPTS -jar $executable $ags

bin/sinatra-petstore-server.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="$@ generate -t modules/swagger-codegen/src/main/resources/sinatra -i modules/swagger-codegen/src/test/resources/2_0/petstore.json -l sinatra -o samples/server/petstore/sinatra"
+
+java $JAVA_OPTS -jar $executable $ags

bin/slim-petstore-server.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="$@ generate -t modules/swagger-codegen/src/main/resources/slim -i modules/swagger-codegen/src/test/resources/2_0/petstore.json -l slim -o samples/server/petstore/slim"
+
+java $JAVA_OPTS -jar $executable $ags

bin/spring-mvc-petstore-j8-async-server.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="$@ generate -t modules/swagger-codegen/src/main/resources/JavaSpringMVC -i modules/swagger-codegen/src/test/resources/2_0/petstore.json -l spring-mvc -o samples/server/petstore/spring-mvc-j8-async -c bin/spring-mvc-petstore-j8-async.json"
+
+java $JAVA_OPTS -jar $executable $ags

bin/spring-mvc-petstore-j8-async.json

@@ -0,0 +1,3 @@
+{
+    "library": "j8-async"
+}

bin/swift-petstore.json

@@ -0,0 +1,4 @@
+{
+  "projectName": "PetstoreClient",
+  "responseAs": "PromiseKit"
+}

bin/swift-petstore.sh

@@ -26,6 +26,6 @@ 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="$@ generate -t modules/swagger-codegen/src/main/resources/swift -i modules/swagger-codegen/src/test/resources/2_0/petstore.json -l swift -o samples/client/petstore/swift"
+ags="$@ generate -t modules/swagger-codegen/src/main/resources/swift -i modules/swagger-codegen/src/test/resources/2_0/petstore.json -l swift -c ./bin/swift-petstore.json -o samples/client/petstore/swift"
 
-java -DappName=PetstoreClient $JAVA_OPTS -jar $executable $ags
+java $JAVA_OPTS -jar $executable $ags

bin/typescript-angular-petstore.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="$@ generate -i modules/swagger-codegen/src/test/resources/2_0/petstore.json -l typescript-angular -o samples/client/petstore/typescript-angular"
+
+java $JAVA_OPTS -jar $executable $ags

bin/typescript-node-petstore.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="$@ generate -i modules/swagger-codegen/src/test/resources/2_0/petstore.json -l typescript-node -o samples/client/petstore/typescript-node"
+
+java $JAVA_OPTS -jar $executable $ags

bin/windows/akka-scala-petstore.bat

@@ -0,0 +1,10 @@
+set executable=.\modules\swagger-codegen-cli\target\swagger-codegen-cli.jar
+
+If Not Exist %executable% (
+  mvn clean package
+)
+
+set JAVA_OPTS=%JAVA_OPTS% -XX:MaxPermSize=256M -Xmx1024M -DloggerPath=conf/log4j.properties
+set ags=generate -t modules\swagger-codegen\src\main\resources\akka-scala -i modules\swagger-codegen\src\test\resources\2_0\petstore.json -l akka-scala -o samples\client\petstore\akka-scala
+
+java %JAVA_OPTS% -jar %executable% %ags%

bin/windows/android-petstore.bat

@@ -0,0 +1,10 @@
+set executable=.\modules\swagger-codegen-cli\target\swagger-codegen-cli.jar
+
+If Not Exist %executable% (
+  mvn clean package
+)
+
+set JAVA_OPTS=%JAVA_OPTS% -XX:MaxPermSize=256M -Xmx1024M -DloggerPath=conf/log4j.properties
+set ags=generate -t modules\swagger-codegen\src\main\resources\android -i modules\swagger-codegen\src\test\resources\2_0\petstore.json -l android -o samples\client\petstore\android\default
+
+java %JAVA_OPTS% -jar %executable% %ags%

bin/windows/async-scala-petstore.sh

@@ -0,0 +1,10 @@
+set executable=.\modules\swagger-codegen-cli\target\swagger-codegen-cli.jar
+
+If Not Exist %executable% (
+  mvn clean package
+)
+
+set JAVA_OPTS=%JAVA_OPTS% -XX:MaxPermSize=256M -Xmx1024M -DloggerPath=conf/log4j.properties
+set ags=generate -t modules\swagger-codegen\src\main\resources\asyncscala -i modules\swagger-codegen\src\test\resources\2_0\petstore.json -l async-scala -o samples\client\petstore\async-scala
+
+java %JAVA_OPTS% -jar %executable% %ags%

bin/windows/clojure-petstore.bat

@@ -0,0 +1,10 @@
+set executable=.\modules\swagger-codegen-cli\target\swagger-codegen-cli.jar
+
+If Not Exist %executable% (
+  mvn clean package
+)
+
+set JAVA_OPTS=%JAVA_OPTS% -XX:MaxPermSize=256M -Xmx1024M -DloggerPath=conf/log4j.properties
+set ags=generate -t modules\swagger-codegen\src\main\resources\clojure -i modules\swagger-codegen\src\test\resources\2_0\petstore.json -l clojure -o samples\client\petstore\clojure
+
+java %JAVA_OPTS% -jar %executable% %ags%

bin/windows/csharp-petstore.bat

@@ -0,0 +1,10 @@
+set executable=.\modules\swagger-codegen-cli\target\swagger-codegen-cli.jar
+
+If Not Exist %executable% (
+  mvn clean package
+)
+
+set JAVA_OPTS=%JAVA_OPTS% -XX:MaxPermSize=256M -Xmx1024M -DloggerPath=conf/log4j.properties
+set ags=generate -t modules\swagger-codegen\src\main\resources\csharp -i modules\swagger-codegen\src\test\resources\2_0\petstore.json -l csharp -o samples\client\petstore\csharp\SwaggerClientTest\Lib\SwaggerClient
+
+java %JAVA_OPTS% -jar %executable% %ags%

bin/windows/dart-petstore.bat

@@ -0,0 +1,10 @@
+set executable=.\modules\swagger-codegen-cli\target\swagger-codegen-cli.jar
+
+If Not Exist %executable% (
+  mvn clean package
+)
+
+set JAVA_OPTS=%JAVA_OPTS% -XX:MaxPermSize=256M -Xmx1024M -DloggerPath=conf/log4j.properties
+set ags=generate -t modules\swagger-codegen\src\main\resources\dart -i modules\swagger-codegen\src\test\resources\2_0\petstore.json -l dart -o samples\client\petstore\dart
+
+java %JAVA_OPTS% -jar %executable% %ags%

bin/windows/dynamic-html-petstore.bat

@@ -0,0 +1,10 @@
+set executable=.\modules\swagger-codegen-cli\target\swagger-codegen-cli.jar
+
+If Not Exist %executable% (
+  mvn clean package
+)
+
+set JAVA_OPTS=%JAVA_OPTS% -XX:MaxPermSize=256M -Xmx1024M -DloggerPath=conf/log4j.properties
+set ags=generate -t modules\swagger-codegen\src\main\resources\dynamic-html -i modules\swagger-codegen\src\test\resources\2_0\petstore.json -l dynamic-html -o samples\client\petstore\dynamic-html
+
+java %JAVA_OPTS% -jar %executable% %ags%

bin/windows/flash-petstore.bat

@@ -0,0 +1,10 @@
+set executable=.\modules\swagger-codegen-cli\target\swagger-codegen-cli.jar
+
+If Not Exist %executable% (
+  mvn clean package
+)
+
+set JAVA_OPTS=%JAVA_OPTS% -XX:MaxPermSize=256M -Xmx1024M -DloggerPath=conf/log4j.properties
+set ags=generate -t modules\swagger-codegen\src\main\resources\flash -i modules\swagger-codegen\src\test\resources\2_0\petstore.json -l flash -o samples\client\petstore\flash
+
+java %JAVA_OPTS% -jar %executable% %ags%

bin/windows/html-petstore.bat

@@ -0,0 +1,10 @@
+set executable=.\modules\swagger-codegen-cli\target\swagger-codegen-cli.jar
+
+If Not Exist %executable% (
+  mvn clean package
+)
+
+set JAVA_OPTS=%JAVA_OPTS% -XX:MaxPermSize=256M -Xmx1024M -DloggerPath=conf/log4j.properties
+set ags=generate -t modules\swagger-codegen\src\main\resources\html -i modules\swagger-codegen\src\test\resources\2_0\petstore.json -l html -o samples\client\petstore\html
+
+java %JAVA_OPTS% -jar %executable% %ags%

bin/windows/java-petstore.bat

@@ -0,0 +1,10 @@
+set executable=.\modules\swagger-codegen-cli\target\swagger-codegen-cli.jar
+
+If Not Exist %executable% (
+  mvn clean package
+)
+
+set JAVA_OPTS=%JAVA_OPTS% -XX:MaxPermSize=256M -Xmx1024M -DloggerPath=conf/log4j.properties
+set ags=generate -t modules\swagger-codegen\src\main\resources\java -i modules\swagger-codegen\src\test\resources\2_0\petstore.json -l java -o samples\client\petstore\java
+
+java %JAVA_OPTS% -jar %executable% %ags%

bin/windows/javascript-petstore.bat

@@ -0,0 +1,10 @@
+set executable=.\modules\swagger-codegen-cli\target\swagger-codegen-cli.jar
+
+If Not Exist %executable% (
+  mvn clean package
+)
+
+set JAVA_OPTS=%JAVA_OPTS% -XX:MaxPermSize=256M -Xmx1024M -DloggerPath=conf/log4j.properties
+set ags=generate -t modules\swagger-codegen\src\main\resources\javascript -i modules\swagger-codegen\src\test\resources\2_0\petstore.json -l javascript -o samples\client\petstore\javascript
+
+java %JAVA_OPTS% -jar %executable% %ags%

bin/windows/objc-petstore.bat

@@ -0,0 +1,10 @@
+set executable=.\modules\swagger-codegen-cli\target\swagger-codegen-cli.jar
+
+If Not Exist %executable% (
+  mvn clean package
+)
+
+set JAVA_OPTS=%JAVA_OPTS% -XX:MaxPermSize=256M -Xmx1024M -DloggerPath=conf/log4j.properties
+set ags=generate -t modules\swagger-codegen\src\main\resources\objc -i modules\swagger-codegen\src\test\resources\2_0\petstore.json -l objc -o samples\client\petstore\objc
+
+java %JAVA_OPTS% -DappName=PetstoreClient -jar %executable% %ags%

bin/windows/perl-petstore.bat

@@ -0,0 +1,10 @@
+set executable=.\modules\swagger-codegen-cli\target\swagger-codegen-cli.jar
+
+If Not Exist %executable% (
+  mvn clean package
+)
+
+set JAVA_OPTS=%JAVA_OPTS% -XX:MaxPermSize=256M -Xmx1024M -DloggerPath=conf/log4j.properties
+set ags=generate -t modules\swagger-codegen\src\main\resources\perl -i modules\swagger-codegen\src\test\resources\2_0\petstore.json -l perl -o samples\client\petstore\perl
+
+java %JAVA_OPTS% -jar %executable% %ags%

bin/windows/php-petstore.bat

@@ -0,0 +1,10 @@
+set executable=.\modules\swagger-codegen-cli\target\swagger-codegen-cli.jar
+
+If Not Exist %executable% (
+  mvn clean package
+)
+
+set JAVA_OPTS=%JAVA_OPTS% -XX:MaxPermSize=256M -Xmx1024M -DloggerPath=conf/log4j.properties
+set ags=generate -t modules\swagger-codegen\src\main\resources\php -i modules\swagger-codegen\src\test\resources\2_0\petstore.json -l php -o samples\client\petstore\php
+
+java %JAVA_OPTS% -jar %executable% %ags%

bin/windows/python-petstore.bat

@@ -0,0 +1,10 @@
+set executable=.\modules\swagger-codegen-cli\target\swagger-codegen-cli.jar
+
+If Not Exist %executable% (
+  mvn clean package
+)
+
+set JAVA_OPTS=%JAVA_OPTS% -XX:MaxPermSize=256M -Xmx1024M -DloggerPath=conf/log4j.properties
+set ags=generate -t modules\swagger-codegen\src\main\resources\python -i modules\swagger-codegen\src\test\resources\2_0\petstore.json -l python -o samples\client\petstore\python
+
+java %JAVA_OPTS% -jar %executable% %ags%

bin/windows/qt5cpp-petstore.bat

@@ -0,0 +1,10 @@
+set executable=.\modules\swagger-codegen-cli\target\swagger-codegen-cli.jar
+
+If Not Exist %executable% (
+  mvn clean package
+)
+
+set JAVA_OPTS=%JAVA_OPTS% -XX:MaxPermSize=256M -Xmx1024M -DloggerPath=conf/log4j.properties
+set ags=generate -t modules\swagger-codegen\src\main\resources\qt5cpp -i modules\swagger-codegen\src\test\resources\2_0\petstore.json -l qt5cpp -o samples\client\petstore\qt5cpp
+
+java %JAVA_OPTS% -jar %executable% %ags%

bin/windows/ruby-petstore.bat

@@ -0,0 +1,10 @@
+set executable=.\modules\swagger-codegen-cli\target\swagger-codegen-cli.jar
+
+If Not Exist %executable% (
+  mvn clean package
+)
+
+set JAVA_OPTS=%JAVA_OPTS% -XX:MaxPermSize=256M -Xmx1024M -DloggerPath=conf/log4j.properties
+set ags=generate -t modules\swagger-codegen\src\main\resources\ruby -i modules\swagger-codegen\src\test\resources\2_0\petstore.json -l ruby -o samples\client\petstore\ruby
+
+java %JAVA_OPTS% -jar %executable% %ags%

bin/windows/scala-petstore.bat

@@ -0,0 +1,10 @@
+set executable=.\modules\swagger-codegen-cli\target\swagger-codegen-cli.jar
+
+If Not Exist %executable% (
+  mvn clean package
+)
+
+set JAVA_OPTS=%JAVA_OPTS% -XX:MaxPermSize=256M -Xmx1024M -DloggerPath=conf/log4j.properties
+set ags=generate -t modules\swagger-codegen\src\main\resources\scala -i modules\swagger-codegen\src\test\resources\2_0\petstore.json -l scala -o samples\client\petstore\scala
+
+java %JAVA_OPTS% -jar %executable% %ags%

bin/windows/swift-petstore.bat

@@ -0,0 +1,10 @@
+set executable=.\modules\swagger-codegen-cli\target\swagger-codegen-cli.jar
+
+If Not Exist %executable% (
+  mvn clean package
+)
+
+set JAVA_OPTS=%JAVA_OPTS% -XX:MaxPermSize=256M -Xmx1024M -DloggerPath=conf/log4j.properties
+set ags=generate -t modules\swagger-codegen\src\main\resources\swift -i modules\swagger-codegen\src\test\resources\2_0\petstore.json -l swift -o samples\client\petstore\swift
+
+java %JAVA_OPTS% -jar %executable% %ags%

bin/windows/tizen-petstore.bat

@@ -0,0 +1,10 @@
+set executable=.\modules\swagger-codegen-cli\target\swagger-codegen-cli.jar
+
+If Not Exist %executable% (
+  mvn clean package
+)
+
+set JAVA_OPTS=%JAVA_OPTS% -XX:MaxPermSize=256M -Xmx1024M -DloggerPath=conf/log4j.properties
+set ags=generate -t modules\swagger-codegen\src\main\resources\tizen -i modules\swagger-codegen\src\test\resources\2_0\petstore.json -l tizen -o samples\client\petstore\tizen
+
+java %JAVA_OPTS% -jar %executable% %ags%

bin/windows/typescript-angular.bat

@@ -0,0 +1,10 @@
+set executable=.\modules\swagger-codegen-cli\target\swagger-codegen-cli.jar
+
+If Not Exist %executable% (
+  mvn clean package
+)
+
+set JAVA_OPTS=%JAVA_OPTS% -XX:MaxPermSize=256M -Xmx1024M -DloggerPath=conf/log4j.properties
+set ags=generate -t modules\swagger-codegen\src\main\resources\typescript-angular -i modules\swagger-codegen\src\test\resources\2_0\petstore.json -l typescript-angular -o samples\client\petstore\typescript-angular
+
+java %JAVA_OPTS% -jar %executable% %ags%

bin/windows/typescript-node.bat

@@ -0,0 +1,10 @@
+set executable=.\modules\swagger-codegen-cli\target\swagger-codegen-cli.jar
+
+If Not Exist %executable% (
+  mvn clean package
+)
+
+set JAVA_OPTS=%JAVA_OPTS% -XX:MaxPermSize=256M -Xmx1024M -DloggerPath=conf/log4j.properties
+set ags=generate -t modules\swagger-codegen\src\main\resources\typescript-node -i modules\swagger-codegen\src\test\resources\2_0\petstore.json -l typescript-node -o samples\client\petstore\typescript-node
+
+java %JAVA_OPTS% -jar %executable% %ags%

modules/swagger-codegen-cli/pom.xml

@@ -3,7 +3,7 @@
     <parent>
         <groupId>io.swagger</groupId>
         <artifactId>swagger-codegen-project</artifactId>
-        <version>2.1.2</version>
+        <version>2.1.5</version>
         <relativePath>../..</relativePath>
     </parent>
     <modelVersion>4.0.0</modelVersion>
@@ -41,7 +41,7 @@
                 <version>2.3</version>
                 <executions>
                     <execution>
-                        <id>reduced-pom</id>
+                        <id>process-resources</id>
                         <phase>package</phase>
                         <goals>
                             <goal>shade</goal>
@@ -52,15 +52,6 @@
                             <dependencyReducedPomLocation>
                                 ${java.io.tmpdir}/dependency-reduced-pom.xml
                             </dependencyReducedPomLocation>
-                        </configuration>
-                    </execution>
-                    <execution>
-                        <id>process-resources</id>
-                        <phase>package</phase>
-                        <goals>
-                            <goal>shade</goal>
-                        </goals>
-                        <configuration>
                             <transformers>
                                 <transformer
                                         implementation="org.apache.maven.plugins.shade.resource.ServicesResourceTransformer"/>
@@ -79,26 +70,34 @@
             <artifactId>swagger-codegen</artifactId>
             <version>${project.version}</version>
         </dependency>
-
         <!--https://github.com/airlift/airline-->
         <dependency>
             <groupId>io.airlift</groupId>
             <artifactId>airline</artifactId>
             <version>0.7</version>
         </dependency>
-
         <dependency>
             <groupId>com.googlecode.lambdaj</groupId>
             <artifactId>lambdaj</artifactId>
             <version>2.3.3</version>
         </dependency>
-
         <dependency>
             <groupId>org.slf4j</groupId>
             <artifactId>slf4j-simple</artifactId>
             <version>${slf4j-version}</version>
         </dependency>
-
+        <dependency>
+            <groupId>org.testng</groupId>
+            <artifactId>testng</artifactId>
+            <version>${testng-version}</version>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.jmockit</groupId>
+            <artifactId>jmockit</artifactId>
+            <version>${jmockit-version}</version>
+            <scope>test</scope>
+        </dependency>
     </dependencies>
 
 </project>

modules/swagger-codegen-cli/src/main/java/io/swagger/codegen/SwaggerCodegen.java

@@ -21,7 +21,7 @@ public class SwaggerCodegen {
 
 
     public static void main(String[] args) {
-        Cli.CliBuilder<Runnable> builder = Cli.<Runnable>builder("swagger")
+        Cli.CliBuilder<Runnable> builder = Cli.<Runnable>builder("swagger-codegen-cli")
                 .withDescription("Swagger code generator CLI. More info on swagger.io")
                 .withDefaultCommand(Langs.class)
                 .withCommands(

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

@@ -4,10 +4,7 @@ import io.airlift.airline.Command;
 import io.airlift.airline.Option;
 import io.swagger.codegen.CliOption;
 import io.swagger.codegen.CodegenConfig;
-
-import java.util.ServiceLoader;
-
-import static java.util.ServiceLoader.load;
+import io.swagger.codegen.CodegenConfigLoader;
 
 @Command(name = "config-help", description = "Config help for chosen lang")
 public class ConfigHelp implements Runnable {
@@ -16,36 +13,14 @@ public class ConfigHelp implements Runnable {
             description = "language to get config help for")
     private String lang;
 
-    /**
-     * Tries to load config class with SPI first, then with class name directly from classpath
-     *
-     * @param name name of config, or full qualified class name in classpath
-     * @return config class
-     */
-    private static CodegenConfig forName(String name) {
-        ServiceLoader<CodegenConfig> loader = load(CodegenConfig.class);
-        for (CodegenConfig config : loader) {
-            if (config.getName().equals(name)) {
-                return config;
-            }
-        }
-
-        // else try to load directly
-        try {
-            return (CodegenConfig) Class.forName(name).newInstance();
-        } catch (Exception e) {
-            throw new RuntimeException("Can't load config class with name ".concat(name), e);
-        }
-    }
-
     @Override
     public void run() {
         System.out.println();
-        CodegenConfig config = forName(lang);
+        CodegenConfig config = CodegenConfigLoader.forName(lang);
         System.out.println("CONFIG OPTIONS");
         for (CliOption langCliOption : config.cliOptions()) {
             System.out.println("\t" + langCliOption.getOpt());
-            System.out.println("\t    " + langCliOption.getDescription());
+            System.out.println("\t    " + langCliOption.getOptionHelp().replaceAll("\n", "\n\t    "));
             System.out.println();
         }
     }

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

@@ -1,23 +1,22 @@
 package io.swagger.codegen.cmd;
 
-import config.Config;
-import config.ConfigParser;
 import io.airlift.airline.Command;
 import io.airlift.airline.Option;
-import io.swagger.codegen.CliOption;
 import io.swagger.codegen.ClientOptInput;
-import io.swagger.codegen.ClientOpts;
-import io.swagger.codegen.CodegenConfig;
+import io.swagger.codegen.CodegenConstants;
 import io.swagger.codegen.DefaultGenerator;
-import io.swagger.models.Swagger;
-import io.swagger.parser.SwaggerParser;
+import io.swagger.codegen.cmd.utils.OptionUtils;
+import io.swagger.codegen.config.CodegenConfigurator;
+import org.apache.commons.lang3.tuple.Pair;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
-import java.io.File;
-import java.util.ServiceLoader;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
 
-import static java.util.ServiceLoader.load;
 import static org.apache.commons.lang3.StringUtils.isNotEmpty;
 
 /**
@@ -31,10 +30,8 @@ public class Generate implements Runnable {
 
     public static final Logger LOG = LoggerFactory.getLogger(Generate.class);
 
-    public static final String TEMPLATE_DIR_PARAM = "templateDir";
-
     @Option(name = {"-v", "--verbose"}, description = "verbose mode")
-    private boolean verbose;
+    private Boolean verbose;
 
     @Option(name = {"-l", "--lang"}, title = "language", required = true,
             description = "client language to generate (maybe class name in classpath, required)")
@@ -66,93 +63,187 @@ public class Generate implements Runnable {
             "Supported options can be different for each language. Run config-help -l {lang} command for language specific config options.")
     private String configFile;
 
-    /**
-     * Tries to load config class with SPI first, then with class name directly from classpath
-     *
-     * @param name name of config, or full qualified class name in classpath
-     * @return config class
-     */
-    private static CodegenConfig forName(String name) {
-        ServiceLoader<CodegenConfig> loader = load(CodegenConfig.class);
-        for (CodegenConfig config : loader) {
-            if (config.getName().equals(name)) {
-                return config;
-            }
-        }
+    @Option(name = {"-s", "--skip-overwrite"}, title = "skip overwrite", description = "specifies if the existing files should be " +
+            "overwritten during the generation.")
+    private Boolean skipOverwrite;
 
-        // else try to load directly
-        try {
-            return (CodegenConfig) Class.forName(name).newInstance();
-        } catch (Exception e) {
-            throw new RuntimeException("Can't load config class with name ".concat(name), e);
-        }
-    }
+    @Option(name = {"--api-package"}, title = "api package", description = CodegenConstants.API_PACKAGE_DESC)
+    private String apiPackage;
+
+    @Option(name = {"--model-package"}, title = "model package", description = CodegenConstants.MODEL_PACKAGE_DESC)
+    private String modelPackage;
+
+    @Option(name = {"--instantiation-types"}, title = "instantiation types", description = "sets instantiation type mappings in the format of type=instantiatedType,type=instantiatedType." +
+            "For example (in Java): array=ArrayList,map=HashMap. In other words array types will get instantiated as ArrayList in generated code.")
+    private String instantiationTypes;
+
+    @Option(name = {"--type-mappings"}, title = "type mappings", description = "sets mappings between swagger spec types and generated code types " +
+            "in the format of swaggerType=generatedType,swaggerType=generatedType. For example: array=List,map=Map,string=String")
+    private String typeMappings;
+
+    @Option(name = {"--additional-properties"}, title = "additional properties", description = "sets additional properties that can be referenced by the mustache templates in the format of name=value,name=value")
+    private String additionalProperties;
+
+    @Option(name = {"--language-specific-primitives"}, title = "language specific primitives",
+            description = "specifies additional language specific primitive types in the format of type1,type2,type3,type3. For example: String,boolean,Boolean,Double")
+    private String languageSpecificPrimitives;
+
+    @Option(name = {"--import-mappings"}, title = "import mappings",
+            description = "specifies mappings between a given class and the import that should be used for that class in the format of type=import,type=import")
+    private String importMappings;
+
+    @Option(name = {"--invoker-package"}, title = "invoker package", description = CodegenConstants.INVOKER_PACKAGE_DESC)
+    private String invokerPackage;
+
+    @Option(name = {"--group-id"}, title = "group id", description = CodegenConstants.GROUP_ID_DESC)
+    private String groupId;
+
+    @Option(name = {"--artifact-id"}, title = "artifact id", description = CodegenConstants.ARTIFACT_ID_DESC)
+    private String artifactId;
+
+    @Option(name = {"--artifact-version"}, title = "artifact version", description = CodegenConstants.ARTIFACT_VERSION_DESC)
+    private String artifactVersion;
+
+    @Option(name = {"--library"}, title = "library", description = CodegenConstants.LIBRARY_DESC)
+    private String library;
 
     @Override
     public void run() {
-        verbosed(verbose);
 
-        setSystemProperties();
+        //attempt to read from config file
+        CodegenConfigurator configurator = CodegenConfigurator.fromFile(configFile);
 
-        ClientOptInput input = new ClientOptInput();
-
-        if (isNotEmpty(auth)) {
-            input.setAuth(auth);
+        //if a config file wasn't specified or we were unable to read it
+        if(configurator == null) {
+            //createa a fresh configurator
+            configurator = new CodegenConfigurator();
         }
 
-        CodegenConfig config = forName(lang);
-        config.setOutputDir(new File(output).getAbsolutePath());
-
-        if (null != templateDir) {
-            config.additionalProperties().put(TEMPLATE_DIR_PARAM, new File(templateDir).getAbsolutePath());
+        //now override with any specified parameters
+        if (verbose != null) {
+            configurator.setVerbose(verbose);
         }
 
-        if (null != configFile) {
-            Config genConfig = ConfigParser.read(configFile);
-            if (null != genConfig) {
-                for (CliOption langCliOption : config.cliOptions()) {
-                    if (genConfig.hasOption(langCliOption.getOpt())) {
-                        config.additionalProperties().put(langCliOption.getOpt(), genConfig.getOption(langCliOption.getOpt()));
-                    }
-                }
-            }
+        if(skipOverwrite != null) {
+            configurator.setSkipOverwrite(skipOverwrite);
         }
 
-        input.setConfig(config);
+        if(isNotEmpty(spec)) {
+            configurator.setInputSpec(spec);
+        }
 
-        Swagger swagger = new SwaggerParser().read(spec, input.getAuthorizationValues(), true);
-        new DefaultGenerator().opts(input.opts(new ClientOpts()).swagger(swagger)).generate();
+        if(isNotEmpty(lang)) {
+            configurator.setLang(lang);
+        }
+
+        if(isNotEmpty(output)) {
+            configurator.setOutputDir(output);
+        }
+
+        if(isNotEmpty(auth)) {
+            configurator.setAuth(auth);
+        }
+
+        if(isNotEmpty(templateDir)) {
+            configurator.setTemplateDir(templateDir);
+        }
+
+        if(isNotEmpty(apiPackage)) {
+            configurator.setApiPackage(apiPackage);
+        }
+
+        if(isNotEmpty(modelPackage)) {
+            configurator.setModelPackage(modelPackage);
+        }
+
+        if(isNotEmpty(invokerPackage)) {
+            configurator.setInvokerPackage(invokerPackage);
+        }
+
+        if(isNotEmpty(groupId)) {
+            configurator.setGroupId(groupId);
+        }
+
+        if(isNotEmpty(artifactId)) {
+            configurator.setArtifactId(artifactId);
+        }
+
+        if(isNotEmpty(artifactVersion)) {
+            configurator.setArtifactVersion(artifactVersion);
+        }
+
+        if(isNotEmpty(library)) {
+            configurator.setLibrary(library);
+        }
+
+        setSystemProperties(configurator);
+        setInstantiationTypes(configurator);
+        setImportMappings(configurator);
+        setTypeMappings(configurator);
+        setAdditionalProperties(configurator);
+        setLanguageSpecificPrimitives(configurator);
+
+        final ClientOptInput clientOptInput = configurator.toClientOptInput();
+
+        new DefaultGenerator().opts(clientOptInput).generate();
     }
 
-    private void setSystemProperties() {
-        if (systemProperties != null && systemProperties.length() > 0) {
-            for (String property : systemProperties.split(",")) {
-                int ix = property.indexOf('=');
-                if (ix > 0 && ix < property.length() - 1) {
-                    System.setProperty(property.substring(0, ix), property.substring(ix + 1));
-                }
-            }
+    private void setSystemProperties(CodegenConfigurator configurator) {
+        final Map<String, String> map = createMapFromKeyValuePairs(systemProperties);
+        for (Map.Entry<String, String> entry : map.entrySet()) {
+            configurator.addSystemProperty(entry.getKey(), entry.getValue());
         }
     }
 
-    /**
-     * If true parameter, adds system properties which enables debug mode in generator
-     *
-     * @param verbose - if true, enables debug mode
-     */
-    private void verbosed(boolean verbose) {
-        if (!verbose) {
-            return;
+    private void setInstantiationTypes(CodegenConfigurator configurator) {
+        final Map<String, String> map = createMapFromKeyValuePairs(instantiationTypes);
+        for (Map.Entry<String, String> entry : map.entrySet()) {
+            configurator.addInstantiationType(entry.getKey(), entry.getValue());
         }
-        LOG.info("\nVERBOSE MODE: ON. Additional debug options are injected" +
-                "\n - [debugSwagger] prints the swagger specification as interpreted by the codegen" +
-                "\n - [debugModels] prints models passed to the template engine" +
-                "\n - [debugOperations] prints operations passed to the template engine" +
-                "\n - [debugSupportingFiles] prints additional data passed to the template engine");
+    }
 
-        System.setProperty("debugSwagger", "");
-        System.setProperty("debugModels", "");
-        System.setProperty("debugOperations", "");
-        System.setProperty("debugSupportingFiles", "");
+    private void setImportMappings(CodegenConfigurator configurator) {
+        final Map<String, String> map = createMapFromKeyValuePairs(importMappings);
+        for (Map.Entry<String, String> entry : map.entrySet()) {
+            configurator.addImportMapping(entry.getKey(), entry.getValue());
+        }
+    }
+
+    private void setTypeMappings(CodegenConfigurator configurator) {
+        final Map<String, String> map = createMapFromKeyValuePairs(typeMappings);
+        for (Map.Entry<String, String> entry : map.entrySet()) {
+            configurator.addTypeMapping(entry.getKey(), entry.getValue());
+        }
+    }
+
+    private void setAdditionalProperties(CodegenConfigurator configurator) {
+        final Map<String, String> map = createMapFromKeyValuePairs(additionalProperties);
+        for (Map.Entry<String, String> entry : map.entrySet()) {
+            configurator.addAdditionalProperty(entry.getKey(), entry.getValue());
+        }
+    }
+
+    private void setLanguageSpecificPrimitives(CodegenConfigurator configurator) {
+        final Set<String> set = createSetFromCsvList(languageSpecificPrimitives);
+        for (String item : set) {
+            configurator.addLanguageSpecificPrimitive(item);
+        }
+    }
+
+    private Set<String> createSetFromCsvList(String csvProperty) {
+        final List<String> values = OptionUtils.splitCommaSeparatedList(csvProperty);
+        return new HashSet<String>(values);
+    }
+
+    private Map createMapFromKeyValuePairs(String commaSeparatedKVPairs) {
+        final List<Pair<String, String>> pairs = OptionUtils.parseCommaSeparatedTuples(commaSeparatedKVPairs);
+
+        Map result = new HashMap();
+
+        for (Pair<String, String> pair : pairs) {
+            result.put(pair.getLeft(), pair.getRight());
+        }
+
+        return result;
     }
 }

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

@@ -1,6 +1,7 @@
 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;
 import com.samskivert.mustache.Mustache;
@@ -9,7 +10,6 @@ import io.airlift.airline.Option;
 import io.swagger.codegen.DefaultGenerator;
 import io.swagger.codegen.SupportingFile;
 import org.apache.commons.io.FileUtils;
-import org.apache.commons.lang3.StringUtils;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
@@ -55,7 +55,7 @@ public class Meta implements Runnable {
         final File targetDir = new File(outputFolder);
         LOG.info("writing to folder [{}]", targetDir.getAbsolutePath());
 
-        String mainClass = StringUtils.capitalize(name) + "Generator";
+        String mainClass = CaseFormat.LOWER_HYPHEN.to(CaseFormat.UPPER_CAMEL, name) + "Generator";
 
         List<SupportingFile> supportingFiles = ImmutableList.of(
                 new SupportingFile("pom.mustache", "", "pom.xml"),
@@ -68,11 +68,18 @@ public class Meta implements Runnable {
                         "src/main/resources/META-INF/services", "io.swagger.codegen.CodegenConfig")
         );
 
+        String swaggerVersion = this.getClass().getPackage().getImplementationVersion();
+        // if the code is running outside of the jar (i.e. from the IDE), it will not have the version available.
+        // let's default it with something.
+        if (swaggerVersion==null) {
+            swaggerVersion = "2.1.3";
+        }
         Map<String, Object> data = new ImmutableMap.Builder<String, Object>()
                 .put("generatorPackage", targetPackage)
                 .put("generatorClass", mainClass)
                 .put("name", name)
-                .put("fullyQualifiedGeneratorClass", targetPackage + "." + mainClass).build();
+                .put("fullyQualifiedGeneratorClass", targetPackage + "." + mainClass)
+                .put("swaggerCodegenVersion", swaggerVersion).build();
 
 
         with(supportingFiles).convert(processFiles(targetDir, data));
@@ -128,6 +135,7 @@ public class Meta implements Runnable {
      */
     private Mustache.TemplateLoader loader(final DefaultGenerator generator) {
         return new Mustache.TemplateLoader() {
+            @Override
             public Reader getTemplate(String name) {
                 return generator.getTemplateReader(TEMPLATE_DIR_CLASSPATH
                         + File.separator + name.concat(MUSTACHE_EXTENSION));

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

@@ -0,0 +1,43 @@
+package io.swagger.codegen.cmd.utils;
+
+import org.apache.commons.lang3.tuple.Pair;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import static org.apache.commons.lang3.StringUtils.isNotEmpty;
+
+public class OptionUtils {
+
+    public static List<Pair<String, String>> parseCommaSeparatedTuples(String input) {
+
+        List<Pair<String, String>> results = new ArrayList<Pair<String, String>>();
+
+        final List<String> tuples = splitCommaSeparatedList(input);
+
+        for (String tuple : tuples) {
+            int ix = tuple.indexOf('=');
+            if (ix > 0 && ix < tuple.length() - 1) {
+                final Pair<String, String> pair = Pair.of(tuple.substring(0, ix), tuple.substring(ix + 1));
+                results.add(pair);
+            }
+        }
+
+        return results;
+    }
+
+    public static List<String> splitCommaSeparatedList(String input) {
+
+        List<String> results = new ArrayList<String>();
+
+        if(input != null && !input.isEmpty()) {
+            for (String value : input.split(",")) {
+                if(isNotEmpty(value))
+                results.add(value);
+            }
+        }
+
+        return results;
+    }
+
+}

modules/swagger-codegen-cli/src/test/java/io/swagger/codegen/cmd/GenerateTest.java

@@ -0,0 +1,357 @@
+package io.swagger.codegen.cmd;
+
+import io.swagger.codegen.ClientOptInput;
+import io.swagger.codegen.DefaultGenerator;
+import io.swagger.codegen.SwaggerCodegen;
+import io.swagger.codegen.config.CodegenConfigurator;
+import mockit.Expectations;
+import mockit.FullVerifications;
+import mockit.Injectable;
+import mockit.Mocked;
+import mockit.Verifications;
+import org.apache.commons.lang3.ArrayUtils;
+import org.testng.annotations.Test;
+
+public class GenerateTest {
+
+    @Mocked
+    CodegenConfigurator configurator;
+
+    @Injectable
+    ClientOptInput clientOptInput;
+
+    @Mocked
+    DefaultGenerator generator;
+
+    @Test
+    public void testVerbose() throws Exception {
+        setupAndRunGenericTest("-v");
+
+        new FullVerifications() {{
+            configurator.setVerbose(true);
+            times = 1;
+        }};
+
+        setupAndRunGenericTest("--verbose");
+
+        new FullVerifications() {{
+            configurator.setVerbose(true);
+            times = 1;
+        }};
+    }
+
+    @Test
+    public void testRequiredArgs_ShortArgs() throws Exception {
+        setupAndRunTest("-i", "swagger.yaml", "-l", "java", "-o", "src/main/java", false, null);
+        new FullVerifications() {{
+        }};
+    }
+
+    @Test
+    public void testRequiredArgs_LongArgs() throws Exception {
+        setupAndRunTest("--input-spec", "swagger.yaml", "--lang", "java", "--output", "src/main/java", false, null);
+        new FullVerifications() {{
+        }};
+    }
+
+    @Test
+    public void testTemplateDir() throws Exception {
+
+        final String templateDir = "src/main/resources/customTemplates";
+
+        setupAndRunGenericTest("--template-dir", templateDir);
+
+        new FullVerifications() {{
+            configurator.setTemplateDir(templateDir);
+            times = 1;
+        }};
+
+        setupAndRunGenericTest("-t", templateDir);
+
+        new FullVerifications() {{
+            configurator.setTemplateDir(templateDir);
+            times = 1;
+        }};
+    }
+
+    @Test
+    public void testAuth() throws Exception {
+
+        final String auth = "hello:world";
+
+        setupAndRunGenericTest("--auth", auth);
+
+        new FullVerifications() {{
+            configurator.setAuth(auth);
+            times = 1;
+        }};
+
+        setupAndRunGenericTest("-a", auth);
+
+        new FullVerifications() {{
+            configurator.setAuth(auth);
+            times = 1;
+        }};
+
+        setupAndRunGenericTest();
+
+        new FullVerifications() {{
+            configurator.setAuth(anyString);
+            times = 0;
+        }};
+    }
+
+    @Test
+    public void testSystemProperties() throws Exception {
+
+        setupAndRunGenericTest("-D", "hello=world,foo=bar");
+
+        new FullVerifications() {{
+            configurator.addSystemProperty("hello", "world");
+            times = 1;
+            configurator.addSystemProperty("foo", "bar");
+            times = 1;
+        }};
+
+        setupAndRunGenericTest("-D", "hello=world,key=,foo=bar");
+
+        new FullVerifications() {{
+            configurator.addSystemProperty("hello", "world");
+            times = 1;
+            configurator.addSystemProperty("foo", "bar");
+            times = 1;
+            configurator.addSystemProperty("key", anyString);
+            times = 0;
+        }};
+    }
+
+
+    @Test
+    public void testConfig() throws Exception {
+
+        setupAndRunTest("-i", "swagger.yaml", "-l", "java", "-o", "src/main/java", true, "config.json", "-c", "config.json");
+
+        new FullVerifications(){{}};
+
+        setupAndRunTest("-i", "swagger.yaml", "-l", "java", "-o", "src/main/java", true, "config.json", "--config", "config.json");
+
+        new FullVerifications(){{}};
+    }
+
+    @Test
+    public void testSkipOverwrite() throws Exception {
+
+        setupAndRunGenericTest("-s");
+        new FullVerifications(){{
+            configurator.setSkipOverwrite(true); times=1;
+        }};
+
+        setupAndRunGenericTest("--skip-overwrite");
+        new FullVerifications(){{
+            configurator.setSkipOverwrite(true); times=1;
+        }};
+    }
+
+    @Test
+    public void testApiPackage() throws Exception {
+        final String value = "io.foo.bar.api";
+        setupAndRunGenericTest("--api-package", value);
+
+        new FullVerifications(){{
+           configurator.setApiPackage(value); times=1;
+        }};
+    }
+
+    @Test
+    public void testModelPackage() throws Exception {
+        final String value = "io.foo.bar.api";
+        setupAndRunGenericTest("--model-package", value);
+
+        new FullVerifications(){{
+            configurator.setModelPackage(value); times=1;
+        }};
+    }
+
+    @Test
+    public void testInstantiationTypes() throws Exception {
+
+        setupAndRunGenericTest("--instantiation-types", "hello=world,key=,foo=bar");
+
+        new FullVerifications() {{
+            configurator.addInstantiationType("hello", "world");
+            times = 1;
+            configurator.addInstantiationType("foo", "bar");
+            times = 1;
+            configurator.addInstantiationType("key", anyString);
+            times = 0;
+        }};
+    }
+
+    @Test
+    public void testTypeMappings() throws Exception {
+        setupAndRunGenericTest("--type-mappings", "hello=world,key=,foo=bar");
+
+        new FullVerifications() {{
+            configurator.addTypeMapping("hello", "world");
+            times = 1;
+            configurator.addTypeMapping("foo", "bar");
+            times = 1;
+            configurator.addTypeMapping("key", anyString);
+            times = 0;
+        }};
+    }
+
+    @Test
+    public void testAdditionalProperties() throws Exception {
+        setupAndRunGenericTest("--additional-properties", "hello=world,key=,foo=bar");
+
+        new FullVerifications() {{
+            configurator.addAdditionalProperty("hello", "world");
+            times = 1;
+            configurator.addAdditionalProperty("foo", "bar");
+            times = 1;
+            configurator.addAdditionalProperty("key", anyString);
+            times = 0;
+        }};
+    }
+
+    @Test
+    public void testLanguageSpecificPrimitives() throws Exception {
+        setupAndRunGenericTest("--language-specific-primitives", "foo,bar,,hello,world");
+
+        new FullVerifications() {{
+            configurator.addLanguageSpecificPrimitive("foo");
+            times = 1;
+            configurator.addLanguageSpecificPrimitive("bar");
+            times = 1;
+            configurator.addLanguageSpecificPrimitive("hello");
+            times = 1;
+            configurator.addLanguageSpecificPrimitive("world");
+            times = 1;
+        }};
+    }
+
+    @Test
+    public void testImportMappings() throws Exception {
+        setupAndRunGenericTest("--import-mappings", "hello=world,key=,foo=bar");
+
+        new FullVerifications() {{
+            configurator.addImportMapping("hello", "world");
+            times = 1;
+            configurator.addImportMapping("foo", "bar");
+            times = 1;
+            configurator.addImportMapping("key", anyString);
+            times = 0;
+        }};
+    }
+
+    @Test
+    public void testInvokerPackage() throws Exception {
+        final String value = "io.foo.bar.api";
+        setupAndRunGenericTest("--invoker-package", value);
+
+        new FullVerifications(){{
+            configurator.setInvokerPackage(value); times=1;
+        }};
+    }
+
+    @Test
+    public void testGroupId() throws Exception {
+        final String value = "io.foo.bar.api";
+        setupAndRunGenericTest("--group-id", value);
+
+        new FullVerifications(){{
+            configurator.setGroupId(value); times=1;
+        }};
+    }
+
+    @Test
+    public void testArtifactId() throws Exception {
+        final String value = "awesome-api";
+        setupAndRunGenericTest("--artifact-id", value);
+
+        new FullVerifications(){{
+            configurator.setArtifactId(value); times=1;
+        }};
+    }
+
+    @Test
+    public void testArtifactVersion() throws Exception {
+        final String value = "1.2.3";
+        setupAndRunGenericTest("--artifact-version", value);
+
+        new FullVerifications(){{
+            configurator.setArtifactVersion(value); times=1;
+        }};
+    }
+
+    @Test
+    public void testLibrary() throws Exception {
+        final String value = "library1";
+        setupAndRunGenericTest("--library", value);
+
+        new FullVerifications(){{
+            configurator.setLibrary(value); times=1;
+        }};
+    }
+
+    private void setupAndRunTest(String specFlag, final String spec, String langFlag, final String lang,
+                                 String outputDirFlag, final String outputDir, boolean configuratorFromFile,
+                                 final String configFile, String... additionalParameters) {
+        final String[] commonArgs = {"generate", langFlag, lang, outputDirFlag, outputDir, specFlag, spec};
+
+        String[] argsToUse = ArrayUtils.addAll(commonArgs, additionalParameters);
+
+        if (configuratorFromFile) {
+
+            new Expectations(){{
+                CodegenConfigurator.fromFile(configFile);
+                times = 1;
+                result = configurator;
+            }};
+
+        } else {
+            new Expectations() {{
+                CodegenConfigurator.fromFile(anyString);
+                result = null;
+
+                new CodegenConfigurator();
+                times = 1;
+                result = configurator;
+            }};
+        }
+
+        new Expectations() {{
+
+            configurator.toClientOptInput();
+            times = 1;
+            result = clientOptInput;
+
+            new DefaultGenerator();
+            times = 1;
+            result = generator;
+
+            generator.opts(clientOptInput);
+            times = 1;
+            result = generator;
+
+            generator.generate();
+            times = 1;
+
+        }};
+
+        SwaggerCodegen.main(argsToUse);
+
+        new Verifications() {{
+            configurator.setLang(lang);
+            times = 1;
+            configurator.setInputSpec(spec);
+            times = 1;
+            configurator.setOutputDir(outputDir);
+        }};
+    }
+
+    private void setupAndRunGenericTest(String... additionalParameters) {
+        setupAndRunTest("-i", "swagger.yaml", "-l", "java", "-o", "src/main/java", false, null, additionalParameters);
+    }
+}

modules/swagger-codegen-cli/src/test/java/io/swagger/codegen/cmd/utils/OptionUtilsTest.java

@@ -0,0 +1,52 @@
+package io.swagger.codegen.cmd.utils;
+
+import org.apache.commons.lang3.tuple.Pair;
+import org.junit.Test;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+import static org.testng.Assert.assertEquals;
+import static org.testng.Assert.assertNotNull;
+
+public class OptionUtilsTest {
+
+    @Test
+    public void splitCommaSeparatedList() throws Exception {
+        doCommaSeparatedListTest("a,b,c", Arrays.asList("a", "b", "c"));
+        doCommaSeparatedListTest("a,,c", Arrays.asList("a", "c"));
+        doCommaSeparatedListTest("", new ArrayList<String>());
+        doCommaSeparatedListTest(null, new ArrayList<String>());
+    }
+
+    @Test
+    public void testParseCommaSeparatedTuples() throws Exception {
+        doTupleListTest("a=1,b=2,c=3", Arrays.asList(Pair.of("a", "1"), Pair.of("b", "2"), Pair.of("c", "3")));
+        doTupleListTest("a=1,,c=3", Arrays.asList(Pair.of("a", "1"), Pair.of("c", "3")));
+        doTupleListTest("a=1,xyz,c=3", Arrays.asList(Pair.of("a", "1"), Pair.of("c", "3")));
+        doTupleListTest("a=1,=,c=3", Arrays.asList(Pair.of("a", "1"), Pair.of("c", "3")));
+        doTupleListTest("", new ArrayList<Pair<String, String>>());
+        doTupleListTest(null, new ArrayList<Pair<String, String>>());
+    }
+
+    private void doTupleListTest(String input, List<Pair<String, String>> expectedResults) {
+        final List<Pair<String, String>> result = OptionUtils.parseCommaSeparatedTuples(input);
+        assertNotNull(result);
+        assertEquals(result.size(), expectedResults.size());
+        for (int i = 0; i < expectedResults.size(); i++) {
+            final Pair<String, String> actualPair = result.get(i);
+            final Pair<String, String> expected = expectedResults.get(i);
+            assertEquals(actualPair, expected);
+        }
+    }
+
+    private void doCommaSeparatedListTest(String csvStr, List<String> expectedResults) {
+        final List<String> result = OptionUtils.splitCommaSeparatedList(csvStr);
+        assertNotNull(result);
+        assertEquals(result.size(), expectedResults.size());
+        for (int i = 0; i < expectedResults.size(); i++) {
+            assertEquals(result.get(i), expectedResults.get(i));
+        }
+    }
+}

modules/swagger-codegen-maven-plugin/README.md

@@ -0,0 +1,53 @@
+swagger-codegen-maven-plugin
+============================
+
+A Maven plugin to support the [swagger](http://swagger.io) code generation project
+
+Usage
+============================
+
+Add to your `build->plugins` section (default phase is `generate-sources` phase)
+```xml
+<plugin>
+    <groupId>io.swagger</groupId>
+    <artifactId>swagger-codegen-maven-plugin</artifactId>
+    <version>2.1.5-SNAPSHOT</version>
+    <executions>
+        <execution>
+            <goals>
+                <goal>generate</goal>
+            </goals>
+            <configuration>
+                <inputSpec>src/main/resources/api.yaml</inputSpec>
+                <language>java</language>
+                <configOptions>
+                   <sourceFolder>src/gen/java/main</sourceFolder>
+                </configOptions>
+            </configuration>
+        </execution>
+    </executions>
+</plugin>
+```
+
+Followed by:
+
+```
+mvn clean compile
+```
+
+### General Configuration parameters
+
+- `inputSpec` - OpenAPI Spec file path
+- `language` - target generation language
+- `output` - target output path (default is `${project.build.directory}/generated-sources/swagger`)
+- `templateDirectory` - directory with mustache templates
+- `addCompileSourceRoot` - add the output directory to the project as a source root (`true` by default)
+- `modelPackage` - the package to use for generated model objects/classes
+- `apiPackage` - the package to use for generated api objects/classes
+- `invokerPackage` - the package to use for the generated invoker objects
+- `configOptions` - a map of language-specific parameters (see below)
+- `configHelp` - dumps the configuration help for the specified library (generates no sources)
+
+### Sample configuration
+
+- Please see [an example configuration](examples) for using the plugin

modules/swagger-codegen-maven-plugin/examples/java-client.xml

@@ -0,0 +1,115 @@
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+    <groupId>io.swagger</groupId>
+    <artifactId>sample-project</artifactId>
+    <packaging>jar</packaging>
+    <version>1.0-SNAPSHOT</version>
+    <name>sample-project</name>
+    <url>http://maven.apache.org</url>
+    <build>
+        <plugins>
+            <!-- activate the plugin -->
+            <plugin>
+                <groupId>io.swagger</groupId>
+                <artifactId>swagger-codegen-maven-plugin</artifactId>
+                <version>2.1.5-SNAPSHOT</version>
+                <executions>
+                    <execution>
+                        <goals>
+                            <goal>generate</goal>
+                        </goals>
+                        <configuration>
+                            <!-- specify the swagger yaml -->
+                            <inputSpec>swagger.yaml</inputSpec>
+
+                            <!-- target to generate -->
+                            <language>java</language>
+
+                            <!-- pass any necessary config options -->
+                            <configOptions>
+                                <dateLibrary>java8</dateLibrary>
+                            </configOptions>
+
+                            <!-- override the default library to jersey2 -->
+                            <library>jersey2</library>
+                        </configuration>
+                    </execution>
+                </executions>
+            </plugin>
+        </plugins>
+    </build>
+    <dependencies>
+        <!-- dependencies are needed for the client being generated -->
+        <dependency>
+            <groupId>io.swagger</groupId>
+            <artifactId>swagger-annotations</artifactId>
+            <version>${swagger-annotations-version}</version>
+        </dependency>
+
+        <!-- HTTP client: jersey-client -->
+        <dependency>
+            <groupId>org.glassfish.jersey.core</groupId>
+            <artifactId>jersey-client</artifactId>
+            <version>${jersey-version}</version>
+        </dependency>
+        <dependency>
+            <groupId>org.glassfish.jersey.media</groupId>
+            <artifactId>jersey-media-multipart</artifactId>
+            <version>${jersey-version}</version>
+        </dependency>
+        <dependency>
+            <groupId>org.glassfish.jersey.media</groupId>
+            <artifactId>jersey-media-json-jackson</artifactId>
+            <version>2.22.1</version>
+        </dependency>
+
+        <!-- JSON processing: jackson -->
+        <dependency>
+            <groupId>com.fasterxml.jackson.core</groupId>
+            <artifactId>jackson-core</artifactId>
+            <version>${jackson-version}</version>
+        </dependency>
+        <dependency>
+            <groupId>com.fasterxml.jackson.core</groupId>
+            <artifactId>jackson-annotations</artifactId>
+            <version>${jackson-version}</version>
+        </dependency>
+        <dependency>
+            <groupId>com.fasterxml.jackson.core</groupId>
+            <artifactId>jackson-databind</artifactId>
+            <version>${jackson-version}</version>
+        </dependency>
+        <dependency>
+            <groupId>com.fasterxml.jackson.datatype</groupId>
+            <artifactId>jackson-datatype-joda</artifactId>
+            <version>2.1.5</version>
+        </dependency>
+        <dependency>
+            <groupId>joda-time</groupId>
+            <artifactId>joda-time</artifactId>
+            <version>${jodatime-version}</version>
+        </dependency>
+
+        <!-- Base64 encoding that works in both JVM and Android -->
+        <dependency>
+            <groupId>com.brsanthu</groupId>
+            <artifactId>migbase64</artifactId>
+            <version>2.2</version>
+        </dependency>
+        <!-- test dependencies -->
+        <dependency>
+            <groupId>junit</groupId>
+            <artifactId>junit</artifactId>
+            <version>${junit-version}</version>
+            <scope>test</scope>
+        </dependency>
+    </dependencies>
+    <properties>
+        <swagger-annotations-version>1.5.0</swagger-annotations-version>
+        <jersey-version>2.12</jersey-version>
+        <jackson-version>2.4.2</jackson-version>
+        <jodatime-version>2.3</jodatime-version>
+        <maven-plugin-version>1.0.0</maven-plugin-version>
+        <junit-version>4.8.1</junit-version>
+    </properties>
+</project>

modules/swagger-codegen-maven-plugin/examples/swagger.yaml

@@ -0,0 +1,702 @@
+---
+swagger: "2.0"
+info:
+  description: "This is a sample server Petstore server.  You can find out more about\
+    \ Swagger at [http://swagger.io](http://swagger.io) or on [irc.freenode.net, #swagger](http://swagger.io/irc/).\
+    \  For this sample, you can use the api key `special-key` to test the authorization\
+    \ filters."
+  version: "1.0.0"
+  title: "Swagger Petstore"
+  termsOfService: "http://swagger.io/terms/"
+  contact:
+    email: "apiteam@swagger.io"
+  license:
+    name: "Apache 2.0"
+    url: "http://www.apache.org/licenses/LICENSE-2.0.html"
+host: "petstore.swagger.io"
+basePath: "/v2"
+tags:
+- name: "pet"
+  description: "Everything about your Pets"
+  externalDocs:
+    description: "Find out more"
+    url: "http://swagger.io"
+- name: "store"
+  description: "Access to Petstore orders"
+- name: "user"
+  description: "Operations about user"
+  externalDocs:
+    description: "Find out more about our store"
+    url: "http://swagger.io"
+schemes:
+- "http"
+paths:
+  /pet:
+    post:
+      tags:
+      - "pet"
+      summary: "Add a new pet to the store"
+      description: ""
+      operationId: "addPet"
+      consumes:
+      - "application/json"
+      - "application/xml"
+      produces:
+      - "application/xml"
+      - "application/json"
+      parameters:
+      - in: "body"
+        name: "body"
+        description: "Pet object that needs to be added to the store"
+        required: true
+        schema:
+          $ref: "#/definitions/Pet"
+      responses:
+        405:
+          description: "Invalid input"
+      security:
+      - petstore_auth:
+        - "write:pets"
+        - "read:pets"
+    put:
+      tags:
+      - "pet"
+      summary: "Update an existing pet"
+      description: ""
+      operationId: "updatePet"
+      consumes:
+      - "application/json"
+      - "application/xml"
+      produces:
+      - "application/xml"
+      - "application/json"
+      parameters:
+      - in: "body"
+        name: "body"
+        description: "Pet object that needs to be added to the store"
+        required: true
+        schema:
+          $ref: "#/definitions/Pet"
+      responses:
+        400:
+          description: "Invalid ID supplied"
+        404:
+          description: "Pet not found"
+        405:
+          description: "Validation exception"
+      security:
+      - petstore_auth:
+        - "write:pets"
+        - "read:pets"
+  /pet/findByStatus:
+    get:
+      tags:
+      - "pet"
+      summary: "Finds Pets by status"
+      description: "Multiple status values can be provided with comma seperated strings"
+      operationId: "findPetsByStatus"
+      produces:
+      - "application/xml"
+      - "application/json"
+      parameters:
+      - name: "status"
+        in: "query"
+        description: "Status values that need to be considered for filter"
+        required: true
+        type: "array"
+        items:
+          type: "string"
+          enum:
+          - "available"
+          - "pending"
+          - "sold"
+          default: "available"
+        collectionFormat: "csv"
+      responses:
+        200:
+          description: "successful operation"
+          schema:
+            type: "array"
+            items:
+              $ref: "#/definitions/Pet"
+        400:
+          description: "Invalid status value"
+      security:
+      - petstore_auth:
+        - "write:pets"
+        - "read:pets"
+  /pet/findByTags:
+    get:
+      tags:
+      - "pet"
+      summary: "Finds Pets by tags"
+      description: "Muliple tags can be provided with comma seperated strings. Use\
+        \ tag1, tag2, tag3 for testing."
+      operationId: "findPetsByTags"
+      produces:
+      - "application/xml"
+      - "application/json"
+      parameters:
+      - name: "tags"
+        in: "query"
+        description: "Tags to filter by"
+        required: true
+        type: "array"
+        items:
+          type: "string"
+        collectionFormat: "csv"
+      responses:
+        200:
+          description: "successful operation"
+          schema:
+            type: "array"
+            items:
+              $ref: "#/definitions/Pet"
+        400:
+          description: "Invalid tag value"
+      security:
+      - petstore_auth:
+        - "write:pets"
+        - "read:pets"
+  /pet/{petId}:
+    get:
+      tags:
+      - "pet"
+      summary: "Find pet by ID"
+      description: "Returns a single pet"
+      operationId: "getPetById"
+      produces:
+      - "application/xml"
+      - "application/json"
+      parameters:
+      - name: "petId"
+        in: "path"
+        description: "ID of pet to return"
+        required: true
+        type: "integer"
+        format: "int64"
+      responses:
+        200:
+          description: "successful operation"
+          schema:
+            $ref: "#/definitions/Pet"
+        400:
+          description: "Invalid ID supplied"
+        404:
+          description: "Pet not found"
+      security:
+      - api_key: []
+    post:
+      tags:
+      - "pet"
+      summary: "Updates a pet in the store with form data"
+      description: ""
+      operationId: "updatePetWithForm"
+      consumes:
+      - "application/x-www-form-urlencoded"
+      produces:
+      - "application/xml"
+      - "application/json"
+      parameters:
+      - name: "petId"
+        in: "path"
+        description: "ID of pet that needs to be updated"
+        required: true
+        type: "integer"
+        format: "int64"
+      - name: "name"
+        in: "formData"
+        description: "Updated name of the pet"
+        required: false
+        type: "string"
+      - name: "status"
+        in: "formData"
+        description: "Updated status of the pet"
+        required: false
+        type: "string"
+      responses:
+        405:
+          description: "Invalid input"
+      security:
+      - petstore_auth:
+        - "write:pets"
+        - "read:pets"
+    delete:
+      tags:
+      - "pet"
+      summary: "Deletes a pet"
+      description: ""
+      operationId: "deletePet"
+      produces:
+      - "application/xml"
+      - "application/json"
+      parameters:
+      - name: "api_key"
+        in: "header"
+        required: false
+        type: "string"
+      - name: "petId"
+        in: "path"
+        description: "Pet id to delete"
+        required: true
+        type: "integer"
+        format: "int64"
+      responses:
+        400:
+          description: "Invalid pet value"
+      security:
+      - petstore_auth:
+        - "write:pets"
+        - "read:pets"
+  /pet/{petId}/uploadImage:
+    post:
+      tags:
+      - "pet"
+      summary: "uploads an image"
+      description: ""
+      operationId: "uploadFile"
+      consumes:
+      - "multipart/form-data"
+      produces:
+      - "application/json"
+      parameters:
+      - name: "petId"
+        in: "path"
+        description: "ID of pet to update"
+        required: true
+        type: "integer"
+        format: "int64"
+      - name: "additionalMetadata"
+        in: "formData"
+        description: "Additional data to pass to server"
+        required: false
+        type: "string"
+      - name: "file"
+        in: "formData"
+        description: "file to upload"
+        required: false
+        type: "file"
+      responses:
+        200:
+          description: "successful operation"
+          schema:
+            $ref: "#/definitions/ApiResponse"
+      security:
+      - petstore_auth:
+        - "write:pets"
+        - "read:pets"
+  /store/inventory:
+    get:
+      tags:
+      - "store"
+      summary: "Returns pet inventories by status"
+      description: "Returns a map of status codes to quantities"
+      operationId: "getInventory"
+      produces:
+      - "application/json"
+      parameters: []
+      responses:
+        200:
+          description: "successful operation"
+          schema:
+            type: "object"
+            additionalProperties:
+              type: "integer"
+              format: "int32"
+      security:
+      - api_key: []
+  /store/order:
+    post:
+      tags:
+      - "store"
+      summary: "Place an order for a pet"
+      description: ""
+      operationId: "placeOrder"
+      produces:
+      - "application/xml"
+      - "application/json"
+      parameters:
+      - in: "body"
+        name: "body"
+        description: "order placed for purchasing the pet"
+        required: true
+        schema:
+          $ref: "#/definitions/Order"
+      responses:
+        200:
+          description: "successful operation"
+          schema:
+            $ref: "#/definitions/Order"
+        400:
+          description: "Invalid Order"
+  /store/order/{orderId}:
+    get:
+      tags:
+      - "store"
+      summary: "Find purchase order by ID"
+      description: "For valid response try integer IDs with value <= 5 or > 10. Other\
+        \ values will generated exceptions"
+      operationId: "getOrderById"
+      produces:
+      - "application/xml"
+      - "application/json"
+      parameters:
+      - name: "orderId"
+        in: "path"
+        description: "ID of pet that needs to be fetched"
+        required: true
+        type: "integer"
+        maximum: 5.0
+        minimum: 1.0
+        format: "int64"
+      responses:
+        200:
+          description: "successful operation"
+          schema:
+            $ref: "#/definitions/Order"
+        400:
+          description: "Invalid ID supplied"
+        404:
+          description: "Order not found"
+    delete:
+      tags:
+      - "store"
+      summary: "Delete purchase order by ID"
+      description: "For valid response try integer IDs with value < 1000. Anything\
+        \ above 1000 or nonintegers will generate API errors"
+      operationId: "deleteOrder"
+      produces:
+      - "application/xml"
+      - "application/json"
+      parameters:
+      - name: "orderId"
+        in: "path"
+        description: "ID of the order that needs to be deleted"
+        required: true
+        type: "string"
+        minimum: 1.0
+      responses:
+        400:
+          description: "Invalid ID supplied"
+        404:
+          description: "Order not found"
+  /user:
+    post:
+      tags:
+      - "user"
+      summary: "Create user"
+      description: "This can only be done by the logged in user."
+      operationId: "createUser"
+      produces:
+      - "application/xml"
+      - "application/json"
+      parameters:
+      - in: "body"
+        name: "body"
+        description: "Created user object"
+        required: true
+        schema:
+          $ref: "#/definitions/User"
+      responses:
+        default:
+          description: "successful operation"
+  /user/createWithArray:
+    post:
+      tags:
+      - "user"
+      summary: "Creates list of users with given input array"
+      description: ""
+      operationId: "createUsersWithArrayInput"
+      produces:
+      - "application/xml"
+      - "application/json"
+      parameters:
+      - in: "body"
+        name: "body"
+        description: "List of user object"
+        required: true
+        schema:
+          type: "array"
+          items:
+            $ref: "#/definitions/User"
+      responses:
+        default:
+          description: "successful operation"
+  /user/createWithList:
+    post:
+      tags:
+      - "user"
+      summary: "Creates list of users with given input array"
+      description: ""
+      operationId: "createUsersWithListInput"
+      produces:
+      - "application/xml"
+      - "application/json"
+      parameters:
+      - in: "body"
+        name: "body"
+        description: "List of user object"
+        required: true
+        schema:
+          type: "array"
+          items:
+            $ref: "#/definitions/User"
+      responses:
+        default:
+          description: "successful operation"
+  /user/login:
+    get:
+      tags:
+      - "user"
+      summary: "Logs user into the system"
+      description: ""
+      operationId: "loginUser"
+      produces:
+      - "application/xml"
+      - "application/json"
+      parameters:
+      - name: "username"
+        in: "query"
+        description: "The user name for login"
+        required: true
+        type: "string"
+      - name: "password"
+        in: "query"
+        description: "The password for login in clear text"
+        required: true
+        type: "string"
+      responses:
+        200:
+          description: "successful operation"
+          schema:
+            type: "string"
+          headers:
+            X-Rate-Limit:
+              type: "integer"
+              format: "int32"
+              description: "calls per hour allowed by the user"
+            X-Expires-After:
+              type: "string"
+              format: "date-time"
+              description: "date in UTC when toekn expires"
+        400:
+          description: "Invalid username/password supplied"
+  /user/logout:
+    get:
+      tags:
+      - "user"
+      summary: "Logs out current logged in user session"
+      description: ""
+      operationId: "logoutUser"
+      produces:
+      - "application/xml"
+      - "application/json"
+      parameters: []
+      responses:
+        default:
+          description: "successful operation"
+  /user/{username}:
+    get:
+      tags:
+      - "user"
+      summary: "Get user by user name"
+      description: ""
+      operationId: "getUserByName"
+      produces:
+      - "application/xml"
+      - "application/json"
+      parameters:
+      - name: "username"
+        in: "path"
+        description: "The name that needs to be fetched. Use user1 for testing. "
+        required: true
+        type: "string"
+      responses:
+        200:
+          description: "successful operation"
+          schema:
+            $ref: "#/definitions/User"
+        400:
+          description: "Invalid username supplied"
+        404:
+          description: "User not found"
+    put:
+      tags:
+      - "user"
+      summary: "Updated user"
+      description: "This can only be done by the logged in user."
+      operationId: "updateUser"
+      produces:
+      - "application/xml"
+      - "application/json"
+      parameters:
+      - name: "username"
+        in: "path"
+        description: "name that need to be deleted"
+        required: true
+        type: "string"
+      - in: "body"
+        name: "body"
+        description: "Updated user object"
+        required: true
+        schema:
+          $ref: "#/definitions/User"
+      responses:
+        400:
+          description: "Invalid user supplied"
+        404:
+          description: "User not found"
+    delete:
+      tags:
+      - "user"
+      summary: "Delete user"
+      description: "This can only be done by the logged in user."
+      operationId: "deleteUser"
+      produces:
+      - "application/xml"
+      - "application/json"
+      parameters:
+      - name: "username"
+        in: "path"
+        description: "The name that needs to be deleted"
+        required: true
+        type: "string"
+      responses:
+        400:
+          description: "Invalid username supplied"
+        404:
+          description: "User not found"
+securityDefinitions:
+  petstore_auth:
+    type: "oauth2"
+    authorizationUrl: "http://petstore.swagger.io/api/oauth/dialog"
+    flow: "implicit"
+    scopes:
+      write:pets: "modify pets in your account"
+      read:pets: "read your pets"
+  api_key:
+    type: "apiKey"
+    name: "api_key"
+    in: "header"
+definitions:
+  Order:
+    type: "object"
+    properties:
+      id:
+        type: "integer"
+        format: "int64"
+      petId:
+        type: "integer"
+        format: "int64"
+      quantity:
+        type: "integer"
+        format: "int32"
+      shipDate:
+        type: "string"
+        format: "date-time"
+      status:
+        type: "string"
+        description: "Order Status"
+        enum:
+        - "placed"
+        - "approved"
+        - "delivered"
+      complete:
+        type: "boolean"
+        default: false
+    xml:
+      name: "Order"
+  Category:
+    type: "object"
+    properties:
+      id:
+        type: "integer"
+        format: "int64"
+      name:
+        type: "string"
+    xml:
+      name: "Category"
+  User:
+    type: "object"
+    properties:
+      id:
+        type: "integer"
+        format: "int64"
+      username:
+        type: "string"
+      firstName:
+        type: "string"
+      lastName:
+        type: "string"
+      email:
+        type: "string"
+      password:
+        type: "string"
+      phone:
+        type: "string"
+      userStatus:
+        type: "integer"
+        format: "int32"
+        description: "User Status"
+    xml:
+      name: "User"
+  Tag:
+    type: "object"
+    properties:
+      id:
+        type: "integer"
+        format: "int64"
+      name:
+        type: "string"
+    xml:
+      name: "Tag"
+  Pet:
+    type: "object"
+    required:
+    - "name"
+    - "photoUrls"
+    properties:
+      id:
+        type: "integer"
+        format: "int64"
+      category:
+        $ref: "#/definitions/Category"
+      name:
+        type: "string"
+        example: "doggie"
+      photoUrls:
+        type: "array"
+        xml:
+          name: "photoUrl"
+          wrapped: true
+        items:
+          type: "string"
+      tags:
+        type: "array"
+        xml:
+          name: "tag"
+          wrapped: true
+        items:
+          $ref: "#/definitions/Tag"
+      status:
+        type: "string"
+        description: "pet status in the store"
+        enum:
+        - "available"
+        - "pending"
+        - "sold"
+    xml:
+      name: "Pet"
+  ApiResponse:
+    type: "object"
+    properties:
+      code:
+        type: "integer"
+        format: "int32"
+      type:
+        type: "string"
+      message:
+        type: "string"
+externalDocs:
+  description: "Find out more about Swagger"
+  url: "http://swagger.io"

modules/swagger-codegen-maven-plugin/pom.xml

@@ -0,0 +1,87 @@
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
+
+    <modelVersion>4.0.0</modelVersion>
+
+    <parent>
+        <groupId>io.swagger</groupId>
+        <artifactId>swagger-codegen-project</artifactId>
+        <version>2.1.5</version>
+        <relativePath>../..</relativePath>
+    </parent>
+    <artifactId>swagger-codegen-maven-plugin</artifactId>
+    <name>swagger-codegen (maven-plugin)</name>
+    <packaging>maven-plugin</packaging>
+    <description>maven plugin to build modules from swagger codegen</description>
+    <properties>
+        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+    </properties>
+    <dependencies>
+        <dependency>
+            <groupId>org.apache.maven</groupId>
+            <artifactId>maven-core</artifactId>
+            <version>3.2.5</version>
+        </dependency>
+        <dependency>
+            <groupId>org.apache.maven</groupId>
+            <artifactId>maven-artifact</artifactId>
+            <version>3.2.5</version>
+            <scope>provided</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.apache.maven</groupId>
+            <artifactId>maven-compat</artifactId>
+            <version>3.2.5</version>
+        </dependency>
+        <dependency>
+            <groupId>org.apache.maven</groupId>
+            <artifactId>maven-plugin-api</artifactId>
+            <version>3.2.5</version>
+        </dependency>
+        <dependency>
+            <groupId>org.apache.maven.plugin-tools</groupId>
+            <artifactId>maven-plugin-annotations</artifactId>
+            <version>3.4</version>
+        </dependency>
+        <dependency>
+            <groupId>io.swagger</groupId>
+            <artifactId>swagger-codegen</artifactId>
+            <version>${project.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>junit</groupId>
+            <artifactId>junit</artifactId>
+            <version>4.12</version>
+            <scope>test</scope>
+        </dependency>
+    </dependencies>
+    <build>
+        <pluginManagement>
+            <plugins>
+                <plugin>
+                    <groupId>org.apache.maven.plugins</groupId>
+                    <artifactId>maven-plugin-plugin</artifactId>
+                    <version>3.4</version>
+                    <configuration>
+                        <skipErrorNoDescriptorsFound>true</skipErrorNoDescriptorsFound>
+                    </configuration>
+                    <executions>
+                        <execution>
+                            <id>mojo-descriptor</id>
+                            <phase>process-classes</phase>
+                            <goals>
+                                <goal>descriptor</goal>
+                            </goals>
+                        </execution>
+                        <execution>
+                            <id>help-goal</id>
+                            <goals>
+                                <goal>helpmojo</goal>
+                            </goals>
+                        </execution>
+                    </executions>
+                </plugin>
+            </plugins>
+        </pluginManagement>
+    </build>
+</project>

modules/swagger-codegen-maven-plugin/src/main/java/io/swagger/codegen/plugin/AdditionalParams.java

@@ -0,0 +1,16 @@
+package io.swagger.codegen.plugin;
+
+/**
+ * User: lanwen
+ * Date: 24.03.15
+ * Time: 14:47
+ */
+public final class AdditionalParams {
+    public static final String TEMPLATE_DIR_PARAM = "templateDir";
+    public static final String MODEL_PACKAGE_PARAM = "modelPackage";
+    public static final String API_PACKAGE_PARAM = "apiPackage";
+    public static final String INVOKER_PACKAGE_PARAM = "invokerPackage";
+    public static final String LIBRARY_PARAM = "library";
+
+    private AdditionalParams() {}
+}

modules/swagger-codegen-maven-plugin/src/main/java/io/swagger/codegen/plugin/CodeGenMojo.java

@@ -0,0 +1,203 @@
+package io.swagger.codegen.plugin;
+
+/*
+ * Copyright 2001-2005 The Apache Software Foundation.
+ *
+ * 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.
+ */
+
+import config.Config;
+import config.ConfigParser;
+import io.swagger.codegen.*;
+import io.swagger.models.Swagger;
+import io.swagger.parser.SwaggerParser;
+import org.apache.maven.plugin.AbstractMojo;
+import org.apache.maven.plugin.MojoExecutionException;
+import org.apache.maven.plugins.annotations.LifecyclePhase;
+import org.apache.maven.plugins.annotations.Mojo;
+import org.apache.maven.plugins.annotations.Parameter;
+import org.apache.maven.project.MavenProject;
+
+import java.io.File;
+import java.util.HashMap;
+import java.util.Map;
+
+import static io.swagger.codegen.plugin.AdditionalParams.*;
+
+/**
+ * Goal which generates client/server code from a swagger json/yaml definition.
+ */
+@Mojo(name = "generate", defaultPhase = LifecyclePhase.GENERATE_SOURCES)
+public class CodeGenMojo extends AbstractMojo {
+    /**
+     * Location of the output directory.
+     */
+    @Parameter(name = "output",
+            property = "swagger.codegen.maven.plugin.output",
+            defaultValue = "${project.build.directory}/generated-sources/swagger")
+    private File output;
+
+    /**
+     * Location of the swagger spec, as URL or file.
+     */
+    @Parameter(name = "inputSpec", required = true)
+    private String inputSpec;
+
+    /**
+     * Folder containing the template files.
+     */
+    @Parameter(name = "templateDirectory")
+    private File templateDirectory;
+
+    /**
+     * The package to use for generated model objects/classes
+     */
+    @Parameter(name = "modelPackage")
+    private String modelPackage;
+
+    /**
+     * The package to use for generated api objects/classes
+     */
+    @Parameter(name = "apiPackage")
+    private String apiPackage;
+
+    /**
+     * The package to use for the generated invoker objects
+     */
+    @Parameter(name = "invokerPackage")
+    private String invokerPackage;
+
+    /**
+     * Client language to generate.
+     */
+    @Parameter(name = "language", required = true)
+    private String language;
+
+    /**
+     * Path to separate json configuration file.
+     */
+    @Parameter(name = "configurationFile", required = false)
+    private String configurationFile;
+
+    /**
+     * Sets the library
+     */
+    @Parameter(name = "library", required = false)
+    private String library;
+
+    /**
+     * A map of language-specific parameters as passed with the -c option to the command line
+     */
+    @Parameter(name = "configOptions")
+    private Map configOptions;
+
+    /**
+     * Add the output directory to the project as a source root, so that the
+     * generated java types are compiled and included in the project artifact.
+     */
+    @Parameter(defaultValue = "true")
+    private boolean addCompileSourceRoot = true;
+
+    @Parameter
+    protected Map<String, String> environmentVariables = new HashMap<String, String>();
+
+    @Parameter
+    private boolean configHelp = false;
+
+    /**
+     * The project being built.
+     */
+    @Parameter(readonly = true, required = true, defaultValue = "${project}")
+    private MavenProject project;
+
+    @Override
+    public void execute() throws MojoExecutionException {
+        Swagger swagger = new SwaggerParser().read(inputSpec);
+
+        CodegenConfig config = CodegenConfigLoader.forName(language);
+        config.setOutputDir(output.getAbsolutePath());
+
+        if (environmentVariables != null) {
+            for(String key : environmentVariables.keySet()) {
+                String value = environmentVariables.get(key);
+                if(value == null) {
+                    // don't put null values
+                    value = "";
+                }
+                System.setProperty(key, value);
+            }
+        }
+        if (null != library) {
+            config.setLibrary(library);
+        }
+        if (null != templateDirectory) {
+            config.additionalProperties().put(TEMPLATE_DIR_PARAM, templateDirectory.getAbsolutePath());
+        }
+        if (null != modelPackage) {
+            config.additionalProperties().put(MODEL_PACKAGE_PARAM, modelPackage);
+        }
+        if (null != apiPackage) {
+            config.additionalProperties().put(API_PACKAGE_PARAM, apiPackage);
+        }
+        if (null != invokerPackage) {
+            config.additionalProperties().put(INVOKER_PACKAGE_PARAM, invokerPackage);
+        }
+
+        if (configOptions != null) {
+            for (CliOption langCliOption : config.cliOptions()) {
+                if (configOptions.containsKey(langCliOption.getOpt())) {
+                    config.additionalProperties().put(langCliOption.getOpt(),
+                            configOptions.get(langCliOption.getOpt()));
+                }
+            }
+        }
+
+        if (null != configurationFile) {
+            Config genConfig = ConfigParser.read(configurationFile);
+            if (null != genConfig) {
+                for (CliOption langCliOption : config.cliOptions()) {
+                    if (genConfig.hasOption(langCliOption.getOpt())) {
+                        config.additionalProperties().put(langCliOption.getOpt(), genConfig.getOption(langCliOption.getOpt()));
+                    }
+                }
+            } else {
+            	throw new RuntimeException("Unable to read configuration file");
+            }
+        }
+        
+        ClientOptInput input = new ClientOptInput().opts(new ClientOpts()).swagger(swagger);
+        input.setConfig(config);
+
+        if(configHelp) {
+            for (CliOption langCliOption : config.cliOptions()) {
+                System.out.println("\t" + langCliOption.getOpt());
+                System.out.println("\t    " + langCliOption.getOptionHelp().replaceAll("\n", "\n\t    "));
+                System.out.println();
+            }
+            return;
+        }
+        try {
+            new DefaultGenerator().opts(input).generate();
+        } catch (Exception e) {
+            // Maven logs exceptions thrown by plugins only if invoked with -e
+        	// I find it annoying to jump through hoops to get basic diagnostic information,
+        	// so let's log it in any case:
+            getLog().error(e); 
+            throw new MojoExecutionException("Code generation failed. See above for the full exception.");
+        }
+
+        if (addCompileSourceRoot) {
+            project.addCompileSourceRoot(output.toString());
+        }
+    }
+}

modules/swagger-codegen/.gitignore

@@ -0,0 +1 @@
+/.settings/

modules/swagger-codegen/pom.xml

@@ -3,7 +3,7 @@
     <parent>
         <groupId>io.swagger</groupId>
         <artifactId>swagger-codegen-project</artifactId>
-        <version>2.1.2</version>
+        <version>2.1.5</version>
         <relativePath>../..</relativePath>
     </parent>
     <modelVersion>4.0.0</modelVersion>
@@ -70,44 +70,6 @@
                     </execution>
                 </executions>
             </plugin>
-            <plugin>
-                <groupId>net.alchim31.maven</groupId>
-                <artifactId>scala-maven-plugin</artifactId>
-                <executions>
-                    <execution>
-                        <goals>
-                            <goal>add-source</goal>
-                            <goal>compile</goal>
-                            <goal>testCompile</goal>
-                        </goals>
-                    </execution>
-                </executions>
-                <configuration>
-                    <configuration>
-                        <recompileMode>incremental</recompileMode>
-                    </configuration>
-                    <jvmArgs>
-                        <jvmArg>-Xmx384m</jvmArg>
-                    </jvmArgs>
-                    <args>
-                        <arg>-target:jvm-1.6</arg>
-                        <arg>-deprecation</arg>
-                    </args>
-                    <launchers>
-                        <launcher>
-                            <id>run-scalatest</id>
-                            <mainClass>org.scalatest.tools.Runner</mainClass>
-                            <args>
-                                <arg>-p</arg>
-                                <arg>${project.build.testOutputDirectory}</arg>
-                            </args>
-                            <jvmArgs>
-                                <jvmArg>-Xmx512m</jvmArg>
-                            </jvmArgs>
-                        </launcher>
-                    </launchers>
-                </configuration>
-            </plugin>
             <plugin>
                 <artifactId>maven-compiler-plugin</artifactId>
                 <version>3.0</version>
@@ -141,24 +103,19 @@
                 <artifactId>maven-release-plugin</artifactId>
                 <version>2.1</version>
             </plugin>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-jar-plugin</artifactId>
+                <version>2.6</version>
+                <executions>
+                    <execution>
+                        <goals>
+                            <goal>test-jar</goal>
+                        </goals>
+                    </execution>
+                </executions>
+            </plugin>
         </plugins>
-        <pluginManagement>
-            <plugins>
-                <plugin>
-                    <groupId>net.alchim31.maven</groupId>
-                    <artifactId>scala-maven-plugin</artifactId>
-                    <version>${scala-maven-plugin-version}</version>
-                </plugin>
-                <plugin>
-                    <groupId>org.apache.maven.plugins</groupId>
-                    <artifactId>maven-gpg-plugin</artifactId>
-                    <configuration>
-                        <releaseProfiles>release</releaseProfiles>
-                        <goals>sign</goals>
-                    </configuration>
-                </plugin>
-            </plugins>
-        </pluginManagement>
     </build>
     <profiles>
         <profile>
@@ -166,43 +123,6 @@
             <properties>
                 <skipTests>true</skipTests>
             </properties>
-            <build>
-                <plugins>
-                    <plugin>
-                        <groupId>net.alchim31.maven</groupId>
-                        <artifactId>scala-maven-plugin</artifactId>
-                        <executions>
-                            <execution>
-                                <goals>
-                                    <goal>compile</goal>
-                                    <goal>testCompile</goal>
-                                </goals>
-                            </execution>
-                        </executions>
-                        <configuration>
-                            <scala-version>${scala-version}</scala-version>
-                        </configuration>
-                    </plugin>
-                    <plugin>
-                        <groupId>org.codehaus.mojo</groupId>
-                        <artifactId>build-helper-maven-plugin</artifactId>
-                        <executions>
-                            <execution>
-                                <id>add-source</id>
-                                <phase>prepare-package</phase>
-                                <goals>
-                                    <goal>add-source</goal>
-                                </goals>
-                                <configuration>
-                                    <sources>
-                                        <source>src/main/scala</source>
-                                    </sources>
-                                </configuration>
-                            </execution>
-                        </executions>
-                    </plugin>
-                </plugins>
-            </build>
         </profile>
         <profile>
             <id>release-sign-artifacts</id>
@@ -234,6 +154,7 @@
     <reporting>
         <outputDirectory>target/site</outputDirectory>
         <plugins>
+
             <plugin>
                 <groupId>org.apache.maven.plugins</groupId>
                 <artifactId>maven-javadoc-plugin</artifactId>
@@ -248,11 +169,6 @@
                     <excludePackageNames/>
                 </configuration>
             </plugin>
-            <plugin>
-                <groupId>net.alchim31.maven</groupId>
-                <artifactId>scala-maven-plugin</artifactId>
-                <version>${scala-maven-plugin-version}</version>
-            </plugin>
             <plugin>
                 <groupId>org.apache.maven.plugins</groupId>
                 <artifactId>maven-jxr-plugin</artifactId>
@@ -322,6 +238,11 @@
             <artifactId>slf4j-api</artifactId>
             <version>${slf4j-version}</version>
         </dependency>
+        <dependency>
+            <groupId>org.slf4j</groupId>
+            <artifactId>slf4j-simple</artifactId>
+            <version>${slf4j-version}</version>
+        </dependency>
         <dependency>
             <groupId>commons-lang</groupId>
             <artifactId>commons-lang</artifactId>
@@ -333,15 +254,21 @@
             <version>${commons-cli-version}</version>
         </dependency>
         <dependency>
-            <groupId>org.scalatest</groupId>
-            <artifactId>scalatest_2.11</artifactId>
-            <version>${scala-test-version}</version>
+            <groupId>org.testng</groupId>
+            <artifactId>testng</artifactId>
+            <version>${testng-version}</version>
             <scope>test</scope>
         </dependency>
         <dependency>
-            <groupId>org.scala-lang</groupId>
-            <artifactId>scala-library</artifactId>
-            <version>${scala-version}</version>
+            <groupId>org.reflections</groupId>
+            <artifactId>reflections</artifactId>
+            <version>${reflections-version}</version>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.jmockit</groupId>
+            <artifactId>jmockit</artifactId>
+            <version>${jmockit-version}</version>
             <scope>test</scope>
         </dependency>
     </dependencies>

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

@@ -60,10 +60,46 @@ public abstract class AbstractGenerator {
         throw new RuntimeException("can't load template " + name);
     }
 
-    private String getCPResourcePath(String name) {
+    /**
+     * Get the template file path with template dir prepended, and use the
+     * library template if exists.
+     */
+    public String getFullTemplateFile(CodegenConfig config, String templateFile) {
+        String library = config.getLibrary();
+        if (library != null && !"".equals(library)) {
+            String libTemplateFile = config.templateDir() + File.separator +
+                "libraries" + File.separator + library + File.separator +
+                templateFile;
+
+            if (new File(libTemplateFile).exists()) {
+                return libTemplateFile;
+            }
+
+            libTemplateFile = config.embeddedTemplateDir() + File.separator +
+                "libraries" + File.separator + library + File.separator +
+                templateFile;
+            if (embeddedTemplateExists(libTemplateFile)) {
+                // Fall back to the template file embedded/packaged in the JAR file...
+                return libTemplateFile;
+            }
+        }
+        String template = config.templateDir() + File.separator + templateFile;
+        if (new File(template).exists()) {
+            return template;
+        } else {
+            // Fall back to the template file embedded/packaged in the JAR file...
+            return config.embeddedTemplateDir() + File.separator + templateFile;
+        }
+    }
+
+    public boolean embeddedTemplateExists(String name) {
+        return this.getClass().getClassLoader().getResource(getCPResourcePath(name)) != null;
+    }
+
+    public String getCPResourcePath(String name) {
         if (!"/".equals(File.separator)) {
             return name.replaceAll(Pattern.quote(File.separator), "/");
         }
         return name;
     }
-}
+}

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

@@ -1,14 +1,32 @@
 package io.swagger.codegen;
 
+import io.swagger.annotations.ApiModelProperty;
+import io.swagger.models.properties.BooleanProperty;
+import io.swagger.models.properties.StringProperty;
+
+import com.fasterxml.jackson.annotation.JsonIgnore;
+
+import java.util.LinkedHashMap;
+import java.util.Map;
+
 public class CliOption {
     private final String opt;
     private String description;
+    private String type;
+    private String defaultValue;
+    private Map<String, String> enumValues;
 
     public CliOption(String opt, String description) {
-        this.opt = opt;
-        this.description = description;
+        this(opt, description, StringProperty.TYPE);
     }
 
+    public CliOption(String opt, String description, String type) {
+        this.opt = opt;
+        this.description = description;
+        this.type = type;
+    }
+
+    @ApiModelProperty(name = "optionName")
     public String getOpt() {
         return opt;
     }
@@ -20,4 +38,66 @@ public class CliOption {
     public void setDescription(String description) {
         this.description = description;
     }
+
+    @ApiModelProperty(value = "Data type is based on the types supported by the JSON-Schema")
+    public String getType() {
+        return type;
+    }
+
+    public void setType(String type) {
+        this.type = type;
+    }
+
+    public String getDefault() {
+        return defaultValue;
+    }
+
+    public void setDefault(String defaultValue) {
+        this.defaultValue = defaultValue;
+    }
+
+    public CliOption defaultValue(String defaultValue) {
+        this.defaultValue = defaultValue;
+        return this;
+    }
+
+    public CliOption addEnum(String value, String description) {
+        if (this.enumValues == null) {
+            this.enumValues = new LinkedHashMap<String, String>();
+        }
+        if (!enumValues.containsKey(value)) {
+            enumValues.put(value, description);
+        }
+        return this;
+    }
+
+    public Map<String, String> getEnum() {
+        return enumValues;
+    }
+
+    public void setEnum(Map<String, String> enumValues) {
+        this.enumValues = enumValues;
+    }
+
+    public static CliOption newBoolean(String opt, String description) {
+        return new CliOption(opt, description, BooleanProperty.TYPE).defaultValue(Boolean.FALSE.toString());
+    }
+
+    public static CliOption newString(String opt, String description) {
+        return new CliOption(opt, description, StringProperty.TYPE);
+    }
+
+    @JsonIgnore
+    public String getOptionHelp() {
+        StringBuilder sb = new StringBuilder(description);
+        if(defaultValue != null) {
+            sb.append(" (Default: ").append(defaultValue).append(")");
+        }
+        if (enumValues != null) {
+            for (Map.Entry<String, String> entry : enumValues.entrySet()) {
+                sb.append("\n    ").append(entry.getKey()).append(" - ").append(entry.getValue());
+            }
+        }
+        return sb.toString();
+    }
 }

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

@@ -1,6 +1,7 @@
 package io.swagger.codegen;
 
 import io.swagger.annotations.ApiModelProperty;
+import io.swagger.codegen.auth.AuthParser;
 import io.swagger.models.Swagger;
 import io.swagger.models.auth.AuthorizationValue;
 
@@ -9,8 +10,10 @@ import java.net.URLEncoder;
 import java.util.ArrayList;
 import java.util.List;
 
+import static org.apache.commons.lang3.StringUtils.isNotEmpty;
+
 public class ClientOptInput {
-    protected CodegenConfig config;
+    private CodegenConfig config;
     private ClientOpts opts;
     private Swagger swagger;
     private List<AuthorizationValue> auths;
@@ -25,42 +28,28 @@ public class ClientOptInput {
         return this;
     }
 
+    public ClientOptInput config(CodegenConfig codegenConfig) {
+        this.setConfig(codegenConfig);
+        return this;
+    }
+
+    @Deprecated
+    public ClientOptInput auth(String urlEncodedAuthString) {
+        this.setAuth(urlEncodedAuthString);
+        return this;
+    }
+
+    @Deprecated
     public String getAuth() {
-        if (auths != null) {
-            StringBuilder b = new StringBuilder();
-            for (AuthorizationValue v : auths) {
-                try {
-                    if (b.toString().length() > 0) {
-                        b.append(",");
-                    }
-                    b.append(URLEncoder.encode(v.getKeyName(), "UTF-8"))
-                            .append(":")
-                            .append(URLEncoder.encode(v.getValue(), "UTF-8"));
-                } catch (Exception e) {
-                    // continue
-                    e.printStackTrace();
-                }
-            }
-            return b.toString();
-        } else {
-            return null;
-        }
+        return AuthParser.reconstruct(auths);
     }
 
+    @Deprecated
     public void setAuth(String urlEncodedAuthString) {
-        List<AuthorizationValue> auths = new ArrayList<AuthorizationValue>();
-        if (urlEncodedAuthString != null && !"".equals(urlEncodedAuthString)) {
-            String[] parts = urlEncodedAuthString.split(",");
-            for (String part : parts) {
-                String[] kvPair = part.split(":");
-                if (kvPair.length == 2) {
-                    auths.add(new AuthorizationValue(URLDecoder.decode(kvPair[0]), URLDecoder.decode(kvPair[1]), "header"));
-                }
-            }
-        }
-        this.auths = auths;
+        this.auths = AuthParser.parse(urlEncodedAuthString);
     }
 
+    @Deprecated
     public List<AuthorizationValue> getAuthorizationValues() {
         return auths;
     }

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

@@ -1,5 +1,7 @@
 package io.swagger.codegen;
 
+import config.Config;
+import config.ConfigParser;
 import io.swagger.models.Swagger;
 import io.swagger.parser.SwaggerParser;
 import org.apache.commons.cli.BasicParser;
@@ -9,6 +11,7 @@ import org.apache.commons.cli.HelpFormatter;
 import org.apache.commons.cli.Options;
 
 import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.HashMap;
 import java.util.Iterator;
 import java.util.List;
@@ -41,6 +44,7 @@ public class Codegen extends DefaultGenerator {
         options.addOption("t", "template-dir", true, "folder containing the template files");
         options.addOption("d", "debug-info", false, "prints additional info for debugging");
         options.addOption("a", "auth", true, "adds authorization headers when fetching the swagger definitions remotely. Pass in a URL-encoded string of name:header with a comma separating multiple values");
+        options.addOption("c", "config", true, "location of the configuration file");
 
         ClientOptInput clientOptInput = new ClientOptInput();
         ClientOpts clientOpts = new ClientOpts();
@@ -84,8 +88,20 @@ public class Codegen extends DefaultGenerator {
             if (cmd.hasOption("i")) {
                 swagger = new SwaggerParser().read(cmd.getOptionValue("i"), clientOptInput.getAuthorizationValues(), true);
             }
+            if (cmd.hasOption("c")) {
+                String configFile = cmd.getOptionValue("c");
+                Config genConfig = ConfigParser.read(configFile);
+                config = clientOptInput.getConfig();
+                if (null != genConfig && null != config) {
+                    for (CliOption langCliOption : config.cliOptions()) {
+                        if (genConfig.hasOption(langCliOption.getOpt())) {
+                            config.additionalProperties().put(langCliOption.getOpt(), genConfig.getOption(langCliOption.getOpt()));
+                        }
+                    }
+                }
+            }
             if (cmd.hasOption("t")) {
-                clientOpts.getProperties().put("templateDir", String.valueOf(cmd.getOptionValue("t")));
+                clientOpts.getProperties().put(CodegenConstants.TEMPLATE_DIR, String.valueOf(cmd.getOptionValue("t")));
             }
         } catch (Exception e) {
             usage(options);
@@ -145,4 +161,4 @@ public class Codegen extends DefaultGenerator {
             configString = sb.toString();
         }
     }
-}
+}

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

@@ -29,6 +29,8 @@ public interface CodegenConfig {
 
     String templateDir();
 
+    String embeddedTemplateDir();
+
     String modelFileFolder();
 
     String modelPackage();
@@ -65,6 +67,10 @@ public interface CodegenConfig {
 
     CodegenModel fromModel(String name, Model model);
 
+    CodegenModel fromModel(String name, Model model, Map<String, Model> allDefinitions);
+
+    CodegenOperation fromOperation(String resourcePath, String httpMethod, Operation operation, Map<String, Model> definitions, Swagger swagger);
+    
     CodegenOperation fromOperation(String resourcePath, String httpMethod, Operation operation, Map<String, Model> definitions);
 
     List<CodegenSecurity> fromSecurity(Map<String, SecuritySchemeDefinition> schemes);
@@ -81,6 +87,10 @@ public interface CodegenConfig {
 
     Map<String, String> modelTemplateFiles();
 
+    Set<String> languageSpecificPrimitives();
+
+    void preprocessSwagger(Swagger swagger);
+
     void processSwagger(Swagger swagger);
 
     String toApiFilename(String name);
@@ -99,7 +109,24 @@ public interface CodegenConfig {
 
     Map<String, Object> postProcessSupportingFileData(Map<String, Object> objs);
 
+    void postProcessModelProperty(CodegenModel model, CodegenProperty property);
+
+    void postProcessParameter(CodegenParameter parameter);
+
     String apiFilename(String templateName, String tag);
 
     boolean shouldOverwrite(String filename);
+
+    boolean isSkipOverwrite();
+
+    void setSkipOverwrite(boolean skipOverwrite);
+
+    Map<String, String> supportedLibraries();
+
+    void setLibrary(String library);
+
+    /**
+     * Library template (sub-template).
+     */
+    String getLibrary();
 }

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

@@ -0,0 +1,34 @@
+package io.swagger.codegen;
+
+import java.util.ServiceLoader;
+
+import static java.util.ServiceLoader.load;
+
+public class CodegenConfigLoader {
+    /**
+     * Tries to load config class with SPI first, then with class name directly from classpath
+     *
+     * @param name name of config, or full qualified class name in classpath
+     * @return config class
+     */
+    public static CodegenConfig forName(String name) {
+        ServiceLoader<CodegenConfig> loader = load(CodegenConfig.class);
+
+        StringBuilder availableConfigs = new StringBuilder();
+
+        for (CodegenConfig config : loader) {
+            if (config.getName().equals(name)) {
+                return config;
+            }
+
+            availableConfigs.append(config.getName()).append("\n");
+        }
+
+        // else try to load directly
+        try {
+            return (CodegenConfig) Class.forName(name).newInstance();
+        } catch (Exception e) {
+            throw new RuntimeException("Can't load config class with name ".concat(name) + " Available: " + availableConfigs.toString(), e);
+        }
+    }
+}

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

@@ -0,0 +1,57 @@
+package io.swagger.codegen;
+
+/**
+ * A class for storing constants that are used throughout the project.
+ */
+public class CodegenConstants {
+    public static final String API_PACKAGE = "apiPackage";
+    public static final String API_PACKAGE_DESC = "package for generated api classes";
+
+    public static final String MODEL_PACKAGE = "modelPackage";
+    public static final String MODEL_PACKAGE_DESC = "package for generated models";
+
+    public static final String TEMPLATE_DIR = "templateDir";
+
+
+    public static final String INVOKER_PACKAGE = "invokerPackage";
+    public static final String INVOKER_PACKAGE_DESC = "root package for generated code";
+
+    public static final String GROUP_ID = "groupId";
+    public static final String GROUP_ID_DESC = "groupId in generated pom.xml";
+
+    public static final String ARTIFACT_ID = "artifactId";
+    public static final String ARTIFACT_ID_DESC = "artifactId in generated pom.xml";
+
+    public static final String ARTIFACT_VERSION = "artifactVersion";
+    public static final String ARTIFACT_VERSION_DESC = "artifact version in generated pom.xml";
+
+    public static final String SOURCE_FOLDER = "sourceFolder";
+    public static final String SOURCE_FOLDER_DESC = "source folder for generated code";
+
+    public static final String IMPL_FOLDER = "implFolder";
+    public static final String IMPL_FOLDER_DESC = "folder for generated implementation code";
+    
+    public static final String LOCAL_VARIABLE_PREFIX = "localVariablePrefix";
+    public static final String LOCAL_VARIABLE_PREFIX_DESC = "prefix for generated code members and local variables";
+
+    public static final String SERIALIZABLE_MODEL = "serializableModel";
+    public static final String SERIALIZABLE_MODEL_DESC = "boolean - toggle \"implements Serializable\" for generated models";
+
+    public static final String SERIALIZE_BIG_DECIMAL_AS_STRING = "bigDecimalAsString";
+    public static final String SERIALIZE_BIG_DECIMAL_AS_STRING_DESC = "Treat BigDecimal values as Strings to avoid precision loss.";
+
+    public static final String LIBRARY = "library";
+    public static final String LIBRARY_DESC = "library template (sub-template)";
+
+    public static final String SORT_PARAMS_BY_REQUIRED_FLAG = "sortParamsByRequiredFlag";
+    public static final String SORT_PARAMS_BY_REQUIRED_FLAG_DESC = "Sort method arguments to place required parameters before optional parameters.";
+
+    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 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/CodegenModel.java

@@ -2,17 +2,22 @@ package io.swagger.codegen;
 
 import io.swagger.models.ExternalDocs;
 
-import java.util.ArrayList;
-import java.util.HashSet;
-import java.util.List;
-import java.util.Set;
+import java.util.*;
 
 public class CodegenModel {
-    public String parent;
-    public String name, classname, description, classVarName, modelJson;
+    public String parent, parentSchema;
+    public String name, classname, description, classVarName, modelJson, dataType;
+    public String unescapedDescription;
     public String defaultValue;
     public List<CodegenProperty> vars = new ArrayList<CodegenProperty>();
-    public Set<String> imports = new HashSet<String>();
-    public Boolean hasVars, emptyVars, hasMoreModels, hasEnums;
+    public List<String> allowableValues;
+
+    // list of all required parameters
+    public Set<String> mandatory = new HashSet<String>();
+    
+    public Set<String> imports = new TreeSet<String>();
+    public Boolean hasVars, emptyVars, hasMoreModels, hasEnums, isEnum;
     public ExternalDocs externalDocs;
-}
+
+    public Map<String, Object> vendorExtensions;
+}

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

@@ -10,9 +10,10 @@ import java.util.Set;
 
 public class CodegenOperation {
     public final List<CodegenProperty> responseHeaders = new ArrayList<CodegenProperty>();
-    public Boolean hasConsumes, hasProduces, hasParams, returnTypeIsPrimitive,
-            returnSimpleType, subresourceOperation, isMapContainer, isListContainer,
-            hasMore = Boolean.TRUE, isMultipart;
+    public Boolean hasAuthMethods, hasConsumes, hasProduces, hasParams, hasOptionalParams,
+            returnTypeIsPrimitive, returnSimpleType, subresourceOperation, isMapContainer,
+            isListContainer, isMultipart, hasMore = Boolean.TRUE,
+            isResponseBinary = Boolean.FALSE, hasReference = Boolean.FALSE;
     public String path, operationId, returnType, httpMethod, returnBaseType,
             returnContainer, summary, notes, baseName, defaultResponse;
     public List<Map<String, String>> consumes, produces;
@@ -29,7 +30,61 @@ public class CodegenOperation {
     public Set<String> imports = new HashSet<String>();
     public List<Map<String, String>> examples;
     public ExternalDocs externalDocs;
+    public Map<String, Object> vendorExtensions;
+    public String nickname; // legacy support
+
+    /**
+     * Check if there's at least one parameter
+     *
+     * @return true if parameter exists, false otherwise
+     */
+    private boolean nonempty(List<CodegenParameter> params) {
+        return params != null && params.size() > 0;
+    }
+
+    /**
+     * Check if there's at least one body parameter
+     *
+     * @return true if body parameter exists, false otherwise
+     */
+    public boolean getHasBodyParam() {
+        return nonempty(bodyParams);
+    }
+
+    /**
+     * Check if there's at least one query parameter
+     *
+     * @return true if query parameter exists, false otherwise
+     */
+    public boolean getHasQueryParams() {
+        return nonempty(queryParams);
+    }
+
+    /**
+     * Check if there's at least one header parameter
+     *
+     * @return true if header parameter exists, false otherwise
+     */
+    public boolean getHasHeaderParams() {
+        return nonempty(headerParams);
+    }
+
+    /**
+     * Check if there's at least one path parameter
+     *
+     * @return true if path parameter exists, false otherwise
+     */
+    public boolean getHasPathParams() {
+        return nonempty(pathParams);
+    }
+
+    /**
+     * Check if there's at least one form parameter
+     *
+     * @return true if any form parameter exists, false otherwise
+     */
+    public boolean getHasFormParams() {
+        return nonempty(formParams);
+    }
 
-    // legacy support
-    public String nickname;
 }

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

@@ -1,10 +1,20 @@
 package io.swagger.codegen;
 
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.List;
+
 public class CodegenParameter {
     public Boolean isFormParam, isQueryParam, isPathParam, isHeaderParam,
-            isCookieParam, isBodyParam, isFile, notFile, hasMore, isContainer, secondaryParam;
+            isCookieParam, isBodyParam, isFile, notFile, hasMore, isContainer, 
+            secondaryParam, isBinary, isCollectionFormatMulti;
     public String baseName, paramName, dataType, collectionFormat, description, baseType, defaultValue;
     public String jsonSchema;
+    public boolean isEnum;
+    public List<String> _enum;
+    public Map<String, Object> allowableValues;
+    public Map<String, Object> vendorExtensions;
 
     /**
      * Determines whether this parameter is mandatory. If the parameter is in "path",
@@ -13,6 +23,51 @@ public class CodegenParameter {
      */
     public Boolean required;
 
+	/**
+	 * See http://json-schema.org/latest/json-schema-validation.html#anchor17.
+	 */
+    public Number maximum;
+	/**
+	 * See http://json-schema.org/latest/json-schema-validation.html#anchor17
+	 */
+    public Boolean exclusiveMaximum;
+	/**
+	 * See http://json-schema.org/latest/json-schema-validation.html#anchor21
+	 */
+    public Number minimum;
+	/**
+	 * See http://json-schema.org/latest/json-schema-validation.html#anchor21
+	 */
+    public Boolean exclusiveMinimum;
+	/**
+	 * See http://json-schema.org/latest/json-schema-validation.html#anchor26
+	 */
+    public Integer maxLength;
+	/**
+	 * See http://json-schema.org/latest/json-schema-validation.html#anchor29
+	 */
+    public Integer minLength;
+	/**
+	 * See http://json-schema.org/latest/json-schema-validation.html#anchor33
+	 */
+    public String pattern;
+	/**
+	 * See http://json-schema.org/latest/json-schema-validation.html#anchor42
+	 */
+    public Integer maxItems;
+	/**
+	 * See http://json-schema.org/latest/json-schema-validation.html#anchor45
+	 */
+    public Integer minItems;
+	/**
+	 * See http://json-schema.org/latest/json-schema-validation.html#anchor49
+	 */
+    public Boolean uniqueItems;
+	/**
+	 * See http://json-schema.org/latest/json-schema-validation.html#anchor14
+	 */
+    public Number multipleOf;
+    
     public CodegenParameter copy() {
         CodegenParameter output = new CodegenParameter();
         output.isFile = this.isFile;
@@ -24,6 +79,7 @@ public class CodegenParameter {
         output.paramName = this.paramName;
         output.dataType = this.dataType;
         output.collectionFormat = this.collectionFormat;
+        output.isCollectionFormatMulti = this.isCollectionFormatMulti;
         output.description = this.description;
         output.baseType = this.baseType;
         output.isFormParam = this.isFormParam;
@@ -33,9 +89,29 @@ public class CodegenParameter {
         output.isCookieParam = this.isCookieParam;
         output.isBodyParam = this.isBodyParam;
         output.required = this.required;
+        output.maximum = this.maximum;
+        output.exclusiveMaximum = this.exclusiveMaximum;
+        output.minimum = this.minimum;
+        output.exclusiveMinimum = this.exclusiveMinimum;
+        output.maxLength = this.maxLength;
+        output.minLength = this.minLength;
+        output.pattern = this.pattern;
+        output.maxItems = this.maxItems;
+        output.minItems = this.minItems;
+        output.uniqueItems = this.uniqueItems;
+        output.multipleOf = this.multipleOf;
         output.jsonSchema = this.jsonSchema;
         output.defaultValue = this.defaultValue;
+        output.isEnum = this.isEnum;
+        if (this._enum != null) {
+            output._enum = new ArrayList<String>(this._enum);
+        }
+        if (this.allowableValues != null) {
+            output.allowableValues = new HashMap<String, Object>(this.allowableValues);
+        }
+        output.vendorExtensions = this.vendorExtensions;
 
         return output;
     }
 }
+

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

@@ -5,7 +5,9 @@ import java.util.Map;
 
 public class CodegenProperty {
     public String baseName, complexType, getter, setter, description, datatype, datatypeWithEnum,
-            name, min, max, defaultValue, baseType, containerType;
+            name, min, max, defaultValue, defaultValueWithParam, baseType, containerType;
+
+    public String unescapedDescription;
 
     /**
      * maxLength validation for strings, see http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.2.1
@@ -29,9 +31,117 @@ public class CodegenProperty {
     public Double maximum;
     public Boolean exclusiveMinimum;
     public Boolean exclusiveMaximum;
-    public Boolean hasMore = null, required = null, secondaryParam = null;
+    public Boolean hasMore, required, secondaryParam;
     public Boolean isPrimitiveType, isContainer, isNotContainer;
     public boolean isEnum;
+    public Boolean isReadOnly = false;
     public List<String> _enum;
     public Map<String, Object> allowableValues;
+    public CodegenProperty items;
+    public Map<String, Object> vendorExtensions;
+
+    @Override
+    public boolean equals(Object obj) {
+        if (obj == null) {
+            return false;
+        }
+        if (getClass() != obj.getClass()) {
+            return false;
+        }
+        final CodegenProperty other = (CodegenProperty) obj;
+        if ((this.baseName == null) ? (other.baseName != null) : !this.baseName.equals(other.baseName)) {
+            return false;
+        }
+        if ((this.complexType == null) ? (other.complexType != null) : !this.complexType.equals(other.complexType)) {
+            return false;
+        }
+        if ((this.getter == null) ? (other.getter != null) : !this.getter.equals(other.getter)) {
+            return false;
+        }
+        if ((this.setter == null) ? (other.setter != null) : !this.setter.equals(other.setter)) {
+            return false;
+        }
+        if ((this.description == null) ? (other.description != null) : !this.description.equals(other.description)) {
+            return false;
+        }
+        if ((this.datatype == null) ? (other.datatype != null) : !this.datatype.equals(other.datatype)) {
+            return false;
+        }
+        if ((this.datatypeWithEnum == null) ? (other.datatypeWithEnum != null) : !this.datatypeWithEnum.equals(other.datatypeWithEnum)) {
+            return false;
+        }
+        if ((this.name == null) ? (other.name != null) : !this.name.equals(other.name)) {
+            return false;
+        }
+        if ((this.min == null) ? (other.min != null) : !this.min.equals(other.min)) {
+            return false;
+        }
+        if ((this.max == null) ? (other.max != null) : !this.max.equals(other.max)) {
+            return false;
+        }
+        if ((this.defaultValue == null) ? (other.defaultValue != null) : !this.defaultValue.equals(other.defaultValue)) {
+            return false;
+        }
+        if ((this.baseType == null) ? (other.baseType != null) : !this.baseType.equals(other.baseType)) {
+            return false;
+        }
+        if ((this.containerType == null) ? (other.containerType != null) : !this.containerType.equals(other.containerType)) {
+            return false;
+        }
+        if (this.maxLength != other.maxLength && (this.maxLength == null || !this.maxLength.equals(other.maxLength))) {
+            return false;
+        }
+        if (this.minLength != other.minLength && (this.minLength == null || !this.minLength.equals(other.minLength))) {
+            return false;
+        }
+        if ((this.pattern == null) ? (other.pattern != null) : !this.pattern.equals(other.pattern)) {
+            return false;
+        }
+        if ((this.example == null) ? (other.example != null) : !this.example.equals(other.example)) {
+            return false;
+        }
+        if ((this.jsonSchema == null) ? (other.jsonSchema != null) : !this.jsonSchema.equals(other.jsonSchema)) {
+            return false;
+        }
+        if (this.minimum != other.minimum && (this.minimum == null || !this.minimum.equals(other.minimum))) {
+            return false;
+        }
+        if (this.maximum != other.maximum && (this.maximum == null || !this.maximum.equals(other.maximum))) {
+            return false;
+        }
+        if (this.exclusiveMinimum != other.exclusiveMinimum && (this.exclusiveMinimum == null || !this.exclusiveMinimum.equals(other.exclusiveMinimum))) {
+            return false;
+        }
+        if (this.exclusiveMaximum != other.exclusiveMaximum && (this.exclusiveMaximum == null || !this.exclusiveMaximum.equals(other.exclusiveMaximum))) {
+            return false;
+        }
+        if (this.required != other.required && (this.required == null || !this.required.equals(other.required))) {
+            return false;
+        }
+        if (this.secondaryParam != other.secondaryParam && (this.secondaryParam == null || !this.secondaryParam.equals(other.secondaryParam))) {
+            return false;
+        }
+        if (this.isPrimitiveType != other.isPrimitiveType && (this.isPrimitiveType == null || !this.isPrimitiveType.equals(other.isPrimitiveType))) {
+            return false;
+        }
+        if (this.isContainer != other.isContainer && (this.isContainer == null || !this.isContainer.equals(other.isContainer))) {
+            return false;
+        }
+        if (this.isNotContainer != other.isNotContainer && (this.isNotContainer == null || !this.isNotContainer.equals(other.isNotContainer))) {
+            return false;
+        }
+        if (this.isEnum != other.isEnum) {
+            return false;
+        }
+        if (this._enum != other._enum && (this._enum == null || !this._enum.equals(other._enum))) {
+            return false;
+        }
+        if (this.allowableValues != other.allowableValues && (this.allowableValues == null || !this.allowableValues.equals(other.allowableValues))) {
+            return false;
+        }
+        if (this.vendorExtensions != other.vendorExtensions && (this.vendorExtensions == null || !this.vendorExtensions.equals(other.vendorExtensions))) {
+            return false;
+        }
+        return true;
+    }
 }

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

@@ -15,6 +15,7 @@ public class CodegenResponse {
     public Boolean primitiveType;
     public Boolean isMapContainer;
     public Boolean isListContainer;
+    public Boolean isBinary = Boolean.FALSE;
     public Object schema;
     public String jsonSchema;
 

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

@@ -1,5 +1,8 @@
 package io.swagger.codegen;
 
+import java.util.List;
+import java.util.Map;
+
 public class CodegenSecurity {
     public String name;
     public String type;
@@ -7,4 +10,7 @@ public class CodegenSecurity {
     // ApiKey specific
     public String keyParamName;
     public Boolean isKeyInQuery, isKeyInHeader;
+    // Oauth specific
+    public String flow, authorizationUrl, tokenUrl;
+    public List<Map<String, Object>> scopes;
 }

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

@@ -2,40 +2,30 @@ package io.swagger.codegen;
 
 import com.samskivert.mustache.Mustache;
 import com.samskivert.mustache.Template;
-import io.swagger.models.Contact;
-import io.swagger.models.Info;
-import io.swagger.models.License;
-import io.swagger.models.Model;
-import io.swagger.models.Operation;
-import io.swagger.models.Path;
-import io.swagger.models.Swagger;
+import io.swagger.models.*;
+import io.swagger.models.auth.OAuth2Definition;
 import io.swagger.models.auth.SecuritySchemeDefinition;
+import io.swagger.models.parameters.Parameter;
 import io.swagger.util.Json;
 import org.apache.commons.io.IOUtils;
+import org.joda.time.DateTime;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 
-import java.io.File;
-import java.io.FileInputStream;
-import java.io.FileOutputStream;
-import java.io.InputStream;
-import java.io.OutputStream;
-import java.io.Reader;
-import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.HashSet;
-import java.util.LinkedHashMap;
-import java.util.LinkedHashSet;
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
+import java.io.*;
+import java.util.*;
 
 import static org.apache.commons.lang3.StringUtils.capitalize;
 import static org.apache.commons.lang3.StringUtils.isNotEmpty;
 
 public class DefaultGenerator extends AbstractGenerator implements Generator {
-    protected CodegenConfig config;
-    protected ClientOptInput opts = null;
-    protected Swagger swagger = null;
+    Logger LOGGER = LoggerFactory.getLogger(DefaultGenerator.class);
 
+    protected CodegenConfig config;
+    protected ClientOptInput opts;
+    protected Swagger swagger;
+
+    @Override
     public Generator opts(ClientOptInput opts) {
         this.opts = opts;
 
@@ -46,7 +36,55 @@ public class DefaultGenerator extends AbstractGenerator implements Generator {
         return this;
     }
 
+    @Override
     public List<File> generate() {
+        Boolean generateApis = null;
+        Boolean generateModels = null;
+        Boolean generateSupportingFiles = null;
+
+        Set<String> modelsToGenerate = null;
+        Set<String> apisToGenerate = null;
+        Set<String> supportingFilesToGenerate = null;
+
+        // allows generating only models by specifying a CSV of models to generate, or empty for all
+        if(System.getProperty("models") != null) {
+            String modelNames = System.getProperty("models");
+            generateModels = true;
+            if(!modelNames.isEmpty()) {
+                modelsToGenerate = new HashSet<String>(Arrays.asList(modelNames.split(",")));
+            }
+        }
+        if(System.getProperty("apis") != null) {
+            String apiNames = System.getProperty("apis");
+            generateApis = true;
+            if(!apiNames.isEmpty()) {
+                apisToGenerate = new HashSet<String>(Arrays.asList(apiNames.split(",")));
+            }
+        }
+        if(System.getProperty("supportingFiles") != null) {
+            String supportingFiles = System.getProperty("supportingFiles");
+            generateSupportingFiles = true;
+            if(!supportingFiles.isEmpty()) {
+                supportingFilesToGenerate = new HashSet<String>(Arrays.asList(supportingFiles.split(",")));
+            }
+        }
+
+        if(generateApis == null && generateModels == null && generateSupportingFiles == null) {
+            // no specifics are set, generate everything
+            generateApis = true; generateModels = true; generateSupportingFiles = true;
+        }
+        else {
+            if(generateApis == null) {
+                generateApis = false;
+            }
+            if(generateModels == null) {
+                generateModels = false;
+            }
+            if(generateSupportingFiles == null) {
+                generateSupportingFiles = false;
+            }
+        }
+
         if (swagger == null || config == null) {
             throw new RuntimeException("missing swagger input or config!");
         }
@@ -54,243 +92,329 @@ public class DefaultGenerator extends AbstractGenerator implements Generator {
             Json.prettyPrint(swagger);
         }
         List<File> files = new ArrayList<File>();
-        try {
-            config.processOpts();
-            if (swagger.getInfo() != null) {
-                Info info = swagger.getInfo();
-                if (info.getTitle() != null) {
-                    config.additionalProperties().put("appName", info.getTitle());
+        config.processOpts();
+        config.preprocessSwagger(swagger);
+
+        config.additionalProperties().put("generatedDate", DateTime.now().toString());
+        config.additionalProperties().put("generatorClass", config.getClass().toString());
+
+        if (swagger.getInfo() != null) {
+            Info info = swagger.getInfo();
+            if (info.getTitle() != null) {
+                config.additionalProperties().put("appName", info.getTitle());
+            }
+            if (info.getVersion() != null) {
+                config.additionalProperties().put("appVersion", info.getVersion());
+            }
+            if (info.getDescription() != null) {
+                config.additionalProperties().put("appDescription",
+                        config.escapeText(info.getDescription()));
+            }
+            if (info.getContact() != null) {
+                Contact contact = info.getContact();
+                config.additionalProperties().put("infoUrl", contact.getUrl());
+                if (contact.getEmail() != null) {
+                    config.additionalProperties().put("infoEmail", contact.getEmail());
                 }
-                if (info.getVersion() != null) {
-                    config.additionalProperties().put("appVersion", info.getVersion());
+            }
+            if (info.getLicense() != null) {
+                License license = info.getLicense();
+                if (license.getName() != null) {
+                    config.additionalProperties().put("licenseInfo", license.getName());
                 }
-                if (info.getDescription() != null) {
-                    config.additionalProperties().put("appDescription",
-                            config.escapeText(info.getDescription()));
+                if (license.getUrl() != null) {
+                    config.additionalProperties().put("licenseUrl", license.getUrl());
                 }
-                if (info.getContact() != null) {
-                    Contact contact = info.getContact();
-                    config.additionalProperties().put("infoUrl", contact.getUrl());
-                    if (contact.getEmail() != null) {
-                        config.additionalProperties().put("infoEmail", contact.getEmail());
+            }
+            if (info.getVersion() != null) {
+                config.additionalProperties().put("version", info.getVersion());
+            }
+        }
+
+        StringBuilder hostBuilder = new StringBuilder();
+        String scheme;
+        if (swagger.getSchemes() != null && swagger.getSchemes().size() > 0) {
+            scheme = swagger.getSchemes().get(0).toValue();
+        } else {
+            scheme = "https";
+        }
+        hostBuilder.append(scheme);
+        hostBuilder.append("://");
+        if (swagger.getHost() != null) {
+            hostBuilder.append(swagger.getHost());
+        } else {
+            hostBuilder.append("localhost");
+        }
+        if (swagger.getBasePath() != null) {
+            hostBuilder.append(swagger.getBasePath());
+        }
+        String contextPath = swagger.getBasePath() == null ? "" : swagger.getBasePath();
+        String basePath = hostBuilder.toString();
+        String basePathWithoutHost = swagger.getBasePath();
+
+
+        // resolve inline models
+        InlineModelResolver inlineModelResolver = new InlineModelResolver();
+        inlineModelResolver.flatten(swagger);
+
+        List<Object> allOperations = new ArrayList<Object>();
+        List<Object> allModels = new ArrayList<Object>();
+
+        // models
+        Map<String, Model> definitions = swagger.getDefinitions();
+        if (definitions != null) {
+        	List<String> sortedModelKeys = sortModelsByInheritance(definitions);
+
+            if(generateModels) {
+                if(modelsToGenerate != null && modelsToGenerate.size() > 0) {
+                    List<String> updatedKeys = new ArrayList<String>();
+                    for(String m : sortedModelKeys) {
+                        if(modelsToGenerate.contains(m)) {
+                            updatedKeys.add(m);
+                        }
+                    }
+                    sortedModelKeys = updatedKeys;
+                }
+
+                for (String name : sortedModelKeys) {
+                    try {
+                        //don't generate models that have an import mapping
+                        if(config.importMapping().containsKey(name)) {
+                            continue;
+                        }
+
+                        Model model = definitions.get(name);
+                        Map<String, Model> modelMap = new HashMap<String, Model>();
+                        modelMap.put(name, model);
+                        Map<String, Object> models = processModels(config, modelMap, definitions);
+                        models.putAll(config.additionalProperties());
+
+                        allModels.add(((List<Object>) models.get("models")).get(0));
+
+                        for (String templateName : config.modelTemplateFiles().keySet()) {
+                            String suffix = config.modelTemplateFiles().get(templateName);
+                            String filename = config.modelFileFolder() + File.separator + config.toModelFilename(name) + suffix;
+                            if (!config.shouldOverwrite(filename)) {
+                                continue;
+                            }
+                            String templateFile = getFullTemplateFile(config, templateName);
+                            String template = readTemplate(templateFile);
+                            Template tmpl = Mustache.compiler()
+                                    .withLoader(new Mustache.TemplateLoader() {
+                                        @Override
+                                        public Reader getTemplate(String name) {
+                                            return getTemplateReader(getFullTemplateFile(config, name + ".mustache"));
+                                        }
+                                    })
+                                    .defaultValue("")
+                                    .compile(template);
+                            writeToFile(filename, tmpl.execute(models));
+                            files.add(new File(filename));
+                        }
+                    } catch (Exception e) {
+                        throw new RuntimeException("Could not generate model '" + name + "'", e);
                     }
                 }
-                if (info.getLicense() != null) {
-                    License license = info.getLicense();
-                    if (license.getName() != null) {
-                        config.additionalProperties().put("licenseInfo", license.getName());
-                    }
-                    if (license.getUrl() != null) {
-                        config.additionalProperties().put("licenseUrl", license.getUrl());
+            }
+        }
+        if (System.getProperty("debugModels") != null) {
+            System.out.println("############ Model info ############");
+            Json.prettyPrint(allModels);
+        }
+
+        // apis
+        Map<String, List<CodegenOperation>> paths = processPaths(swagger.getPaths());
+        if(generateApis) {
+            if(apisToGenerate != null && apisToGenerate.size() > 0) {
+                Map<String, List<CodegenOperation>> updatedPaths = new TreeMap<String, List<CodegenOperation>>();
+                for(String m : paths.keySet()) {
+                    if(apisToGenerate.contains(m)) {
+                        updatedPaths.put(m, paths.get(m));
                     }
                 }
-                if (info.getVersion() != null) {
-                    config.additionalProperties().put("version", info.getVersion());
-                }
+                paths = updatedPaths;
             }
+            for (String tag : paths.keySet()) {
+                try {
+                    List<CodegenOperation> ops = paths.get(tag);
+                    Map<String, Object> operation = processOperations(config, tag, ops);
 
-            StringBuilder hostBuilder = new StringBuilder();
-            String scheme;
-            if (swagger.getSchemes() != null && swagger.getSchemes().size() > 0) {
-                scheme = swagger.getSchemes().get(0).toValue();
-            } else {
-                scheme = "https";
-            }
-            hostBuilder.append(scheme);
-            hostBuilder.append("://");
-            if (swagger.getHost() != null) {
-                hostBuilder.append(swagger.getHost());
-            } else {
-                hostBuilder.append("localhost");
-            }
-            if (swagger.getBasePath() != null) {
-                hostBuilder.append(swagger.getBasePath());
-            } else {
-                hostBuilder.append("/");
-            }
-            String contextPath = swagger.getBasePath() == null ? "/" : swagger.getBasePath();
-            String basePath = hostBuilder.toString();
+                    operation.put("basePath", basePath);
+                    operation.put("basePathWithoutHost", basePathWithoutHost);
+                    operation.put("contextPath", contextPath);
+                    operation.put("baseName", tag);
+                    operation.put("modelPackage", config.modelPackage());
+                    operation.putAll(config.additionalProperties());
+                    operation.put("classname", config.toApiName(tag));
+                    operation.put("classVarName", config.toApiVarName(tag));
+                    operation.put("importPath", config.toApiImport(tag));
 
+                    // Pass sortParamsByRequiredFlag through to the Mustache template...
+                    boolean sortParamsByRequiredFlag = true;
+                    if (this.config.additionalProperties().containsKey(CodegenConstants.SORT_PARAMS_BY_REQUIRED_FLAG)) {
+                        sortParamsByRequiredFlag = Boolean.valueOf((String)this.config.additionalProperties().get(CodegenConstants.SORT_PARAMS_BY_REQUIRED_FLAG).toString());
+                    }
+                    operation.put("sortParamsByRequiredFlag", sortParamsByRequiredFlag);
 
-            List<Object> allOperations = new ArrayList<Object>();
-            List<Object> allModels = new ArrayList<Object>();
+                    processMimeTypes(swagger.getConsumes(), operation, "consumes");
+                    processMimeTypes(swagger.getProduces(), operation, "produces");
 
-            // models
-            Map<String, Model> definitions = swagger.getDefinitions();
-            if (definitions != null) {
-                for (String name : definitions.keySet()) {
-                    Model model = definitions.get(name);
-                    Map<String, Model> modelMap = new HashMap<String, Model>();
-                    modelMap.put(name, model);
-                    Map<String, Object> models = processModels(config, modelMap);
-                    models.putAll(config.additionalProperties());
+                    allOperations.add(new HashMap<String, Object>(operation));
+                    for (int i = 0; i < allOperations.size(); i++) {
+                        Map<String, Object> oo = (Map<String, Object>) allOperations.get(i);
+                        if (i < (allOperations.size() - 1)) {
+                            oo.put("hasMore", "true");
+                        }
+                    }
 
-                    allModels.add(((List<Object>) models.get("models")).get(0));
+                    for (String templateName : config.apiTemplateFiles().keySet()) {
+                        String filename = config.apiFilename(templateName, tag);
+                        if (!config.shouldOverwrite(filename) && new File(filename).exists()) {
+                            continue;
+                        }
 
-                    for (String templateName : config.modelTemplateFiles().keySet()) {
-                        String suffix = config.modelTemplateFiles().get(templateName);
-                        String filename = config.modelFileFolder() + File.separator + config.toModelFilename(name) + suffix;
-                        String template = readTemplate(config.templateDir() + File.separator + templateName);
+                        String templateFile = getFullTemplateFile(config, templateName);
+                        String template = readTemplate(templateFile);
                         Template tmpl = Mustache.compiler()
                                 .withLoader(new Mustache.TemplateLoader() {
+                                    @Override
                                     public Reader getTemplate(String name) {
-                                        return getTemplateReader(config.templateDir() + File.separator + name + ".mustache");
+                                        return getTemplateReader(getFullTemplateFile(config, name + ".mustache"));
                                     }
                                 })
                                 .defaultValue("")
                                 .compile(template);
-                        writeToFile(filename, tmpl.execute(models));
+
+                        writeToFile(filename, tmpl.execute(operation));
                         files.add(new File(filename));
                     }
+                } catch (Exception e) {
+                    throw new RuntimeException("Could not generate api file for '" + tag + "'", e);
                 }
             }
-            if (System.getProperty("debugModels") != null) {
-                System.out.println("############ Model info ############");
-                Json.prettyPrint(allModels);
-            }
+        }
+        if (System.getProperty("debugOperations") != null) {
+            System.out.println("############ Operation info ############");
+            Json.prettyPrint(allOperations);
+        }
 
-            // apis
-            Map<String, List<CodegenOperation>> paths = processPaths(swagger.getPaths());
-            for (String tag : paths.keySet()) {
-                List<CodegenOperation> ops = paths.get(tag);
-                Map<String, Object> operation = processOperations(config, tag, ops);
+        // supporting files
+        Map<String, Object> bundle = new HashMap<String, Object>();
+        bundle.putAll(config.additionalProperties());
+        bundle.put("apiPackage", config.apiPackage());
 
-                operation.put("basePath", basePath);
-                operation.put("contextPath", contextPath);
-                operation.put("baseName", tag);
-                operation.put("modelPackage", config.modelPackage());
-                operation.putAll(config.additionalProperties());
-                operation.put("classname", config.toApiName(tag));
-                operation.put("classVarName", config.toApiVarName(tag));
-                operation.put("importPath", config.toApiImport(tag));
+        Map<String, Object> apis = new HashMap<String, Object>();
+        apis.put("apis", allOperations);
+        if (swagger.getHost() != null) {
+            bundle.put("host", swagger.getHost());
+        }
+        bundle.put("swagger", this.swagger);
+        bundle.put("basePath", basePath);
+        bundle.put("scheme", scheme);
+        bundle.put("contextPath", contextPath);
+        bundle.put("apiInfo", apis);
+        bundle.put("models", allModels);
+        bundle.put("apiFolder", config.apiPackage().replace('.', File.separatorChar));
+        bundle.put("modelPackage", config.modelPackage());
+        List<CodegenSecurity> authMethods = config.fromSecurity(swagger.getSecurityDefinitions());
+        if (authMethods != null && !authMethods.isEmpty()) {
+            bundle.put("authMethods", authMethods);
+            bundle.put("hasAuthMethods", true);
+        }
+        if (swagger.getExternalDocs() != null) {
+            bundle.put("externalDocs", swagger.getExternalDocs());
+        }
+        for (int i = 0; i < allModels.size() - 1; i++) {
+            HashMap<String, CodegenModel> cm = (HashMap<String, CodegenModel>) allModels.get(i);
+            CodegenModel m = cm.get("model");
+            m.hasMoreModels = true;
+        }
 
-                processMimeTypes(swagger.getConsumes(), operation, "consumes");
-                processMimeTypes(swagger.getProduces(), operation, "produces");
+        config.postProcessSupportingFileData(bundle);
 
-                allOperations.add(new HashMap<String, Object>(operation));
-                for (int i = 0; i < allOperations.size(); i++) {
-                    Map<String, Object> oo = (Map<String, Object>) allOperations.get(i);
-                    if (i < (allOperations.size() - 1)) {
-                        oo.put("hasMore", "true");
+        if (System.getProperty("debugSupportingFiles") != null) {
+            System.out.println("############ Supporting file info ############");
+            Json.prettyPrint(bundle);
+        }
+
+        if(generateSupportingFiles) {
+            for (SupportingFile support : config.supportingFiles()) {
+                try {
+                    String outputFolder = config.outputFolder();
+                    if (isNotEmpty(support.folder)) {
+                        outputFolder += File.separator + support.folder;
                     }
-                }
-
-                for (String templateName : config.apiTemplateFiles().keySet()) {
-
-                    String filename = config.apiFilename(templateName, tag);
-                    if (new File(filename).exists() && !config.shouldOverwrite(filename)) {
+                    File of = new File(outputFolder);
+                    if (!of.isDirectory()) {
+                        of.mkdirs();
+                    }
+                    String outputFilename = outputFolder + File.separator + support.destinationFilename;
+                    if (!config.shouldOverwrite(outputFilename)) {
                         continue;
                     }
 
-                    String template = readTemplate(config.templateDir() + File.separator + templateName);
-                    Template tmpl = Mustache.compiler()
-                            .withLoader(new Mustache.TemplateLoader() {
-                                public Reader getTemplate(String name) {
-                                    return getTemplateReader(config.templateDir() + File.separator + name + ".mustache");
-                                }
-                            })
-                            .defaultValue("")
-                            .compile(template);
+                    String templateFile = getFullTemplateFile(config, support.templateFile);
 
-                    writeToFile(filename, tmpl.execute(operation));
-                    files.add(new File(filename));
-                }
-            }
-            if (System.getProperty("debugOperations") != null) {
-                System.out.println("############ Operation info ############");
-                Json.prettyPrint(allOperations);
-            }
-
-            // supporting files
-            Map<String, Object> bundle = new HashMap<String, Object>();
-            bundle.putAll(config.additionalProperties());
-            bundle.put("apiPackage", config.apiPackage());
-
-            Map<String, Object> apis = new HashMap<String, Object>();
-            apis.put("apis", allOperations);
-            if (swagger.getHost() != null) {
-                bundle.put("host", swagger.getHost());
-            }
-            bundle.put("basePath", basePath);
-            bundle.put("scheme", scheme);
-            bundle.put("contextPath", contextPath);
-            bundle.put("apiInfo", apis);
-            bundle.put("models", allModels);
-            bundle.put("apiFolder", config.apiPackage().replace('.', File.separatorChar));
-            bundle.put("modelPackage", config.modelPackage());
-            bundle.put("authMethods", config.fromSecurity(swagger.getSecurityDefinitions()));
-            if (swagger.getExternalDocs() != null) {
-                bundle.put("externalDocs", swagger.getExternalDocs());
-            }
-            for (int i = 0; i < allModels.size() - 1; i++) {
-                HashMap<String, CodegenModel> cm = (HashMap<String, CodegenModel>) allModels.get(i);
-                CodegenModel m = cm.get("model");
-                m.hasMoreModels = true;
-            }
-
-            config.postProcessSupportingFileData(bundle);
-
-            if (System.getProperty("debugSupportingFiles") != null) {
-                System.out.println("############ Supporting file info ############");
-                Json.prettyPrint(bundle);
-            }
-
-            for (SupportingFile support : config.supportingFiles()) {
-                String outputFolder = config.outputFolder();
-                if (isNotEmpty(support.folder)) {
-                    outputFolder += File.separator + support.folder;
-                }
-                File of = new File(outputFolder);
-                if (!of.isDirectory()) {
-                    of.mkdirs();
-                }
-                String outputFilename = outputFolder + File.separator + support.destinationFilename;
-
-                if (support.templateFile.endsWith("mustache")) {
-                    String template = readTemplate(config.templateDir() + File.separator + support.templateFile);
-                    Template tmpl = Mustache.compiler()
-                            .withLoader(new Mustache.TemplateLoader() {
-                                public Reader getTemplate(String name) {
-                                    return getTemplateReader(config.templateDir() + File.separator + name + ".mustache");
-                                }
-                            })
-                            .defaultValue("")
-                            .compile(template);
-
-                    writeToFile(outputFilename, tmpl.execute(bundle));
-                    files.add(new File(outputFilename));
-                } else {
-                    InputStream in = null;
-
-                    try {
-                        in = new FileInputStream(config.templateDir() + File.separator + support.templateFile);
-                    } catch (Exception e) {
-                        // continue
-                    }
-                    if (in == null) {
-                        in = this.getClass().getClassLoader().getResourceAsStream(config.templateDir() + File.separator + support.templateFile);
-                    }
-                    File outputFile = new File(outputFilename);
-                    OutputStream out = new FileOutputStream(outputFile, false);
-                    if (in != null && out != null) {
-                        IOUtils.copy(in, out);
-                    } else {
-                        if (in == null) {
-                            System.out.println("can't open " + config.templateDir() + File.separator + support.templateFile + " for input");
+                    boolean shouldGenerate = true;
+                    if(supportingFilesToGenerate != null && supportingFilesToGenerate.size() > 0) {
+                        if(supportingFilesToGenerate.contains(support.destinationFilename)) {
+                            shouldGenerate = true;
                         }
-                        if (out == null) {
-                            System.out.println("can't open " + outputFile + " for output");
+                        else {
+                            shouldGenerate = false;
                         }
                     }
+                    if(shouldGenerate) {
+                        if (templateFile.endsWith("mustache")) {
+                            String template = readTemplate(templateFile);
+                            Template tmpl = Mustache.compiler()
+                                    .withLoader(new Mustache.TemplateLoader() {
+                                        @Override
+                                        public Reader getTemplate(String name) {
+                                            return getTemplateReader(getFullTemplateFile(config, name + ".mustache"));
+                                        }
+                                    })
+                                    .defaultValue("")
+                                    .compile(template);
 
-                    files.add(outputFile);
+                            writeToFile(outputFilename, tmpl.execute(bundle));
+                            files.add(new File(outputFilename));
+                        } else {
+                            InputStream in = null;
+
+                            try {
+                                in = new FileInputStream(templateFile);
+                            } catch (Exception e) {
+                                // continue
+                            }
+                            if (in == null) {
+                                in = this.getClass().getClassLoader().getResourceAsStream(getCPResourcePath(templateFile));
+                            }
+                            File outputFile = new File(outputFilename);
+                            OutputStream out = new FileOutputStream(outputFile, false);
+                            if (in != null && out != null) {
+                                System.out.println("writing file " + outputFile);
+                                IOUtils.copy(in, out);
+                            } else {
+                                if (in == null) {
+                                    System.out.println("can't open " + templateFile + " for input");
+                                }
+                                if (out == null) {
+                                    System.out.println("can't open " + outputFile + " for output");
+                                }
+                            }
+
+                            files.add(outputFile);
+                        }
+                    }
+                } catch (Exception e) {
+                    throw new RuntimeException("Could not generate supporting file '" + support + "'", e);
                 }
             }
-
-            config.processSwagger(swagger);
-        } catch (Exception e) {
-            e.printStackTrace();
         }
+
+        config.processSwagger(swagger);
+
         return files;
     }
 
@@ -315,17 +439,64 @@ public class DefaultGenerator extends AbstractGenerator implements Generator {
         }
     }
 
+    private List<String> sortModelsByInheritance(final Map<String, Model> definitions) {
+    	List<String> sortedModelKeys = new ArrayList<String>(definitions.keySet());
+    	Comparator<String> cmp = new Comparator<String>() {
+			@Override
+			public int compare(String o1, String o2) {
+				Model model1 = definitions.get(o1);
+				Model model2 = definitions.get(o2);
+
+				int model1InheritanceDepth = getInheritanceDepth(model1);
+				int model2InheritanceDepth = getInheritanceDepth(model2);
+
+				if (model1InheritanceDepth == model2InheritanceDepth) {
+					return 0;
+				} else if (model1InheritanceDepth > model2InheritanceDepth) {
+					return 1;
+				} else {
+					return -1;
+				}
+			}
+
+			private int getInheritanceDepth(Model model) {
+				int inheritanceDepth = 0;
+				Model parent = getParent(model);
+
+				while (parent != null) {
+					inheritanceDepth++;
+					parent = getParent(parent);
+				}
+
+				return inheritanceDepth;
+			}
+
+			private Model getParent(Model model) {
+				if (model instanceof ComposedModel) {
+					return definitions.get(((ComposedModel) model).getParent().getReference());
+				}
+
+				return null;
+			}
+		};
+
+		Collections.sort(sortedModelKeys, cmp);
+
+		return sortedModelKeys;
+    }
+
     public Map<String, List<CodegenOperation>> processPaths(Map<String, Path> paths) {
         Map<String, List<CodegenOperation>> ops = new HashMap<String, List<CodegenOperation>>();
 
         for (String resourcePath : paths.keySet()) {
             Path path = paths.get(resourcePath);
-            processOperation(resourcePath, "get", path.getGet(), ops);
-            processOperation(resourcePath, "put", path.getPut(), ops);
-            processOperation(resourcePath, "post", path.getPost(), ops);
-            processOperation(resourcePath, "delete", path.getDelete(), ops);
-            processOperation(resourcePath, "patch", path.getPatch(), ops);
-            processOperation(resourcePath, "options", path.getOptions(), ops);
+            processOperation(resourcePath, "get", path.getGet(), ops, path);
+            processOperation(resourcePath, "head", path.getHead(), ops, path);
+            processOperation(resourcePath, "put", path.getPut(), ops, path);
+            processOperation(resourcePath, "post", path.getPost(), ops, path);
+            processOperation(resourcePath, "delete", path.getDelete(), ops, path);
+            processOperation(resourcePath, "patch", path.getPatch(), ops, path);
+            processOperation(resourcePath, "options", path.getOptions(), ops, path);
         }
         return ops;
     }
@@ -338,44 +509,110 @@ public class DefaultGenerator extends AbstractGenerator implements Generator {
         return map.get(name);
     }
 
-
-    public void processOperation(String resourcePath, String httpMethod, Operation operation, Map<String, List<CodegenOperation>> operations) {
+    public void processOperation(String resourcePath, String httpMethod, Operation operation, Map<String, List<CodegenOperation>> operations, Path path) {
         if (operation != null) {
+            if (System.getProperty("debugOperations") != null) {
+                LOGGER.debug("processOperation: resourcePath= " + resourcePath + "\t;" + httpMethod + " " + operation + "\n");
+            }
             List<String> tags = operation.getTags();
             if (tags == null) {
                 tags = new ArrayList<String>();
                 tags.add("default");
             }
+            
+            /*
+             build up a set of parameter "ids" defined at the operation level
+             per the swagger 2.0 spec "A unique parameter is defined by a combination of a name and location"
+              i'm assuming "location" == "in"
+            */
+            Set<String> operationParameters = new HashSet<String>();
+            if (operation.getParameters() != null) {
+                for (Parameter parameter : operation.getParameters()) {
+                    operationParameters.add(generateParameterId(parameter));
+                }
+            }
+
+            //need to propagate path level down to the operation
+            if(path.getParameters() != null) {
+                for (Parameter parameter : path.getParameters()) {
+                    //skip propagation if a parameter with the same name is already defined at the operation level
+                    if (!operationParameters.contains(generateParameterId(parameter))) {
+                        operation.addParameter(parameter);
+                    }
+                }
+            }
 
             for (String tag : tags) {
-                CodegenOperation co = config.fromOperation(resourcePath, httpMethod, operation, swagger.getDefinitions());
-                co.tags = new ArrayList<String>();
-                co.tags.add(sanitizeTag(tag));
-                config.addOperationToGroup(sanitizeTag(tag), resourcePath, operation, co, operations);
+                CodegenOperation co = null;
+                try {
+                    co = config.fromOperation(resourcePath, httpMethod, operation, swagger.getDefinitions(), swagger);
+                    co.tags = new ArrayList<String>();
+                    co.tags.add(sanitizeTag(tag));
+                    config.addOperationToGroup(sanitizeTag(tag), resourcePath, operation, co, operations);
 
-                List<Map<String, List<String>>> securities = operation.getSecurity();
-                if (securities == null) {
-                    continue;
-                }
-                Map<String, SecuritySchemeDefinition> authMethods = new HashMap<String, SecuritySchemeDefinition>();
-                for (Map<String, List<String>> security : securities) {
-                    if (security.size() != 1) {
-                        //Not sure what to do
+                    List<Map<String, List<String>>> securities = operation.getSecurity();
+                    if (securities == null && swagger.getSecurity() != null) {
+                        securities = new ArrayList<Map<String, List<String>>>();
+                        for (SecurityRequirement sr : swagger.getSecurity()) {
+                            securities.add(sr.getRequirements());
+                        }
+                    }
+                    if (securities == null || securities.isEmpty()) {
                         continue;
                     }
-                    String securityName = security.keySet().iterator().next();
-                    SecuritySchemeDefinition securityDefinition = fromSecurity(securityName);
-                    if (securityDefinition != null) {
-                        authMethods.put(securityName, securityDefinition);
+                    Map<String, SecuritySchemeDefinition> authMethods = new HashMap<String, SecuritySchemeDefinition>();
+                    // NOTE: Use only the first security requirement for now.
+                    // See the "security" field of "Swagger Object":
+                    //  https://github.com/OAI/OpenAPI-Specification/blob/master/versions/2.0.md#swagger-object
+                    //  "there is a logical OR between the security requirements"
+                    if (securities.size() > 1) {
+                        LOGGER.warn("More than 1 security requirements are found, using only the first one");
+                    }
+                    Map<String, List<String>> security = securities.get(0);
+                    for (String securityName : security.keySet()) {
+                        SecuritySchemeDefinition securityDefinition = fromSecurity(securityName);
+                        if (securityDefinition != null) {
+                            if(securityDefinition instanceof OAuth2Definition) {
+                                OAuth2Definition oauth2Definition = (OAuth2Definition) securityDefinition;
+                                OAuth2Definition oauth2Operation = new OAuth2Definition();
+                                oauth2Operation.setType(oauth2Definition.getType());
+                                oauth2Operation.setAuthorizationUrl(oauth2Definition.getAuthorizationUrl());
+                                oauth2Operation.setFlow(oauth2Definition.getFlow());
+                                oauth2Operation.setTokenUrl(oauth2Definition.getTokenUrl());
+                                oauth2Operation.setScopes(new HashMap<String, String>());
+                                for (String scope : security.get(securityName)) {
+                                    if (oauth2Definition.getScopes().containsKey(scope)) {
+                                        oauth2Operation.addScope(scope, oauth2Definition.getScopes().get(scope));
+                                    }
+                                }
+                                authMethods.put(securityName, oauth2Operation);
+                            } else {
+                                authMethods.put(securityName, securityDefinition);
+                            }
+                        }
+                    }
+                    if (!authMethods.isEmpty()) {
+                        co.authMethods = config.fromSecurity(authMethods);
+                        co.hasAuthMethods = true;
                     }
                 }
-                if (!authMethods.isEmpty()) {
-                    co.authMethods = config.fromSecurity(authMethods);
+                catch (Exception ex) {
+                    String msg = "Could not process operation:\n" //
+                        + "  Tag: " + tag + "\n"//
+                        + "  Operation: " + operation.getOperationId() + "\n" //
+                        + "  Resource: " + httpMethod + " " + resourcePath + "\n"//
+                        + "  Definitions: " + swagger.getDefinitions() + "\n"  //
+                        + "  Exception: " + ex.getMessage();
+                    throw new RuntimeException(msg, ex);
                 }
             }
         }
     }
 
+    private String generateParameterId(Parameter parameter) {
+        return parameter.getName() + ":" + parameter.getIn();
+    }
+
     protected String sanitizeTag(String tag) {
         // remove spaces and make strong case
         String[] parts = tag.split(" ");
@@ -392,6 +629,7 @@ public class DefaultGenerator extends AbstractGenerator implements Generator {
         Map<String, Object> operations = new HashMap<String, Object>();
         Map<String, Object> objs = new HashMap<String, Object>();
         objs.put("classname", config.toApiName(tag));
+        objs.put("pathPrefix", config.toApiVarName(tag));
 
         // check for operationId uniqueness
         Set<String> opIds = new HashSet<String>();
@@ -429,6 +667,12 @@ public class DefaultGenerator extends AbstractGenerator implements Generator {
         }
 
         operations.put("imports", imports);
+
+        // add a flag to indicate whether there's any {{import}}
+        if (imports.size() > 0) {
+            operations.put("hasImport", true);
+        }
+
         config.postProcessOperations(operations);
         if (objs.size() > 0) {
             List<CodegenOperation> os = (List<CodegenOperation>) objs.get("operation");
@@ -441,41 +685,47 @@ public class DefaultGenerator extends AbstractGenerator implements Generator {
         return operations;
     }
 
-    public Map<String, Object> processModels(CodegenConfig config, Map<String, Model> definitions) {
+    public Map<String, Object> processModels(CodegenConfig config, Map<String, Model> definitions, Map<String, Model> allDefinitions) {
         Map<String, Object> objs = new HashMap<String, Object>();
         objs.put("package", config.modelPackage());
         List<Object> models = new ArrayList<Object>();
         Set<String> allImports = new LinkedHashSet<String>();
         for (String key : definitions.keySet()) {
             Model mm = definitions.get(key);
-            CodegenModel cm = config.fromModel(key, mm);
+            CodegenModel cm = config.fromModel(key, mm, allDefinitions);
             Map<String, Object> mo = new HashMap<String, Object>();
             mo.put("model", cm);
             mo.put("importPath", config.toModelImport(key));
             models.add(mo);
+
             allImports.addAll(cm.imports);
         }
         objs.put("models", models);
 
-        List<Map<String, String>> imports = new ArrayList<Map<String, String>>();
+        Set<String> importSet = new TreeSet<String>();
         for (String nextImport : allImports) {
-            Map<String, String> im = new LinkedHashMap<String, String>();
+            Map<String, String> im = new HashMap<String, String>();
             String mapping = config.importMapping().get(nextImport);
             if (mapping == null) {
                 mapping = config.toModelImport(nextImport);
             }
             if (mapping != null && !config.defaultIncludes().contains(mapping)) {
-                im.put("import", mapping);
-                imports.add(im);
+                importSet.add(mapping);
             }
             // add instantiation types
             mapping = config.instantiationTypes().get(nextImport);
             if (mapping != null && !config.defaultIncludes().contains(mapping)) {
-                im.put("import", mapping);
-                imports.add(im);
+                importSet.add(mapping);
             }
         }
 
+        List<Map<String, String>> imports = new ArrayList<Map<String, String>>();
+        for(String s: importSet) {
+            Map<String, String> item = new HashMap<String, String>();
+            item.put("import", s);
+            imports.add(item);
+        }
+
         objs.put("imports", imports);
         config.postProcessModels(objs);
 

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

@@ -0,0 +1,389 @@
+package io.swagger.codegen;
+
+import com.sun.org.apache.xpath.internal.operations.Mod;
+import io.swagger.models.*;
+import io.swagger.models.parameters.BodyParameter;
+import io.swagger.models.parameters.Parameter;
+import io.swagger.models.parameters.RefParameter;
+import io.swagger.models.properties.*;
+import io.swagger.util.Json;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class InlineModelResolver {
+    private Swagger swagger;
+    private boolean skipMatches;
+    static Logger LOGGER = LoggerFactory.getLogger(InlineModelResolver.class);
+
+    Map<String, Model> addedModels = new HashMap<String, Model>();
+    Map<String, String> generatedSignature = new HashMap<String, String>();
+
+    public void flatten(Swagger swagger) {
+        this.swagger = swagger;
+
+        if (swagger.getDefinitions() == null) {
+            swagger.setDefinitions(new HashMap<String, Model>());
+        }
+
+        // operations
+        Map<String, Path> paths = swagger.getPaths();
+        Map<String, Model> models = swagger.getDefinitions();
+
+        if (paths != null) {
+            for (String pathname : paths.keySet()) {
+                Path path = paths.get(pathname);
+
+                for (Operation operation : path.getOperations()) {
+                    List<Parameter> parameters = operation.getParameters();
+
+                    if (parameters != null) {
+                        for (Parameter parameter : parameters) {
+                            if (parameter instanceof BodyParameter) {
+                                BodyParameter bp = (BodyParameter) parameter;
+                                if (bp.getSchema() != null) {
+                                    Model model = bp.getSchema();
+                                    if(model instanceof ModelImpl) {
+                                        ModelImpl obj = (ModelImpl) model;
+                                        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);
+                                        }
+                                    }
+                                    else if (model instanceof ArrayModel) {
+                                        ArrayModel am = (ArrayModel) model;
+                                        Property inner = am.getItems();
+
+                                        if(inner instanceof ObjectProperty) {
+                                            String modelName = uniqueName(bp.getName());
+                                            ObjectProperty op = (ObjectProperty) inner;
+                                            flattenProperties(op.getProperties(), pathname);
+
+                                            Model innerModel = modelFromProperty(op, modelName);
+                                            String existing = matchGenerated(innerModel);
+                                            if (existing != null) {
+                                                am.setItems(new RefProperty(existing));
+                                            } else {
+                                                am.setItems(new RefProperty(modelName));
+                                                addGenerated(modelName, innerModel);
+                                                swagger.addDefinition(modelName, innerModel);
+                                            }
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                    Map<String, Response> responses = operation.getResponses();
+                    if (responses != null) {
+                        for (String key : responses.keySet()) {
+                            Response response = responses.get(key);
+                            if (response.getSchema() != null) {
+                                Property property = response.getSchema();
+                                if (property instanceof ObjectProperty) {
+                                    String modelName = uniqueName("inline_response_" + key);
+                                    ObjectProperty op = (ObjectProperty) property;
+                                    Model model = modelFromProperty(op, modelName);
+                                    String existing = matchGenerated(model);
+                                    if (existing != null) {
+                                        response.setSchema(new RefProperty(existing));
+                                    } else {
+                                        response.setSchema(new RefProperty(modelName));
+                                        addGenerated(modelName, model);
+                                        swagger.addDefinition(modelName, model);
+                                    }
+                                } else if (property instanceof ArrayProperty) {
+                                    ArrayProperty ap = (ArrayProperty) property;
+                                    Property inner = ap.getItems();
+
+                                    if(inner instanceof ObjectProperty) {
+                                        String modelName = uniqueName("inline_response_" + key);
+                                        ObjectProperty op = (ObjectProperty) inner;
+                                        flattenProperties(op.getProperties(), pathname);
+
+                                        Model innerModel = modelFromProperty(op, modelName);
+                                        String existing = matchGenerated(innerModel);
+                                        if (existing != null) {
+                                            ap.setItems(new RefProperty(existing));
+                                        } else {
+                                            ap.setItems(new RefProperty(modelName));
+                                            addGenerated(modelName, innerModel);
+                                            swagger.addDefinition(modelName, innerModel);
+                                        }
+                                    }
+                                } else if (property instanceof MapProperty) {
+                                    MapProperty mp = (MapProperty) property;
+
+                                    Property innerProperty = mp.getAdditionalProperties();
+                                    if(innerProperty instanceof ObjectProperty) {
+                                        String modelName = uniqueName("inline_response_" + key);
+                                        ObjectProperty op = (ObjectProperty) innerProperty;
+                                        flattenProperties(op.getProperties(), pathname);
+
+                                        Model innerModel = modelFromProperty(op, modelName);
+                                        String existing = matchGenerated(innerModel);
+                                        if (existing != null) {
+                                            mp.setAdditionalProperties(new RefProperty(existing));
+                                        } else {
+                                            mp.setAdditionalProperties(new RefProperty(modelName));
+                                            addGenerated(modelName, innerModel);
+                                            swagger.addDefinition(modelName, innerModel);
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        // definitions
+        if (models != null) {
+            List<String> modelNames = new ArrayList<String>(models.keySet());
+            for (String modelName : modelNames) {
+                Model model = models.get(modelName);
+                if (model instanceof ModelImpl) {
+                    ModelImpl m = (ModelImpl) model;
+
+                    Map<String, Property> properties = m.getProperties();
+                    flattenProperties(properties, modelName);
+
+                } else if (model instanceof ArrayModel) {
+                    ArrayModel m = (ArrayModel) model;
+                    Property inner = m.getItems();
+                    if (inner instanceof ObjectProperty) {
+                        String innerModelName = uniqueName(modelName + "_inner");
+                        Model innerModel = modelFromProperty((ObjectProperty) inner, modelName);
+
+                        String existing = matchGenerated(innerModel);
+                        if (existing == null) {
+                            swagger.addDefinition(innerModelName, innerModel);
+                            addGenerated(innerModelName, innerModel);
+                            m.setItems(new RefProperty(innerModelName));
+                        } else {
+                            m.setItems(new RefProperty(existing));
+                        }
+                    }
+                } else if (model instanceof ComposedModel) {
+                    ComposedModel m = (ComposedModel) model;
+                }
+            }
+        }
+    }
+
+    public String matchGenerated(Model model) {
+        if (this.skipMatches) {
+            return null;
+        }
+        String json = Json.pretty(model);
+        if (generatedSignature.containsKey(json)) {
+            return generatedSignature.get(json);
+        }
+        return null;
+    }
+
+    public void addGenerated(String name, Model model) {
+        generatedSignature.put(Json.pretty(model), name);
+    }
+
+    public String uniqueName(String key) {
+        int count = 0;
+        boolean done = false;
+        key = key.replaceAll("[^a-z_\\.A-Z0-9 ]", "");
+        while (!done) {
+            String name = key;
+            if (count > 0) {
+                name = key + "_" + count;
+            }
+            if (swagger.getDefinitions() == null) {
+                return name;
+            } else if (!swagger.getDefinitions().containsKey(name)) {
+                return name;
+            }
+            count += 1;
+        }
+        return key;
+    }
+
+    public void flattenProperties(Map<String, Property> properties, String path) {
+        if (properties == null) {
+            return;
+        }
+        Map<String, Property> propsToUpdate = new HashMap<String, Property>();
+        Map<String, Model> modelsToAdd = new HashMap<String, Model>();
+        for (String key : properties.keySet()) {
+            Property property = properties.get(key);
+            if (property instanceof ObjectProperty && ((ObjectProperty)property).getProperties().size() > 0) {
+                String modelName = uniqueName(path + "_" + key);
+
+                ObjectProperty op = (ObjectProperty) property;
+                Model model = modelFromProperty(op, modelName);
+
+                String existing = matchGenerated(model);
+
+                if (existing != null) {
+                    propsToUpdate.put(key, new RefProperty(existing));
+                } else {
+                    propsToUpdate.put(key, new RefProperty(modelName));
+                    modelsToAdd.put(modelName, model);
+                    addGenerated(modelName, model);
+                    swagger.addDefinition(modelName, model);
+                }
+            } else if (property instanceof ArrayProperty) {
+                ArrayProperty ap = (ArrayProperty) property;
+                Property inner = ap.getItems();
+
+                if (inner instanceof ObjectProperty) {
+                    String modelName = uniqueName(path + "_" + key);
+
+                    ObjectProperty op = (ObjectProperty) inner;
+                    flattenProperties(op.getProperties(), path);
+
+                    Model innerModel = modelFromProperty(op, modelName);
+                    String existing = matchGenerated(innerModel);
+
+                    if (existing != null) {
+                        ap.setItems(new RefProperty(existing));
+                    } else {
+                        ap.setItems(new RefProperty(modelName));
+                        addGenerated(modelName, innerModel);
+                        swagger.addDefinition(modelName, innerModel);
+                    }
+                }
+            } else if (property instanceof MapProperty) {
+                MapProperty mp = (MapProperty) property;
+                Property inner = mp.getAdditionalProperties();
+
+                if (inner instanceof ObjectProperty) {
+                    String modelName = uniqueName(path + "_" + key);
+
+                    ObjectProperty op = (ObjectProperty) inner;
+                    flattenProperties(op.getProperties(), path);
+
+                    Model innerModel = modelFromProperty(op, modelName);
+                    String existing = matchGenerated(innerModel);
+
+                    if (existing != null) {
+                        mp.setAdditionalProperties(new RefProperty(existing));
+                    } else {
+                        mp.setAdditionalProperties(new RefProperty(modelName));
+                        addGenerated(modelName, innerModel);
+                        swagger.addDefinition(modelName, innerModel);
+                    }
+                }
+            } else {
+            }
+        }
+        if (propsToUpdate.size() > 0) {
+            for (String key : propsToUpdate.keySet()) {
+                properties.put(key, propsToUpdate.get(key));
+            }
+        }
+        for (String key : modelsToAdd.keySet()) {
+            swagger.addDefinition(key, modelsToAdd.get(key));
+            this.addedModels.put(key, modelsToAdd.get(key));
+        }
+    }
+
+    public Model modelFromProperty(ArrayProperty object, String path) {
+        String access = object.getAccess();
+        String description = object.getDescription();
+        String example = object.getExample();
+        String name = object.getName();
+        Integer position = object.getPosition();
+        Boolean readOnly = object.getReadOnly();
+        Boolean required = object.getRequired();
+        String title = object.getTitle();
+        Map<String, Object> extensions = object.getVendorExtensions();
+        Xml xml = object.getXml();
+
+//        object.getItems()
+//        Map<String, Property> properties = object.getProperties();
+
+        Property inner = object.getItems();
+        if (inner instanceof ObjectProperty) {
+            ArrayModel model = new ArrayModel();
+            model.setDescription(description);
+            model.setExample(example);
+//          model.setName(name);
+//          model.setXml(xml);
+
+            model.setItems(object.getItems());
+            return model;
+        }
+
+//        if(properties != null) {
+//            flattenProperties(properties, path);
+//            model.setProperties(properties);
+//        }
+
+        return null;
+    }
+
+    public Model modelFromProperty(ObjectProperty object, String path) {
+        String access = object.getAccess();
+        String description = object.getDescription();
+        String example = object.getExample();
+        String name = object.getName();
+        Integer position = object.getPosition();
+        Boolean readOnly = object.getReadOnly();
+        Boolean required = object.getRequired();
+        String title = object.getTitle();
+        Map<String, Object> extensions = object.getVendorExtensions();
+        Xml xml = object.getXml();
+
+        Map<String, Property> properties = object.getProperties();
+
+        ModelImpl model = new ModelImpl();
+        model.setDescription(description);
+        model.setExample(example);
+        model.setName(name);
+        model.setXml(xml);
+
+        if (properties != null) {
+            flattenProperties(properties, path);
+            model.setProperties(properties);
+        }
+
+        return model;
+    }
+
+    public Model modelFromProperty(MapProperty object, String path) {
+        String access = object.getAccess();
+        String description = object.getDescription();
+        String example = object.getExample();
+        String name = object.getName();
+        Integer position = object.getPosition();
+        Boolean readOnly = object.getReadOnly();
+        Boolean required = object.getRequired();
+        String title = object.getTitle();
+        Map<String, Object> extensions = object.getVendorExtensions();
+        Xml xml = object.getXml();
+
+        ArrayModel model = new ArrayModel();
+        model.setDescription(description);
+        model.setExample(example);
+        model.setItems(object.getAdditionalProperties());
+
+        return model;
+    }
+
+    public boolean isSkipMatches() {
+        return skipMatches;
+    }
+
+    public void setSkipMatches(boolean skipMatches) {
+        this.skipMatches = skipMatches;
+    }
+
+}

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

@@ -157,6 +157,7 @@ public class MetaGenerator extends AbstractGenerator {
                     String template = readTemplate(templateDir + File.separator + support.templateFile);
                     Template tmpl = Mustache.compiler()
                             .withLoader(new Mustache.TemplateLoader() {
+                                @Override
                                 public Reader getTemplate(String name) {
                                     return getTemplateReader(templateDir + File.separator + name + ".mustache");
                                 }

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

@@ -10,4 +10,14 @@ public class SupportingFile {
         this.folder = folder;
         this.destinationFilename = destinationFilename;
     }
+
+    public String toString() {
+        StringBuilder builder = new StringBuilder();
+        builder.append("SupportingFile:").append("\n");
+        builder.append("\ttemplateFile: ").append(templateFile).append("\n");
+        builder.append("\tfolder: ").append(folder).append("\n");
+        builder.append("\tdestinationFilename: ").append(destinationFilename).append("\n");
+
+        return builder.toString();
+    }
 }

modules/swagger-codegen/src/main/java/io/swagger/codegen/auth/AuthParser.java

@@ -0,0 +1,50 @@
+package io.swagger.codegen.auth;
+
+import io.swagger.models.auth.AuthorizationValue;
+
+import java.net.URLDecoder;
+import java.net.URLEncoder;
+import java.util.ArrayList;
+import java.util.List;
+
+import static org.apache.commons.lang3.StringUtils.isNotEmpty;
+
+public class AuthParser {
+
+    public static List<AuthorizationValue> parse(String urlEncodedAuthStr) {
+        List<AuthorizationValue> auths = new ArrayList<AuthorizationValue>();
+        if (isNotEmpty(urlEncodedAuthStr)) {
+            String[] parts = urlEncodedAuthStr.split(",");
+            for (String part : parts) {
+                String[] kvPair = part.split(":");
+                if (kvPair.length == 2) {
+                    auths.add(new AuthorizationValue(URLDecoder.decode(kvPair[0]), URLDecoder.decode(kvPair[1]), "header"));
+                }
+            }
+        }
+        return auths;
+    }
+
+    public static String reconstruct(List<AuthorizationValue> authorizationValueList) {
+        if (authorizationValueList != null) {
+            StringBuilder b = new StringBuilder();
+            for (AuthorizationValue v : authorizationValueList) {
+                try {
+                    if (b.toString().length() > 0) {
+                        b.append(",");
+                    }
+                    b.append(URLEncoder.encode(v.getKeyName(), "UTF-8"))
+                            .append(":")
+                            .append(URLEncoder.encode(v.getValue(), "UTF-8"));
+                } catch (Exception e) {
+                    // continue
+                    e.printStackTrace();
+                }
+            }
+            return b.toString();
+        } else {
+            return null;
+        }
+    }
+
+}

modules/swagger-codegen/src/main/java/io/swagger/codegen/config/CodegenConfigurator.java

@@ -0,0 +1,401 @@
+package io.swagger.codegen.config;
+
+import com.fasterxml.jackson.annotation.JsonAnyGetter;
+import com.fasterxml.jackson.annotation.JsonAnySetter;
+import io.swagger.codegen.CliOption;
+import io.swagger.codegen.ClientOptInput;
+import io.swagger.codegen.ClientOpts;
+import io.swagger.codegen.CodegenConfig;
+import io.swagger.codegen.CodegenConfigLoader;
+import io.swagger.codegen.CodegenConstants;
+import io.swagger.codegen.auth.AuthParser;
+import io.swagger.models.Swagger;
+import io.swagger.models.auth.AuthorizationValue;
+import io.swagger.parser.SwaggerParser;
+import io.swagger.util.Json;
+import org.apache.commons.lang3.Validate;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.io.File;
+import java.io.IOException;
+import java.nio.file.Paths;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+import static org.apache.commons.lang3.StringUtils.isNotEmpty;
+
+/**
+ * A class that contains all codegen configuration properties a user would want to manipulate.
+ * An instance could be created by deserializing a JSON file or being populated from CLI or Maven plugin parameters.
+ * It also has a convenience method for creating a ClientOptInput class which is THE object DefaultGenerator.java needs
+ * to generate code.
+ */
+public class CodegenConfigurator {
+
+    public static final Logger LOG = LoggerFactory.getLogger(CodegenConfigurator.class);
+
+    private String lang;
+    private String inputSpec;
+    private String outputDir;
+    private boolean verbose;
+    private boolean skipOverwrite;
+    private String templateDir;
+    private String auth;
+    private String apiPackage;
+    private String modelPackage;
+    private String invokerPackage;
+    private String groupId;
+    private String artifactId;
+    private String artifactVersion;
+    private String library;
+    private Map<String, String> systemProperties = new HashMap<String, String>();
+    private Map<String, String> instantiationTypes = new HashMap<String, String>();
+    private Map<String, String> typeMappings = new HashMap<String, String>();
+    private Map<String, String> additionalProperties = new HashMap<String, String>();
+    private Map<String, String> importMappings = new HashMap<String, String>();
+    private Set<String> languageSpecificPrimitives = new HashSet<String>();
+
+    private final Map<String, String> dynamicProperties = new HashMap<String, String>(); //the map that holds the JsonAnySetter/JsonAnyGetter values
+
+    public CodegenConfigurator() {
+        this.setOutputDir(".");
+    }
+
+    public CodegenConfigurator setLang(String lang) {
+        this.lang = lang;
+        return this;
+    }
+
+    public CodegenConfigurator setInputSpec(String inputSpec) {
+        this.inputSpec = inputSpec;
+        return this;
+    }
+
+    public String getInputSpec() {
+        return inputSpec;
+    }
+
+    public String getOutputDir() {
+        return outputDir;
+    }
+
+    public CodegenConfigurator setOutputDir(String outputDir) {
+        this.outputDir = toAbsolutePathStr(outputDir);
+        return this;
+    }
+
+    public String getModelPackage() {
+        return modelPackage;
+    }
+
+    public CodegenConfigurator setModelPackage(String modelPackage) {
+        this.modelPackage = modelPackage;
+        return this;
+    }
+
+    public boolean isVerbose() {
+        return verbose;
+    }
+
+    public CodegenConfigurator setVerbose(boolean verbose) {
+        this.verbose = verbose;
+        return this;
+    }
+
+    public boolean isSkipOverwrite() {
+        return skipOverwrite;
+    }
+
+    public CodegenConfigurator setSkipOverwrite(boolean skipOverwrite) {
+        this.skipOverwrite = skipOverwrite;
+        return this;
+    }
+
+    public String getLang() {
+        return lang;
+    }
+
+    public String getTemplateDir() {
+        return templateDir;
+    }
+
+    public CodegenConfigurator setTemplateDir(String templateDir) {
+        this.templateDir = new File(templateDir).getAbsolutePath();
+        return this;
+    }
+
+    public String getAuth() {
+        return auth;
+    }
+
+    public CodegenConfigurator setAuth(String auth) {
+        this.auth = auth;
+        return this;
+    }
+
+    public String getApiPackage() {
+        return apiPackage;
+    }
+
+    public CodegenConfigurator setApiPackage(String apiPackage) {
+        this.apiPackage = apiPackage;
+        return this;
+    }
+
+    public String getInvokerPackage() {
+        return invokerPackage;
+    }
+
+    public CodegenConfigurator setInvokerPackage(String invokerPackage) {
+        this.invokerPackage = invokerPackage;
+        return this;
+    }
+
+    public String getGroupId() {
+        return groupId;
+    }
+
+    public CodegenConfigurator setGroupId(String groupId) {
+        this.groupId = groupId;
+        return this;
+    }
+
+    public String getArtifactId() {
+        return artifactId;
+    }
+
+    public CodegenConfigurator setArtifactId(String artifactId) {
+        this.artifactId = artifactId;
+        return this;
+    }
+
+    public String getArtifactVersion() {
+        return artifactVersion;
+    }
+
+    public CodegenConfigurator setArtifactVersion(String artifactVersion) {
+        this.artifactVersion = artifactVersion;
+        return this;
+    }
+
+    public Map<String, String> getSystemProperties() {
+        return systemProperties;
+    }
+
+    public CodegenConfigurator setSystemProperties(Map<String, String> systemProperties) {
+        this.systemProperties = systemProperties;
+        return this;
+    }
+
+    public CodegenConfigurator addSystemProperty(String key, String value) {
+        this.systemProperties.put(key, value);
+        return this;
+    }
+
+    public Map<String, String> getInstantiationTypes() {
+        return instantiationTypes;
+    }
+
+    public CodegenConfigurator setInstantiationTypes(Map<String, String> instantiationTypes) {
+        this.instantiationTypes = instantiationTypes;
+        return this;
+    }
+
+    public CodegenConfigurator addInstantiationType(String key, String value) {
+        this.instantiationTypes.put(key, value);
+        return this;
+    }
+
+    public Map<String, String> getTypeMappings() {
+        return typeMappings;
+    }
+
+    public CodegenConfigurator setTypeMappings(Map<String, String> typeMappings) {
+        this.typeMappings = typeMappings;
+        return this;
+    }
+
+    public CodegenConfigurator addTypeMapping(String key, String value) {
+        this.typeMappings.put(key, value);
+        return this;
+    }
+
+    public Map<String, String> getAdditionalProperties() {
+        return additionalProperties;
+    }
+
+    public CodegenConfigurator setAdditionalProperties(Map<String, String> additionalProperties) {
+        this.additionalProperties = additionalProperties;
+        return this;
+    }
+
+    public CodegenConfigurator addAdditionalProperty(String key, String value) {
+        this.additionalProperties.put(key, value);
+        return this;
+    }
+
+    public Map<String, String> getImportMappings() {
+        return importMappings;
+    }
+
+    public CodegenConfigurator setImportMappings(Map<String, String> importMappings) {
+        this.importMappings = importMappings;
+        return this;
+    }
+
+    public CodegenConfigurator addImportMapping(String key, String value) {
+        this.importMappings.put(key, value);
+        return this;
+    }
+
+    public Set<String> getLanguageSpecificPrimitives() {
+        return languageSpecificPrimitives;
+    }
+
+    public CodegenConfigurator setLanguageSpecificPrimitives(Set<String> languageSpecificPrimitives) {
+        this.languageSpecificPrimitives = languageSpecificPrimitives;
+        return this;
+    }
+
+    public CodegenConfigurator addLanguageSpecificPrimitive(String value) {
+        this.languageSpecificPrimitives.add(value);
+        return this;
+    }
+
+    public String getLibrary() {
+        return library;
+    }
+
+    public CodegenConfigurator setLibrary(String library) {
+        this.library = library;
+        return this;
+    }
+
+    public ClientOptInput toClientOptInput() {
+
+        Validate.notEmpty(lang, "language must be specified");
+        Validate.notEmpty(inputSpec, "input spec must be specified");
+
+        setVerboseFlags();
+        setSystemProperties();
+
+        CodegenConfig config = CodegenConfigLoader.forName(lang);
+
+        config.setOutputDir(outputDir);
+        config.setSkipOverwrite(skipOverwrite);
+
+        config.instantiationTypes().putAll(instantiationTypes);
+        config.typeMapping().putAll(typeMappings);
+        config.importMapping().putAll(importMappings);
+        config.languageSpecificPrimitives().addAll(languageSpecificPrimitives);
+
+        checkAndSetAdditionalProperty(apiPackage, CodegenConstants.API_PACKAGE);
+        checkAndSetAdditionalProperty(modelPackage, CodegenConstants.MODEL_PACKAGE);
+        checkAndSetAdditionalProperty(invokerPackage, CodegenConstants.INVOKER_PACKAGE);
+        checkAndSetAdditionalProperty(groupId, CodegenConstants.GROUP_ID);
+        checkAndSetAdditionalProperty(artifactId, CodegenConstants.ARTIFACT_ID);
+        checkAndSetAdditionalProperty(artifactVersion, CodegenConstants.ARTIFACT_VERSION);
+        checkAndSetAdditionalProperty(templateDir, toAbsolutePathStr(templateDir), CodegenConstants.TEMPLATE_DIR);
+
+        handleDynamicProperties(config);
+
+        if (isNotEmpty(library)) {
+            config.setLibrary(library);
+        }
+
+        config.additionalProperties().putAll(additionalProperties);
+
+        ClientOptInput input = new ClientOptInput()
+                .config(config);
+
+        final List<AuthorizationValue> authorizationValues = AuthParser.parse(auth);
+
+        Swagger swagger = new SwaggerParser().read(inputSpec, authorizationValues, true);
+
+        input.opts(new ClientOpts())
+                .swagger(swagger);
+
+        return input;
+    }
+
+    @JsonAnySetter
+    public CodegenConfigurator addDynamicProperty(String name, Object value) {
+        dynamicProperties.put(name, value.toString());
+        return this;
+    }
+
+    @JsonAnyGetter
+    public Map<String, String> getDynamicProperties() {
+        return dynamicProperties;
+    }
+
+    private void handleDynamicProperties(CodegenConfig codegenConfig) {
+        for (CliOption langCliOption : codegenConfig.cliOptions()) {
+            String opt = langCliOption.getOpt();
+            if (dynamicProperties.containsKey(opt)) {
+                codegenConfig.additionalProperties().put(opt, dynamicProperties.get(opt));
+            }
+            else if(systemProperties.containsKey(opt)) {
+                codegenConfig.additionalProperties().put(opt, systemProperties.get(opt).toString());
+            }
+        }
+    }
+
+    private void setVerboseFlags() {
+        if (!verbose) {
+            return;
+        }
+        LOG.info("\nVERBOSE MODE: ON. Additional debug options are injected" +
+                "\n - [debugSwagger] prints the swagger specification as interpreted by the codegen" +
+                "\n - [debugModels] prints models passed to the template engine" +
+                "\n - [debugOperations] prints operations passed to the template engine" +
+                "\n - [debugSupportingFiles] prints additional data passed to the template engine");
+
+        System.setProperty("debugSwagger", "");
+        System.setProperty("debugModels", "");
+        System.setProperty("debugOperations", "");
+        System.setProperty("debugSupportingFiles", "");
+    }
+
+    private void setSystemProperties() {
+        for (Map.Entry<String, String> entry : systemProperties.entrySet()) {
+            System.setProperty(entry.getKey(), entry.getValue());
+        }
+    }
+
+    private static String toAbsolutePathStr(String path) {
+        if (isNotEmpty(path)) {
+            return Paths.get(path).toAbsolutePath().toString();
+        }
+
+        return path;
+
+    }
+
+    private void checkAndSetAdditionalProperty(String property, String propertyKey) {
+        checkAndSetAdditionalProperty(property, property, propertyKey);
+    }
+
+    private void checkAndSetAdditionalProperty(String property, String valueToSet, String propertyKey) {
+        if (isNotEmpty(property)) {
+            additionalProperties.put(propertyKey, valueToSet);
+        }
+    }
+
+    public static CodegenConfigurator fromFile(String configFile) {
+
+        if (isNotEmpty(configFile)) {
+            try {
+                return Json.mapper().readValue(new File(configFile), CodegenConfigurator.class);
+            } catch (IOException e) {
+                LOG.error("Unable to deserialize config file: " + configFile, e);
+            }
+        }
+        return null;
+    }
+
+}