fixed javadoc plugin

Merge pull request #1827 from swagger-api/release-prepare
updated versions
2016-01-06 12:30:24 -08:00 · 2016-01-06 10:16:30 -08:00 · 2016-01-06 09:47:32 -08:00 · 2016-01-06 09:41:06 -08:00 · 2016-01-06 09:36:00 -08:00 · 2016-01-06 09:31:14 -08:00
2370 changed files with 226682 additions and 42859 deletions
--- a/.dockerignore
+++ b/.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/
--- a/.gitignore
+++ b/.gitignore
@@ -9,9 +9,11 @@ version.properties
 lib/*
 build/*
 generated-files/*
+generated-sources/*
 generated-code/*
 *.swp
 *.swo
+*.csproj.user

 /target
 /generated-files
@@ -22,4 +24,44 @@ 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/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~
--- a/.travis.yml
+++ b/.travis.yml
@@ -0,0 +1,22 @@
+sudo: required
+language: java
+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
--- a/CONTRIBUTING.md
+++ b/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)
--- a/13
+++ b/13
@@ -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"]
--- a/11
+++ b/11
@@ -0,0 +1,11 @@
+Copyright 2015 SmartBear Software
+
+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 [apache.org/licenses/LICENSE-2.0](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.
--- a/README.md
+++ b/README.md
@@ -1,142 +1,550 @@
 # 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.  You can find out more about both the spec and the framework at 
-http://swagger.wordnik.com.  For more information about Wordnik's APIs, please visit http://developer.wordnik.com.  
+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/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 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 | 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):

-* [Java 1.6](http://java.oracle.com)
+```
+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/)

-* [Scala](http://www.scala-lang.org)
+#### OS X Users
+Don't forget to install Java 7. You probably have 1.6 or 1.8.

-You also need to add the scala binary to your PATH.
+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
+```

-After cloning the project, you need to build it from source with this command:
+### 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 Wordnik's [petstore](http://petstore.swagger.wordnik.com) API as follows:
+You can build a client against the swagger sample [petstore](http://petstore.swagger.io) API as follows:

 ```
-./bin/scala-petstore.sh
+./bin/java-petstore.sh
 ```

-This will run the script in [samples/client/petstore/ScalaPetstoreCodegen.scala](https://github.com/wordnik/swagger-codegen/blob/master/samples/client/petstore/scala/ScalaPetstoreCodegen.scala) and create the client.  You can then
-compile and run the client, as well as unit tests against it:
+(On Windows, run `./bin/windows/java-petstore.bat` instead)
+
+This will run the generator with this command:

 ```
-cd samples/client/petstore/scala
+java -jar modules/swagger-codegen-cli/target/swagger-codegen-cli.jar generate \
+  -i http://petstore.swagger.io/v2/swagger.json \
+  -l java \
+  -o samples/client/petstore/java
+```
+
+with a number of options.  You can get the options with the `help generate` command:
+
+```
+NAME
+        swagger generate - Generate code with chosen lang
+
+SYNOPSIS
+        swagger generate [(-a <authorization> | --auth <authorization>)]
+                [(-c <configuration file> | --config <configuration file>)]
+                [-D <system properties>]
+                (-i <spec file> | --input-spec <spec file>)
+                (-l <language> | --lang <language>)
+                [(-o <output directory> | --output <output directory>)]
+                [(-t <template directory> | --template-dir <template directory>)]
+                [(-v | --verbose)]
+                [(-s | --skip-overwrite)]
+
+OPTIONS
+        -a <authorization>, --auth <authorization>
+            adds authorization headers when fetching the swagger definitions
+            remotely. Pass in a URL-encoded string of name:header with a comma
+            separating multiple values
+
+        -c <configuration file>, --config <configuration file>
+            Path to json configuration file. File content should be in a json
+            format {"optionKey":"optionValue", "optionKey1":"optionValue1"...}
+            Supported options can be different for each language. Run
+            config-help -l {lang} command for language specific config options.
+
+        -D <system properties>
+            sets specified system properties in the format of
+            name=value,name=value
+
+        -i <spec file>, --input-spec <spec file>
+            location of the OpenAPI Spec, as URL or file (required)
+
+        -l <language>, --lang <language>
+            client language to generate (maybe class name in classpath,
+            required)
+
+        -o <output directory>, --output <output directory>
+            where to write the generated files (current dir by default)
+
+        -t <template directory>, --template-dir <template directory>
+            folder containing the template files
+
+        -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:
+
+```
+cd samples/client/petstore/java
 mvn package
 ```

 Other languages have petstore samples, too:
 ```
-./bin/flash-petstore.sh
+./bin/android-petstore.sh
 ./bin/java-petstore.sh
 ./bin/objc-petstore.sh
-./bin/php-petstore.sh
-./bin/python-petstore.sh
-./bin/python3-petstore.sh
-./bin/ruby-petstore.sh
 ```

 ### Generating libraries from your server
-It's just as easy--you can either run the default generators:
-
-```
-./bin/runscala.sh com.wordnik.swagger.codegen.BasicScalaGenerator http://petstore.swagger.wordnik.com/api/resources.json special-key
-```
-
-Replace `Scala` with `Flash`, `Java`, `Objc`, `PHP`, `Python`, `Python3`, `Ruby`.
-
-You will probably want to override some of the defaults--like packages, etc.  For doing this, just create a scala
-script with the overrides you want.  Follow [ScalaPetstoreCodegen](https://github.com/wordnik/swagger-codegen/blob/master/samples/client/petstore/scala/ScalaPetstoreCodegen.scala) as an example:
-
-For example, create `src/main/scala/MyCodegen.scala` with these contents:
-
-```scala
-import com.wordnik.swagger.codegen.BasicScalaGenerator
-
-object MyCodegen extends BasicScalaGenerator {
-  def main(args: Array[String]) = generateClient(args)
-
-  // location of templates
-  override def templateDir = "scala"
-
-  // where to write generated code
-  override def destinationDir = "client/scala/src/main/scala"
-
-  // api invoker package
-  override def invokerPackage = "com.myapi.client"
-
-  // package for models
-  override def modelPackage = Some("com.myapi.client.model")
-
-  // package for api classes
-  override def apiPackage = Some("com.myapi.client.api")
-
-  // supporting classes
-  override def supportingFiles = List(
-    ("apiInvoker.mustache", destinationDir + java.io.File.separator + packageName.replaceAll("\\.", java.io.File.separator), "ApiInvoker.scala"),
-    ("pom.mustache", destinationDir, "pom.xml")
-  )
-}
-```
-
-Now you can generate your client like this:
-
-```
-./bin/runscala.sh src/main/scala/MyCodegen.scala http://my.api.com/resources.json super-secret-key
-```
-
-w00t!  Thanks to the scala interpretor, you didn't even need to recompile.
+It's just as easy--just use the `-i` flag to point to either a server or file.

 ### Modifying the client library format
-Don't like the default swagger client syntax?  Want a different language supported?  No problem!  Swagger codegen
-processes mustache templates with the [scalate](http://scalate.fusesource.org/) engine.  You can modify our templates or
-make your own.
+Don't like the default swagger client syntax?  Want a different language supported?  No problem!  Swagger codegen processes mustache templates with the [jmustache](https://github.com/samskivert/jmustache) engine.  You can modify our templates or make your own.

-You can look at `src/main/resources/${your-language}` for examples.  To make your own templates, create your own files
-and override the `templateDir` in your script to point to the right place.  It actually is that easy.
+You can look at `modules/swagger-codegen/src/main/resources/${your-language}` for examples.  To make your own templates, create your own files and use the `-t` flag to specify your template folder.  It actually is that easy.
+
+### Making your own codegen modules
+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-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/wordnik/swagger.js)--it's completely dynamic and doesn't require
+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 OpenAPI Specification.

-#### 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
+:exclamation: On Dec 7th 2015, a Javascript API client generator has been added by @jfiala.
+
+### 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:

 ```
-DfileMap=/path/to/files
+-i ./modules/swagger-codegen/src/test/resources/2_0/petstore.json
 ```

-Or for example:
-```
-./bin/java-petstore-filemap.sh
-```
+Great for creating libraries on your ci server, from the [Swagger Editor](http://editor.swagger.io)... or while coding on an airplane.

-Which simple passes `-DfileMap=src/test/resources/petstore` as an argument.  Great for creating libraries on your
-ci server... 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:

-### Validating your swagger spec
-You can use the validation tool to see that your server is creating a proper spec file.  If you want to learn
-more about the spec file and format, please see [swagger-core](https://github.com/wordnik/swagger-core/wiki).  This
-tool will read the server and generate a report of any violations of the spec.  If there are violations, the
-client codegen and ui may not work correctly.
-
-To validate an api and write output to ./swagger-errors.html:
+The default is generate *everything* supported by the specific library.  Once you enable a feature, it will restrict the contents generated:

 ```
-./bin/validate.sh http://petstore.swagger.wordnik.com/api/resources.json "" ./swagger-errors.html
+# 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
+PythonClientCodegen.java
+Qt5CPPGenerator.java
+RubyClientCodegen.java
+ScalaClientCodegen.java
+ScalatraServerCodegen.java
+SilexServerCodegen.java
+SinatraServerCodegen.java
+SlimFrameworkServerCodegen.java
+SpringMVCServerCodegen.java
+StaticDocCodegen.java
+StaticHtmlGenerator.java
+SwaggerGenerator.java
+SwaggerYamlGenerator.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.
+
+```
+java -jar modules/swagger-codegen-cli/target/swagger-codegen-cli.jar generate \
+  -i http://petstore.swagger.io/v2/swagger.json \
+  -l java \
+  -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.  **These options are applied 
+by passing them with `-D{optionName}={optionValue}**.
+
+```
+java -jar modules/swagger-codegen-cli/target/swagger-codegen-cli.jar config-help -l java
+```
+
+Output
+
+```
+CONFIG OPTIONS
+	modelPackage
+	    package for generated models
+
+	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
+
+	groupId
+	    groupId in generated pom.xml
+
+	artifactId
+	    artifactId in generated pom.xml
+
+	artifactVersion
+	    artifact version in generated pom.xml
+
+	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
+
+```
+{
+  "groupId":"com.my.company",
+  "artifactId":"MyClent",
+  "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 the config class for the specific language.
+To change, for example, the prefix for the Objective-C generated files, simply subclass the ObjcClientCodegen.java:
+
+```
+package com.mycompany.swagger.codegen;
+
+import io.swagger.codegen.languages.*;
+
+public class MyObjcCodegen extends ObjcClientCodegen {
+  static {
+    PREFIX = "HELO";
+  }
+}
+```
+
+and specify the `classname` when running the generator:
+
+```
+-l com.mycompany.swagger.codegen.MyObjcCodegen
+```
+
+Your subclass will now be loaded and overrides the `PREFIX` value in the superclass.
+
+### 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:
+
+http://online.swagger.io/validator/debug?url=http://petstore.swagger.io/v2/swagger.json
+
+### Generating dynamic html api documentation
+
+To do so, just use the `-l dynamic-html` flag when reading a spec file.  This creates HTML documentation that is available as a single-page application with AJAX.  To view the documentation:
+
+```
+cd samples/dynamic-html/
+npm install
+node .
+```
+
+Which launches a node.js server so the AJAX calls have a place to go.
+
+
+### Generating static html api documentation
+
+To do so, just use the `-l html` flag when reading a spec file.  This creates a single, simple HTML file with embedded css so you can ship it as an email attachment, or load it from your filesystem:
+
+```
+cd samples/html/
+open index.html
+```
+
+
+### To build a server stub
+
+You can also use the codegen to generate a server for a couple different frameworks.  Take a look here:
+
+### Node.js
+
+```
+java -jar modules/swagger-codegen-cli/target/swagger-codegen-cli.jar generate \
+  -i http://petstore.swagger.io/v2/swagger.json \
+  -l nodejs \
+  -o samples/server/petstore/nodejs
+```
+
+### 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
+```
+
+### 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 \
+  -l scalatra \
+  -o samples/server/petstore/scalatra
+```
+
+### Java JAX-RS
+
+```
+java -jar modules/swagger-codegen-cli/target/swagger-codegen-cli.jar generate \
+  -i http://petstore.swagger.io/v2/swagger.json \
+  -l jaxrs \
+  -o samples/server/petstore/jaxrs
+```
+
+### Java Spring MVC
+
+```
+java -jar modules/swagger-codegen-cli/target/swagger-codegen-cli.jar generate \
+  -i http://petstore.swagger.io/v2/swagger.json \
+  -l spring-mvc \
+  -o samples/server/petstore/spring-mvc
 ```

 ### To build the codegen library
@@ -147,24 +555,32 @@ This will create the swagger-codegen library from source.
 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 modify your codegen script to use a file path!
+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.


-### To build a server stub
+## Online generators

-You can also use the codegen to generate a server for a couple different frameworks.  Take a look here:
+One can also generate API client or server using the online generators (https://generator.swagger.io)

-* [javascript node.js Server generator](https://github.com/wordnik/swagger-codegen/tree/master/samples/server-generator/node)
+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.

-* [ruby sinatra generator](https://github.com/wordnik/swagger-codegen/tree/master/samples/server-generator/sinatra)
+Guidelines for Contribution
+---------------------------

-* [scala scalatra generator](https://github.com/wordnik/swagger-codegen/tree/master/samples/server-generator/scalatra)
+Please refer to this [page](https://github.com/swagger-api/swagger-codegen/blob/master/CONTRIBUTING.md)

 License
 -------

-Copyright 2012 Wordnik, Inc.
+Copyright 2015 SmartBear Software

 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
--- a/bin/akka-scala-petstore.sh
+++ b/bin/akka-scala-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/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
--- a/bin/all-petstore.sh
+++ b/bin/all-petstore.sh
@@ -0,0 +1,50 @@
+#!/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
+
+cd $APP_DIR
+./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/java-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/qt5-petstore.sh
+./bin/ruby-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
--- a/bin/all-wordnik.sh
+++ b/bin/all-wordnik.sh
@@ -0,0 +1,24 @@
+#!/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
+
+cd $APP_DIR
+./bin/android-java-wordnik-api.sh
+./bin/java-wordnik-api.sh
+./bin/objc-wordnik-api.sh
+./bin/scala-wordnik-api.sh
--- a/bin/android-java-wordnik-api.sh
+++ b/bin/android-java-wordnik-api.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/wordnik.json -l android -o samples/client/wordnik/android-java"
+
+java $JAVA_OPTS -jar $executable $ags
--- a/bin/android-petstore-volley.json
+++ b/bin/android-petstore-volley.json
@@ -0,0 +1,4 @@
+{
+    "library": "volley",
+    "artifactId": "swagger-petstore-android-volley"
+}
--- a/bin/android-petstore-volley.sh
+++ b/bin/android-petstore-volley.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 android -c bin/android-petstore-volley.json -o samples/client/petstore/android/volley"
+
+java $JAVA_OPTS -jar $executable $ags
--- a/bin/android-petstore.sh
+++ b/bin/android-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/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
--- a/bin/clojure-petstore.sh
+++ b/bin/clojure-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 clojure -o samples/client/petstore/clojure"
+
+java $JAVA_OPTS -jar $executable $ags
--- a/bin/csharp-dotnet2-petstore.sh
+++ b/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
--- a/bin/csharp-petstore.sh
+++ b/bin/csharp-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 csharp -o samples/client/petstore/csharp/SwaggerClientTest/Lib/SwaggerClient"
+
+java $JAVA_OPTS -jar $executable $ags
--- a/bin/dart-petstore.sh
+++ b/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
--- a/bin/dynamic-html.sh
+++ b/bin/dynamic-html.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 dynamic-html  -o samples/dynamic-html"
+
+java $JAVA_OPTS -jar $executable $ags
--- a/bin/flash-petstore.sh
+++ b/bin/flash-petstore.sh
@@ -1,6 +1,31 @@
-#!/bin/bash
-DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
+#!/bin/sh

-export CLASSPATH="$DIR/../target/lib/*:$DIR/../target/*"
+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"
-JAVA_OPTS=$JAVA_OPTS scala -cp $CLASSPATH "$@" samples/client/petstore/flash/FlashPetstoreCodegen.scala http://petstore.swagger.wordnik.com/api/api-docs.json special-key
+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
--- a/bin/flaskConnexion.sh
+++ b/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
--- a/bin/html-petstore.sh
+++ b/bin/html-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 html  -o samples/html"
+
+java $JAVA_OPTS -jar $executable $ags
--- a/bin/java-inflector-petstore-server.sh
+++ b/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
--- a/bin/java-petstore-all.sh
+++ b/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
--- a/bin/java-petstore-feign.json
+++ b/bin/java-petstore-feign.json
@@ -0,0 +1,4 @@
+{
+    "library": "feign",
+    "artifactId": "swagger-petstore-feign"
+}
--- a/bin/java-petstore-feign.sh
+++ b/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
--- a/bin/java-petstore-filemap.sh
+++ b/bin/java-petstore-filemap.sh
@@ -1,6 +0,0 @@
-#!/bin/bash
-DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
-
-export CLASSPATH="$DIR/../target/lib/*:$DIR/../target/*"
-export JAVA_OPTS="${JAVA_OPTS} -XX:MaxPermSize=256M -Xmx1024M -DloggerPath=conf/log4j.properties"
-JAVA_OPTS=$JAVA_OPTS scala -cp $CLASSPATH "$@" samples/client/petstore/java/JavaPetstoreCodegen.scala http://petstore.swagger.wordnik.com/api/api-docs.json special-key
--- a/bin/java-petstore-jersey2.json
+++ b/bin/java-petstore-jersey2.json
@@ -0,0 +1,4 @@
+{
+    "library": "jersey2",
+    "artifactId": "swagger-petstore-jersey2"
+}
--- a/bin/java-petstore-jersey2.sh
+++ b/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
--- a/bin/java-petstore-okhttp-gson.json
+++ b/bin/java-petstore-okhttp-gson.json
@@ -0,0 +1,4 @@
+{
+    "library": "okhttp-gson",
+    "artifactId": "swagger-petstore-okhttp-gson"
+}
--- a/bin/java-petstore-okhttp-gson.sh
+++ b/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
--- a/bin/java-petstore-retrofit.json
+++ b/bin/java-petstore-retrofit.json
@@ -0,0 +1,4 @@
+{
+    "library": "retrofit",
+    "artifactId": "swagger-petstore-retrofit"
+}
--- a/bin/java-petstore-retrofit.sh
+++ b/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
--- a/bin/java-petstore-retrofit2.json
+++ b/bin/java-petstore-retrofit2.json
@@ -0,0 +1,4 @@
+{
+    "library": "retrofit2",
+    "artifactId": "swagger-petstore-retrofit2"
+}
--- a/bin/java-petstore-retrofit2.sh
+++ b/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
--- a/bin/java-petstore.sh
+++ b/bin/java-petstore.sh
@@ -1,6 +1,31 @@
-#!/bin/bash
-DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
+#!/bin/sh

-export CLASSPATH="$DIR/../target/lib/*:$DIR/../target/*"
+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"
-JAVA_OPTS=$JAVA_OPTS scala -cp $CLASSPATH "$@" samples/client/petstore/java/JavaPetstoreCodegen.scala http://petstore.swagger.wordnik.com/api/api-docs.json special-key
+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
--- a/bin/java-wordnik-api.sh
+++ b/bin/java-wordnik-api.sh
@@ -1,6 +1,31 @@
-#!/bin/bash
-DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
+#!/bin/sh

-export CLASSPATH="$DIR/../target/lib/*:$DIR/../target/*"
-export JAVA_OPTS="${JAVA_OPTS} -XX:MaxPermSize=256M -Xmx1024M -DloggerPath=conf/log4j.properties -DfileMap=samples/client/wordnik-api/spec-files"
-JAVA_OPTS=$JAVA_OPTS scala -cp $CLASSPATH "$@" samples/client/wordnik-api/java/JavaWordnikApiCodegen.scala http://api.wordnik.com/v4/resources.json
+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/wordnik.json -l java -o samples/client/wordnik/java"
+
+java $JAVA_OPTS -jar $executable $ags
--- a/bin/javascript-petstore.sh
+++ b/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
--- a/bin/jaxrs-petstore-server.sh
+++ b/bin/jaxrs-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/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
--- a/bin/nodejs-petstore-server.sh
+++ b/bin/nodejs-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 -i modules/swagger-codegen/src/test/resources/2_0/petstore.json -l nodejs -o samples/server/petstore/nodejs"
+
+java $JAVA_OPTS -Dservice -jar $executable $ags
--- a/bin/objc-petstore.sh
+++ b/bin/objc-petstore.sh
@@ -1,6 +1,31 @@
-#!/bin/bash
-DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
+#!/bin/sh

-export CLASSPATH="$DIR/../target/*:$DIR/../target/lib/*"
+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"
-JAVA_OPTS=$JAVA_OPTS scala -cp $CLASSPATH "$@" samples/client/petstore/objc/ObjcPetstoreCodegen.scala http://petstore.swagger.wordnik.com/api/api-docs.json special-key
+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 -DappName=PetstoreClient $JAVA_OPTS -jar $executable $ags
--- a/bin/objc-wordnik-api.sh
+++ b/bin/objc-wordnik-api.sh
@@ -1,6 +1,31 @@
-#!/bin/bash
-DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
+#!/bin/sh

-export CLASSPATH="$DIR/../target/lib/*:$DIR/../target/*"
-export JAVA_OPTS="${JAVA_OPTS} -XX:MaxPermSize=256M -Xmx1024M -DloggerPath=conf/log4j.properties -DfileMap=samples/client/wordnik-api/spec-files"
-JAVA_OPTS=$JAVA_OPTS scala -cp $CLASSPATH "$@" samples/client/wordnik-api/objc/ObjcWordnikApiCodegen.scala http://api.wordnik.com/v4/resources.json
+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/wordnik.json -l objc -o samples/client/wordnik/objc"
+
+java $JAVA_OPTS -jar $executable $ags
--- a/bin/perl-petstore.sh
+++ b/bin/perl-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 perl -o samples/client/petstore/perl"
+
+java $JAVA_OPTS -jar $executable $ags
--- a/bin/php-petstore.sh
+++ b/bin/php-petstore.sh
@@ -1,6 +1,31 @@
-#!/bin/bash
-DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
+#!/bin/sh

-export CLASSPATH="$DIR/../target/lib/*:$DIR/../target/*"
+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"
-JAVA_OPTS=$JAVA_OPTS scala -cp $CLASSPATH "$@" samples/client/petstore/php/PHPPetstoreCodegen.scala http://petstore.swagger.wordnik.com/api/api-docs.json special-key
+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
--- a/bin/python-petstore.sh
+++ b/bin/python-petstore.sh
@@ -1,6 +1,31 @@
-#!/bin/bash
-DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
+#!/bin/sh

-export CLASSPATH="$DIR/../target/lib/*:$DIR/../target/*"
+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"
-JAVA_OPTS=$JAVA_OPTS scala -cp $CLASSPATH "$@" samples/client/petstore/python/PythonPetstoreCodegen.scala http://petstore.swagger.wordnik.com/api/api-docs.json special-key
+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
--- a/bin/python3-petstore.sh
+++ b/bin/python3-petstore.sh
@@ -1,6 +0,0 @@
-#!/bin/bash
-DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
-
-export CLASSPATH="$DIR/../target/lib/*:$DIR/../target/*"
-export JAVA_OPTS="${JAVA_OPTS} -XX:MaxPermSize=256M -Xmx1024M -DloggerPath=conf/log4j.properties"
-JAVA_OPTS=$JAVA_OPTS scala -cp $CLASSPATH "$@" samples/client/petstore/python3/Python3PetstoreCodegen.scala http://petstore.swagger.wordnik.com/api/api-docs.json special-key
--- a/bin/qt5-petstore.sh
+++ b/bin/qt5-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/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
--- a/bin/ruby-petstore.json
+++ b/bin/ruby-petstore.json
@@ -0,0 +1,5 @@
+{
+  "gemName": "petstore",
+  "moduleName": "Petstore",
+  "gemVersion": "1.0.0"
+}
--- a/bin/ruby-petstore.sh
+++ b/bin/ruby-petstore.sh
@@ -1,6 +1,31 @@
-#!/bin/bash
-DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
+#!/bin/sh

-export CLASSPATH="$DIR/../target/lib/*:$DIR/../target/*"
+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"
-JAVA_OPTS=$JAVA_OPTS scala -cp $CLASSPATH "$@" samples/client/petstore/ruby/RubyPetstoreCodegen.scala http://petstore.swagger.wordnik.com/api/api-docs.json special-key
+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
--- a/bin/runscala.sh
+++ b/bin/runscala.sh
@@ -1,7 +0,0 @@
-#!/bin/bash
-DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
-
-export CLASSPATH="$DIR/../target/lib/*:$DIR/../target/*"
-export JAVA_OPTS="${JAVA_OPTS} -XX:MaxPermSize=256M -Xmx1024M -DloggerPath=conf/log4j.properties"
-JAVA_OPTS=$JAVA_OPTS scala -cp $CLASSPATH "$@"
-
--- a/bin/scala-async-petstore.sh
+++ b/bin/scala-async-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/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
--- a/bin/scala-petstore.sh
+++ b/bin/scala-petstore.sh
@@ -1,6 +1,31 @@
-#!/bin/bash
-DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
+#!/bin/sh

-export CLASSPATH="$DIR/../target/lib/*:$DIR/../target/*"
+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"
-JAVA_OPTS=$JAVA_OPTS scala -cp $CLASSPATH "$@" samples/client/petstore/scala/ScalaPetstoreCodegen.scala http://petstore.swagger.wordnik.com/api/api-docs.json special-key
+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
--- a/bin/scala-wordnik-api.sh
+++ b/bin/scala-wordnik-api.sh
@@ -1,6 +1,31 @@
-#!/bin/bash
-DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
+#!/bin/sh

-export CLASSPATH="$DIR/../target/lib/*:$DIR/../target/*"
-export JAVA_OPTS="${JAVA_OPTS} -XX:MaxPermSize=256M -Xmx1024M -DloggerPath=conf/log4j.properties -DfileMap=samples/client/wordnik-api/spec-files"
-JAVA_OPTS=$JAVA_OPTS scala -cp $CLASSPATH "$@" samples/client/wordnik-api/scala/ScalaWordnikApiCodegen.scala http://api.wordnik.com/v4/resources.json
+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/wordnik.json -l scala -o samples/client/wordnik/scala"
+
+java $JAVA_OPTS -jar $executable $ags
--- a/bin/scalatra-petstore-server.sh
+++ b/bin/scalatra-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/scalatra -i modules/swagger-codegen/src/test/resources/2_0/petstore.json -l scalatra -o samples/server/petstore/scalatra"
+
+java $JAVA_OPTS -jar $executable $ags
--- a/bin/silex-petstore-server.sh
+++ b/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
--- a/bin/sinatra-petstore-server.sh
+++ b/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
--- a/bin/slim-petstore-server.sh
+++ b/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
--- a/bin/spring-mvc-petstore-j8-async-server.sh
+++ b/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
--- a/bin/spring-mvc-petstore-j8-async.json
+++ b/bin/spring-mvc-petstore-j8-async.json
@@ -0,0 +1,3 @@
+{
+    "library": "j8-async"
+}
--- a/bin/spring-mvc-petstore-server.sh
+++ b/bin/spring-mvc-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/JavaSpringMVC -i modules/swagger-codegen/src/test/resources/2_0/petstore.json -l spring-mvc -o samples/server/petstore/spring-mvc"
+
+java $JAVA_OPTS -jar $executable $ags
--- a/bin/swift-petstore.json
+++ b/bin/swift-petstore.json
@@ -0,0 +1,4 @@
+{
+  "projectName": "PetstoreClient",
+  "responseAs": "PromiseKit"
+}
--- a/bin/swift-petstore.sh
+++ b/bin/swift-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/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 $JAVA_OPTS -jar $executable $ags
--- a/bin/tizen-petstore.sh
+++ b/bin/tizen-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/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
--- a/bin/typescript-angular-petstore.sh
+++ b/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
--- a/bin/typescript-node-petstore.sh
+++ b/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
--- a/bin/validate.sh
+++ b/bin/validate.sh
@@ -1,6 +0,0 @@
-#!/bin/bash
-DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
-
-export CLASSPATH="$DIR/../target/lib/*:$DIR/../target/*"
-export JAVA_OPTS="${JAVA_OPTS} -XX:MaxPermSize=256M -Xmx1024M -DloggerPath=conf/log4j.properties"
-JAVA_OPTS=$JAVA_OPTS scala -cp $CLASSPATH com.wordnik.swagger.codegen.spec.Validator "$@"
--- a/bin/windows/akka-scala-petstore.bat
+++ b/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%
--- a/bin/windows/android-petstore.bat
+++ b/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%
--- a/bin/windows/async-scala-petstore.sh
+++ b/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%
--- a/bin/windows/clojure-petstore.bat
+++ b/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%
--- a/bin/windows/csharp-petstore.bat
+++ b/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%
--- a/bin/windows/dart-petstore.bat
+++ b/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%
--- a/bin/windows/dynamic-html-petstore.bat
+++ b/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%
--- a/bin/windows/flash-petstore.bat
+++ b/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%
--- a/bin/windows/html-petstore.bat
+++ b/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%
--- a/bin/windows/java-petstore.bat
+++ b/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%
--- a/bin/windows/javascript-petstore.bat
+++ b/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%
--- a/bin/windows/objc-petstore.bat
+++ b/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%
--- a/bin/windows/perl-petstore.bat
+++ b/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%
--- a/bin/windows/php-petstore.bat
+++ b/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%
--- a/bin/windows/python-petstore.bat
+++ b/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%
--- a/bin/windows/qt5cpp-petstore.bat
+++ b/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%
--- a/bin/windows/ruby-petstore.bat
+++ b/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%
--- a/bin/windows/scala-petstore.bat
+++ b/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%
--- a/bin/windows/swift-petstore.bat
+++ b/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%
--- a/bin/windows/tizen-petstore.bat
+++ b/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%
--- a/bin/windows/typescript-angular.bat
+++ b/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%
--- a/bin/windows/typescript-node.bat
+++ b/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%
--- a/modules/swagger-codegen-cli/pom.xml
+++ b/modules/swagger-codegen-cli/pom.xml
@@ -0,0 +1,103 @@
+<project xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://maven.apache.org/POM/4.0.0"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
+    <parent>
+        <groupId>io.swagger</groupId>
+        <artifactId>swagger-codegen-project</artifactId>
+        <version>2.1.5</version>
+        <relativePath>../..</relativePath>
+    </parent>
+    <modelVersion>4.0.0</modelVersion>
+
+    <artifactId>swagger-codegen-cli</artifactId>
+    <packaging>jar</packaging>
+
+    <name>swagger-codegen (executable)</name>
+
+    <build>
+        <finalName>swagger-codegen-cli</finalName>
+        <resources>
+            <resource>
+                <directory>src/main/resources</directory>
+                <excludes>
+                    <exclude>logback.xml</exclude>
+                </excludes>
+            </resource>
+        </resources>
+        <plugins>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-jar-plugin</artifactId>
+                <configuration>
+                    <archive>
+                        <manifest>
+                            <mainClass>io.swagger.codegen.SwaggerCodegen</mainClass>
+                        </manifest>
+                    </archive>
+                </configuration>
+            </plugin>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-shade-plugin</artifactId>
+                <version>2.3</version>
+                <executions>
+                    <execution>
+                        <id>process-resources</id>
+                        <phase>package</phase>
+                        <goals>
+                            <goal>shade</goal>
+                        </goals>
+                        <configuration>
+                            <minimizeJar>false</minimizeJar>
+                            <createDependencyReducedPom>true</createDependencyReducedPom>
+                            <dependencyReducedPomLocation>
+                                ${java.io.tmpdir}/dependency-reduced-pom.xml
+                            </dependencyReducedPomLocation>
+                            <transformers>
+                                <transformer
+                                        implementation="org.apache.maven.plugins.shade.resource.ServicesResourceTransformer"/>
+                            </transformers>
+                        </configuration>
+                    </execution>
+                </executions>
+            </plugin>
+        </plugins>
+    </build>
+
+    <dependencies>
+
+        <dependency>
+            <groupId>io.swagger</groupId>
+            <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>
--- a/modules/swagger-codegen-cli/src/main/java/io/swagger/codegen/SwaggerCodegen.java
+++ b/modules/swagger-codegen-cli/src/main/java/io/swagger/codegen/SwaggerCodegen.java
@@ -0,0 +1,37 @@
+package io.swagger.codegen;
+
+import io.airlift.airline.Cli;
+import io.airlift.airline.Help;
+import io.swagger.codegen.cmd.ConfigHelp;
+import io.swagger.codegen.cmd.Generate;
+import io.swagger.codegen.cmd.Langs;
+import io.swagger.codegen.cmd.Meta;
+
+/**
+ * User: lanwen
+ * Date: 24.03.15
+ * Time: 17:56
+ * <p>
+ * Command line interface for swagger codegen
+ * use `swagger-codegen-cli.jar help` for more info
+ *
+ * @since 2.1.3-M1
+ */
+public class SwaggerCodegen {
+
+
+    public static void main(String[] args) {
+        Cli.CliBuilder<Runnable> builder = Cli.<Runnable>builder("swagger-codegen-cli")
+                .withDescription("Swagger code generator CLI. More info on swagger.io")
+                .withDefaultCommand(Langs.class)
+                .withCommands(
+                        Generate.class,
+                        Meta.class,
+                        Langs.class,
+                        Help.class,
+                        ConfigHelp.class
+                );
+
+        builder.build().parse(args).run();
+    }
+}
--- a/modules/swagger-codegen-cli/src/main/java/io/swagger/codegen/cmd/ConfigHelp.java
+++ b/modules/swagger-codegen-cli/src/main/java/io/swagger/codegen/cmd/ConfigHelp.java
@@ -0,0 +1,27 @@
+package io.swagger.codegen.cmd;
+
+import io.airlift.airline.Command;
+import io.airlift.airline.Option;
+import io.swagger.codegen.CliOption;
+import io.swagger.codegen.CodegenConfig;
+import io.swagger.codegen.CodegenConfigLoader;
+
+@Command(name = "config-help", description = "Config help for chosen lang")
+public class ConfigHelp implements Runnable {
+
+    @Option(name = {"-l", "--lang"}, title = "language", required = true,
+            description = "language to get config help for")
+    private String lang;
+
+    @Override
+    public void run() {
+        System.out.println();
+        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.getOptionHelp().replaceAll("\n", "\n\t    "));
+            System.out.println();
+        }
+    }
+}
--- a/modules/swagger-codegen-cli/src/main/java/io/swagger/codegen/cmd/Generate.java
+++ b/modules/swagger-codegen-cli/src/main/java/io/swagger/codegen/cmd/Generate.java
@@ -0,0 +1,249 @@
+package io.swagger.codegen.cmd;
+
+import io.airlift.airline.Command;
+import io.airlift.airline.Option;
+import io.swagger.codegen.ClientOptInput;
+import io.swagger.codegen.CodegenConstants;
+import io.swagger.codegen.DefaultGenerator;
+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.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;
+
+/**
+ * User: lanwen
+ * Date: 24.03.15
+ * Time: 20:22
+ */
+
+@Command(name = "generate", description = "Generate code with chosen lang")
+public class Generate implements Runnable {
+
+    public static final Logger LOG = LoggerFactory.getLogger(Generate.class);
+
+    @Option(name = {"-v", "--verbose"}, description = "verbose mode")
+    private Boolean verbose;
+
+    @Option(name = {"-l", "--lang"}, title = "language", required = true,
+            description = "client language to generate (maybe class name in classpath, required)")
+    private String lang;
+
+    @Option(name = {"-o", "--output"}, title = "output directory",
+            description = "where to write the generated files (current dir by default)")
+    private String output = "";
+
+    @Option(name = {"-i", "--input-spec"}, title = "spec file", required = true,
+            description = "location of the swagger spec, as URL or file (required)")
+    private String spec;
+
+    @Option(name = {"-t", "--template-dir"}, title = "template directory",
+            description = "folder containing the template files")
+    private String templateDir;
+
+    @Option(name = {"-a", "--auth"}, title = "authorization",
+            description = "adds authorization headers when fetching the swagger definitions remotely. " +
+                    "Pass in a URL-encoded string of name:header with a comma separating multiple values")
+    private String auth;
+
+    @Option(name = {"-D"}, title = "system properties", description = "sets specified system properties in " +
+            "the format of name=value,name=value")
+    private String systemProperties;
+
+    @Option(name = {"-c", "--config"}, title = "configuration file", description = "Path to json configuration file. " +
+            "File content should be in a json format {\"optionKey\":\"optionValue\", \"optionKey1\":\"optionValue1\"...} " +
+            "Supported options can be different for each language. Run config-help -l {lang} command for language specific config options.")
+    private String configFile;
+
+    @Option(name = {"-s", "--skip-overwrite"}, title = "skip overwrite", description = "specifies if the existing files should be " +
+            "overwritten during the generation.")
+    private Boolean skipOverwrite;
+
+    @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() {
+
+        //attempt to read from config file
+        CodegenConfigurator configurator = CodegenConfigurator.fromFile(configFile);
+
+        //if a config file wasn't specified or we were unable to read it
+        if(configurator == null) {
+            //createa a fresh configurator
+            configurator = new CodegenConfigurator();
+        }
+
+        //now override with any specified parameters
+        if (verbose != null) {
+            configurator.setVerbose(verbose);
+        }
+
+        if(skipOverwrite != null) {
+            configurator.setSkipOverwrite(skipOverwrite);
+        }
+
+        if(isNotEmpty(spec)) {
+            configurator.setInputSpec(spec);
+        }
+
+        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(CodegenConfigurator configurator) {
+        final Map<String, String> map = createMapFromKeyValuePairs(systemProperties);
+        for (Map.Entry<String, String> entry : map.entrySet()) {
+            configurator.addSystemProperty(entry.getKey(), entry.getValue());
+        }
+    }
+
+    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());
+        }
+    }
+
+    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;
+    }
+}
--- a/modules/swagger-codegen-cli/src/main/java/io/swagger/codegen/cmd/Langs.java
+++ b/modules/swagger-codegen-cli/src/main/java/io/swagger/codegen/cmd/Langs.java
@@ -0,0 +1,23 @@
+package io.swagger.codegen.cmd;
+
+import ch.lambdaj.collection.LambdaIterable;
+import io.airlift.airline.Command;
+import io.swagger.codegen.CodegenConfig;
+
+import static ch.lambdaj.Lambda.on;
+import static ch.lambdaj.collection.LambdaCollections.with;
+import static java.util.ServiceLoader.load;
+
+/**
+ * User: lanwen
+ * Date: 24.03.15
+ * Time: 20:25
+ */
+@Command(name = "langs", description = "Shows available langs")
+public class Langs implements Runnable {
+    @Override
+    public void run() {
+        LambdaIterable<String> langs = with(load(CodegenConfig.class)).extract(on(CodegenConfig.class).getName());
+        System.out.printf("Available languages: %s%n", langs);
+    }
+}
--- a/modules/swagger-codegen-cli/src/main/java/io/swagger/codegen/cmd/Meta.java
+++ b/modules/swagger-codegen-cli/src/main/java/io/swagger/codegen/cmd/Meta.java
@@ -0,0 +1,155 @@
+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;
+import io.airlift.airline.Command;
+import io.airlift.airline.Option;
+import io.swagger.codegen.DefaultGenerator;
+import io.swagger.codegen.SupportingFile;
+import org.apache.commons.io.FileUtils;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.io.File;
+import java.io.IOException;
+import java.io.Reader;
+import java.util.List;
+import java.util.Map;
+
+import static ch.lambdaj.collection.LambdaCollections.with;
+import static com.google.common.base.Joiner.on;
+
+/**
+ * User: lanwen
+ * Date: 24.03.15
+ * Time: 20:22
+ */
+
+@Command(name = "meta", description = "MetaGenerator. Generator for creating a new template set " +
+        "and configuration for Codegen.  The output will be based on the language you " +
+        "specify, and includes default templates to include.")
+public class Meta implements Runnable {
+
+    private static final Logger LOG = LoggerFactory.getLogger(Meta.class);
+
+    private static final String TEMPLATE_DIR_CLASSPATH = "codegen";
+    private static final String MUSTACHE_EXTENSION = ".mustache";
+
+    @Option(name = {"-o", "--output"}, title = "output directory",
+            description = "where to write the generated files (current dir by default)")
+    private String outputFolder = "";
+
+    @Option(name = {"-n", "--name"}, title = "name",
+            description = "the human-readable name of the generator")
+    private String name = "default";
+
+    @Option(name = {"-p", "--package"}, title = "package",
+            description = "the package to put the main class into (defaults to io.swagger.codegen)")
+    private String targetPackage = "io.swagger.codegen";
+
+    @Override
+    public void run() {
+        final File targetDir = new File(outputFolder);
+        LOG.info("writing to folder [{}]", targetDir.getAbsolutePath());
+
+        String mainClass = CaseFormat.LOWER_HYPHEN.to(CaseFormat.UPPER_CAMEL, name) + "Generator";
+
+        List<SupportingFile> supportingFiles = ImmutableList.of(
+                new SupportingFile("pom.mustache", "", "pom.xml"),
+                new SupportingFile("generatorClass.mustache",
+                        on(File.separator).join("src/main/java", asPath(targetPackage)), mainClass.concat(".java")),
+                new SupportingFile("README.mustache", "", "README.md"),
+                new SupportingFile("api.template", "src/main/resources" + File.separator + name, "api.mustache"),
+                new SupportingFile("model.template", "src/main/resources" + File.separator + name, "model.mustache"),
+                new SupportingFile("services.mustache",
+                        "src/main/resources/META-INF/services", "io.swagger.codegen.CodegenConfig")
+        );
+
+        String swaggerVersion = 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)
+                .put("swaggerCodegenVersion", swaggerVersion).build();
+
+
+        with(supportingFiles).convert(processFiles(targetDir, data));
+    }
+
+    /**
+     * Converter method to process supporting files: execute with mustache,
+     * or simply copy to destination directory
+     *
+     * @param targetDir - destination directory
+     * @param data      - map with additional params needed to process templates
+     * @return converter object to pass to lambdaj
+     */
+    private Converter<SupportingFile, File> processFiles(final File targetDir, final Map<String, Object> data) {
+        return new Converter<SupportingFile, File>() {
+            private DefaultGenerator generator = new DefaultGenerator();
+
+            @Override
+            public File convert(SupportingFile support) {
+                try {
+                    File destinationFolder = new File(new File(targetDir.getAbsolutePath()), support.folder);
+                    File outputFile = new File(destinationFolder, support.destinationFilename);
+
+                    String template = generator
+                            .readTemplate(new File(TEMPLATE_DIR_CLASSPATH, support.templateFile).getPath());
+                    String formatted = template;
+
+                    if (support.templateFile.endsWith(MUSTACHE_EXTENSION)) {
+                        LOG.info("writing file to {}", outputFile.getAbsolutePath());
+                        formatted = Mustache.compiler().withLoader(loader(generator))
+                                .defaultValue("")
+                                .compile(template)
+                                .execute(data);
+                    } else {
+                        LOG.info("copying file to {}", outputFile.getAbsolutePath());
+                    }
+
+                    FileUtils.writeStringToFile(outputFile, formatted);
+                    return outputFile;
+
+                } catch (IOException e) {
+                    throw new RuntimeException("Can't generate project", e);
+                }
+            }
+        };
+    }
+
+    /**
+     * Creates mustache loader for template using classpath loader
+     *
+     * @param generator - class with reader getter
+     * @return loader for template
+     */
+    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));
+            }
+        };
+    }
+
+    /**
+     * Converts package name to path on file system
+     *
+     * @param packageName - package name to convert
+     * @return relative path
+     */
+    private String asPath(String packageName) {
+        return packageName.replace(".", File.separator);
+    }
+}
--- a/modules/swagger-codegen-cli/src/main/java/io/swagger/codegen/cmd/utils/OptionUtils.java
+++ b/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;
+    }
+
+}
--- a/modules/swagger-codegen-cli/src/main/resources/logback.xml
+++ b/modules/swagger-codegen-cli/src/main/resources/logback.xml
@@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<configuration>
+    <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
+        <layout class="ch.qos.logback.classic.PatternLayout">
+            <Pattern>%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n</Pattern>
+        </layout>
+    </appender>
+    <logger name="io.swagger" level="debug"/>
+    <root level="error">
+        <appender-ref ref="STDOUT"/>
+    </root>
+</configuration>
--- a/modules/swagger-codegen-cli/src/test/java/io/swagger/codegen/cmd/GenerateTest.java
+++ b/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);
+    }
+}
--- a/modules/swagger-codegen-cli/src/test/java/io/swagger/codegen/cmd/utils/OptionUtilsTest.java
+++ b/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));
+        }
+    }
+}
--- a/modules/swagger-codegen-maven-plugin/README.md
+++ b/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
--- a/modules/swagger-codegen-maven-plugin/examples/java-client.xml
+++ b/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>
--- a/Show More
+++ b/Show More