sinatra-swagger-exposer 0.3.0 → 0.4.0

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

@@ -25,16 +25,16 @@ module Sinatra
       TYPE_ARRAY = 'array'
 
       PRIMITIVE_TYPES = [
-          TYPE_INTEGER,
-          TYPE_LONG,
-          TYPE_FLOAT,
-          TYPE_DOUBLE,
-          TYPE_STRING,
-          TYPE_BYTE,
-          TYPE_BOOLEAN,
-          TYPE_DATE,
-          TYPE_DATE_TIME,
-          TYPE_PASSWORD,
+        TYPE_INTEGER,
+        TYPE_LONG,
+        TYPE_FLOAT,
+        TYPE_DOUBLE,
+        TYPE_STRING,
+        TYPE_BYTE,
+        TYPE_BOOLEAN,
+        TYPE_DATE,
+        TYPE_DATE_TIME,
+        TYPE_PASSWORD,
       ]
 
       TYPE_FILE = 'file'
@@ -56,15 +56,15 @@ module Sinatra
       PARAMS_MAX_LENGTH = :maxLength
 
       PARAMS_LIST = [
-          PARAMS_FORMAT,
-          PARAMS_DEFAULT,
-          PARAMS_EXAMPLE,
-          PARAMS_MINIMUM,
-          PARAMS_MAXIMUM,
-          PARAMS_EXCLUSIVE_MINIMUM,
-          PARAMS_EXCLUSIVE_MAXIMUM,
-          PARAMS_MIN_LENGTH,
-          PARAMS_MAX_LENGTH,
+        PARAMS_FORMAT,
+        PARAMS_DEFAULT,
+        PARAMS_EXAMPLE,
+        PARAMS_MINIMUM,
+        PARAMS_MAXIMUM,
+        PARAMS_EXCLUSIVE_MINIMUM,
+        PARAMS_EXCLUSIVE_MAXIMUM,
+        PARAMS_MIN_LENGTH,
+        PARAMS_MAX_LENGTH,
       ]
 
     end

data/lib/sinatra/swagger-exposer/swagger-request-processor-creator.rb

@@ -0,0 +1,180 @@
+require_relative 'swagger-parameter-helper'
+
+require_relative 'processing/swagger-array-value-processor'
+require_relative 'processing/swagger-processor-dispatcher'
+require_relative 'processing/swagger-primitive-value-processor'
+require_relative 'processing/swagger-request-processor'
+require_relative 'processing/swagger-response-processor'
+require_relative 'processing/swagger-type-value-processor'
+
+module Sinatra
+
+  module SwaggerExposer
+
+    # Create processor from configuration
+    class SwaggerProcessorCreator
+
+      include Sinatra::SwaggerExposer::SwaggerParameterHelper
+
+      # Initialize
+      # @param types [Sinatra::SwaggerExposer::SwaggerTypes]
+      def initialize(types)
+        @types = types
+      end
+
+      # Create an endpoint processor
+      # @param swagger_endpoint [Sinatra::SwaggerExposer::Configuration::SwaggerEndpoint] the endpoint
+      # @return [Sinatra::SwaggerExposer::Processing::SwaggerRequestProcessor]
+      def create_request_processor(swagger_endpoint)
+        request_processor = Sinatra::SwaggerExposer::Processing::SwaggerRequestProcessor.new(swagger_endpoint.produces)
+
+        swagger_endpoint.parameters.each do |parameter|
+          processor = create_parameter_value_processor(parameter)
+          dispatcher = Sinatra::SwaggerExposer::Processing::SwaggerProcessorDispatcher.new(
+            parameter.how_to_pass,
+            processor
+          )
+          if dispatcher.useful?
+            request_processor.add_dispatcher(dispatcher)
+          end
+        end
+
+        swagger_endpoint.responses.each_pair do |code, endpoint_response|
+          response_value_processor = create_response_value_processor(endpoint_response)
+          response_processor = Sinatra::SwaggerExposer::Processing::SwaggerResponseProcessor.new(
+            endpoint_response,
+            response_value_processor
+          )
+          request_processor.add_response_processor(
+            code,
+            response_processor.useful? ? response_processor : nil
+          )
+        end
+
+        request_processor
+      end
+
+      private
+
+      # Create a response processor
+      # @param endpoint_response [Sinatra::SwaggerExposer::Configuration::SwaggerEndpointResponse]
+      # @return [Sinatra::SwaggerExposer::Processing::SwaggerTypeValueProcessor]
+      def create_response_value_processor(endpoint_response)
+        response_type = endpoint_response.type
+        if response_type == TYPE_ARRAY
+          processor_for_values = create_processor_for_type('Response', endpoint_response.items, false)
+          Sinatra::SwaggerExposer::Processing::SwaggerArrayValueProcessor.new('Response', true, processor_for_values)
+        elsif response_type == TYPE_FILE
+          # Don't validate the files' content
+          nil
+        elsif response_type
+          create_processor_for_type('Response', response_type, false)
+        else
+          nil
+        end
+      end
+
+      # Create a parameter processor for a parameter
+      # @param parameter [Sinatra::SwaggerExposer::Configuration::SwaggerEndpointParameter]
+      # @return [Sinatra::SwaggerExposer::Processing::SwaggerTypeValueProcessor]
+      def create_parameter_value_processor(parameter)
+        type_name = parameter.type
+        if type_name == TYPE_ARRAY
+          if PRIMITIVE_TYPES.include? parameter.items
+            processor_for_values = Sinatra::SwaggerExposer::Processing::SwaggerPrimitiveValueProcessor.new(
+              parameter.name,
+              false,
+              parameter.items,
+              parameter.default,
+              parameter.params
+            )
+          else
+            processor_for_values = create_processor_for_type(parameter.name, parameter.items, false)
+          end
+          Sinatra::SwaggerExposer::Processing::SwaggerArrayValueProcessor.new(
+            parameter.name,
+            parameter.required,
+            processor_for_values
+          )
+        elsif PRIMITIVE_TYPES.include? type_name
+          Sinatra::SwaggerExposer::Processing::SwaggerPrimitiveValueProcessor.new(
+            parameter.name,
+            parameter.required,
+            type_name,
+            parameter.default,
+            parameter.params
+          )
+        else
+          create_processor_for_type(parameter.name, parameter.type, parameter.required)
+        end
+      end
+
+      # Create a type parameter processor for a type parameter
+      # @param parameter_name [String] the parameter name
+      # @param parameter_type [String] the parameter type
+      # @param parameter_required [TrueClass] if the parameter is required
+      # @return [Sinatra::SwaggerExposer::Processing::SwaggerTypeValueProcessor]
+      def create_processor_for_type(parameter_name, parameter_type, parameter_required)
+        attributes_processors = create_attributes_processors_for_type(parameter_type)
+        Sinatra::SwaggerExposer::Processing::SwaggerTypeValueProcessor.new(
+          parameter_name,
+          parameter_required,
+          attributes_processors
+        )
+      end
+
+      # Get attributes processor for a type
+      # @param type_name [String] the type name
+      # @return [Array<Sinatra::SwaggerExposer::Processing::SwaggerBaseValueProcessor>]
+      def create_attributes_processors_for_type(type_name)
+        type = @types[type_name]
+        attributes_processors = []
+        type.properties.each_pair do |property_name, property|
+          attributes_processors <<
+            create_processor_for_property(
+              property_name,
+              property,
+              type.required.include?(property.name)
+            )
+        end
+        if type.extends
+          attributes_processors = attributes_processors + create_attributes_processors_for_type(type.extends)
+        end
+        attributes_processors
+      end
+
+      # Create a processor for a type property
+      # @param type_property [Sinatra::SwaggerExposer::Configuration::SwaggerTypeProperty]
+      # @return [Sinatra::SwaggerExposer::Processing::SwaggerBaseValueProcessor]
+      def create_processor_for_property(name, type_property, required)
+        property_type = type_property.type
+        if property_type == TYPE_ARRAY
+          if PRIMITIVE_TYPES.include? type_property.items
+            processor_for_values = Sinatra::SwaggerExposer::Processing::SwaggerPrimitiveValueProcessor.new(
+              name,
+              false,
+              type_property.items,
+              type_property.properties[:default],
+              type_property.properties
+            )
+          else
+            processor_for_values = create_processor_for_type(name, type_property.items, false)
+          end
+          Sinatra::SwaggerExposer::Processing::SwaggerArrayValueProcessor.new(name, required, processor_for_values)
+        elsif PRIMITIVE_TYPES.include? property_type
+          Sinatra::SwaggerExposer::Processing::SwaggerPrimitiveValueProcessor.new(
+            name,
+            required,
+            property_type,
+            type_property.properties[:default],
+            type_property.properties
+          )
+        else
+          create_processor_for_type(name, property_type, required)
+        end
+      end
+
+    end
+
+  end
+end

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

@@ -1,5 +1,5 @@
 module Sinatra
   module SwaggerExposer
-    VERSION = '0.3.0'
+    VERSION = '0.4.0'
   end
 end

data/sinatra-swagger-exposer.gemspec

@@ -6,19 +6,20 @@ require 'sinatra/swagger-exposer/version'
 excluded_patterns = ['test/', 'example/', '.travis.yml', '.gitignore']
 
 Gem::Specification.new do |spec|
-  spec.name          = 'sinatra-swagger-exposer'
-  spec.version       = Sinatra::SwaggerExposer::VERSION
-  spec.authors       = ['Julien Kirch']
+  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 to expose your API as a Swagger endpoint and to validate and enrich the invocation parameters}
-  spec.homepage      = 'https://github.com/archiloque/sinatra-swagger-exposer'
-  spec.license       = 'MIT'
+  spec.summary = %q{Expose swagger API from your Sinatra app}
+  spec.description = %q{This Sinatra extension enable you to add metadata to your code to expose your API as a Swagger endpoint and to validate and enrich the invocation parameters}
+  spec.homepage = 'https://github.com/archiloque/sinatra-swagger-exposer'
+  spec.license = 'MIT'
 
-  spec.files         = `git ls-files -z`.split("\x0").reject { |f| excluded_patterns.any?{|ep| f.start_with?(ep)}}
+  spec.files = `git ls-files -z`.split("\x0").reject { |f| excluded_patterns.any? { |ep| f.start_with?(ep) } }
   spec.require_paths = ['lib']
 
   spec.add_dependency 'sinatra', '~> 1.4'
+  spec.add_dependency 'mime-types', '~> 2.6.2'
 
   spec.add_development_dependency 'bundler'
   spec.add_development_dependency 'rake', '~> 10.0'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sinatra-swagger-exposer
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.0
 platform: ruby
 authors:
 - Julien Kirch
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-07-29 00:00:00.000000000 Z
+date: 2016-03-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sinatra
@@ -24,6 +24,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.4'
+- !ruby/object:Gem::Dependency
+  name: mime-types
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.6.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.6.2
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -107,27 +121,31 @@ files:
 - LICENSE.txt
 - README.md
 - Rakefile
+- lib/sinatra/swagger-exposer/configuration/swagger-configuration-utilities.rb
 - lib/sinatra/swagger-exposer/configuration/swagger-endpoint-parameter.rb
 - lib/sinatra/swagger-exposer/configuration/swagger-endpoint-response.rb
 - lib/sinatra/swagger-exposer/configuration/swagger-endpoint.rb
+- lib/sinatra/swagger-exposer/configuration/swagger-hash-like.rb
 - lib/sinatra/swagger-exposer/configuration/swagger-info.rb
 - lib/sinatra/swagger-exposer/configuration/swagger-parameter-validation-helper.rb
+- lib/sinatra/swagger-exposer/configuration/swagger-response-header.rb
+- lib/sinatra/swagger-exposer/configuration/swagger-response-headers.rb
 - lib/sinatra/swagger-exposer/configuration/swagger-type-property.rb
 - lib/sinatra/swagger-exposer/configuration/swagger-type.rb
 - lib/sinatra/swagger-exposer/configuration/swagger-types.rb
-- lib/sinatra/swagger-exposer/processing/swagger-array-value-preprocessor.rb
-- lib/sinatra/swagger-exposer/processing/swagger-base-value-preprocessor.rb
-- lib/sinatra/swagger-exposer/processing/swagger-parameter-preprocessor.rb
-- lib/sinatra/swagger-exposer/processing/swagger-preprocessor-dispatcher.rb
-- lib/sinatra/swagger-exposer/processing/swagger-primitive-value-preprocessor.rb
-- lib/sinatra/swagger-exposer/processing/swagger-request-preprocessor.rb
-- lib/sinatra/swagger-exposer/processing/swagger-type-value-preprocessor.rb
+- lib/sinatra/swagger-exposer/processing/swagger-array-value-processor.rb
+- lib/sinatra/swagger-exposer/processing/swagger-base-value-processor.rb
+- lib/sinatra/swagger-exposer/processing/swagger-parameter-processor.rb
+- lib/sinatra/swagger-exposer/processing/swagger-primitive-value-processor.rb
+- lib/sinatra/swagger-exposer/processing/swagger-processor-dispatcher.rb
+- lib/sinatra/swagger-exposer/processing/swagger-request-processor.rb
+- lib/sinatra/swagger-exposer/processing/swagger-response-processor.rb
+- lib/sinatra/swagger-exposer/processing/swagger-type-value-processor.rb
 - lib/sinatra/swagger-exposer/swagger-content-creator.rb
 - lib/sinatra/swagger-exposer/swagger-exposer.rb
 - lib/sinatra/swagger-exposer/swagger-invalid-exception.rb
 - lib/sinatra/swagger-exposer/swagger-parameter-helper.rb
-- lib/sinatra/swagger-exposer/swagger-preprocessor-creator.rb
-- lib/sinatra/swagger-exposer/swagger-utilities.rb
+- lib/sinatra/swagger-exposer/swagger-request-processor-creator.rb
 - lib/sinatra/swagger-exposer/version.rb
 - sinatra-swagger-exposer.gemspec
 homepage: https://github.com/archiloque/sinatra-swagger-exposer

data/lib/sinatra/swagger-exposer/processing/swagger-array-value-preprocessor.rb

@@ -1,46 +0,0 @@
-require_relative '../swagger-parameter-helper'
-require_relative '../swagger-invalid-exception'
-require_relative 'swagger-base-value-preprocessor'
-
-module Sinatra
-
-  module SwaggerExposer
-
-    module Processing
-
-      # Validate arrays parameters
-      class SwaggerArrayValuePreprocessor < SwaggerBaseValuePreprocessor
-
-        include Sinatra::SwaggerExposer::SwaggerParameterHelper
-
-        attr_reader :preprocessor_for_values
-
-        # Initialize
-        # @param name [String] the name
-        # @param required [TrueClass] if the parameter is required
-        # @param preprocessor_for_values [Sinatra::SwaggerExposer::Processing::SwaggerBaseValuePreprocessor] processor for the values
-        def initialize(name, required, preprocessor_for_values)
-          super(name, required)
-          @preprocessor_for_values = preprocessor_for_values
-        end
-
-        def useful?
-          true
-        end
-
-        def validate_param_value(value)
-          if value
-            if value.is_a? Array
-              value.collect { |i| @preprocessor_for_values.validate_param_value(i) }
-            else
-              raise SwaggerInvalidException.new("Parameter [#{name}] should be an array but is [#{value}]")
-            end
-          else
-            nil
-          end
-        end
-
-      end
-    end
-  end
-end

data/lib/sinatra/swagger-exposer/processing/swagger-request-preprocessor.rb

@@ -1,64 +0,0 @@
-require 'json'
-
-require_relative '../swagger-invalid-exception'
-
-module Sinatra
-
-  module SwaggerExposer
-
-    module Processing
-
-      # A preprocessor for a request, apply the parameters preprocessors then execute the query code
-      class SwaggerRequestPreprocessor
-
-        attr_reader :preprocessors_dispatchers
-
-        def initialize
-          @preprocessors_dispatchers = []
-        end
-
-        def add_dispatcher(dispatcher)
-          @preprocessors_dispatchers << dispatcher
-        end
-
-        VALID_JSON_CONTENT_TYPES = ['application/json', 'application/json; charset=utf-8']
-
-        # Run the preprocessor the call the route content
-        # @param app the sinatra app being run
-        # @params block_params [Array] the block parameters
-        # @param block the block containing the route content
-        def run(app, block_params, &block)
-          parsed_body = {}
-          if VALID_JSON_CONTENT_TYPES.include? app.env['CONTENT_TYPE']
-            body = app.request.body.read
-            unless body.empty?
-              begin
-                parsed_body = JSON.parse(body)
-              rescue JSON::ParserError => e
-                return [400, {:code => 400, :message => e.message}.to_json]
-              end
-            end
-          end
-          app.params['parsed_body'] = parsed_body
-          unless @preprocessors_dispatchers.empty?
-            @preprocessors_dispatchers.each do |preprocessor_dispatcher|
-              begin
-                preprocessor_dispatcher.process(app, parsed_body)
-              rescue SwaggerInvalidException => e
-                app.content_type :json
-                return [400, {:code => 400, :message => e.message}.to_json]
-              end
-            end
-          end
-          if block
-            # Execute the block in the context of the app
-            app.instance_exec(*block_params, &block)
-          else
-            ''
-          end
-        end
-
-      end
-    end
-  end
-end