Merge pull request #1437 from swagger-api/release-prepare

updated versions for release

.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-java/hello.txt
+samples/client/petstore/objc/Build
+samples/client/petstore/objc/Pods
+samples/server/petstore/nodejs/node_modules
+target
+.idea
+.lib
+atlassian-ide-plugin.xml
+.DS_Store
+
+samples/client/petstore/php/SwaggerClient-php/composer.lock
+samples/client/petstore/php/SwaggerClient-php/vendor/
+
+samples/client/petstore/silex/SwaggerServer/composer.lock
+samples/client/petstore/silex/SwaggerServer/venodr/

.gitignore

@@ -9,6 +9,7 @@ version.properties
 lib/*
 build/*
 generated-files/*
+generated-sources/*
 generated-code/*
 *.swp
 *.swo
@@ -22,9 +23,35 @@ 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-java/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
 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

.travis.yml

@@ -1,3 +1,5 @@
-language: scala
-scala:
-   - 2.10.2
+sudo: false
+language: java
+script: mvn verify -Psamples
+jdk:
+  - oraclejdk7

Dockerfile

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

LICENSE

@@ -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.

README.md

@@ -1,230 +1,463 @@
 # Swagger Code Generator
 
-[![Build Status](https://travis-ci.org/wordnik/swagger-codegen.png)](https://travis-ci.org/wordnik/swagger-codegen)
+[![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)
 
 ## 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/swagger-api/swagger-spec) 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
+    - [Build and run using docker](#build-and-run-using-docker)
+    - [Build a nodejs server stub](#build-a-nodejs-server-stub)
+    - [Compatibility](#compatibility)
+    - [Prerequisites](#prerequisites)
+    - [OS X Users](#os-x-users)
+      - [Building](#building)
+  - 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 swagger 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)
+      - [rails-grape](#rails-grape)
+      - [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)
+  - [License](#license)
+
+## 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 nodejs server stub
+
+ ```
+./run-in-docker.sh generate \
+  -i http://petstore.swagger.io/v2/swagger.json \
+  -l nodejs \
+  -o samples/server/petstore/nodejs
+ ```
+
+## Compatibility
+The Swagger Specification has undergone 3 revisions since initial creation in 2010.  The swagger-codegen project has the following compatibilies with the swagger specification:
+
+Swagger Codegen Version    | Release Date | Swagger Spec compatibility | Notes
+-------------------------- | ------------ | -------------------------- | -----
+2.1.5-SNAPSHOT             |              | 1.0, 1.1, 1.2, 2.0   | [master](https://github.com/swagger-api/swagger-codegen)
+2.1.4 (**current stable**) | 2015-10-25   | 1.0, 1.1, 1.2, 2.0   | [tag v2.1.4](https://github.com/swagger-api/swagger-codegen/tree/v2.1.3)
+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:
 
-* [Java 1.7](http://java.oracle.com)
-
-Note!  Some folks have had issues with OOM errors with java version "1.6.0_51".  It's strongly suggested that you upgrade to 1.7!
+* [Java 7](http://java.oracle.com)
 
 * [Apache maven 3.0.3 or greater](http://maven.apache.org/)
+ 
+#### OS X Users
+Don't forget to install Java 7. You probably have 1.6 or 1.8.
 
-* [Scala 2.9.1](http://www.scala-lang.org)
-
-* [sbt (only download if you're building on Windows)](http://www.scala-sbt.org/)
-
-You also need to add the scala binary to your PATH.
-
-After cloning the project, you need to build it from source with this command:
-
+Export JAVA_HOME in order to user proper Java version:
 ```
-./sbt assembly
+export JAVA_HOME=`/usr/libexec/java_home -v 1.7`
+export PATH=${JAVA_HOME}/bin:$PATH
 ```
 
-or for Windows...
+#### Building
+
+After cloning the project, you can build it from source with this command:
 
 ```
-sbt assembly
+mvn package
 ```
 
-
 ### 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:
+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 swagger 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/api-docs 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-distribution/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.
 
 ### 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 swagger specification.
 
-#### Generating a client from flat files (i.e. no remote server calls)
+
+#### Generating a client from local files
 If you don't want to call your server, you can save the swagger 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:
+Great for creating libraries on your ci server, from the [Swagger Editor](http://editor.swagger.io)... or while coding on an airplane.
+
+### Selective generation
+You may not want to generate *all* models in your project.  Likewise you may want just one or two apis to be written.  If that's the case, you can use system properties to control the output:
+
+The default is generate *everything* supported by the specific library.  Once you enable a feature, it will restrict the contents generated:
+
 ```
-./bin/java-petstore-filemap.sh
+# 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
 ```
 
-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.
+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
+AsyncScalaClientCodegen.java
+CSharpClientCodegen.java
+CsharpDotNet2ClientCodegen.java
+DartClientCodegen.java
+FlashClientCodegen.java
+JavaClientCodegen.java
+JavaInflectorServerCodegen.java
+JaxRSServerCodegen.java
+NodeJSServerCodegen.java
+ObjcClientCodegen.java
+PerlClientCodegen.java
+PhpClientCodegen.java
+PythonClientCodegen.java
+Qt5CPPGenerator.java
+RubyClientCodegen.java
+ScalaClientCodegen.java
+ScalatraServerCodegen.java
+SilexServerCodegen.java
+SinatraServerCodegen.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.
+
+```
+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
+	    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)
+```
+
+Your config file for java can look like
+
+```
+{
+  "groupId":"com.my.company",
+  "artifactId":"MyClent",
+  "artifactVersion":"1.2.0"
+}
+```
+
+For all the unspecified options default values will be used.
+
+Another way to override default options is to extend config class for 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.
 
 ### 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:
+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:
 
 ```
-./bin/validate.sh http://petstore.swagger.wordnik.com/api/api-docs "specia-key" ./swagger-errors.html
+cd samples/dynamic-html/
+npm install
+node .
 ```
 
-### Generating static api documentation
-If you need to make static pages or don't want the sandbox of the swagger-ui, you can use the codegen to build them.  Remember, the engine is just using mustache templates--the output format is your call.
+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:
 
 ```
-./bin/static-docs.sh
+cd samples/html/
+open index.html
 ```
 
-Will produce the output here:
-
-```
-https://github.com/wordnik/swagger-codegen/tree/master/samples/docs/swagger-static-docs
-```
-
-which is based on these templates:
-
-```
-https://github.com/wordnik/swagger-codegen/tree/master/src/main/resources/swagger-static
-```
-
-and looks like this
-
-![Image](https://raw.github.com/wordnik/swagger-codegen/master/samples/docs/swagger-static-docs/static-docs.png)
 
 ### To build a server stub
 
 You can also use the codegen to generate a server for a couple different frameworks.  Take a look here:
 
-* [javascript node.js Server generator](https://github.com/wordnik/swagger-codegen/tree/master/samples/server-generator/node)
+### node.js
 
-* [ruby sinatra generator](https://github.com/wordnik/swagger-codegen/tree/master/samples/server-generator/sinatra)
-
-* [scala scalatra generator](https://github.com/wordnik/swagger-codegen/tree/master/samples/server-generator/scalatra)
-
-* [java jax-rs generator](https://github.com/wordnik/swagger-codegen/tree/master/samples/server-generator/java-jaxrs)
-
-
-### Migrating from Swagger 1.1 to 1.2 format
-
-If you've spent time hand-crafting your swagger spec files, you can use the [SpecConverter](https://github.com/wordnik/swagger-codegen/blob/master/src/main/scala/com/wordnik/swagger/codegen/SpecConverter.scala) to do the dirty work.  For example:
-
-```bash
-$ ./bin/update-spec.sh http://developer.wordnik.com/v4/resources.json wordnik-developer
-writing file wordnik-developer/api-docs
-calling: http://developer.wordnik.com/v4/account.json
-calling: http://developer.wordnik.com/v4/word.json
-calling: http://developer.wordnik.com/v4/words.json
-calling: http://developer.wordnik.com/v4/wordList.json
-calling: http://developer.wordnik.com/v4/wordLists.json
-writing file wordnik-developer/account
-writing file wordnik-developer/word
-writing file wordnik-developer/words
-writing file wordnik-developer/wordList
-writing file wordnik-developer/wordLists
+```
+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
 ```
 
-Will read the 1.1 spec from wordnik developer and write it into the folder called `wordnik-developer`.
+### rails-grape
 
+*Not yet migrated to this branch*
 
+### 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
 
 This will create the swagger-codegen library from source.  
 
 ```
-./sbt assembly
+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
 
 License
 -------
 
-Copyright 2013 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.

bin/Version.scala

@@ -1,7 +0,0 @@
-val version = scala.util.Properties.scalaPropOrElse("version.number", "unknown").toString match {
-  case "2.10.0" => "2.10"
-  case "2.10.2" => "2.10"
-  case "2.10.3" => "2.10"
-  case e: String => e
-}
-println(version)

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

bin/all-petstore.sh

@@ -18,20 +18,29 @@ if [ ! -d "${APP_DIR}" ]; then
 fi
 
 cd $APP_DIR
-./bin/java-wordnik-api.sh
-./bin/php-wordnik-api.sh
-./bin/python3-wordnik-api.sh
-./bin/objc-wordnik-api.sh
-./bin/python-wordnik-api.sh
-./bin/scala-wordnik-api.sh
-
+./bin/akka-scala-petstore.sh
 ./bin/android-java-petstore.sh
 ./bin/csharp-petstore.sh
-./bin/flash-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/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/python3-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/spring-mvc-petstore-server.sh
+./bin/swift-petstore.sh
+./bin/tizen-petstore.sh
+./bin/typescript-angular-petstore.sh
+./bin/typescript-node-petstore.sh

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

bin/android-java-petstore.sh

@@ -1,7 +1,6 @@
 #!/bin/sh
 
 SCRIPT="$0"
-SCALA_RUNNER_VERSION=$(scala ./bin/Version.scala)
 
 while [ -h "$SCRIPT" ] ; do
   ls=`ls -ld "$SCRIPT"`
@@ -18,15 +17,15 @@ if [ ! -d "${APP_DIR}" ]; then
   APP_DIR=`cd "${APP_DIR}"; pwd`
 fi
 
-cd $APP_DIR
+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="$@ samples/client/petstore/android-java/AndroidJavaPetstoreCodegen.scala http://petstore.swagger.wordnik.com/api/api-docs special-key"
+ags="$@ generate -t modules/swagger-codegen/src/main/resources/android-java -i modules/swagger-codegen/src/test/resources/2_0/petstore.json -l android -o samples/client/petstore/android-java"
 
-if [ -f $APP_DIR/target/scala-$SCALA_RUNNER_VERSION/swagger-codegen.jar ]; then
-  scala -cp target/scala-$SCALA_RUNNER_VERSION/swagger-codegen.jar $ags
-else
-  echo "Please set scalaVersion := \"$SCALA_RUNNER_VERSION\" in build.sbt and run ./sbt assembly"
-fi
+java $JAVA_OPTS -jar $executable $ags

bin/android-java-wordnik-api.sh

@@ -1,7 +1,6 @@
 #!/bin/sh
 
 SCRIPT="$0"
-SCALA_RUNNER_VERSION=$(scala ./bin/Version.scala)
 
 while [ -h "$SCRIPT" ] ; do
   ls=`ls -ld "$SCRIPT"`
@@ -18,15 +17,15 @@ if [ ! -d "${APP_DIR}" ]; then
   APP_DIR=`cd "${APP_DIR}"; pwd`
 fi
 
-cd $APP_DIR
+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="$@ samples/client/petstore/android-java/AndroidJavaPetstoreCodegen.scala http://petstore.swagger.wordnik.com/api/api-docs special-key"
+ags="$@ generate -i modules/swagger-codegen/src/test/resources/2_0/wordnik.json -l android -o samples/client/wordnik/android-java"
 
-if [ -f $APP_DIR/target/scala-$SCALA_RUNNER_VERSION/swagger-codegen.jar ]; then
-  scala -cp target/scala-$SCALA_RUNNER_VERSION/swagger-codegen.jar $ags
-else
-  echo "Please set scalaVersion := \"$SCALA_RUNNER_VERSION\" in build.sbt and run ./sbt assembly"
-fi
+java $JAVA_OPTS -jar $executable $ags

bin/csharp-dotnet2-petstore.sh

@@ -0,0 +1,31 @@
+#!/bin/sh
+
+SCRIPT="$0"
+
+while [ -h "$SCRIPT" ] ; do
+  ls=`ls -ld "$SCRIPT"`
+  link=`expr "$ls" : '.*-> \(.*\)$'`
+  if expr "$link" : '/.*' > /dev/null; then
+    SCRIPT="$link"
+  else
+    SCRIPT=`dirname "$SCRIPT"`/"$link"
+  fi
+done
+
+if [ ! -d "${APP_DIR}" ]; then
+  APP_DIR=`dirname "$SCRIPT"`/..
+  APP_DIR=`cd "${APP_DIR}"; pwd`
+fi
+
+executable="./modules/swagger-codegen-cli/target/swagger-codegen-cli.jar"
+
+if [ ! -f "$executable" ]
+then
+  mvn clean package
+fi
+
+# if you've executed sbt assembly previously it will use that instead.
+export JAVA_OPTS="${JAVA_OPTS} -XX:MaxPermSize=256M -Xmx1024M -DloggerPath=conf/log4j.properties"
+ags="$@ generate -i modules/swagger-codegen/src/test/resources/2_0/petstore.json -l CsharpDotNet2 -o samples/client/petstore/csharp-dotnet2/SwaggerClientTest/Lib/SwaggerClient"
+
+java $JAVA_OPTS -jar $executable $ags

bin/csharp-petstore.sh

@@ -1,7 +1,6 @@
 #!/bin/sh
 
 SCRIPT="$0"
-SCALA_RUNNER_VERSION=$(scala ./bin/Version.scala)
 
 while [ -h "$SCRIPT" ] ; do
   ls=`ls -ld "$SCRIPT"`
@@ -18,15 +17,15 @@ if [ ! -d "${APP_DIR}" ]; then
   APP_DIR=`cd "${APP_DIR}"; pwd`
 fi
 
-cd $APP_DIR
+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="$@ samples/client/petstore/csharp/CsharpPetstoreCodegen.scala http://petstore.swagger.wordnik.com/api/api-docs special-key"
+ags="$@ generate -i modules/swagger-codegen/src/test/resources/2_0/petstore.json -l csharp -o samples/client/petstore/csharp/SwaggerClientTest/Lib/SwaggerClient"
 
-if [ -f $APP_DIR/target/scala-$SCALA_RUNNER_VERSION/swagger-codegen.jar ]; then
-  scala -cp target/scala-$SCALA_RUNNER_VERSION/swagger-codegen.jar $ags
-else
-  echo "Please set scalaVersion := \"$SCALA_RUNNER_VERSION\" in build.sbt and run ./sbt assembly"
-fi
+java $JAVA_OPTS -jar $executable $ags

bin/dart-petstore.sh

@@ -0,0 +1,31 @@
+#!/bin/sh
+
+SCRIPT="$0"
+
+while [ -h "$SCRIPT" ] ; do
+  ls=`ls -ld "$SCRIPT"`
+  link=`expr "$ls" : '.*-> \(.*\)$'`
+  if expr "$link" : '/.*' > /dev/null; then
+    SCRIPT="$link"
+  else
+    SCRIPT=`dirname "$SCRIPT"`/"$link"
+  fi
+done
+
+if [ ! -d "${APP_DIR}" ]; then
+  APP_DIR=`dirname "$SCRIPT"`/..
+  APP_DIR=`cd "${APP_DIR}"; pwd`
+fi
+
+executable="./modules/swagger-codegen-cli/target/swagger-codegen-cli.jar"
+
+if [ ! -f "$executable" ]
+then
+  mvn clean package
+fi
+
+# if you've executed sbt assembly previously it will use that instead.
+export JAVA_OPTS="${JAVA_OPTS} -XX:MaxPermSize=256M -Xmx1024M -DloggerPath=conf/log4j.properties"
+ags="$@ generate -i modules/swagger-codegen/src/test/resources/2_0/petstore.json -l dart -o samples/client/petstore/dart"
+
+java $JAVA_OPTS -jar $executable $ags

bin/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

bin/flash-petstore.sh

@@ -1,7 +1,6 @@
 #!/bin/sh
 
 SCRIPT="$0"
-SCALA_RUNNER_VERSION=$(scala ./bin/Version.scala)
 
 while [ -h "$SCRIPT" ] ; do
   ls=`ls -ld "$SCRIPT"`
@@ -18,15 +17,15 @@ if [ ! -d "${APP_DIR}" ]; then
   APP_DIR=`cd "${APP_DIR}"; pwd`
 fi
 
-cd $APP_DIR
+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="$@ samples/client/petstore/flash/FlashPetstoreCodegen.scala http://petstore.swagger.wordnik.com/api/api-docs special-key"
+export JAVA_OPTS="${JAVA_OPTS} -XX:MaxPermSize=256M -Xmx1024M -DloggerPath=conf/log4j.properties"
+ags="$@ generate -t modules/swagger-codegen/src/main/resources/flash -i modules/swagger-codegen/src/test/resources/2_0/petstore.json -l flash -o samples/client/petstore/flash"
 
-if [ -f $APP_DIR/target/scala-$SCALA_RUNNER_VERSION/swagger-codegen.jar ]; then
-  scala -cp target/scala-$SCALA_RUNNER_VERSION/swagger-codegen.jar $ags
-else
-  echo "Please set scalaVersion := \"$SCALA_RUNNER_VERSION\" in build.sbt and run ./sbt assembly"
-fi
+java $JAVA_OPTS -jar $executable $ags

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

bin/java-inflector-petstore-server.sh

@@ -0,0 +1,31 @@
+#!/bin/sh
+
+SCRIPT="$0"
+
+while [ -h "$SCRIPT" ] ; do
+  ls=`ls -ld "$SCRIPT"`
+  link=`expr "$ls" : '.*-> \(.*\)$'`
+  if expr "$link" : '/.*' > /dev/null; then
+    SCRIPT="$link"
+  else
+    SCRIPT=`dirname "$SCRIPT"`/"$link"
+  fi
+done
+
+if [ ! -d "${APP_DIR}" ]; then
+  APP_DIR=`dirname "$SCRIPT"`/..
+  APP_DIR=`cd "${APP_DIR}"; pwd`
+fi
+
+executable="./modules/swagger-codegen-cli/target/swagger-codegen-cli.jar"
+
+if [ ! -f "$executable" ]
+then
+  mvn clean package
+fi
+
+# if you've executed sbt assembly previously it will use that instead.
+export JAVA_OPTS="${JAVA_OPTS} -XX:MaxPermSize=256M -Xmx1024M -DloggerPath=conf/log4j.properties"
+ags="$@ generate -t modules/swagger-codegen/src/main/resources/JavaInflector -i modules/swagger-codegen/src/test/resources/2_0/petstore.json -l inflector -o samples/server/petstore/java-inflector"
+
+java $JAVA_OPTS -jar $executable $ags

bin/java-petstore-filemap.sh

@@ -1,32 +0,0 @@
-#!/bin/sh
-
-SCRIPT="$0"
-SCALA_RUNNER_VERSION=$(scala ./bin/Version.scala)
-
-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
-
-
-# if you've executed sbt assembly previously it will use that instead.
-export JAVA_OPTS="${JAVA_OPTS} -XX:MaxPermSize=256M -Xmx1024M -DfileMap=src/test/resources/petstore-1.1/resources.json -DloggerPath=conf/log4j.properties"
-ags="$@ samples/client/petstore/java/JavaPetstoreCodegen.scala http://petstore.swagger.wordnik.com/api/api-docs special-key"
-
-if [ -f $APP_DIR/target/scala-$SCALA_RUNNER_VERSION/swagger-codegen.jar ]; then
-  scala -cp target/scala-$SCALA_RUNNER_VERSION/swagger-codegen.jar $ags
-else
-  echo "Please set scalaVersion := \"$SCALA_RUNNER_VERSION\" in build.sbt and run ./sbt assembly"
-fi

bin/java-petstore-jersey2.json

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

bin/java-petstore-jersey2.sh

@@ -0,0 +1,31 @@
+#!/bin/sh
+
+SCRIPT="$0"
+
+while [ -h "$SCRIPT" ] ; do
+  ls=`ls -ld "$SCRIPT"`
+  link=`expr "$ls" : '.*-> \(.*\)$'`
+  if expr "$link" : '/.*' > /dev/null; then
+    SCRIPT="$link"
+  else
+    SCRIPT=`dirname "$SCRIPT"`/"$link"
+  fi
+done
+
+if [ ! -d "${APP_DIR}" ]; then
+  APP_DIR=`dirname "$SCRIPT"`/..
+  APP_DIR=`cd "${APP_DIR}"; pwd`
+fi
+
+executable="./modules/swagger-codegen-cli/target/swagger-codegen-cli.jar"
+
+if [ ! -f "$executable" ]
+then
+  mvn clean package
+fi
+
+# if you've executed sbt assembly previously it will use that instead.
+export JAVA_OPTS="${JAVA_OPTS} -XX:MaxPermSize=256M -Xmx1024M -DloggerPath=conf/log4j.properties"
+ags="$@ generate -i modules/swagger-codegen/src/test/resources/2_0/petstore.json -l java -c bin/java-petstore-jersey2.json -o samples/client/petstore/java/jersey2"
+
+java $JAVA_OPTS -jar $executable $ags

bin/java-petstore-okhttp-gson.json

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

bin/java-petstore-okhttp-gson.sh

@@ -0,0 +1,31 @@
+#!/bin/sh
+
+SCRIPT="$0"
+
+while [ -h "$SCRIPT" ] ; do
+  ls=`ls -ld "$SCRIPT"`
+  link=`expr "$ls" : '.*-> \(.*\)$'`
+  if expr "$link" : '/.*' > /dev/null; then
+    SCRIPT="$link"
+  else
+    SCRIPT=`dirname "$SCRIPT"`/"$link"
+  fi
+done
+
+if [ ! -d "${APP_DIR}" ]; then
+  APP_DIR=`dirname "$SCRIPT"`/..
+  APP_DIR=`cd "${APP_DIR}"; pwd`
+fi
+
+executable="./modules/swagger-codegen-cli/target/swagger-codegen-cli.jar"
+
+if [ ! -f "$executable" ]
+then
+  mvn clean package
+fi
+
+# if you've executed sbt assembly previously it will use that instead.
+export JAVA_OPTS="${JAVA_OPTS} -XX:MaxPermSize=256M -Xmx1024M -DloggerPath=conf/log4j.properties"
+ags="$@ generate -i modules/swagger-codegen/src/test/resources/2_0/petstore.json -l java -c bin/java-petstore-okhttp-gson.json -o samples/client/petstore/java/okhttp-gson"
+
+java $JAVA_OPTS -jar $executable $ags

bin/java-petstore-retrofit.json

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

bin/java-petstore-retrofit.sh

@@ -0,0 +1,31 @@
+#!/bin/sh
+
+SCRIPT="$0"
+
+while [ -h "$SCRIPT" ] ; do
+  ls=`ls -ld "$SCRIPT"`
+  link=`expr "$ls" : '.*-> \(.*\)$'`
+  if expr "$link" : '/.*' > /dev/null; then
+    SCRIPT="$link"
+  else
+    SCRIPT=`dirname "$SCRIPT"`/"$link"
+  fi
+done
+
+if [ ! -d "${APP_DIR}" ]; then
+  APP_DIR=`dirname "$SCRIPT"`/..
+  APP_DIR=`cd "${APP_DIR}"; pwd`
+fi
+
+executable="./modules/swagger-codegen-cli/target/swagger-codegen-cli.jar"
+
+if [ ! -f "$executable" ]
+then
+  mvn clean package
+fi
+
+# if you've executed sbt assembly previously it will use that instead.
+export JAVA_OPTS="${JAVA_OPTS} -XX:MaxPermSize=256M -Xmx1024M -DloggerPath=conf/log4j.properties"
+ags="$@ generate -i modules/swagger-codegen/src/test/resources/2_0/petstore.json -l java -c bin/java-petstore-retrofit.json -o samples/client/petstore/java/retrofit"
+
+java $JAVA_OPTS -jar $executable $ags

bin/java-petstore.sh

@@ -1,7 +1,6 @@
 #!/bin/sh
 
 SCRIPT="$0"
-SCALA_RUNNER_VERSION=$(scala ./bin/Version.scala)
 
 while [ -h "$SCRIPT" ] ; do
   ls=`ls -ld "$SCRIPT"`
@@ -18,15 +17,15 @@ if [ ! -d "${APP_DIR}" ]; then
   APP_DIR=`cd "${APP_DIR}"; pwd`
 fi
 
-cd $APP_DIR
+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="$@ samples/client/petstore/java/JavaPetstoreCodegen.scala http://petstore.swagger.wordnik.com/api/api-docs special-key"
+ags="$@ generate -i modules/swagger-codegen/src/test/resources/2_0/petstore.json -l java -o samples/client/petstore/java/default"
 
-if [ -f $APP_DIR/target/scala-$SCALA_RUNNER_VERSION/swagger-codegen.jar ]; then
-  scala -cp target/scala-$SCALA_RUNNER_VERSION/swagger-codegen.jar $ags
-else
-  echo "Please set scalaVersion := \"$SCALA_RUNNER_VERSION\" in build.sbt and run ./sbt assembly"
-fi
+java $JAVA_OPTS -jar $executable $ags

bin/java-wordnik-api.sh

@@ -1,7 +1,6 @@
 #!/bin/sh
 
 SCRIPT="$0"
-SCALA_RUNNER_VERSION=$(scala ./bin/Version.scala)
 
 while [ -h "$SCRIPT" ] ; do
   ls=`ls -ld "$SCRIPT"`
@@ -18,15 +17,15 @@ if [ ! -d "${APP_DIR}" ]; then
   APP_DIR=`cd "${APP_DIR}"; pwd`
 fi
 
-cd $APP_DIR
+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 -DfileMap=samples/client/wordnik-api/spec-files/resources.json"
-ags="$@ samples/client/wordnik-api/java/JavaWordnikApiCodegen.scala http://api.wordnik.com/v4/resources.json"
+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"
 
-if [ -f $APP_DIR/target/scala-$SCALA_RUNNER_VERSION/swagger-codegen.jar ]; then
-  scala -cp target/scala-$SCALA_RUNNER_VERSION/swagger-codegen.jar $ags
-else
-  echo "Please set scalaVersion := \"$SCALA_RUNNER_VERSION\" in build.sbt and run ./sbt assembly"
-fi
+java $JAVA_OPTS -jar $executable $ags

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 -Dswagger.codegen.jaxrs.impl.source=src/main/java"
+
+java $JAVA_OPTS -jar $executable $ags

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

bin/objc-petstore.sh

@@ -1,9 +1,6 @@
 #!/bin/sh
 
 SCRIPT="$0"
-SCALA_RUNNER_VERSION=$(scala ./bin/Version.scala)
-
-version="$(scala ./bin/Version.scala)"
 
 while [ -h "$SCRIPT" ] ; do
   ls=`ls -ld "$SCRIPT"`
@@ -20,15 +17,15 @@ if [ ! -d "${APP_DIR}" ]; then
   APP_DIR=`cd "${APP_DIR}"; pwd`
 fi
 
-cd $APP_DIR
+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="$@ samples/client/petstore/objc/ObjcPetstoreCodegen.scala http://petstore.swagger.wordnik.com/api/api-docs 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"
 
-if [ -f $APP_DIR/target/scala-$SCALA_RUNNER_VERSION/swagger-codegen.jar ]; then
-  scala -cp target/scala-$SCALA_RUNNER_VERSION/swagger-codegen.jar $ags
-else
-  echo "Please set scalaVersion := \"$SCALA_RUNNER_VERSION\" in build.sbt and run ./sbt assembly"
-fi
+java -DappName=PetstoreClient $JAVA_OPTS -jar $executable $ags

bin/objc-wordnik-api.sh

@@ -1,7 +1,6 @@
 #!/bin/sh
 
 SCRIPT="$0"
-SCALA_RUNNER_VERSION=$(scala ./bin/Version.scala)
 
 while [ -h "$SCRIPT" ] ; do
   ls=`ls -ld "$SCRIPT"`
@@ -18,15 +17,15 @@ if [ ! -d "${APP_DIR}" ]; then
   APP_DIR=`cd "${APP_DIR}"; pwd`
 fi
 
-cd $APP_DIR
+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 -DfileMap=samples/client/wordnik-api/spec-files"
-ags="$@ samples/client/wordnik-api/objc/ObjcWordnikApiCodegen.scala http://api.wordnik.com/v4/resources.json"
+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"
 
-if [ -f $APP_DIR/target/scala-$SCALA_RUNNER_VERSION/swagger-codegen.jar ]; then
-  scala -cp target/scala-$SCALA_RUNNER_VERSION/swagger-codegen.jar $ags
-else
-  echo "Please set scalaVersion := \"$SCALA_RUNNER_VERSION\" in build.sbt and run ./sbt assembly"
-fi
+java $JAVA_OPTS -jar $executable $ags

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

bin/php-petstore.sh

@@ -1,7 +1,6 @@
 #!/bin/sh
 
 SCRIPT="$0"
-SCALA_RUNNER_VERSION=$(scala ./bin/Version.scala)
 
 while [ -h "$SCRIPT" ] ; do
   ls=`ls -ld "$SCRIPT"`
@@ -18,15 +17,15 @@ if [ ! -d "${APP_DIR}" ]; then
   APP_DIR=`cd "${APP_DIR}"; pwd`
 fi
 
-cd $APP_DIR
+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="$@ samples/client/petstore/php/PHPPetstoreCodegen.scala http://petstore.swagger.wordnik.com/api/api-docs 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"
 
-if [ -f $APP_DIR/target/scala-$SCALA_RUNNER_VERSION/swagger-codegen.jar ]; then
-  scala -cp target/scala-$SCALA_RUNNER_VERSION/swagger-codegen.jar $ags
-else
-  echo "Please set scalaVersion := \"$SCALA_RUNNER_VERSION\" in build.sbt and run ./sbt assembly"
-fi
+java $JAVA_OPTS -jar $executable $ags

bin/php-wordnik-api.sh

@@ -1,32 +0,0 @@
-#!/bin/sh
-
-SCRIPT="$0"
-SCALA_RUNNER_VERSION=$(scala ./bin/Version.scala)
-
-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
-
-
-# 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 -DfileMap=samples/client/wordnik-api/spec-files/resources.json"
-ags="$@ samples/client/wordnik-api/php/PHPWordnikApiCodegen.scala http://api.wordnik.com/v4/resources.json"
-
-if [ -f $APP_DIR/target/scala-$SCALA_RUNNER_VERSION/swagger-codegen.jar ]; then
-  scala -cp target/scala-$SCALA_RUNNER_VERSION/swagger-codegen.jar $ags
-else
-  echo "Please set scalaVersion := \"$SCALA_RUNNER_VERSION\" in build.sbt and run ./sbt assembly"
-fi

bin/python-petstore.sh

@@ -1,7 +1,6 @@
 #!/bin/sh
 
 SCRIPT="$0"
-SCALA_RUNNER_VERSION=$(scala ./bin/Version.scala)
 
 while [ -h "$SCRIPT" ] ; do
   ls=`ls -ld "$SCRIPT"`
@@ -18,15 +17,15 @@ if [ ! -d "${APP_DIR}" ]; then
   APP_DIR=`cd "${APP_DIR}"; pwd`
 fi
 
-cd $APP_DIR
+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="$@ samples/client/petstore/python/PythonPetstoreCodegen.scala http://petstore.swagger.wordnik.com/api/api-docs 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"
 
-if [ -f $APP_DIR/target/scala-$SCALA_RUNNER_VERSION/swagger-codegen.jar ]; then
-  scala -cp target/scala-$SCALA_RUNNER_VERSION/swagger-codegen.jar $ags
-else
-  echo "Please set scalaVersion := \"$SCALA_RUNNER_VERSION\" in build.sbt and run ./sbt assembly"
-fi
+java $JAVA_OPTS -jar $executable $ags

bin/python-wordnik-api.sh

@@ -1,32 +0,0 @@
-#!/bin/sh
-
-SCRIPT="$0"
-SCALA_RUNNER_VERSION=$(scala ./bin/Version.scala)
-
-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
-
-
-# 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 -DfileMap=samples/client/wordnik-api/spec-files/resources.json"
-ags="$@ samples/client/wordnik-api/python/PythonWordnikApiCodegen.scala http://api.wordnik.com/v4/resources.json"
-
-if [ -f $APP_DIR/target/scala-$SCALA_RUNNER_VERSION/swagger-codegen.jar ]; then
-  scala -cp target/scala-$SCALA_RUNNER_VERSION/swagger-codegen.jar $ags
-else
-  echo "Please set scalaVersion := \"$SCALA_RUNNER_VERSION\" in build.sbt and run ./sbt assembly"
-fi

bin/python3-petstore.sh

@@ -1,32 +0,0 @@
-#!/bin/sh
-
-SCRIPT="$0"
-SCALA_RUNNER_VERSION=$(scala ./bin/Version.scala)
-
-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
-
-
-# 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="$@ samples/client/petstore/python3/Python3PetstoreCodegen.scala http://petstore.swagger.wordnik.com/api/api-docs special-key"
-
-if [ -f $APP_DIR/target/scala-$SCALA_RUNNER_VERSION/swagger-codegen.jar ]; then
-  scala -cp target/scala-$SCALA_RUNNER_VERSION/swagger-codegen.jar $ags
-else
-  echo "Please set scalaVersion := \"$SCALA_RUNNER_VERSION\" in build.sbt and run ./sbt assembly"
-fi

bin/python3-wordnik-api.sh

@@ -1,32 +0,0 @@
-#!/bin/sh
-
-SCRIPT="$0"
-SCALA_RUNNER_VERSION=$(scala ./bin/Version.scala)
-
-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
-
-
-# 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 -DfileMap=samples/client/wordnik-api/spec-files/resources.json"
-ags="$@ samples/client/wordnik-api/python3/Python3WordnikApiCodegen.scala http://api.wordnik.com/v4/resources.json"
-
-if [ -f $APP_DIR/target/scala-$SCALA_RUNNER_VERSION/swagger-codegen.jar ]; then
-  scala -cp target/scala-$SCALA_RUNNER_VERSION/swagger-codegen.jar $ags
-else
-  echo "Please set scalaVersion := \"$SCALA_RUNNER_VERSION\" in build.sbt and run ./sbt assembly"
-fi

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

bin/ruby-petstore.json

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

bin/ruby-petstore.sh

@@ -1,7 +1,6 @@
 #!/bin/sh
 
 SCRIPT="$0"
-SCALA_RUNNER_VERSION=$(scala ./bin/Version.scala)
 
 while [ -h "$SCRIPT" ] ; do
   ls=`ls -ld "$SCRIPT"`
@@ -18,15 +17,15 @@ if [ ! -d "${APP_DIR}" ]; then
   APP_DIR=`cd "${APP_DIR}"; pwd`
 fi
 
-cd $APP_DIR
+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="$@ samples/client/petstore/ruby/RubyPetstoreCodegen.scala http://petstore.swagger.wordnik.com/api/api-docs 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"
 
-if [ -f $APP_DIR/target/scala-$SCALA_RUNNER_VERSION/swagger-codegen.jar ]; then
-  scala -cp target/scala-$SCALA_RUNNER_VERSION/swagger-codegen.jar $ags
-else
-  echo "Please set scalaVersion := \"$SCALA_RUNNER_VERSION\" in build.sbt and run ./sbt assembly"
-fi
+java $JAVA_OPTS -jar $executable $ags

bin/runscala.sh

@@ -1,32 +0,0 @@
-#!/bin/sh
-
-SCRIPT="$0"
-SCALA_RUNNER_VERSION=$(scala ./bin/Version.scala)
-
-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
-
-
-# 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="$@"
-
-if [ -f $APP_DIR/target/scala-$SCALA_RUNNER_VERSION/swagger-codegen.jar ]; then
-  scala -cp target/scala-$SCALA_RUNNER_VERSION/swagger-codegen.jar $ags
-else
-  echo "Please set scalaVersion := \"$SCALA_RUNNER_VERSION\" in build.sbt and run ./sbt assembly"
-fi

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

bin/scala-async.sh

@@ -1,31 +0,0 @@
-#!/bin/sh
-
-SCRIPT="$0"
-SCALA_RUNNER_VERSION=$(scala ./bin/Version.scala)
-
-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
-
-
-# if you've executed sbt assembly previously it will use that instead.
-ags="com.wordnik.swagger.codegen.ScalaAsyncClientGenerator $@"
-
-if [ -f $APP_DIR/target/scala-$SCALA_RUNNER_VERSION/swagger-codegen.jar ]; then
-  scala -cp target/scala-$SCALA_RUNNER_VERSION/swagger-codegen.jar $ags
-else
-  echo "Please set scalaVersion := \"$SCALA_RUNNER_VERSION\" in build.sbt and run ./sbt assembly"
-fi

bin/scala-petstore.sh

@@ -1,7 +1,6 @@
 #!/bin/sh
 
 SCRIPT="$0"
-SCALA_RUNNER_VERSION=$(scala ./bin/Version.scala)
 
 while [ -h "$SCRIPT" ] ; do
   ls=`ls -ld "$SCRIPT"`
@@ -18,15 +17,15 @@ if [ ! -d "${APP_DIR}" ]; then
   APP_DIR=`cd "${APP_DIR}"; pwd`
 fi
 
-cd $APP_DIR
+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="$@ samples/client/petstore/scala/ScalaPetstoreCodegen.scala http://petstore.swagger.wordnik.com/api/api-docs 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"
 
-if [ -f $APP_DIR/target/scala-$SCALA_RUNNER_VERSION/swagger-codegen.jar ]; then
-  scala -cp target/scala-$SCALA_RUNNER_VERSION/swagger-codegen.jar $ags
-else
-  echo "Please set scalaVersion := \"$SCALA_RUNNER_VERSION\" in build.sbt and run ./sbt assembly"
-fi
+java $JAVA_OPTS -jar $executable $ags

bin/scala-wordnik-api.sh

@@ -1,7 +1,6 @@
 #!/bin/sh
 
 SCRIPT="$0"
-SCALA_RUNNER_VERSION=$(scala ./bin/Version.scala)
 
 while [ -h "$SCRIPT" ] ; do
   ls=`ls -ld "$SCRIPT"`
@@ -18,15 +17,15 @@ if [ ! -d "${APP_DIR}" ]; then
   APP_DIR=`cd "${APP_DIR}"; pwd`
 fi
 
-cd $APP_DIR
+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 -DfileMap=samples/client/wordnik-api/spec-files/resources.json"
-ags="$@ samples/client/wordnik-api/scala/ScalaWordnikApiCodegen.scala http://api.wordnik.com/v4/resources.json"
+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"
 
-if [ -f $APP_DIR/target/scala-$SCALA_RUNNER_VERSION/swagger-codegen.jar ]; then
-  scala -cp target/scala-$SCALA_RUNNER_VERSION/swagger-codegen.jar $ags
-else
-  echo "Please set scalaVersion := \"$SCALA_RUNNER_VERSION\" in build.sbt and run ./sbt assembly"
-fi
+java $JAVA_OPTS -jar $executable $ags

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

bin/silex-petstore-server.sh

@@ -0,0 +1,31 @@
+#!/bin/sh
+
+SCRIPT="$0"
+
+while [ -h "$SCRIPT" ] ; do
+  ls=`ls -ld "$SCRIPT"`
+  link=`expr "$ls" : '.*-> \(.*\)$'`
+  if expr "$link" : '/.*' > /dev/null; then
+    SCRIPT="$link"
+  else
+    SCRIPT=`dirname "$SCRIPT"`/"$link"
+  fi
+done
+
+if [ ! -d "${APP_DIR}" ]; then
+  APP_DIR=`dirname "$SCRIPT"`/..
+  APP_DIR=`cd "${APP_DIR}"; pwd`
+fi
+
+executable="./modules/swagger-codegen-cli/target/swagger-codegen-cli.jar"
+
+if [ ! -f "$executable" ]
+then
+  mvn clean package
+fi
+
+# if you've executed sbt assembly previously it will use that instead.
+export JAVA_OPTS="${JAVA_OPTS} -XX:MaxPermSize=256M -Xmx1024M -DloggerPath=conf/log4j.properties"
+ags="$@ generate -t modules/swagger-codegen/src/main/resources/silex -i modules/swagger-codegen/src/test/resources/2_0/petstore.json -l silex -o samples/server/petstore/silex"
+
+java $JAVA_OPTS -jar $executable $ags

bin/sinatra-petstore-server.sh

@@ -0,0 +1,31 @@
+#!/bin/sh
+
+SCRIPT="$0"
+
+while [ -h "$SCRIPT" ] ; do
+  ls=`ls -ld "$SCRIPT"`
+  link=`expr "$ls" : '.*-> \(.*\)$'`
+  if expr "$link" : '/.*' > /dev/null; then
+    SCRIPT="$link"
+  else
+    SCRIPT=`dirname "$SCRIPT"`/"$link"
+  fi
+done
+
+if [ ! -d "${APP_DIR}" ]; then
+  APP_DIR=`dirname "$SCRIPT"`/..
+  APP_DIR=`cd "${APP_DIR}"; pwd`
+fi
+
+executable="./modules/swagger-codegen-cli/target/swagger-codegen-cli.jar"
+
+if [ ! -f "$executable" ]
+then
+  mvn clean package
+fi
+
+# if you've executed sbt assembly previously it will use that instead.
+export JAVA_OPTS="${JAVA_OPTS} -XX:MaxPermSize=256M -Xmx1024M -DloggerPath=conf/log4j.properties"
+ags="$@ generate -t modules/swagger-codegen/src/main/resources/sinatra -i modules/swagger-codegen/src/test/resources/2_0/petstore.json -l sinatra -o samples/server/petstore/sinatra"
+
+java $JAVA_OPTS -jar $executable $ags

bin/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

bin/static-docs.sh

@@ -1,32 +0,0 @@
-#!/bin/sh
-
-SCRIPT="$0"
-SCALA_RUNNER_VERSION=$(scala ./bin/Version.scala)
-
-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
-
-
-# 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 -DfileMap=samples/client/wordnik-api/spec-files"
-ags="$@ SwaggerDocGenerator http://developer.wordnik.com/v4/resources.json"
-
-if [ -f $APP_DIR/target/scala-$SCALA_RUNNER_VERSION/swagger-codegen.jar ]; then
-  scala -cp target/scala-$SCALA_RUNNER_VERSION/swagger-codegen.jar $ags
-else
-  echo "Please set scalaVersion := \"$SCALA_RUNNER_VERSION\" in build.sbt and run ./sbt assembly"
-fi

bin/swift-petstore.json

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

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

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

bin/typescript-angular-petstore.sh

@@ -0,0 +1,31 @@
+#!/bin/sh
+
+SCRIPT="$0"
+
+while [ -h "$SCRIPT" ] ; do
+  ls=`ls -ld "$SCRIPT"`
+  link=`expr "$ls" : '.*-> \(.*\)$'`
+  if expr "$link" : '/.*' > /dev/null; then
+    SCRIPT="$link"
+  else
+    SCRIPT=`dirname "$SCRIPT"`/"$link"
+  fi
+done
+
+if [ ! -d "${APP_DIR}" ]; then
+  APP_DIR=`dirname "$SCRIPT"`/..
+  APP_DIR=`cd "${APP_DIR}"; pwd`
+fi
+
+executable="./modules/swagger-codegen-cli/target/swagger-codegen-cli.jar"
+
+if [ ! -f "$executable" ]
+then
+  mvn clean package
+fi
+
+# if you've executed sbt assembly previously it will use that instead.
+export JAVA_OPTS="${JAVA_OPTS} -XX:MaxPermSize=256M -Xmx1024M -DloggerPath=conf/log4j.properties"
+ags="$@ generate -i modules/swagger-codegen/src/test/resources/2_0/petstore.json -l typescript-angular -o samples/client/petstore/typescript-angular"
+
+java $JAVA_OPTS -jar $executable $ags

bin/typescript-node-petstore.sh

@@ -0,0 +1,31 @@
+#!/bin/sh
+
+SCRIPT="$0"
+
+while [ -h "$SCRIPT" ] ; do
+  ls=`ls -ld "$SCRIPT"`
+  link=`expr "$ls" : '.*-> \(.*\)$'`
+  if expr "$link" : '/.*' > /dev/null; then
+    SCRIPT="$link"
+  else
+    SCRIPT=`dirname "$SCRIPT"`/"$link"
+  fi
+done
+
+if [ ! -d "${APP_DIR}" ]; then
+  APP_DIR=`dirname "$SCRIPT"`/..
+  APP_DIR=`cd "${APP_DIR}"; pwd`
+fi
+
+executable="./modules/swagger-codegen-cli/target/swagger-codegen-cli.jar"
+
+if [ ! -f "$executable" ]
+then
+  mvn clean package
+fi
+
+# if you've executed sbt assembly previously it will use that instead.
+export JAVA_OPTS="${JAVA_OPTS} -XX:MaxPermSize=256M -Xmx1024M -DloggerPath=conf/log4j.properties"
+ags="$@ generate -i modules/swagger-codegen/src/test/resources/2_0/petstore.json -l typescript-node -o samples/client/petstore/typescript-node"
+
+java $JAVA_OPTS -jar $executable $ags

bin/update-spec.sh

@@ -1,31 +0,0 @@
-#!/bin/sh
-
-SCRIPT="$0"
-SCALA_RUNNER_VERSION=$(scala ./bin/Version.scala)
-
-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
-
-
-# if you've executed sbt assembly previously it will use that instead.
-ags="com.wordnik.swagger.codegen.SpecConverter $@"
-
-if [ -f $APP_DIR/target/scala-$SCALA_RUNNER_VERSION/swagger-codegen.jar ]; then
-  scala -cp target/scala-$SCALA_RUNNER_VERSION/swagger-codegen.jar $ags
-else
-  echo "Please set scalaVersion := \"$SCALA_RUNNER_VERSION\" in build.sbt and run ./sbt assembly"
-fi

bin/validate.sh

@@ -1,31 +0,0 @@
-#!/bin/sh
-
-SCRIPT="$0"
-SCALA_RUNNER_VERSION=$(scala ./bin/Version.scala)
-
-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
-
-
-# if you've executed sbt assembly previously it will use that instead.
-ags="com.wordnik.swagger.codegen.spec.Validator $@"
-
-if [ -f $APP_DIR/target/scala-$SCALA_RUNNER_VERSION/swagger-codegen.jar ]; then
-  scala -cp target/scala-$SCALA_RUNNER_VERSION/swagger-codegen.jar $ags
-else
-  echo "Please set scalaVersion := \"$SCALA_RUNNER_VERSION\" in build.sbt and run ./sbt assembly"
-fi

bin/yml2swagger.js

@@ -1,56 +0,0 @@
-fs = require('fs')
-yaml = require('js-yaml')
-
-var args = process.argv.splice(2);
-
-if(args.length == 0) {
-  process.exit(1);
-}
-
-var arg0 = args[0];
-var outputdir = ".";
-
-if(args.length > 1) {
-  outputdir = args[1];
-}
-
-var file = fs.lstatSync(arg0);
-
-if(file.isFile()) {
-  convert(arg0, outputdir);
-}
-else if (file.isDirectory()) {
-  var files = fs.readdirSync(arg0);
-  files.map(function(item) {
-    var filename = arg0 + "/" + item;
-    var file = fs.lstatSync(filename);
-    if(file.isFile()) {
-      convert(filename, outputdir);
-    }
-  });
-}
-
-function convert(filename, outputdir) {
-  console.log("converting " + filename);
-  fs.readFile(filename, "utf8", function (err, data) {
-    if(err) {
-      console.log(err);
-    }
-    else {
-      try {
-        var js = yaml.load(data);
-        var prettyJs = JSON.stringify(js, undefined, 2);
-        var outputFilename = outputdir + "/" + filename.split("/").pop().replace(".yml", "") + ".json";
-        console.log("writing to " + outputFilename);
-        fs.writeFile(outputFilename, prettyJs, function(err) {
-          if(err) {
-              console.log(err);
-          }
-        });
-      }
-      catch (err) {
-        console.log(err);
-      }
-    }
-  });
-}

build.sbt

@@ -1,133 +0,0 @@
-import xml.Group
-import AssemblyKeys._
-
-organization := "com.wordnik"
-
-name := "swagger-codegen"
-
-version := "2.0.13"
-
-scalaVersion := "2.10.1"
-
-crossVersion := CrossVersion.full
-
-javacOptions ++= Seq("-target", "1.6", "-source", "1.6", "-Xlint:unchecked", "-Xlint:deprecation")
-
-scalacOptions ++= Seq("-optimize", "-unchecked", "-deprecation", "-Xcheckinit", "-encoding", "utf8")
-
-crossScalaVersions := Seq("2.9.0", "2.9.0-1", "2.9.1", "2.9.1-1", "2.9.2", "2.9.3", "2.10.0", "2.10.1", "2.10.2")
-
-libraryDependencies ++= Seq(
-  "org.json4s"                  %% "json4s-jackson"     % "3.2.5",
-  "io.backchat.inflector"       %% "scala-inflector"    % "1.3.5",
-  "commons-io"                   % "commons-io"         % "2.3",
-  "ch.qos.logback"               % "logback-classic"    % "1.0.13" % "provided",
-  "org.rogach"                  %% "scallop"            % "0.8.1",
-  "junit"                        % "junit"              % "4.11" % "test",
-  "org.scalatest"               %% "scalatest"          % "1.9.1" % "test"
-)
-
-libraryDependencies <+= scalaVersion {
-  case v if v.startsWith("2.9") => 
-    "org.fusesource.scalate" % "scalate-core_2.9" % "1.6.1"
-  case v if v.startsWith("2.10") => { 
-    "org.fusesource.scalate" %% "scalate-core" % "1.6.1"
-  }
-}
-
-libraryDependencies ++= {
-  scalaVersion.toString match {
-    case v if v.startsWith("2.10") => Seq("org.scala-lang" % "scala-reflect" % v)
-    case _ => Seq()
-  }
-}
-
-packageOptions <+= (name, version, organization) map {
-  (title, version, vendor) =>
-    Package.ManifestAttributes(
-      "Created-By" -> "Simple Build Tool",
-      "Built-By" -> System.getProperty("user.name"),
-      "Build-Jdk" -> System.getProperty("java.version"),
-      "Specification-Title" -> title,
-      "Specification-Version" -> version,
-      "Specification-Vendor" -> vendor,
-      "Implementation-Title" -> title,
-      "Implementation-Version" -> version,
-      "Implementation-Vendor-Id" -> vendor,
-      "Implementation-Vendor" -> vendor
-    )
-}
-
-publishTo <<= (version) { version: String =>
-  if (version.trim.endsWith("SNAPSHOT"))
-    Some("Sonatype Nexus Snapshots" at "https://oss.sonatype.org/content/repositories/snapshots")
-  else
-    Some("Sonatype Nexus Releases" at "https://oss.sonatype.org/service/local/staging/deploy/maven2")
-}
-
-//publishTo := Some(Resolver.file("file",  new File(Path.userHome.absolutePath+"/.m2/repository")))
-
-artifact in (Compile, assembly) ~= { art =>
-  art.copy(`classifier` = Some("assembly"))
-}
-
-addArtifact(artifact in (Compile, assembly), assembly)
-
-publishMavenStyle := true
-
-publishArtifact in Test := false
-
-pomIncludeRepository := { x => false }
-
-credentials += Credentials(Path.userHome / ".ivy2" / ".credentials")
-
-homepage := Some(new URL("https://github.com/wordnik/swagger-codegen"))
-
-parallelExecution in Test := false
-
-startYear := Some(2009)
-
-licenses := Seq(("Apache License 2.0", new URL("http://www.apache.org/licenses/LICENSE-2.0.html")))
-
-pomExtra <<= (pomExtra, name, description) {(pom, name, desc) => pom ++ Group(
-  <scm>
-    <connection>scm:git:git@github.com:wordnik/swagger-codegen.git</connection>
-    <developerConnection>scm:git:git@github.com:wordnik/swagger-codegen.git</developerConnection>
-    <url>https://github.com/wordnik/swagger-codegen</url>
-  </scm>
-  <issueManagement>
-    <system>github</system>
-    <url>https://github.com/wordnik/swagger-codegen/issues</url>
-  </issueManagement>
-  <developers>
-    <developer>
-      <id>rpidikiti</id>
-      <name>Ramesh Pidikiti</name>
-      <email>ramesh@wordnik.com</email>
-    </developer>
-    <developer>
-      <id>ayush</id>
-      <name>Ayush Gupta</name>
-      <email>ayush@glugbot.com</email>
-    </developer>
-    <developer>
-      <id>fehguy</id>
-      <name>Tony Tam</name>
-      <email>fehguy@gmail.com</email>
-    </developer>
-    <developer>
-      <id>casualjim</id>
-      <name>Ivan Porto Carrero</name>
-      <url>http://flanders.co.nz/</url>
-    </developer>
-    <developer>
-      <id>radius314</id>
-      <name>Danny Gershman</name>
-      <email>danny.gershman@gmail.com</email>
-    </developer>
-  </developers>
-)}
-
-assemblySettings
-
-jarName in assembly := "swagger-codegen.jar"

distro/pom.xml.disabled

@@ -1,124 +0,0 @@
-<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
-  <modelVersion>4.0.0</modelVersion>
-  <parent>
-    <groupId>org.sonatype.oss</groupId>
-    <artifactId>oss-parent</artifactId>
-    <version>5</version>
-  </parent>
-  <groupId>com.wordnik</groupId>
-  <artifactId>swagger-codegen-distribution</artifactId>
-  <packaging>jar</packaging>
-  <version>2.0.2-SNAPSHOT</version>
-  <name>swagger-codegen-distribution</name>
-  <url>https://github.com/wordnik/swagger-codegen</url>
-  <scm>
-    <connection>scm:git:git@github.com:wordnik/swagger-codegen.git</connection>
-    <developerConnection>scm:git:git@github.com:wordnik/swagger-codegen.git</developerConnection>
-    <url>https://github.com/wordnik/swagger-codegen</url>
-  </scm>
-  <prerequisites>
-    <maven>2.2.0</maven>
-  </prerequisites>
-  <developers>
-    <developer>
-      <id>fehguy</id>
-      <name>Tony Tam</name>
-      <email>fehguy@gmail.com</email>
-    </developer>
-  </developers>
-  <issueManagement>
-    <system>github</system>
-    <url>https://github.com/wordnik/swagger-codegen/issues</url>
-  </issueManagement>
-  <mailingLists>
-    <mailingList>
-      <name>wordnik-api</name>
-      <archive>https://groups.google.com/forum/#!forum/wordnik-api</archive>
-    </mailingList>
-  </mailingLists>
-  <licenses>
-    <license>
-      <name>Apache License 2.0</name>
-      <url>http://www.apache.org/licenses/LICENSE-2.0.html</url>
-      <distribution>repo</distribution>
-    </license>
-  </licenses>
-  <build>
-    <plugins>
-      <plugin>
-        <artifactId>maven-dependency-plugin</artifactId>
-        <executions>
-          <execution>
-            <phase>package</phase>
-            <goals>
-              <goal>copy-dependencies</goal>
-            </goals>
-            <configuration>
-              <outputDirectory>${project.build.directory}/lib</outputDirectory>
-            </configuration>
-          </execution>
-        </executions>
-      </plugin>
-      <plugin>
-        <artifactId>maven-failsafe-plugin</artifactId>
-        <version>2.6</version>
-        <executions>
-          <execution>
-            <goals>
-              <goal>integration-test</goal>
-              <goal>verify</goal>
-            </goals>
-          </execution>
-        </executions>
-      </plugin>
-      <plugin>
-        <executions>
-          <execution>
-            <id>distro-assembly</id>
-            <phase>package</phase>
-            <goals>
-              <goal>single</goal>
-            </goals>
-          </execution>
-        </executions>
-        <artifactId>maven-assembly-plugin</artifactId>
-        <version>2.3</version>
-        <configuration>
-          <descriptors>
-            <descriptor>src/main/assembly/distribution.xml</descriptor>
-          </descriptors>
-        </configuration>
-      </plugin>
-      <plugin>
-        <groupId>org.apache.maven.plugins</groupId>
-        <artifactId>maven-dependency-plugin</artifactId>
-        <version>2.4</version>
-        <executions>
-          <execution>
-            <id>src-dependencies</id>
-            <phase>package</phase>
-            <goals>
-              <goal>unpack-dependencies</goal>
-            </goals>
-            <configuration>
-              <includeGroupIds>com.wordnik</includeGroupIds>
-              <includeArtifactIds>text-data</includeArtifactIds>
-              <outputDirectory>${project.build.directory}</outputDirectory>
-            </configuration>
-          </execution>
-        </executions>
-      </plugin>
-    </plugins>
-  </build>
-  <dependencies>
-    <dependency>
-      <groupId>com.wordnik</groupId>
-      <artifactId>swagger-codegen_2.9.1</artifactId>
-      <version>${swagger.codegen.version}</version>
-      <scope>compile</scope>
-    </dependency>
-  </dependencies>
-  <properties>
-    <swagger.codegen.version>2.0.2-SNAPSHOT</swagger.codegen.version>
-  </properties>
-</project>

distro/src/main/assembly/distribution.xml

@@ -1,29 +0,0 @@
-<assembly
-  xmlns="http://maven.apache.org/plugins/maven-assembly-plugin/assembly/1.1.2"
-  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-  xsi:schemaLocation="http://maven.apache.org/plugins/maven-assembly-plugin/assembly/1.1.2 http://maven.apache.org/xsd/assembly-1.1.2.xsd">
-  <id>distribution</id>
-  <baseDirectory>swagger-codegen</baseDirectory>
-  <includeBaseDirectory>false</includeBaseDirectory>
-  <formats>
-    <format>zip</format>
-  </formats>
-  <dependencySets>
-    <dependencySet>
-      <scope>compile</scope>
-      <outputDirectory>target/lib</outputDirectory>
-      <includes>
-        <include>*:jar:*</include>
-      </includes>
-    </dependencySet>
-  </dependencySets>
-  <fileSets>
-    <fileSet>
-      <directory>../bin</directory>
-      <includes>
-        <include>*.*</include>
-      </includes>
-      <outputDirectory>bin</outputDirectory>
-    </fileSet>
-  </fileSets>
-</assembly>

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.4</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>

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")
+                .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();
+    }
+}

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.getDescription().replaceAll("\n", "\n\t    "));
+            System.out.println();
+        }
+    }
+}

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;
+    }
+}

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);
+    }
+}

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

@@ -0,0 +1,147 @@
+package io.swagger.codegen.cmd;
+
+import ch.lambdaj.function.convert.Converter;
+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.apache.commons.lang3.StringUtils;
+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 = StringUtils.capitalize(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")
+        );
+
+        Map<String, Object> data = new ImmutableMap.Builder<String, Object>()
+                .put("generatorPackage", targetPackage)
+                .put("generatorClass", mainClass)
+                .put("name", name)
+                .put("fullyQualifiedGeneratorClass", targetPackage + "." + mainClass).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() {
+            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);
+    }
+}

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

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

modules/swagger-codegen-cli/src/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>

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

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

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

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

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

@@ -0,0 +1,55 @@
+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>${project.version}</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` - swagger 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)
+
+### Java-specific parameters (under configOptions)
+
+- `sourceFolder` - the folder to use for generated sources under the output folder
+- `groupId` - groupId in generated pom.xml
+- `artifactId` - artifactId in generated pom.xml
+- `artifactVersion` - artifact version in generated pom.xml

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

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

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

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

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

@@ -0,0 +1,195 @@
+package io.swagger.codegen.plugin;
+
+/*
+ * Copyright 2001-2005 The Apache Software Foundation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import io.swagger.codegen.CliOption;
+import io.swagger.codegen.ClientOptInput;
+import io.swagger.codegen.ClientOpts;
+import io.swagger.codegen.CodegenConfig;
+import io.swagger.codegen.CodegenConfigLoader;
+import io.swagger.codegen.DefaultGenerator;
+import io.swagger.models.Swagger;
+import io.swagger.parser.SwaggerParser;
+
+import org.apache.maven.plugin.AbstractMojo;
+import org.apache.maven.plugin.MojoExecutionException;
+import org.apache.maven.plugins.annotations.LifecyclePhase;
+import org.apache.maven.plugins.annotations.Mojo;
+import org.apache.maven.plugins.annotations.Parameter;
+import org.apache.maven.project.MavenProject;
+
+import config.Config;
+import config.ConfigParser;
+
+import java.io.File;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.ServiceLoader;
+
+import static io.swagger.codegen.plugin.AdditionalParams.API_PACKAGE_PARAM;
+import static io.swagger.codegen.plugin.AdditionalParams.INVOKER_PACKAGE_PARAM;
+import static io.swagger.codegen.plugin.AdditionalParams.MODEL_PACKAGE_PARAM;
+import static io.swagger.codegen.plugin.AdditionalParams.TEMPLATE_DIR_PARAM;
+
+/**
+ * Goal which generates client/server code from a swagger json/yaml definition.
+ */
+@Mojo(name = "generate", defaultPhase = LifecyclePhase.GENERATE_SOURCES)
+public class CodeGenMojo extends AbstractMojo {
+    /**
+     * Location of the output directory.
+     */
+    @Parameter(name = "output",
+            property = "swagger.codegen.maven.plugin.output",
+            defaultValue = "${project.build.directory}/generated-sources/swagger")
+    private File output;
+
+    /**
+     * Location of the swagger spec, as URL or file.
+     */
+    @Parameter(name = "inputSpec", required = true)
+    private String inputSpec;
+
+    /**
+     * Folder containing the template files.
+     */
+    @Parameter(name = "templateDirectory")
+    private File templateDirectory;
+
+    /**
+     * The package to use for generated model objects/classes
+     */
+    @Parameter(name = "modelPackage")
+    private String modelPackage;
+
+    /**
+     * The package to use for generated api objects/classes
+     */
+    @Parameter(name = "apiPackage")
+    private String apiPackage;
+
+    /**
+     * The package to use for the generated invoker objects
+     */
+    @Parameter(name = "invokerPackage")
+    private String invokerPackage;
+
+    /**
+     * Client language to generate.
+     */
+    @Parameter(name = "language", required = true)
+    private String language;
+
+    /**
+     * Path to separate json configuration file.
+     */
+    @Parameter(name = "configurationFile", required = false)
+    private String configurationFile;
+
+    /**
+     * A map of language-specific parameters as passed with the -c option to the command line
+     */
+    @Parameter(name = "configOptions")
+    private Map configOptions;
+
+    /**
+     * Add the output directory to the project as a source root, so that the
+     * generated java types are compiled and included in the project artifact.
+     */
+    @Parameter(defaultValue = "true")
+    private boolean addCompileSourceRoot = true;
+
+    @Parameter
+    protected Map<String, String> environmentVariables = new HashMap<String, String>();
+
+    /**
+     * The project being built.
+     */
+    @Parameter(readonly = true, required = true, defaultValue = "${project}")
+    private MavenProject project;
+
+    @Override
+    public void execute() throws MojoExecutionException {
+        Swagger swagger = new SwaggerParser().read(inputSpec);
+
+        CodegenConfig config = CodegenConfigLoader.forName(language);
+        config.setOutputDir(output.getAbsolutePath());
+
+        if (environmentVariables != null) {
+            for(String key : environmentVariables.keySet()) {
+                String value = environmentVariables.get(key);
+                if(value == null) {
+                    // don't put null values
+                    value = "";
+                }
+                System.setProperty(key, value);
+            }
+        }
+
+        if (null != templateDirectory) {
+            config.additionalProperties().put(TEMPLATE_DIR_PARAM, templateDirectory.getAbsolutePath());
+        }
+        if (null != modelPackage) {
+            config.additionalProperties().put(MODEL_PACKAGE_PARAM, modelPackage);
+        }
+        if (null != apiPackage) {
+            config.additionalProperties().put(API_PACKAGE_PARAM, apiPackage);
+        }
+        if (null != invokerPackage) {
+            config.additionalProperties().put(INVOKER_PACKAGE_PARAM, invokerPackage);
+        }
+
+        if (configOptions != null) {
+            for (CliOption langCliOption : config.cliOptions()) {
+                if (configOptions.containsKey(langCliOption.getOpt())) {
+                    config.additionalProperties().put(langCliOption.getOpt(),
+                            configOptions.get(langCliOption.getOpt()));
+                }
+            }
+        }
+
+        if (null != configurationFile) {
+            Config genConfig = ConfigParser.read(configurationFile);
+            if (null != genConfig) {
+                for (CliOption langCliOption : config.cliOptions()) {
+                    if (genConfig.hasOption(langCliOption.getOpt())) {
+                        config.additionalProperties().put(langCliOption.getOpt(), genConfig.getOption(langCliOption.getOpt()));
+                    }
+                }
+            } else {
+            	throw new RuntimeException("Unable to read configuration file");
+            }
+        }
+        
+        ClientOptInput input = new ClientOptInput().opts(new ClientOpts()).swagger(swagger);
+        input.setConfig(config);
+        
+        try {
+            new DefaultGenerator().opts(input).generate();
+        } catch (Exception e) {
+            // Maven logs exceptions thrown by plugins only if invoked with -e
+        	// I find it annoying to jump through hoops to get basic diagnostic information,
+        	// so let's log it in any case:
+            getLog().error(e); 
+            throw new MojoExecutionException("Code generation failed. See above for the full exception.");
+        }
+
+        if (addCompileSourceRoot) {
+            project.addCompileSourceRoot(output.toString());
+        }
+    }
+}

modules/swagger-codegen/pom.xml

@@ -0,0 +1,271 @@
+<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.4</version>
+        <relativePath>../..</relativePath>
+    </parent>
+    <modelVersion>4.0.0</modelVersion>
+    <artifactId>swagger-codegen</artifactId>
+    <packaging>jar</packaging>
+    <name>swagger-codegen (core library)</name>
+    <build>
+        <sourceDirectory>src/main/java</sourceDirectory>
+        <defaultGoal>install</defaultGoal>
+        <resources>
+            <resource>
+                <directory>src/main/resources</directory>
+                <excludes>
+                    <exclude>logback.xml</exclude>
+                </excludes>
+            </resource>
+        </resources>
+        <extensions>
+            <extension>
+                <groupId>org.jvnet.wagon-svn</groupId>
+                <artifactId>wagon-svn</artifactId>
+                <version>1.8</version>
+            </extension>
+            <extension>
+                <groupId>org.apache.maven.wagon</groupId>
+                <artifactId>wagon-ssh-external</artifactId>
+                <version>1.0-alpha-6</version>
+            </extension>
+            <extension>
+                <groupId>org.apache.maven.wagon</groupId>
+                <artifactId>wagon-webdav</artifactId>
+                <version>1.0-beta-1</version>
+            </extension>
+        </extensions>
+        <directory>target</directory>
+        <finalName>${project.artifactId}-${project.version}</finalName>
+        <plugins>
+            <plugin>
+                <groupId>org.codehaus.mojo</groupId>
+                <artifactId>exec-maven-plugin</artifactId>
+                <version>1.3.2</version>
+                <executions>
+                    <execution>
+                        <goals>
+                            <goal>java</goal>
+                        </goals>
+                    </execution>
+                </executions>
+                <configuration>
+                    <mainClass>io.swagger.codegen.Codegen</mainClass>
+                </configuration>
+            </plugin>
+            <plugin>
+                <artifactId>maven-dependency-plugin</artifactId>
+                <executions>
+                    <execution>
+                        <phase>package</phase>
+                        <goals>
+                            <goal>copy-dependencies</goal>
+                        </goals>
+                        <configuration>
+                            <outputDirectory>${project.build.directory}/lib</outputDirectory>
+                        </configuration>
+                    </execution>
+                </executions>
+            </plugin>
+            <plugin>
+                <artifactId>maven-compiler-plugin</artifactId>
+                <version>3.0</version>
+                <configuration>
+                    <source>1.6</source>
+                    <target>1.6</target>
+                </configuration>
+            </plugin>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-jar-plugin</artifactId>
+                <version>2.4</version>
+                <configuration>
+                    <archive>
+                        <manifestEntries>
+                            <mode>development</mode>
+                            <url>${project.url}</url>
+                            <implementation-version>${project.version}</implementation-version>
+                            <package>io.swagger</package>
+                        </manifestEntries>
+                    </archive>
+                </configuration>
+            </plugin>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-site-plugin</artifactId>
+                <version>2.1</version>
+            </plugin>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-release-plugin</artifactId>
+                <version>2.1</version>
+            </plugin>
+        </plugins>
+    </build>
+    <profiles>
+        <profile>
+            <id>release-profile</id>
+            <properties>
+                <skipTests>true</skipTests>
+            </properties>
+        </profile>
+        <profile>
+            <id>release-sign-artifacts</id>
+            <activation>
+                <property>
+                    <name>performRelease</name>
+                    <value>true</value>
+                </property>
+            </activation>
+            <build>
+                <plugins>
+                    <plugin>
+                        <groupId>org.apache.maven.plugins</groupId>
+                        <artifactId>maven-gpg-plugin</artifactId>
+                        <executions>
+                            <execution>
+                                <id>sign-artifacts</id>
+                                <phase>verify</phase>
+                                <goals>
+                                    <goal>sign</goal>
+                                </goals>
+                            </execution>
+                        </executions>
+                    </plugin>
+                </plugins>
+            </build>
+        </profile>
+    </profiles>
+    <reporting>
+        <outputDirectory>target/site</outputDirectory>
+        <plugins>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-javadoc-plugin</artifactId>
+                <version>2.9</version>
+                <configuration>
+                    <aggregate>true</aggregate>
+                    <debug>true</debug>
+                    <links>
+                        <link>http://java.sun.com/javaee/5/docs/api</link>
+                        <link>http://java.sun.com/j2se/1.5.0/docs/api</link>
+                    </links>
+                    <excludePackageNames/>
+                </configuration>
+            </plugin>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-jxr-plugin</artifactId>
+                <version>2.3</version>
+                <configuration>
+                    <aggregate>true</aggregate>
+                </configuration>
+            </plugin>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-project-info-reports-plugin</artifactId>
+                <version>2.6</version>
+                <reportSets>
+                    <reportSet>
+                        <reports>
+                            <report>project-team</report>
+                        </reports>
+                    </reportSet>
+                </reportSets>
+            </plugin>
+        </plugins>
+    </reporting>
+    <dependencies>
+        <dependency>
+            <groupId>io.swagger</groupId>
+            <artifactId>swagger-parser</artifactId>
+            <version>${swagger-parser-version}</version>
+            <scope>compile</scope>
+        </dependency>
+        <dependency>
+            <groupId>io.swagger</groupId>
+            <artifactId>swagger-compat-spec-parser</artifactId>
+            <version>${swagger-parser-version}</version>
+        </dependency>
+        <dependency>
+            <groupId>${project.groupId}</groupId>
+            <artifactId>swagger-core</artifactId>
+            <version>${swagger-core-version}</version>
+        </dependency>
+        <dependency>
+            <groupId>com.samskivert</groupId>
+            <artifactId>jmustache</artifactId>
+            <version>${jmustache-version}</version>
+        </dependency>
+        <dependency>
+            <groupId>commons-io</groupId>
+            <artifactId>commons-io</artifactId>
+            <version>${commons-io-version}</version>
+        </dependency>
+        <dependency>
+            <groupId>org.apache.maven</groupId>
+            <artifactId>maven-plugin-tools-api</artifactId>
+            <version>2.0</version>
+        </dependency>
+        <dependency>
+            <groupId>org.apache.felix</groupId>
+            <artifactId>maven-bundle-plugin</artifactId>
+            <version>${felix-version}</version>
+        </dependency>
+        <dependency>
+            <groupId>org.slf4j</groupId>
+            <artifactId>slf4j-ext</artifactId>
+            <version>${slf4j-version}</version>
+        </dependency>
+        <dependency>
+            <groupId>org.slf4j</groupId>
+            <artifactId>slf4j-api</artifactId>
+            <version>${slf4j-version}</version>
+        </dependency>
+        <dependency>
+            <groupId>org.slf4j</groupId>
+            <artifactId>slf4j-simple</artifactId>
+            <version>${slf4j-version}</version>
+        </dependency>
+        <dependency>
+            <groupId>commons-lang</groupId>
+            <artifactId>commons-lang</artifactId>
+            <version>${commons-lang-version}</version>
+        </dependency>
+        <dependency>
+            <groupId>commons-cli</groupId>
+            <artifactId>commons-cli</artifactId>
+            <version>${commons-cli-version}</version>
+        </dependency>
+        <dependency>
+            <groupId>org.testng</groupId>
+            <artifactId>testng</artifactId>
+            <version>${testng-version}</version>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.reflections</groupId>
+            <artifactId>reflections</artifactId>
+            <version>${reflections-version}</version>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.jmockit</groupId>
+            <artifactId>jmockit</artifactId>
+            <version>${jmockit-version}</version>
+            <scope>test</scope>
+        </dependency>
+    </dependencies>
+    <repositories>
+        <repository>
+            <id>sonatype-snapshots</id>
+            <url>https://oss.sonatype.org/content/repositories/snapshots</url>
+            <snapshots>
+                <enabled>true</enabled>
+            </snapshots>
+        </repository>
+    </repositories>
+</project>

modules/swagger-codegen/src/main/java/config/Config.java

@@ -0,0 +1,34 @@
+package config;
+
+import com.google.common.collect.ImmutableMap;
+
+import java.util.HashMap;
+import java.util.Map;
+
+public class Config {
+    private Map<String, String> options;
+
+    public Config() {
+        this.options = new HashMap<String, String>();
+    }
+
+    public Config(Map<String, String> properties) {
+        this.options = properties;
+    }
+
+    public Map<String, String> getOptions() {
+        return ImmutableMap.copyOf(options);
+    }
+
+    public boolean hasOption(String opt) {
+        return options.containsKey(opt);
+    }
+
+    public String getOption(String opt) {
+        return options.get(opt);
+    }
+
+    public void setOption(String opt, String value) {
+        options.put(opt, value);
+    }
+}

modules/swagger-codegen/src/main/java/config/ConfigParser.java

@@ -0,0 +1,40 @@
+package config;
+
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.ObjectMapper;
+
+import java.io.File;
+import java.util.Iterator;
+import java.util.Map;
+
+public class ConfigParser {
+
+    public static Config read(String location) {
+
+        System.out.println("reading config from " + location);
+
+        ObjectMapper mapper = new ObjectMapper();
+
+        Config config = new Config();
+
+        try {
+            JsonNode rootNode = mapper.readTree(new File(location));
+            Iterator<Map.Entry<String, JsonNode>> optionNodes = rootNode.fields();
+
+            while (optionNodes.hasNext()) {
+                Map.Entry<String, JsonNode> optionNode = (Map.Entry<String, JsonNode>) optionNodes.next();
+
+                if (optionNode.getValue().isValueNode()) {
+                    config.setOption(optionNode.getKey(), optionNode.getValue().asText());
+                } else {
+                    System.out.println("omitting non-value node " + optionNode.getKey());
+                }
+            }
+        } catch (Exception e) {
+            System.out.println(e.getMessage());
+            return null;
+        }
+
+        return config;
+    }
+}

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

@@ -0,0 +1,90 @@
+package io.swagger.codegen;
+
+import java.io.BufferedWriter;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.io.OutputStreamWriter;
+import java.io.Reader;
+import java.io.Writer;
+import java.util.regex.Pattern;
+
+public abstract class AbstractGenerator {
+
+    public File writeToFile(String filename, String contents) throws IOException {
+        System.out.println("writing file " + filename);
+        File output = new File(filename);
+
+        if (output.getParent() != null && !new File(output.getParent()).exists()) {
+            File parent = new File(output.getParent());
+            parent.mkdirs();
+        }
+        Writer out = new BufferedWriter(new OutputStreamWriter(
+                new FileOutputStream(output), "UTF-8"));
+
+        out.write(contents);
+        out.close();
+        return output;
+    }
+
+    public String readTemplate(String name) {
+        try {
+            Reader reader = getTemplateReader(name);
+            if (reader == null) {
+                throw new RuntimeException("no file found");
+            }
+            java.util.Scanner s = new java.util.Scanner(reader).useDelimiter("\\A");
+            return s.hasNext() ? s.next() : "";
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+        throw new RuntimeException("can't load template " + name);
+    }
+
+    public Reader getTemplateReader(String name) {
+        try {
+            InputStream is = this.getClass().getClassLoader().getResourceAsStream(getCPResourcePath(name));
+            if (is == null) {
+                is = new FileInputStream(new File(name));
+            }
+            if (is == null) {
+                throw new RuntimeException("no file found");
+            }
+            return new InputStreamReader(is);
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+        throw new RuntimeException("can't load template " + name);
+    }
+
+    /**
+     * Get the template file path with template dir prepended, and use the
+     * library template if exists.
+     */
+    public String getFullTemplateFile(CodegenConfig config, String templateFile) {
+        String library = config.getLibrary();
+        if (library != null && !"".equals(library)) {
+            String libTemplateFile = config.templateDir() + File.separator +
+                "libraries" + File.separator + library + File.separator +
+                templateFile;
+            if (templateExists(libTemplateFile)) {
+                return libTemplateFile;
+            }
+        }
+        return config.templateDir() + File.separator + templateFile;
+    }
+
+    public boolean templateExists(String name) {
+        return this.getClass().getClassLoader().getResource(getCPResourcePath(name)) != null;
+    }
+
+    public String getCPResourcePath(String name) {
+        if (!"/".equals(File.separator)) {
+            return name.replaceAll(Pattern.quote(File.separator), "/");
+        }
+        return name;
+    }
+}

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

@@ -0,0 +1,23 @@
+package io.swagger.codegen;
+
+public class CliOption {
+    private final String opt;
+    private String description;
+
+    public CliOption(String opt, String description) {
+        this.opt = opt;
+        this.description = description;
+    }
+
+    public String getOpt() {
+        return opt;
+    }
+
+    public String getDescription() {
+        return description;
+    }
+
+    public void setDescription(String description) {
+        this.description = description;
+    }
+}

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

@@ -0,0 +1,81 @@
+package io.swagger.codegen;
+
+import io.swagger.annotations.ApiModelProperty;
+import io.swagger.codegen.auth.AuthParser;
+import io.swagger.models.Swagger;
+import io.swagger.models.auth.AuthorizationValue;
+
+import java.net.URLDecoder;
+import java.net.URLEncoder;
+import java.util.ArrayList;
+import java.util.List;
+
+import static org.apache.commons.lang3.StringUtils.isNotEmpty;
+
+public class ClientOptInput {
+    private CodegenConfig config;
+    private ClientOpts opts;
+    private Swagger swagger;
+    private List<AuthorizationValue> auths;
+
+    public ClientOptInput swagger(Swagger swagger) {
+        this.setSwagger(swagger);
+        return this;
+    }
+
+    public ClientOptInput opts(ClientOpts opts) {
+        this.setOpts(opts);
+        return this;
+    }
+
+    public ClientOptInput config(CodegenConfig codegenConfig) {
+        this.setConfig(codegenConfig);
+        return this;
+    }
+
+    @Deprecated
+    public ClientOptInput auth(String urlEncodedAuthString) {
+        this.setAuth(urlEncodedAuthString);
+        return this;
+    }
+
+    @Deprecated
+    public String getAuth() {
+        return AuthParser.reconstruct(auths);
+    }
+
+    @Deprecated
+    public void setAuth(String urlEncodedAuthString) {
+        this.auths = AuthParser.parse(urlEncodedAuthString);
+    }
+
+    @Deprecated
+    public List<AuthorizationValue> getAuthorizationValues() {
+        return auths;
+    }
+
+    public CodegenConfig getConfig() {
+        return config;
+    }
+
+    public void setConfig(CodegenConfig config) {
+        this.config = config;
+    }
+
+    public ClientOpts getOpts() {
+        return opts;
+    }
+
+    public void setOpts(ClientOpts opts) {
+        this.opts = opts;
+    }
+
+    @ApiModelProperty(dataType = "Object")
+    public Swagger getSwagger() {
+        return swagger;
+    }
+
+    public void setSwagger(Swagger swagger) {
+        this.swagger = swagger;
+    }
+}

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

@@ -0,0 +1,57 @@
+package io.swagger.codegen;
+
+import io.swagger.codegen.auth.AuthMethod;
+
+import java.util.HashMap;
+import java.util.Map;
+
+public class ClientOpts {
+    protected String uri;
+    protected String target;
+    protected AuthMethod auth;
+    protected Map<String, String> properties = new HashMap<String, String>();
+    protected String outputDirectory;
+
+    public String getUri() {
+        return uri;
+    }
+
+    public void setUri(String uri) {
+        this.uri = uri;
+    }
+
+    public String getTarget() {
+        return target;
+    }
+
+    public void setTarget(String target) {
+        this.target = target;
+    }
+
+    public Map<String, String> getProperties() {
+        return properties;
+    }
+
+    public void setProperties(Map<String, String> properties) {
+        this.properties = properties;
+    }
+
+    public String getOutputDirectory() {
+        return outputDirectory;
+    }
+
+    public void setOutputDirectory(String outputDirectory) {
+        this.outputDirectory = outputDirectory;
+    }
+
+    @Override
+    public String toString() {
+        StringBuilder sb = new StringBuilder();
+        sb.append("ClientOpts: {\n");
+        sb.append("  uri: ").append(uri).append(",");
+        sb.append("  auth: ").append(auth).append(",");
+        sb.append(properties);
+        sb.append("}");
+        return sb.toString();
+    }
+}

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

@@ -0,0 +1,164 @@
+package io.swagger.codegen;
+
+import config.Config;
+import config.ConfigParser;
+import io.swagger.models.Swagger;
+import io.swagger.parser.SwaggerParser;
+import org.apache.commons.cli.BasicParser;
+import org.apache.commons.cli.CommandLine;
+import org.apache.commons.cli.CommandLineParser;
+import org.apache.commons.cli.HelpFormatter;
+import org.apache.commons.cli.Options;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.ServiceLoader;
+
+/**
+ * @deprecated use instead {@link io.swagger.codegen.DefaultGenerator}
+ * or cli interface from https://github.com/swagger-api/swagger-codegen/pull/547
+ */
+@Deprecated
+public class Codegen extends DefaultGenerator {
+    static Map<String, CodegenConfig> configs = new HashMap<String, CodegenConfig>();
+    static String configString;
+    static String debugInfoOptions = "\nThe following additional debug options are available for all codegen targets:" +
+            "\n -DdebugSwagger prints the swagger specification as interpreted by the codegen" +
+            "\n -DdebugModels prints models passed to the template engine" +
+            "\n -DdebugOperations prints operations passed to the template engine" +
+            "\n -DdebugSupportingFiles prints additional data passed to the template engine";
+
+    public static void main(String[] args) {
+
+        StringBuilder sb = new StringBuilder();
+
+        Options options = new Options();
+        options.addOption("h", "help", false, "shows this message");
+        options.addOption("l", "lang", true, "client language to generate.\nAvailable languages include:\n\t[" + configString + "]");
+        options.addOption("o", "output", true, "where to write the generated files");
+        options.addOption("i", "input-spec", true, "location of the swagger spec, as URL or file");
+        options.addOption("t", "template-dir", true, "folder containing the template files");
+        options.addOption("d", "debug-info", false, "prints additional info for debugging");
+        options.addOption("a", "auth", true, "adds authorization headers when fetching the swagger definitions remotely. Pass in a URL-encoded string of name:header with a comma separating multiple values");
+        options.addOption("c", "config", true, "location of the configuration file");
+
+        ClientOptInput clientOptInput = new ClientOptInput();
+        ClientOpts clientOpts = new ClientOpts();
+        Swagger swagger = null;
+
+        CommandLine cmd = null;
+        try {
+            CommandLineParser parser = new BasicParser();
+            CodegenConfig config = null;
+
+            cmd = parser.parse(options, args);
+            if (cmd.hasOption("d")) {
+                usage(options);
+                System.out.println(debugInfoOptions);
+                return;
+            }
+            if (cmd.hasOption("a")) {
+                clientOptInput.setAuth(cmd.getOptionValue("a"));
+            }
+            if (cmd.hasOption("l")) {
+                clientOptInput.setConfig(getConfig(cmd.getOptionValue("l")));
+            } else {
+                usage(options);
+                return;
+            }
+            if (cmd.hasOption("o")) {
+                clientOptInput.getConfig().setOutputDir(cmd.getOptionValue("o"));
+            }
+            if (cmd.hasOption("h")) {
+                if (cmd.hasOption("l")) {
+                    config = getConfig(String.valueOf(cmd.getOptionValue("l")));
+                    if (config != null) {
+                        options.addOption("h", "help", true, config.getHelp());
+                        usage(options);
+                        return;
+                    }
+                }
+                usage(options);
+                return;
+            }
+            if (cmd.hasOption("i")) {
+                swagger = new SwaggerParser().read(cmd.getOptionValue("i"), clientOptInput.getAuthorizationValues(), true);
+            }
+            if (cmd.hasOption("c")) {
+                String configFile = cmd.getOptionValue("c");
+                Config genConfig = ConfigParser.read(configFile);
+                config = clientOptInput.getConfig();
+                if (null != genConfig && null != config) {
+                    for (CliOption langCliOption : config.cliOptions()) {
+                        if (genConfig.hasOption(langCliOption.getOpt())) {
+                            config.additionalProperties().put(langCliOption.getOpt(), genConfig.getOption(langCliOption.getOpt()));
+                        }
+                    }
+                }
+            }
+            if (cmd.hasOption("t")) {
+                clientOpts.getProperties().put(CodegenConstants.TEMPLATE_DIR, String.valueOf(cmd.getOptionValue("t")));
+            }
+        } catch (Exception e) {
+            usage(options);
+            return;
+        }
+        try {
+            clientOptInput
+                    .opts(clientOpts)
+                    .swagger(swagger);
+            new Codegen().opts(clientOptInput).generate();
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+
+    public static List<CodegenConfig> getExtensions() {
+        ServiceLoader<CodegenConfig> loader = ServiceLoader.load(CodegenConfig.class);
+        List<CodegenConfig> output = new ArrayList<CodegenConfig>();
+        Iterator<CodegenConfig> itr = loader.iterator();
+        while (itr.hasNext()) {
+            output.add(itr.next());
+        }
+        return output;
+    }
+
+    static void usage(Options options) {
+        HelpFormatter formatter = new HelpFormatter();
+        formatter.printHelp("Codegen", options);
+    }
+
+    public static CodegenConfig getConfig(String name) {
+        if (configs.containsKey(name)) {
+            return configs.get(name);
+        } else {
+            // see if it's a class
+            try {
+                System.out.println("loading class " + name);
+                Class customClass = Class.forName(name);
+                System.out.println("loaded");
+                return (CodegenConfig) customClass.newInstance();
+            } catch (Exception e) {
+                throw new RuntimeException("can't load class " + name);
+            }
+        }
+    }
+
+    static {
+        List<CodegenConfig> extensions = getExtensions();
+        StringBuilder sb = new StringBuilder();
+
+        for (CodegenConfig config : extensions) {
+            if (sb.toString().length() != 0) {
+                sb.append(", ");
+            }
+            sb.append(config.getName());
+            configs.put(config.getName(), config);
+            configString = sb.toString();
+        }
+    }
+}

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

@@ -0,0 +1,126 @@
+package io.swagger.codegen;
+
+import io.swagger.models.Model;
+import io.swagger.models.Operation;
+import io.swagger.models.Swagger;
+import io.swagger.models.auth.SecuritySchemeDefinition;
+import io.swagger.models.properties.Property;
+
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+public interface CodegenConfig {
+    CodegenType getTag();
+
+    String getName();
+
+    String getHelp();
+
+    Map<String, Object> additionalProperties();
+
+    String apiPackage();
+
+    String apiFileFolder();
+
+    String fileSuffix();
+
+    String outputFolder();
+
+    String templateDir();
+
+    String modelFileFolder();
+
+    String modelPackage();
+
+    String toApiName(String name);
+
+    String toApiVarName(String name);
+
+    String toModelName(String name);
+
+    String toParamName(String name);
+
+    String escapeText(String text);
+
+    String escapeReservedWord(String name);
+
+    String getTypeDeclaration(Property p);
+
+    String getTypeDeclaration(String name);
+
+    void processOpts();
+
+    List<CliOption> cliOptions();
+
+    String generateExamplePath(String path, Operation operation);
+
+    Set<String> reservedWords();
+
+    List<SupportingFile> supportingFiles();
+
+    String getOutputDir();
+
+    void setOutputDir(String dir);
+
+    CodegenModel fromModel(String name, Model model);
+
+    CodegenModel fromModel(String name, Model model, Map<String, Model> allDefinitions);
+
+    CodegenOperation fromOperation(String resourcePath, String httpMethod, Operation operation, Map<String, Model> definitions, Swagger swagger);
+    
+    CodegenOperation fromOperation(String resourcePath, String httpMethod, Operation operation, Map<String, Model> definitions);
+
+    List<CodegenSecurity> fromSecurity(Map<String, SecuritySchemeDefinition> schemes);
+
+    Set<String> defaultIncludes();
+
+    Map<String, String> typeMapping();
+
+    Map<String, String> instantiationTypes();
+
+    Map<String, String> importMapping();
+
+    Map<String, String> apiTemplateFiles();
+
+    Map<String, String> modelTemplateFiles();
+
+    Set<String> languageSpecificPrimitives();
+
+    void preprocessSwagger(Swagger swagger);
+
+    void processSwagger(Swagger swagger);
+
+    String toApiFilename(String name);
+
+    String toModelFilename(String name);
+
+    String toModelImport(String name);
+
+    String toApiImport(String name);
+
+    void addOperationToGroup(String tag, String resourcePath, Operation operation, CodegenOperation co, Map<String, List<CodegenOperation>> operations);
+
+    Map<String, Object> postProcessModels(Map<String, Object> objs);
+
+    Map<String, Object> postProcessOperations(Map<String, Object> objs);
+
+    Map<String, Object> postProcessSupportingFileData(Map<String, Object> objs);
+
+    String apiFilename(String templateName, String tag);
+
+    boolean shouldOverwrite(String filename);
+
+    boolean isSkipOverwrite();
+
+    void setSkipOverwrite(boolean skipOverwrite);
+
+    Map<String, String> supportedLibraries();
+
+    void setLibrary(String library);
+
+    /**
+     * Library template (sub-template).
+     */
+    String getLibrary();
+}

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

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

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

@@ -0,0 +1,43 @@
+package io.swagger.codegen;
+
+/**
+ * A class for storing constants that are used throughout the project.
+ */
+public class CodegenConstants {
+    public static final String API_PACKAGE = "apiPackage";
+    public static final String API_PACKAGE_DESC = "package for generated api classes";
+
+    public static final String MODEL_PACKAGE = "modelPackage";
+    public static final String MODEL_PACKAGE_DESC = "package for generated models";
+
+    public static final String TEMPLATE_DIR = "templateDir";
+
+
+    public static final String INVOKER_PACKAGE = "invokerPackage";
+    public static final String INVOKER_PACKAGE_DESC = "root package for generated code";
+
+    public static final String GROUP_ID = "groupId";
+    public static final String GROUP_ID_DESC = "groupId in generated pom.xml";
+
+    public static final String ARTIFACT_ID = "artifactId";
+    public static final String ARTIFACT_ID_DESC = "artifactId in generated pom.xml";
+
+    public static final String ARTIFACT_VERSION = "artifactVersion";
+    public static final String ARTIFACT_VERSION_DESC = "artifact version in generated pom.xml";
+
+    public static final String SOURCE_FOLDER = "sourceFolder";
+    public static final String SOURCE_FOLDER_DESC = "source folder for generated code";
+
+    public static final String LOCAL_VARIABLE_PREFIX = "localVariablePrefix";
+    public static final String LOCAL_VARIABLE_PREFIX_DESC = "prefix for generated code members and local variables";
+
+    public static final String SERIALIZABLE_MODEL = "serializableModel";
+    public static final String SERIALIZABLE_MODEL_DESC = "boolean - toggle \"implements Serializable\" for generated models";
+
+    public static final String LIBRARY = "library";
+    public static final String LIBRARY_DESC = "library template (sub-template)";
+
+    public static final String SORT_PARAMS_BY_REQUIRED_FLAG = "sortParamsByRequiredFlag";
+    public static final String SORT_PARAMS_BY_REQUIRED_FLAG_DESC = "Sort method arguments to place required parameters before optional parameters. Default: true";
+
+}

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

@@ -0,0 +1,19 @@
+package io.swagger.codegen;
+
+import io.swagger.models.ExternalDocs;
+
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+
+public class CodegenModel {
+    public String parent;
+    public String name, classname, description, classVarName, modelJson;
+    public String unescapedDescription;
+    public String defaultValue;
+    public List<CodegenProperty> vars = new ArrayList<CodegenProperty>();
+    public Set<String> imports = new HashSet<String>();
+    public Boolean hasVars, emptyVars, hasMoreModels, hasEnums;
+    public ExternalDocs externalDocs;
+}

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

@@ -0,0 +1,39 @@
+package io.swagger.codegen;
+
+import java.util.HashMap;
+import java.util.Map;
+
+public final class CodegenModelFactory {
+
+    private static final Map<CodegenModelType, Class<?>> typeMapping = new HashMap<CodegenModelType, Class<?>>();
+
+    /**
+     * Configure a different implementation class.
+     *
+     * @param type           the type that shall be replaced
+     * @param implementation the implementation class must extend the default class and must provide a public no-arg constructor
+     */
+    public static void setTypeMapping(CodegenModelType type, Class<?> implementation) {
+        if (!type.getDefaultImplementation().isAssignableFrom(implementation)) {
+            throw new IllegalArgumentException(implementation.getSimpleName() + " doesn't extend " + type.getDefaultImplementation().getSimpleName());
+        }
+        try {
+            implementation.newInstance();
+        } catch (Exception e) {
+            throw new IllegalArgumentException(e);
+        }
+        typeMapping.put(type, implementation);
+    }
+
+    @SuppressWarnings("unchecked")
+    public static <T> T newInstance(CodegenModelType type) {
+        Class<?> classType = typeMapping.get(type);
+        try {
+            return (T) (classType != null ? classType : type.getDefaultImplementation()).newInstance();
+        } catch (InstantiationException e) {
+            throw new RuntimeException(e);
+        } catch (IllegalAccessException e) {
+            throw new RuntimeException(e);
+        }
+    }
+}

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

@@ -0,0 +1,21 @@
+package io.swagger.codegen;
+
+public enum CodegenModelType {
+
+    MODEL(CodegenModel.class),
+    OPERATION(CodegenOperation.class),
+    PARAMETER(CodegenParameter.class),
+    PROPERTY(CodegenProperty.class),
+    RESPONSE(CodegenResponse.class),
+    SECURITY(CodegenSecurity.class);
+
+    private final Class<?> defaultImplementation;
+
+    private CodegenModelType(Class<?> defaultImplementation) {
+        this.defaultImplementation = defaultImplementation;
+    }
+
+    public Class<?> getDefaultImplementation() {
+        return defaultImplementation;
+    }
+}

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

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

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

@@ -0,0 +1,60 @@
+package io.swagger.codegen;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.List;
+
+public class CodegenParameter {
+    public Boolean isFormParam, isQueryParam, isPathParam, isHeaderParam,
+            isCookieParam, isBodyParam, isFile, notFile, hasMore, isContainer, 
+            secondaryParam, isBinary, isCollectionFormatMulti;
+    public String baseName, paramName, dataType, collectionFormat, description, baseType, defaultValue;
+    public String jsonSchema;
+    public boolean isEnum;
+    public List<String> _enum;
+    public Map<String, Object> allowableValues;
+    public Map<String, Object> vendorExtensions;
+
+    /**
+     * Determines whether this parameter is mandatory. If the parameter is in "path",
+     * this property is required and its value MUST be true. Otherwise, the property
+     * MAY be included and its default value is false.
+     */
+    public Boolean required;
+
+    public CodegenParameter copy() {
+        CodegenParameter output = new CodegenParameter();
+        output.isFile = this.isFile;
+        output.notFile = this.notFile;
+        output.hasMore = this.hasMore;
+        output.isContainer = this.isContainer;
+        output.secondaryParam = this.secondaryParam;
+        output.baseName = this.baseName;
+        output.paramName = this.paramName;
+        output.dataType = this.dataType;
+        output.collectionFormat = this.collectionFormat;
+        output.isCollectionFormatMulti = this.isCollectionFormatMulti;
+        output.description = this.description;
+        output.baseType = this.baseType;
+        output.isFormParam = this.isFormParam;
+        output.isQueryParam = this.isQueryParam;
+        output.isPathParam = this.isPathParam;
+        output.isHeaderParam = this.isHeaderParam;
+        output.isCookieParam = this.isCookieParam;
+        output.isBodyParam = this.isBodyParam;
+        output.required = this.required;
+        output.jsonSchema = this.jsonSchema;
+        output.defaultValue = this.defaultValue;
+        output.isEnum = this.isEnum;
+        if (this._enum != null) {
+            output._enum = new ArrayList<String>(this._enum);
+        }
+        if (this.allowableValues != null) {
+            output.allowableValues = new HashMap<String, Object>(this.allowableValues);
+        }
+        output.vendorExtensions = this.vendorExtensions;
+
+        return output;
+    }
+}

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

@@ -0,0 +1,143 @@
+package io.swagger.codegen;
+
+import java.util.List;
+import java.util.Map;
+
+public class CodegenProperty {
+    public String baseName, complexType, getter, setter, description, datatype, datatypeWithEnum,
+            name, min, max, defaultValue, baseType, containerType;
+
+    public String unescapedDescription;
+
+    /**
+     * maxLength validation for strings, see http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.2.1
+     */
+    public Integer maxLength;
+    /**
+     * minLength validation for strings, see http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.2.2
+     */
+    public Integer minLength;
+    /**
+     * pattern validation for strings, see http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.2.3
+     */
+    public String pattern;
+    /**
+     * A free-form property to include an example of an instance for this schema.
+     */
+    public String example;
+
+    public String jsonSchema;
+    public Double minimum;
+    public Double maximum;
+    public Boolean exclusiveMinimum;
+    public Boolean exclusiveMaximum;
+    public Boolean hasMore = null, required = null, secondaryParam = null;
+    public Boolean isPrimitiveType, isContainer, isNotContainer;
+    public boolean isEnum;
+    public Boolean isReadOnly = false;
+    public List<String> _enum;
+    public Map<String, Object> allowableValues;
+    public CodegenProperty items;
+
+    @Override
+    public boolean equals(Object obj) {
+        if (obj == null) {
+            return false;
+        }
+        if (getClass() != obj.getClass()) {
+            return false;
+        }
+        final CodegenProperty other = (CodegenProperty) obj;
+        if ((this.baseName == null) ? (other.baseName != null) : !this.baseName.equals(other.baseName)) {
+            return false;
+        }
+        if ((this.complexType == null) ? (other.complexType != null) : !this.complexType.equals(other.complexType)) {
+            return false;
+        }
+        if ((this.getter == null) ? (other.getter != null) : !this.getter.equals(other.getter)) {
+            return false;
+        }
+        if ((this.setter == null) ? (other.setter != null) : !this.setter.equals(other.setter)) {
+            return false;
+        }
+        if ((this.description == null) ? (other.description != null) : !this.description.equals(other.description)) {
+            return false;
+        }
+        if ((this.datatype == null) ? (other.datatype != null) : !this.datatype.equals(other.datatype)) {
+            return false;
+        }
+        if ((this.datatypeWithEnum == null) ? (other.datatypeWithEnum != null) : !this.datatypeWithEnum.equals(other.datatypeWithEnum)) {
+            return false;
+        }
+        if ((this.name == null) ? (other.name != null) : !this.name.equals(other.name)) {
+            return false;
+        }
+        if ((this.min == null) ? (other.min != null) : !this.min.equals(other.min)) {
+            return false;
+        }
+        if ((this.max == null) ? (other.max != null) : !this.max.equals(other.max)) {
+            return false;
+        }
+        if ((this.defaultValue == null) ? (other.defaultValue != null) : !this.defaultValue.equals(other.defaultValue)) {
+            return false;
+        }
+        if ((this.baseType == null) ? (other.baseType != null) : !this.baseType.equals(other.baseType)) {
+            return false;
+        }
+        if ((this.containerType == null) ? (other.containerType != null) : !this.containerType.equals(other.containerType)) {
+            return false;
+        }
+        if (this.maxLength != other.maxLength && (this.maxLength == null || !this.maxLength.equals(other.maxLength))) {
+            return false;
+        }
+        if (this.minLength != other.minLength && (this.minLength == null || !this.minLength.equals(other.minLength))) {
+            return false;
+        }
+        if ((this.pattern == null) ? (other.pattern != null) : !this.pattern.equals(other.pattern)) {
+            return false;
+        }
+        if ((this.example == null) ? (other.example != null) : !this.example.equals(other.example)) {
+            return false;
+        }
+        if ((this.jsonSchema == null) ? (other.jsonSchema != null) : !this.jsonSchema.equals(other.jsonSchema)) {
+            return false;
+        }
+        if (this.minimum != other.minimum && (this.minimum == null || !this.minimum.equals(other.minimum))) {
+            return false;
+        }
+        if (this.maximum != other.maximum && (this.maximum == null || !this.maximum.equals(other.maximum))) {
+            return false;
+        }
+        if (this.exclusiveMinimum != other.exclusiveMinimum && (this.exclusiveMinimum == null || !this.exclusiveMinimum.equals(other.exclusiveMinimum))) {
+            return false;
+        }
+        if (this.exclusiveMaximum != other.exclusiveMaximum && (this.exclusiveMaximum == null || !this.exclusiveMaximum.equals(other.exclusiveMaximum))) {
+            return false;
+        }
+        if (this.required != other.required && (this.required == null || !this.required.equals(other.required))) {
+            return false;
+        }
+        if (this.secondaryParam != other.secondaryParam && (this.secondaryParam == null || !this.secondaryParam.equals(other.secondaryParam))) {
+            return false;
+        }
+        if (this.isPrimitiveType != other.isPrimitiveType && (this.isPrimitiveType == null || !this.isPrimitiveType.equals(other.isPrimitiveType))) {
+            return false;
+        }
+        if (this.isContainer != other.isContainer && (this.isContainer == null || !this.isContainer.equals(other.isContainer))) {
+            return false;
+        }
+        if (this.isNotContainer != other.isNotContainer && (this.isNotContainer == null || !this.isNotContainer.equals(other.isNotContainer))) {
+            return false;
+        }
+        if (this.isEnum != other.isEnum) {
+            return false;
+        }
+        if (this._enum != other._enum && (this._enum == null || !this._enum.equals(other._enum))) {
+            return false;
+        }
+        if (this.allowableValues != other.allowableValues && (this.allowableValues == null || !this.allowableValues.equals(other.allowableValues))) {
+            return false;
+        }
+        return true;
+    }
+}

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

@@ -0,0 +1,25 @@
+package io.swagger.codegen;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+
+public class CodegenResponse {
+    public final List<CodegenProperty> headers = new ArrayList<CodegenProperty>();
+    public String code, message;
+    public Boolean hasMore;
+    public List<Map<String, Object>> examples;
+    public String dataType, baseType, containerType;
+    public Boolean isDefault;
+    public Boolean simpleType;
+    public Boolean primitiveType;
+    public Boolean isMapContainer;
+    public Boolean isListContainer;
+    public Boolean isBinary = Boolean.FALSE;
+    public Object schema;
+    public String jsonSchema;
+
+    public boolean isWildcard() {
+        return "0".equals(code) || "default".equals(code);
+    }
+}

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

@@ -0,0 +1,16 @@
+package io.swagger.codegen;
+
+import java.util.List;
+import java.util.Map;
+
+public class CodegenSecurity {
+    public String name;
+    public String type;
+    public Boolean hasMore, isBasic, isOAuth, isApiKey;
+    // ApiKey specific
+    public String keyParamName;
+    public Boolean isKeyInQuery, isKeyInHeader;
+    // Oauth specific
+    public String flow, authorizationUrl, tokenUrl;
+    public List<Map<String, Object>> scopes;
+}

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

@@ -0,0 +1,36 @@
+package io.swagger.codegen;
+
+import com.fasterxml.jackson.annotation.JsonCreator;
+import com.fasterxml.jackson.annotation.JsonValue;
+
+import java.util.HashMap;
+import java.util.Map;
+
+public enum CodegenType {
+    CLIENT, SERVER, DOCUMENTATION, OTHER;
+
+    private static Map<String, CodegenType> names = new HashMap<String, CodegenType>();
+
+    @JsonCreator
+    public static CodegenType forValue(String value) {
+        return names.get(value.toLowerCase());
+    }
+
+    @JsonValue
+    public String toValue() {
+        for (Map.Entry<String, CodegenType> entry : names.entrySet()) {
+            if (entry.getValue() == this) {
+                return entry.getKey();
+            }
+        }
+
+        return null; // or fail
+    }
+
+    static {
+        names.put("client", CLIENT);
+        names.put("server", SERVER);
+        names.put("documentation", DOCUMENTATION);
+        names.put("other", OTHER);
+    }
+}

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

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

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

@@ -0,0 +1,10 @@
+package io.swagger.codegen;
+
+import java.io.File;
+import java.util.List;
+
+public interface Generator {
+    Generator opts(ClientOptInput opts);
+
+    List<File> generate();
+}