sinatra-swagger-exposer 0.2.0 → 0.3.0

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

@@ -0,0 +1,165 @@
+require 'date'
+
+require_relative 'swagger-base-value-preprocessor'
+require_relative '../swagger-parameter-helper'
+require_relative '../swagger-invalid-exception'
+
+module Sinatra
+
+  module SwaggerExposer
+
+    module Processing
+
+      # Validate primitive parameters
+      class SwaggerPrimitiveValuePreprocessor < SwaggerBaseValuePreprocessor
+
+        include Sinatra::SwaggerExposer::SwaggerParameterHelper
+
+        attr_reader :type, :params
+
+        # Initialize
+        # @param name [String] the name
+        # @param required [TrueClass] if the parameter is required
+        # @param type [String] the type name
+        # @param default [Object] the default value
+        # @param params [Hash] parameters
+        def initialize(name, required, type, default, params)
+          super(name, required, default)
+          @type = type
+          @params = params
+        end
+
+        def useful?
+          super ||
+              [TYPE_NUMBER, TYPE_INTEGER, TYPE_BOOLEAN, TYPE_DATE_TIME].include?(@type) || # Must check type
+              (@params.key? PARAMS_MIN_LENGTH) || (@params.key? PARAMS_MAX_LENGTH) # Must check string
+        end
+
+        # Dispatch method
+        def validate_param_value(value)
+          case @type
+            when TYPE_NUMBER
+              return validate_param_value_number(value)
+            when TYPE_INTEGER
+              return validate_param_value_integer(value)
+            when TYPE_BOOLEAN
+              return validate_param_value_boolean(value)
+            when TYPE_DATE_TIME
+              return validate_param_value_date_time(value)
+            else
+              return validate_param_value_string(value)
+          end
+        end
+
+        # Validate a boolean parameter
+        def validate_param_value_boolean(value)
+          if (value == 'true') || value.is_a?(TrueClass)
+            return true
+          elsif (value == 'false') || value.is_a?(FalseClass)
+            return false
+          else
+            raise SwaggerInvalidException.new("Parameter [#{name}] should be an boolean but is [#{value}]")
+          end
+        end
+
+        # Validate an integer parameter
+        def validate_param_value_integer(value)
+          begin
+            f = Float(value)
+            i = Integer(value)
+            if f == i
+              i
+            else
+              raise SwaggerInvalidException.new("Parameter [#{name}] should be an integer but is [#{value}]")
+            end
+            value = Integer(value)
+            validate_numerical_value(value)
+            value
+          rescue ArgumentError
+            raise SwaggerInvalidException.new("Parameter [#{name}] should be an integer but is [#{value}]")
+          rescue TypeError
+            raise SwaggerInvalidException.new("Parameter [#{name}] should be an integer but is [#{value}]")
+          end
+        end
+
+        # Validate a number parameter
+        def validate_param_value_number(value)
+          begin
+            value = Float(value)
+            validate_numerical_value(value)
+            return value
+          rescue ArgumentError
+            raise SwaggerInvalidException.new("Parameter [#{name}] should be a float but is [#{value}]")
+          rescue TypeError
+            raise SwaggerInvalidException.new("Parameter [#{name}] should be a float but is [#{value}]")
+          end
+        end
+
+        # Validate a numerical value
+        # @param value [Numeric] the value
+        def validate_numerical_value(value)
+          validate_numerical_value_internal(
+              value,
+              PARAMS_MINIMUM,
+              PARAMS_EXCLUSIVE_MINIMUM,
+              '>=',
+              '>')
+          validate_numerical_value_internal(
+              value,
+              PARAMS_MAXIMUM,
+              PARAMS_EXCLUSIVE_MAXIMUM,
+              '<=',
+              '<')
+        end
+
+        # Validate a date time parameter
+        def validate_param_value_date_time(value)
+          begin
+            DateTime.rfc3339(value)
+          rescue ArgumentError
+            raise SwaggerInvalidException.new("Parameter [#{name}] should be a date time but is [#{value}]")
+          end
+        end
+
+        # Validate a string parameter
+        def validate_param_value_string(value)
+          if value
+            validate_param_value_string_length(value, PARAMS_MIN_LENGTH, '>=')
+            validate_param_value_string_length(value, PARAMS_MAX_LENGTH, '<=')
+          end
+          value
+        end
+
+        # Validate the length of a string parameter
+        # @param value the value to check
+        # @param limit_param_name [Symbol] the param that contain the value to compare to
+        # @param limit_param_method [String] the comparison method to call
+        def validate_param_value_string_length(value, limit_param_name, limit_param_method)
+          if @params.key? limit_param_name
+            target_value = @params[limit_param_name]
+            unless value.length.send(limit_param_method, target_value)
+              raise SwaggerInvalidException.new("Parameter [#{name}] length should be #{limit_param_method} than #{target_value} but is #{value.length} for [#{value}]")
+            end
+          end
+        end
+
+        # Validate the value of a number
+        # @param value the value to check
+        # @param limit_param_name [Symbol] the param that contain the value to compare to
+        # @param exclusive_limit_param_name [Symbol] the param that indicates if the comparison is absolute
+        # @param limit_param_method [String] the comparison method to call
+        # @param exclusive_limit_param_method [String] the absolute comparison method to call
+        def validate_numerical_value_internal(value, limit_param_name, exclusive_limit_param_name, limit_param_method, exclusive_limit_param_method)
+          if @params.key? limit_param_name
+            target_value = @params[limit_param_name]
+            method_to_call = @params[exclusive_limit_param_name] ? exclusive_limit_param_method : limit_param_method
+            unless value.send(method_to_call, target_value)
+              raise SwaggerInvalidException.new("Parameter [#{name}] should be #{method_to_call} than [#{target_value}] but is [#{value}]")
+            end
+          end
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,64 @@
+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

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

@@ -0,0 +1,37 @@
+require_relative 'swagger-base-value-preprocessor'
+
+module Sinatra
+
+  module SwaggerExposer
+
+    module Processing
+
+      # A preprocessor for a type parameter
+      class SwaggerTypeValuePreprocessor < SwaggerBaseValuePreprocessor
+
+        attr_reader :attributes_preprocessors
+
+        # Initialize
+        # @param name [String] the name
+        # @param required [TrueClass] if the parameter is required
+        # @param attributes_preprocessors [Array[Sinatra::SwaggerExposer::Processing::SwaggerBaseValuePreprocessor]] the attributes preprocessors
+        def initialize(name, required, attributes_preprocessors)
+          super(name, required)
+          @attributes_preprocessors = attributes_preprocessors
+        end
+
+        def useful?
+          super || (!(@attributes_preprocessors.empty?))
+        end
+
+        def validate_param_value(value)
+          @attributes_preprocessors.each do |attribute_preprocessor|
+            attribute_preprocessor.process(value)
+          end
+          value
+        end
+
+      end
+    end
+  end
+end

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

@@ -25,8 +25,9 @@ module Sinatra
           result[:info] = @swagger_info.to_swagger
         end
 
-        unless @swagger_types.empty?
-          result[:definitions] = hash_to_swagger(@swagger_types)
+        swagger_types_as_swagger = @swagger_types.to_swagger
+        if swagger_types_as_swagger
+          result[:definitions] = swagger_types_as_swagger
         end
 
         unless @swagger_endpoints.empty?

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

@@ -1,14 +1,14 @@
 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 'configuration/swagger-endpoint'
+require_relative 'configuration/swagger-endpoint-parameter'
+require_relative 'configuration/swagger-endpoint-response'
+require_relative 'configuration/swagger-info'
+require_relative 'configuration/swagger-types'
 require_relative 'swagger-content-creator'
+require_relative 'swagger-invalid-exception'
+require_relative 'swagger-preprocessor-creator'
 
 module Sinatra
 
@@ -20,7 +20,9 @@ module Sinatra
       app.set :swagger_current_endpoint_info, {}
       app.set :swagger_current_endpoint_parameters, {}
       app.set :swagger_current_endpoint_responses, {}
-      app.set :swagger_types, {}
+      swagger_types = Sinatra::SwaggerExposer::Configuration::SwaggerTypes.new
+      app.set :swagger_types, swagger_types
+      app.set :swagger_preprocessor_creator, Sinatra::SwaggerExposer::SwaggerPreprocessorCreator.new(swagger_types)
       declare_swagger_endpoints(app)
     end
 
@@ -28,7 +30,7 @@ module Sinatra
       app.endpoint_summary 'The swagger endpoint'
       app.endpoint_tags 'swagger'
       app.get '/swagger_doc.json' do
-        swagger_content = ::Sinatra::SwaggerExposer::SwaggerContentCreator.new(
+        swagger_content = Sinatra::SwaggerExposer::SwaggerContentCreator.new(
             settings.respond_to?(:swagger_info) ? settings.swagger_info : nil,
             settings.swagger_types,
             settings.swagger_endpoints
@@ -73,14 +75,14 @@ module Sinatra
     def endpoint_parameter(name, description, how_to_pass, required, type, params = {})
       parameters = settings.swagger_current_endpoint_parameters
       check_if_not_duplicate(name, parameters, 'Parameter')
-      parameters[name] = SwaggerEndpointParameter.new(
+      parameters[name] = Sinatra::SwaggerExposer::Configuration::SwaggerEndpointParameter.new(
           name,
           description,
           how_to_pass,
           required,
           type,
           params,
-          settings.swagger_types.keys)
+          settings.swagger_types.types_names)
     end
 
     # Define fluent endpoint dispatcher
@@ -114,23 +116,19 @@ module Sinatra
 
     # General information
     def general_info(params)
-      set :swagger_info, SwaggerInfo.new(params)
+      set :swagger_info, Sinatra::SwaggerExposer::Configuration::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)
+      settings.swagger_types.add_type(name, params)
     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)
+      responses[code] = Sinatra::SwaggerExposer::Configuration::SwaggerEndpointResponse.new(type, description, settings.swagger_types.types_names)
     end
 
     def route(verb, path, options = {}, &block)
@@ -152,7 +150,7 @@ module Sinatra
       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 = SwaggerEndpoint.new(
+      endpoint = Sinatra::SwaggerExposer::Configuration::SwaggerEndpoint.new(
           type,
           path,
           current_endpoint_parameters.values,
@@ -166,7 +164,7 @@ module Sinatra
       current_endpoint_info.clear
       current_endpoint_parameters.clear
       current_endpoint_responses.clear
-      endpoint.request_preprocessor
+      settings.swagger_preprocessor_creator.create_endpoint_processor(endpoint)
     end
 
     def set_if_not_exist(value, name)

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

@@ -22,6 +22,7 @@ module Sinatra
       TYPE_NUMBER = 'number'
       TYPE_PASSWORD = 'password'
       TYPE_STRING = 'string'
+      TYPE_ARRAY = 'array'
 
       PRIMITIVE_TYPES = [
           TYPE_INTEGER,
@@ -66,7 +67,6 @@ module Sinatra
           PARAMS_MAX_LENGTH,
       ]
 
-
     end
 
   end

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

@@ -0,0 +1,137 @@
+require_relative 'swagger-utilities'
+require_relative 'processing/swagger-array-value-preprocessor'
+require_relative 'processing/swagger-preprocessor-dispatcher'
+require_relative 'processing/swagger-primitive-value-preprocessor'
+require_relative 'processing/swagger-request-preprocessor'
+require_relative 'processing/swagger-type-value-preprocessor'
+
+module Sinatra
+
+  module SwaggerExposer
+
+    # Create processor from configuration
+    class SwaggerPreprocessorCreator
+
+      include Sinatra::SwaggerExposer::SwaggerUtilities
+
+      # 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::SwaggerRequestPreprocessor]
+      def create_endpoint_processor(swagger_endpoint)
+        request_preprocessor = Sinatra::SwaggerExposer::Processing::SwaggerRequestPreprocessor.new
+        swagger_endpoint.parameters.each do |parameter|
+          preprocessor = create_value_preprocessor(parameter)
+          dispatcher = Sinatra::SwaggerExposer::Processing::SwaggerPreprocessorDispatcher.new(parameter.how_to_pass, preprocessor)
+          if dispatcher.useful?
+            request_preprocessor.add_dispatcher(dispatcher)
+          end
+        end
+        request_preprocessor
+      end
+
+      private
+
+      # Create a parameter preprocessor for a parameter
+      # @param parameter [Sinatra::SwaggerExposer::Configuration::SwaggerEndpointParameter]
+      def create_value_preprocessor(parameter)
+        type_name = parameter.type
+        if type_name == TYPE_ARRAY
+          if PRIMITIVE_TYPES.include? parameter.items
+            preprocessor_for_values = Sinatra::SwaggerExposer::Processing::SwaggerPrimitiveValuePreprocessor.new(
+                parameter.name,
+                false,
+                parameter.items,
+                parameter.default,
+                parameter.params
+            )
+          else
+            preprocessor_for_values = create_preprocessor_for_type(parameter.name, parameter.items, false)
+          end
+          Sinatra::SwaggerExposer::Processing::SwaggerArrayValuePreprocessor.new(parameter.name, parameter.required, preprocessor_for_values)
+        elsif PRIMITIVE_TYPES.include? type_name
+          Sinatra::SwaggerExposer::Processing::SwaggerPrimitiveValuePreprocessor.new(
+              parameter.name,
+              parameter.required,
+              type_name,
+              parameter.default,
+              parameter.params
+          )
+        else
+          create_preprocessor_for_type(parameter.name, parameter.type, parameter.required)
+        end
+      end
+
+      # Create a type parameter preprocessor 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::SwaggerTypeValuePreprocessor]
+      def create_preprocessor_for_type(parameter_name, parameter_type, parameter_required)
+        attributes_preprocessors = create_attributes_preprocessors_for_type(parameter_type)
+        Sinatra::SwaggerExposer::Processing::SwaggerTypeValuePreprocessor.new(
+            parameter_name,
+            parameter_required,
+            attributes_preprocessors
+        )
+      end
+
+      # Get attributes preprocessor for a type
+      # @param type_name [String] the type name
+      # @return [Array[Sinatra::SwaggerExposer::Processing::SwaggerPrimitiveValuePreprocessor]]
+      def create_attributes_preprocessors_for_type(type_name)
+        type = @types[type_name]
+        attributes_preprocessors = []
+        type.properties.each_pair do |property_name, property|
+          attributes_preprocessors <<
+              create_preprocessor_for_property(
+                  property_name,
+                  property,
+                  type.required.include?(property.name)
+              )
+        end
+        if type.extends
+          attributes_preprocessors = attributes_preprocessors + create_attributes_preprocessors_for_type(type.extends)
+        end
+        attributes_preprocessors
+      end
+
+      # Create a processor for a type property
+      # @param type_property [Sinatra::SwaggerExposer::Configuration::SwaggerTypeProperty]
+      def create_preprocessor_for_property(name, type_property, required)
+        property_type = type_property.type
+        if property_type == TYPE_ARRAY
+          if PRIMITIVE_TYPES.include? type_property.items
+            preprocessor_for_values = Sinatra::SwaggerExposer::Processing::SwaggerPrimitiveValuePreprocessor.new(
+                name,
+                false,
+                type_property.items,
+                type_property.properties[:default],
+                type_property.properties
+            )
+          else
+            preprocessor_for_values = create_preprocessor_for_type(name, type_property.items, false)
+          end
+          Sinatra::SwaggerExposer::Processing::SwaggerArrayValuePreprocessor.new(name, required, preprocessor_for_values)
+        elsif PRIMITIVE_TYPES.include? property_type
+          Sinatra::SwaggerExposer::Processing::SwaggerPrimitiveValuePreprocessor.new(
+              name,
+              required,
+              property_type,
+              type_property.properties[:default],
+              type_property.properties
+          )
+        else
+          create_preprocessor_for_type(name, property_type, required)
+        end
+      end
+
+    end
+
+  end
+end