sinatra-swagger-exposer 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: b55ef98d692d8d3d3b6d27a92b7a30657d5729bb
+  data.tar.gz: a34f58471cf590358e549b51ac348829b269b1ae
+SHA512:
+  metadata.gz: fe4a2405064efbde281a34810dc78680a3a4ba484cc281f3045ef12211cf8470baadb171db8bb6fdfd53faa11bbb178a3cd3d60a3deb21283bcac17cff3af910
+  data.tar.gz: 86f6a2d376446ed4a59e5d1049955f1cacc2eb0334895d116ab42fcdd891618863a30b5264ec81983d7ff3c453ad4e446dc9de4bb3c5bdb8cef4773c39d7eaca

data/.gitignore

@@ -0,0 +1,10 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+sinatra-swagger-exposer-*.gem

data/.travis.yml

@@ -0,0 +1,6 @@
+language: ruby
+rvm:
+  - 2.2.0
+addons:
+  code_climate:
+    repo_token: 9327b6a5a4de354ce0da555d4ae4ed262ee0fa2e4d210d8fb82511eee5a2dc2f

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,13 @@
+# Contributor Code of Conduct
+
+As contributors and maintainers of this project, we pledge to respect all people who contribute through reporting issues, posting feature requests, updating documentation, submitting pull requests or patches, and other activities.
+
+We are committed to making participation in this project a harassment-free experience for everyone, regardless of level of experience, gender, gender identity and expression, sexual orientation, disability, personal appearance, body size, race, age, or religion.
+
+Examples of unacceptable behavior by participants include the use of sexual language or imagery, derogatory comments or personal attacks, trolling, public or private harassment, insults, or other unprofessional conduct.
+
+Project maintainers have the right and responsibility to remove, edit, or reject comments, commits, code, wiki edits, issues, and other contributions that are not aligned to this Code of Conduct. Project maintainers who do not follow the Code of Conduct may be removed from the project team.
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be reported by opening an issue or contacting one or more of the project maintainers.
+
+This Code of Conduct is adapted from the [Contributor Covenant](http:contributor-covenant.org), version 1.0.0, available at [http://contributor-covenant.org/version/1/0/0/](http://contributor-covenant.org/version/1/0/0/)

data/Gemfile

@@ -0,0 +1,7 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in sinatra-swagger-exposer.gemspec
+gemspec
+
+gem 'codeclimate-test-reporter', group: :test, require: nil
+gem 'coveralls', require: false

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 Julien Kirch
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.asciidoc

@@ -0,0 +1,75 @@
+# Sinatra::SwaggerExposer
+
+image:https://codeclimate.com/github/archiloque/sinatra-swagger-exposer/badges/gpa.svg["Code status", link=https://codeclimate.com/github/archiloque/sinatra-swagger-exposer]
+image:https://travis-ci.org/archiloque/sinatra-swagger-exposer.svg?branch=master["Build Status", link="https://travis-ci.org/archiloque/sinatra-swagger-exposer"]
+image:https://coveralls.io/repos/archiloque/sinatra-swagger-exposer/badge.svg?branch=master["Coverage Status", link="https://coveralls.io/r/archiloque/sinatra-swagger-exposer?branch=master"]
+
+Create Swagger endpoint for your Sinatra application.
+
+This Sinatra extension enable you to add metadata to your code and to expose your API as a Swagger endpoint.
+
+I'm adding features as I need them and it currently doesn't use all the Swagger options, so if you need one that is missing please open an issue or contribute.
+
+## Design choices
+
+- All the declarations are validated when the server is started
+- The declarations are defined to look as ruby-ish as possible
+
+To use it in your app :
+
+[source,ruby]
+----
+require 'sinatra/swagger-exposer/swagger-exposer'
+
+class MyApp < Sinatra::Base
+
+  register Sinatra::SwaggerExposer
+
+  general_info(
+      {
+          version: '0.0.1',
+          title: 'May app',
+          description: 'My wonderful app',
+          license: {
+              name: 'MIT',
+              url: 'http://opensource.org/licenses/MIT'
+          }
+      }
+  )
+
+  type 'Status',
+               {
+                   :properties => {
+                       :status => {
+                           :type => String,
+                           :example => 'OK,
+                       },
+                   },
+                   :required => [:status]
+               }
+
+  endpoint_description 'Base method to ping'
+  endpoint_response 200, 'Standard response', 'Status'
+  endpoint_tags 'Ping'
+  get '/' do
+    json({'status' => 'OK'})
+  end
+
+end
+----
+
+The swagger json endpoint will be exposed at `/swagger_doc.json`.
+
+## Detailed example
+
+A more complete example is available link:https://github.com/archiloque/sinatra-swagger-exposer/tree/master/example[here].
+
+## Resources
+
+- link:https://github.com/swagger-api/swagger-spec/blob/master/versions/2.0.md[Swagger RESTful API Documentation Specification].
+- link:https://github.com/swagger-api/swagger-spec/tree/master/examples/v2.0/json[Swagger json examples].
+- link:https://raw.githubusercontent.com/swagger-api/swagger-spec/master/schemas/v2.0/schema.json[The swagger json schema].
+
+## License
+
+This software is released under the MIT license.

data/Rakefile

@@ -0,0 +1,9 @@
+require 'bundler/gem_tasks'
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+  t.libs << 'test'
+  t.pattern = 'test/**/test-*.rb'
+end
+
+task :default => :test

data/example/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+gem 'sinatra', '~> 1.4.5'
+gem 'sinatra-cross_origin', '~> 0.3.2'

data/example/Gemfile.lock

@@ -0,0 +1,19 @@
+GEM
+  remote: https://rubygems.org/
+  specs:
+    rack (1.6.0)
+    rack-protection (1.5.3)
+      rack
+    sinatra (1.4.6)
+      rack (~> 1.4)
+      rack-protection (~> 1.4)
+      tilt (>= 1.3, < 3)
+    sinatra-cross_origin (0.3.2)
+    tilt (2.0.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  sinatra (~> 1.4.5)
+  sinatra-cross_origin (~> 0.3.2)

data/example/config.ru

@@ -0,0 +1,2 @@
+require_relative 'petstore'
+run Petstore

data/example/petstore.rb

@@ -0,0 +1,102 @@
+require 'sinatra/base'
+require 'json'
+require 'sinatra/cross_origin'
+
+require_relative '../lib/sinatra/swagger-exposer/swagger-exposer'
+
+class Petstore < Sinatra::Base
+
+  set :logging, true
+
+  register Sinatra::CrossOrigin
+  set :allow_origin, :any
+  enable :cross_origin
+
+  register Sinatra::SwaggerExposer
+
+  general_info(
+      {
+          :version => '1.0.0',
+          :title => 'Swagger Petstore',
+          :description => 'A sample API that uses a petstore as an example to demonstrate features in the swagger-2.0 specification',
+          :termsOfService => 'http://swagger.io/terms/',
+          :contact => {:name => 'Swagger API Team',
+                       :email => 'apiteam@swagger.io',
+                       :url => 'http://swagger.io'
+          },
+          :license => {
+              :name => 'Apache 2.0',
+              :url => 'http://github.com/gruntjs/grunt/blob/master/LICENSE-MIT'
+          }
+      }
+  )
+
+  type 'Error', {
+                  :required => [:code, :message],
+                  :properties => {
+                      :code => {
+                          :type => Integer,
+                          :example => 404,
+                          :description => 'The error code',
+                      },
+                      :message => {
+                          :type => String,
+                          :example => 'Pet not found',
+                          :description => 'The error message',
+                      },
+                  },
+              }
+
+
+  type 'Pet', {
+                :required => [:id, :name],
+                :properties => {
+                    :id => {
+                        :type => Integer,
+                        :format => 'int64',
+                    },
+                    :name => {
+                        :type => String,
+                        :example => 'doggie',
+                        :description => 'The pet name',
+                    },
+                    :photoUrls => {
+                        :type => [String],
+                    },
+                    :tags => {
+                        :type => [String],
+                        :description => 'The pet\'s tags',
+                    },
+                    :status => {
+                        :type => String,
+                        :description => 'pet status in the store',
+                        :example => 'sleepy',
+                    },
+                },
+            }
+
+  endpoint_summary 'Finds all the pets'
+  endpoint_description 'Returns all pets from the system that the user has access to'
+  endpoint_tags 'Pets'
+  endpoint_response 200, ['Pet'], 'Standard response'
+  get '/pets' do
+    content_type :json
+    [].to_json
+  end
+
+  endpoint_summary 'Finds a pet by its id'
+  endpoint_description 'Finds a pet by its id, or 404 if the user does not have access to the pet'
+  endpoint_tags 'Pets'
+  endpoint_response 200, 'Pet', 'Standard response'
+  endpoint_response 404, 'Error', 'Pet not found'
+  endpoint_parameter :id, 'The pet id', :path, true, String
+                 {
+                     :example => 'AMZ',
+                 }
+  get '/pets/:id' do
+    content_type :json
+    [404, {:code => 404, :message => 'Pet not found'}]
+  end
+
+end
+

data/lib/sinatra/swagger-exposer/swagger-content-creator.rb

@@ -0,0 +1,58 @@
+require_relative 'swagger-utilities'
+
+module Sinatra
+
+  module SwaggerExposer
+
+    # Create the swagger content
+    class SwaggerContentCreator
+
+      include SwaggerUtilities
+
+      def initialize(swagger_info, swagger_types, swagger_endpoints)
+        @swagger_info = swagger_info
+        @swagger_types = swagger_types
+        @swagger_endpoints = swagger_endpoints
+      end
+
+      def to_swagger
+        result = {
+            swagger: '2.0',
+            consumes: ['application/json'],
+            produces: ['application/json'],
+        }
+        if @swagger_info
+          result[:info] = @swagger_info.to_swagger
+        end
+
+        unless @swagger_types.empty?
+          result[:definitions] = hash_to_swagger(@swagger_types)
+        end
+
+        unless @swagger_endpoints.empty?
+          result_endpoints = {}
+
+          # swagger need the endpoints to be grouped by path
+          endpoints_by_path = @swagger_endpoints.group_by { |endpoint| endpoint.path }
+          endpoints_by_path.keys.sort.each do |path|
+            endpoints = endpoints_by_path[path]
+
+            result_endpoints_for_path = {}
+            endpoints.each do |endpoint|
+              result_endpoints_for_path[endpoint.type] = endpoint.to_swagger
+            end
+
+            result_endpoints[path] = result_endpoints_for_path
+
+          end
+          result[:paths] = result_endpoints
+        end
+
+        result
+      end
+
+    end
+
+  end
+
+end

data/lib/sinatra/swagger-exposer/swagger-endpoint-parameter.rb

@@ -0,0 +1,105 @@
+require_relative 'swagger-invalid-exception'
+require_relative 'swagger-utilities'
+
+module Sinatra
+
+  module SwaggerExposer
+
+    class SwaggerEndpointParameter
+
+      include SwaggerUtilities
+
+      HOW_TO_PASS_BODY = 'body'
+      HOW_TO_PASS= ['path', 'query', 'header', 'formData'] + [HOW_TO_PASS_BODY]
+      PRIMITIVE_TYPES_FOR_NON_BODY = ['string', 'number', 'integer', 'boolean']
+
+      def initialize(name, description, how_to_pass, required, type, params, known_types)
+        unless name.is_a?(String) || name.is_a?(Symbol)
+          raise SwaggerInvalidException.new("Name [#{name}] should be a string or a symbol")
+        end
+        name = name.to_s
+        if name.empty?
+          raise SwaggerInvalidException.new('Name should not be empty')
+        end
+        @name = name
+
+        if description
+          @description = description
+        end
+
+        how_to_pass = how_to_pass.to_s
+        unless HOW_TO_PASS.include? how_to_pass
+          raise SwaggerInvalidException.new("Unknown how to pass value [#{how_to_pass}], registered types are #{HOW_TO_PASS.join(', ')}")
+        end
+        @how_to_pass = how_to_pass
+
+        if @how_to_pass == HOW_TO_PASS_BODY
+          get_type(type, PRIMITIVE_TYPES + known_types)
+        else
+          get_type(type, PRIMITIVE_TYPES_FOR_NON_BODY)
+        end
+
+        unless [true, false].include? required
+          raise SwaggerInvalidException.new("Required should be a boolean instead of [#{required}]")
+        end
+        @required = required
+
+        if params
+          white_list_params(params, [:format])
+        end
+        @params = params
+
+      end
+
+      def to_swagger
+        result = {
+            :name => @name,
+            :in => @how_to_pass,
+            :required => @required
+        }
+
+        if @type
+          if @type == 'array'
+            result[:type] = 'array'
+            if @items
+              if PRIMITIVE_TYPES.include? @items
+                result[:items] = {:type => @items}
+              else
+                result[:schema] = {'$ref' => "#/definitions/#{@items}"}
+              end
+            end
+          else
+            if PRIMITIVE_TYPES.include? @type
+              result[:type] = @type
+            else
+              result[:schema] = {'$ref' => "#/definitions/#{@type}"}
+            end
+          end
+        end
+
+        if @description
+          result[:description] = @description
+        end
+        if @params
+          result.merge!(@params)
+        end
+
+        result
+      end
+
+      def to_s
+        {
+            :name => @name,
+            :in => @how_to_pass,
+            :required => @required,
+            :type => @type,
+            :items => @items,
+            :params => @params,
+            :description => @description,
+        }.to_json
+      end
+
+    end
+
+  end
+end

data/lib/sinatra/swagger-exposer/swagger-endpoint-response.rb

@@ -0,0 +1,61 @@
+require_relative 'swagger-utilities'
+require_relative 'swagger-invalid-exception'
+
+module Sinatra
+
+  module SwaggerExposer
+
+    class SwaggerEndpointResponse
+
+      include SwaggerUtilities
+
+      def initialize(type, description, known_types)
+        get_type(type, known_types + PRIMITIVE_TYPES)
+        if description
+          @description = description
+        end
+      end
+
+      def to_swagger
+        result = {}
+
+        if @type
+          if @type == 'array'
+            schema = {:type => 'array'}
+            if @items
+              if PRIMITIVE_TYPES.include? @items
+                schema[:items] = {:type => @items}
+              else
+                schema[:items] = {'$ref' => "#/definitions/#{@items}"}
+              end
+            end
+            result[:schema] = schema
+          else
+            if PRIMITIVE_TYPES.include? @type
+              result[:schema] = {:type => @type}
+            else
+              result[:schema] = {'$ref' => "#/definitions/#{@type}"}
+            end
+          end
+        end
+
+        if @description
+          result[:description] = @description
+        end
+
+        result
+      end
+
+      def to_s
+        {
+            :type => @type,
+            :items => @items,
+            :description => @description,
+        }.to_json
+      end
+
+
+    end
+
+  end
+end

data/lib/sinatra/swagger-exposer/swagger-endpoint.rb

@@ -0,0 +1,75 @@
+require_relative 'swagger-utilities'
+
+module Sinatra
+
+  module SwaggerExposer
+
+    # An endpoint
+    class SwaggerEndpoint
+
+      include SwaggerUtilities
+
+      attr_reader :path, :type
+
+      def initialize(type, path, parameters, responses, summary, description, tags)
+        @type = type
+        @path = sinatra_path_to_swagger_path(path)
+
+        @parameters = parameters
+        @responses = responses
+
+        @attributes = {}
+        if summary
+          @attributes[:summary] = summary
+        end
+        if description
+          @attributes[:description] = description
+        end
+        if tags
+          @attributes[:tags] = tags
+        end
+      end
+
+      def to_swagger
+        result = {
+            produces: ['application/json'],
+        }.merge(@attributes)
+
+        unless @parameters.empty?
+          result[:parameters] = @parameters.collect { |parameter| parameter.to_swagger }
+        end
+
+        unless @responses.empty?
+          result[:responses] = hash_to_swagger(@responses)
+        end
+
+        result
+      end
+
+      REGEX_PATH_PARAM_MIDDLE = /\A(.*\/)\:([a-z]+)\/(.+)\z/
+      REGEX_PATH_PARAM_END = /\A(.*)\/:([a-z]+)\z/
+
+      def sinatra_path_to_swagger_path(path)
+        while (m = REGEX_PATH_PARAM_MIDDLE.match(path))
+          path = "#{m[1]}{#{m[2]}}/#{m[3]}"
+        end
+        if (m = REGEX_PATH_PARAM_END.match(path))
+          path = "#{m[1]}/{#{m[2]}}"
+        end
+        path
+      end
+
+      def to_s
+        {
+            :type => @type,
+            :path => @path,
+            :attributes => @attributes,
+            :parameters => @parameters,
+            :responses => @responses,
+        }.to_json
+      end
+
+    end
+
+  end
+end

data/lib/sinatra/swagger-exposer/swagger-exposer.rb

@@ -0,0 +1,182 @@
+require 'sinatra/base'
+require 'json'
+
+require_relative 'swagger-endpoint'
+require_relative 'swagger-endpoint-parameter'
+require_relative 'swagger-endpoint-response'
+require_relative 'swagger-info'
+require_relative 'swagger-invalid-exception'
+require_relative 'swagger-type'
+
+require_relative 'swagger-content-creator'
+
+module Sinatra
+
+  # Expose swagger API from your Sinatra app
+  module SwaggerExposer
+
+    def self.registered(app)
+      app.set :swagger_endpoints, []
+      app.set :swagger_current_endpoint_info, {}
+      app.set :swagger_current_endpoint_parameters, {}
+      app.set :swagger_current_endpoint_responses, {}
+      app.set :swagger_types, {}
+
+      # Declare the swagger endpoints
+      app.endpoint_summary 'The swagger endpoint'
+      app.endpoint_tags 'swagger'
+      app.get '/swagger_doc.json' do
+        swagger_content = ::Sinatra::SwaggerExposer::SwaggerContentCreator.new(
+            settings.respond_to?(:swagger_info) ? settings.swagger_info : nil ,
+            settings.swagger_types,
+            settings.swagger_endpoints
+        ).to_swagger
+        content_type :json
+        swagger_content.to_json
+      end
+
+      app.endpoint_summary 'Option method for the swagger endpoint, useful for some CORS stuff'
+      app.endpoint_tags 'swagger'
+      app.options '/swagger_doc.json' do
+        200
+      end
+
+    end
+
+    # Provide a summary for the endpoint
+    def endpoint_summary(summary)
+      set_if_type_and_not_exist(summary, 'summary', String)
+    end
+
+    # Provide a description for the endpoint
+    def endpoint_description(description)
+      set_if_type_and_not_exist(description, 'description', String)
+    end
+
+    # Provide tags for the endpoint
+    def endpoint_tags(*tags)
+      set_if_type_and_not_exist(tags, 'tags', nil)
+    end
+
+    # Define parameter for the endpoint
+    def endpoint_parameter(name, description, how_to_pass, required, type, params = nil)
+      parameters = settings.swagger_current_endpoint_parameters
+      check_if_not_duplicate(name, parameters, 'Parameter')
+      parameters[name] = SwaggerEndpointParameter.new(
+          name,
+          description,
+          how_to_pass,
+          required,
+          type,
+          params,
+          settings.swagger_types.keys)
+    end
+
+    # General information
+    def general_info(params)
+      set :swagger_info, SwaggerInfo.new(params)
+    end
+
+    # Declare a type
+    def type(name, params)
+      types = settings.swagger_types
+      if types.key? name
+        raise SwaggerInvalidException.new("Type [#{name}] already exist with value #{types[name]}")
+      end
+      types[name] = SwaggerType.new(name, params, settings.swagger_types.keys)
+    end
+
+    # Declare a response
+    def endpoint_response(code, type = nil, description = nil)
+      responses = settings.swagger_current_endpoint_responses
+      check_if_not_duplicate(code, responses, 'Response')
+      responses[code] = SwaggerEndpointResponse.new(type, description, settings.swagger_types.keys)
+    end
+
+    def delete(*args, &block)
+      process_endpoint('delete', args)
+      super(*args, &block)
+    end
+
+    def get(*args, &block)
+      process_endpoint('get', args)
+      super(*args, &block)
+    end
+
+    def head(*args, &block)
+      process_endpoint('head', args)
+      super(*args, &block)
+    end
+
+    def link(*args, &block)
+      process_endpoint('link', args)
+      super(*args, &block)
+    end
+
+    def options(*args, &block)
+      process_endpoint('options', args)
+      super(*args, &block)
+    end
+
+    def patch(*args, &block)
+      process_endpoint('patch', args)
+      super(*args, &block)
+    end
+
+    def post(*args, &block)
+      process_endpoint('post', args)
+      super(*args, &block)
+    end
+
+    def put(*args, &block)
+      process_endpoint('put', args)
+      super(*args, &block)
+    end
+
+    def unlink(*args, &block)
+      process_endpoint('unlink', args)
+      super(*args, &block)
+    end
+
+    private
+
+    # Call for each endpoint declaration
+    def process_endpoint(type, args)
+      current_endpoint_info = settings.swagger_current_endpoint_info
+      current_endpoint_parameters = settings.swagger_current_endpoint_parameters
+      current_endpoint_responses = settings.swagger_current_endpoint_responses
+      endpoint_path = args[0]
+      settings.swagger_endpoints << SwaggerEndpoint.new(
+          type,
+          endpoint_path,
+          current_endpoint_parameters.values,
+          current_endpoint_responses.clone,
+          current_endpoint_info[:summary],
+          current_endpoint_info[:description],
+          current_endpoint_info[:tags])
+      current_endpoint_info.clear
+      current_endpoint_parameters.clear
+      current_endpoint_responses.clear
+    end
+
+    def set_if_type_and_not_exist(value, name, type)
+      if type
+        unless value.is_a? type
+          raise SwaggerInvalidException.new("#{name} [#{value}] should be a #{type.to_s.downcase}")
+        end
+      end
+      if settings.swagger_current_endpoint_info.key? name
+        raise SwaggerInvalidException.new("#{name} with value [#{value}] already defined: #{settings.swagger_current_endpoint_info[name]}")
+      end
+      settings.swagger_current_endpoint_info[name] = value
+    end
+
+    def check_if_not_duplicate(key, values, name)
+      if values.key? key
+        raise SwaggerInvalidException.new("#{name} already exist for #{key} with value #{values[key]}")
+      end
+    end
+
+  end
+
+end

data/lib/sinatra/swagger-exposer/swagger-info.rb

@@ -0,0 +1,67 @@
+require_relative 'swagger-invalid-exception'
+
+module Sinatra
+
+  module SwaggerExposer
+
+    # The info declaration
+    class SwaggerInfo
+
+      def initialize(values)
+        @values = process(values, 'info', INFO_FIELDS, values)
+      end
+
+      # Known fields for the info field
+      INFO_FIELDS = {
+          :version => String,
+          :title => String,
+          :description => String,
+          :termsOfService => String,
+          :contact => {:name => String, :email => String, :url => String},
+          :license => {:name  => String, :url => String},
+      }
+
+      # Recursive function
+      def process(current_hash, current_field_name, current_fields, top_level_hash)
+        result = {}
+
+        current_hash.each_pair do |current_key, current_value|
+          key_sym = current_key.to_sym
+          if current_fields.key? key_sym
+
+            field_content = current_fields[key_sym]
+            if field_content == String
+              if current_value.is_a? String
+                result[key_sym] = current_value
+              else
+                raise SwaggerInvalidException.new("Property [#{current_key}] value [#{current_value}] should be a String for #{current_field_name}: #{top_level_hash}")
+              end
+            else
+              if current_value.is_a? Hash
+                sub_params = process(current_value, current_field_name, field_content, top_level_hash)
+                if sub_params
+                  result[key_sym] = sub_params
+                end
+              else
+                raise SwaggerInvalidException.new("Property [#{current_key}] value [#{current_value}] should be a Hash for #{current_field_name}: #{top_level_hash}")
+              end
+            end
+          else
+            raise SwaggerInvalidException.new("Unknown property [#{current_key}] for #{current_field_name}, possible keys are: #{current_fields.keys.join(', ')}: #{top_level_hash}")
+          end
+        end
+        result.empty? ? nil : result
+      end
+
+      def to_swagger
+        @values
+      end
+
+      def to_s
+        @values.to_json
+      end
+
+    end
+
+  end
+end

data/lib/sinatra/swagger-exposer/swagger-invalid-exception.rb

@@ -0,0 +1,16 @@
+module Sinatra
+
+  module SwaggerExposer
+
+    # When something is wrong
+    class SwaggerInvalidException < Exception
+
+      def initialize(message)
+        super(message)
+      end
+
+    end
+
+  end
+
+end

data/lib/sinatra/swagger-exposer/swagger-type-property.rb

@@ -0,0 +1,72 @@
+require_relative 'swagger-utilities'
+require_relative 'swagger-invalid-exception'
+
+module Sinatra
+
+  module SwaggerExposer
+
+    # A property of a type
+    class SwaggerTypeProperty
+
+      include SwaggerUtilities
+
+      OTHER_PROPERTIES = [:example, :description, :format]
+      PROPERTIES = [:type] + OTHER_PROPERTIES
+
+      def initialize(type_name, property_name, property_properties, known_types)
+        @name = property_name
+
+        unless property_properties.is_a? Hash
+          raise SwaggerInvalidException.new("Property [#{property_name}] value [#{property_properties}] of [#{type_name}] should be a hash")
+        end
+
+        if property_properties.key? :type
+          get_type(property_properties[:type], PRIMITIVE_TYPES + known_types)
+        end
+
+        white_list_params(property_properties, PROPERTIES)
+
+        @other_properties = property_properties.select do |key, value|
+          OTHER_PROPERTIES.include? key
+        end
+
+      end
+
+      def to_swagger
+        result = @other_properties.clone
+
+        if @type
+          if @type == 'array'
+            result[:type] = 'array'
+            if @items
+              if PRIMITIVE_TYPES.include? @items
+                result[:items] = {:type => @items}
+              else
+                result[:items] = {'$ref' => "#/definitions/#{@items}"}
+              end
+            end
+          else
+            if PRIMITIVE_TYPES.include? @type
+              result[:type] = @type
+            else
+              result['$ref'] = "#/definitions/#{@type}"
+            end
+          end
+        end
+
+        result
+      end
+
+      def to_s
+        {
+            :name => @name,
+            :type => @type,
+            :items => @items,
+            :other_properties => @other_properties,
+        }.to_json
+      end
+
+    end
+
+  end
+end

data/lib/sinatra/swagger-exposer/swagger-type.rb

@@ -0,0 +1,101 @@
+require_relative 'swagger-invalid-exception'
+require_relative 'swagger-type-property'
+require_relative 'swagger-utilities'
+
+module Sinatra
+
+  module SwaggerExposer
+
+    # A type
+    class SwaggerType
+
+      include SwaggerUtilities
+
+      def initialize(type_name, type_content, known_types)
+        @properties = process_properties(type_name, type_content, known_types)
+        @required = process_required(type_name, type_content, @properties.keys)
+        @example = process_example(type_name, type_content, @properties.keys)
+      end
+
+      def process_properties(type_name, type_content, known_types)
+        possible_value = check_attribute_empty_or_bad(type_name, type_content, :properties, Hash)
+        if possible_value
+          possible_value
+        else
+          result = {}
+          type_content[:properties].each_pair do |property_name, property_properties|
+            result[property_name.to_s] = SwaggerTypeProperty.new(type_name, property_name, property_properties, known_types)
+          end
+          result
+        end
+      end
+
+      def process_required(type_name, type_content, properties_names)
+        possible_value = check_attribute_empty_or_bad(type_name, type_content, :required, Array)
+        if possible_value
+          possible_value
+        else
+          type_content[:required].each do |property_name|
+            property_name = property_name.to_s
+            unless properties_names.include? property_name
+              raise SwaggerInvalidException.new("Required property [#{property_name}] of [#{type_name}] is unknown, known properties: #{properties_names.join(', ')}")
+            end
+          end
+          type_content[:required]
+        end
+      end
+
+      def process_example(type_name, type_content, properties_names)
+        possible_value = check_attribute_empty_or_bad(type_name, type_content, :example, Hash)
+        if possible_value
+          possible_value
+        else
+          type_content[:example].each_pair do |property_name, property_value|
+            property_name = property_name.to_s
+            unless properties_names.include? property_name
+              raise SwaggerInvalidException.new("Example property [#{property_name}] with value [#{property_value}] of [#{type_name}] is unknown, known properties: #{properties_names.join(', ')}")
+            end
+          end
+          type_content[:example]
+        end
+      end
+
+      def check_attribute_empty_or_bad(type_name, type_content, attribute_name, attribute_class)
+        if !type_content.key?(attribute_name)
+          attribute_class.new
+        elsif !type_content[attribute_name].is_a? attribute_class
+          raise SwaggerInvalidException.new("Attribute [#{attribute_name}] of #{type_name} is not an hash: #{type_content[attribute_name]}")
+        end
+      end
+
+      def to_swagger
+        result = {}
+
+        unless @properties.empty?
+          result[:properties] = hash_to_swagger(@properties)
+        end
+
+        unless @required.empty?
+          result[:required] = @required
+        end
+
+        unless @example.empty?
+          result[:example] = @example
+        end
+
+        result
+      end
+
+      def to_s
+        {
+            :properties => @properties,
+            :required => @required,
+            :example => @example,
+        }.to_json
+      end
+
+
+    end
+
+  end
+end

data/lib/sinatra/swagger-exposer/swagger-utilities.rb

@@ -0,0 +1,85 @@
+require_relative 'swagger-invalid-exception'
+
+module Sinatra
+
+  module SwaggerExposer
+
+    module SwaggerUtilities
+
+      PRIMITIVE_TYPES = [
+          'integer',
+          'long',
+          'float',
+          'double',
+          'string',
+          'byte',
+          'boolean',
+          'date',
+          'dateTime',
+          'password'
+      ]
+
+      def hash_to_swagger(hash)
+        result = {}
+        hash.each_pair do |key, value|
+          result[key] = value.to_swagger
+        end
+        result
+      end
+
+      def type_to_s(value)
+        if value.is_a? Class
+          value.to_s.downcase
+        else
+          value
+        end
+      end
+
+      def get_type(type, possible_values)
+        @type = type
+        if type.nil?
+          raise SwaggerInvalidException.new('Type is nil')
+        elsif type.is_a?(String) || @type.is_a?(Class)
+          @type = type_to_s(@type)
+          check_type(@type, possible_values)
+        elsif @type.is_a? Array
+          @items = type_to_s(get_array_type(@type))
+          check_type(@items, possible_values)
+          @type = 'array'
+        else
+          raise SwaggerInvalidException.new("Type [#{@type}] of has an unknown type, should be a class, a string or an array")
+        end
+      end
+
+      def white_list_params(params, allowed_params)
+        params.each_pair do |key, value|
+          unless allowed_params.include? key
+            raise SwaggerInvalidException.new("Unknown property [#{key}] for with value [#{value}], known properties are #{allowed_params.join(', ')}")
+          end
+        end
+      end
+
+      private
+
+      def get_array_type(array)
+        if array.empty?
+          raise SwaggerInvalidException.new('Type is an empty array, you should specify a type as the array content')
+        elsif array.length > 1
+          raise SwaggerInvalidException.new("Type [#{array}] has more than one entry, it should only have one")
+        else
+          type_to_s(array[0])
+        end
+      end
+
+      def check_type(type, possible_values)
+        unless possible_values.include? type
+          raise SwaggerInvalidException.new("Unknown type [#{type}], possible types are #{possible_values.join(', ')}")
+        end
+      end
+
+    end
+
+  end
+
+end
+

data/lib/sinatra/swagger-exposer/version.rb

@@ -0,0 +1,5 @@
+module Sinatra
+  module SwaggerExposer
+    VERSION = '0.0.1'
+  end
+end

data/sinatra-swagger-exposer.gemspec

@@ -0,0 +1,27 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'sinatra/swagger-exposer/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'sinatra-swagger-exposer'
+  spec.version       = Sinatra::SwaggerExposer::VERSION
+  spec.authors       = ['Julien Kirch']
+
+  spec.summary       = %q{Expose swagger API from your Sinatra app}
+  spec.description   = %q{This Sinatra extension enable you to add metadata to your code and to expose your API as a Swagger endpoint}
+  spec.homepage      = 'https://github.com/archiloque/sinatra-swagger-exposer'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.require_paths = ['lib']
+
+  spec.add_dependency 'sinatra', '~> 1.4'
+
+  spec.add_development_dependency 'bundler'
+  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'minitest', '~> 5.5'
+  spec.add_development_dependency 'rack-test', '~> 0.6.3'
+  spec.add_development_dependency 'simplecov'
+
+end

metadata

@@ -0,0 +1,151 @@
+--- !ruby/object:Gem::Specification
+name: sinatra-swagger-exposer
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Julien Kirch
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-04-05 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: sinatra
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.4'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.5'
+- !ruby/object:Gem::Dependency
+  name: rack-test
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.6.3
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.6.3
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: This Sinatra extension enable you to add metadata to your code and to
+  expose your API as a Swagger endpoint
+email: 
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".travis.yml"
+- CODE_OF_CONDUCT.md
+- Gemfile
+- LICENSE.txt
+- README.asciidoc
+- Rakefile
+- example/Gemfile
+- example/Gemfile.lock
+- example/config.ru
+- example/petstore.rb
+- lib/sinatra/swagger-exposer/swagger-content-creator.rb
+- lib/sinatra/swagger-exposer/swagger-endpoint-parameter.rb
+- lib/sinatra/swagger-exposer/swagger-endpoint-response.rb
+- lib/sinatra/swagger-exposer/swagger-endpoint.rb
+- lib/sinatra/swagger-exposer/swagger-exposer.rb
+- lib/sinatra/swagger-exposer/swagger-info.rb
+- lib/sinatra/swagger-exposer/swagger-invalid-exception.rb
+- lib/sinatra/swagger-exposer/swagger-type-property.rb
+- lib/sinatra/swagger-exposer/swagger-type.rb
+- lib/sinatra/swagger-exposer/swagger-utilities.rb
+- lib/sinatra/swagger-exposer/version.rb
+- sinatra-swagger-exposer.gemspec
+homepage: https://github.com/archiloque/sinatra-swagger-exposer
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.5
+signing_key: 
+specification_version: 4
+summary: Expose swagger API from your Sinatra app
+test_files: []