sinatra-swagger-exposer 0.2.0 → 0.3.0

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

@@ -1,187 +0,0 @@
-require 'date'
-
-require_relative 'swagger-endpoint-parameter'
-require_relative 'swagger-parameter-helper'
-require_relative 'swagger-invalid-exception'
-
-module Sinatra
-
-  module SwaggerExposer
-
-    # Process the parameters for validation and enrichment
-    class SwaggerParameterPreprocessor
-
-      include SwaggerParameterHelper
-
-      def initialize(name, how_to_pass, required, type, default, params)
-        @name = name.to_s
-        @how_to_pass = how_to_pass
-        @required = required
-        @type = type
-        @default = default
-        @params = params
-
-        # All headers are upcased
-        if how_to_pass == HOW_TO_PASS_HEADER
-          @name.upcase!
-        end
-      end
-
-      def useful?
-        @required ||
-            (!@default.nil?) ||
-            [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
-
-      def run(app, parsed_body)
-        case @how_to_pass
-          when HOW_TO_PASS_PATH
-            # can't validate
-          when HOW_TO_PASS_QUERY
-            check_param(app.params)
-          when HOW_TO_PASS_HEADER
-            check_param(app.headers)
-          when HOW_TO_PASS_BODY
-            check_param(parsed_body || {})
-        end
-      end
-
-      def check_param(params)
-        if params.key?(@name)
-          params[@name] = validate_param_value(params[@name])
-        elsif @required
-          raise SwaggerInvalidException.new("Mandatory parameter [#{@name}] is missing")
-        elsif @default
-          params[@name] = @default
-        end
-        params
-      end
-
-      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

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

@@ -1,56 +0,0 @@
-require 'json'
-
-require_relative 'swagger-invalid-exception'
-
-module Sinatra
-
-  module SwaggerExposer
-
-    # A preprocessor for a request, apply the parameter preprocessor then execute the query code
-    class SwaggerRequestPreprocessor
-
-      attr_reader :preprocessors
-
-      def initialize
-        @preprocessors = []
-      end
-
-      def add_preprocessor(preprocessor)
-        @preprocessors << preprocessor
-      end
-
-      # 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 app.env['CONTENT_TYPE'] == 'application/json'
-          body = app.request.body.read
-          unless body.empty?
-            parsed_body = JSON.parse(body)
-          end
-        end
-        app.params['parsed_body'] = parsed_body
-        unless @preprocessors.empty?
-          @preprocessors.each do |preprocessor|
-            begin
-              preprocessor.run(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

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

@@ -1,72 +0,0 @@
-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, :minLength, :maxLength]
-      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_to_type(@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

@@ -1,125 +0,0 @@
-require_relative 'swagger-invalid-exception'
-require_relative 'swagger-type-property'
-require_relative 'swagger-utilities'
-
-module Sinatra
-
-  module SwaggerExposer
-
-    # A type
-    class SwaggerType
-
-      include SwaggerUtilities
-
-      PROPERTY_PROPERTIES = :properties
-      PROPERTY_REQUIRED = :required
-      PROPERTY_EXAMPLE = :example
-      PROPERTY_EXTENDS = :extends
-      PROPERTIES = [PROPERTY_PROPERTIES, PROPERTY_REQUIRED, PROPERTY_EXAMPLE, PROPERTY_EXTENDS]
-
-      def initialize(type_name, type_properties, known_types)
-        white_list_params(type_properties, PROPERTIES)
-        @properties = process_properties(type_name, type_properties, known_types)
-        @required = process_required(type_name, type_properties, @properties.keys)
-        @example = process_example(type_name, type_properties, @properties.keys)
-        @extends = process_extends(type_properties, known_types)
-      end
-
-      def process_properties(type_name, type_content, known_types)
-        possible_value = check_attribute_empty_or_bad(type_name, type_content, PROPERTY_PROPERTIES, Hash)
-        if possible_value
-          possible_value
-        else
-          result = {}
-          type_content[PROPERTY_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, PROPERTY_REQUIRED, Array)
-        if possible_value
-          possible_value
-        else
-          type_content[PROPERTY_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#{list_or_none(properties_names, 'properties')}")
-            end
-          end
-          type_content[PROPERTY_REQUIRED]
-        end
-      end
-
-      def process_example(type_name, type_content, properties_names)
-        possible_value = check_attribute_empty_or_bad(type_name, type_content, PROPERTY_EXAMPLE, Hash)
-        if possible_value
-          possible_value
-        else
-          type_content[PROPERTY_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#{list_or_none(properties_names, 'properties')}")
-            end
-          end
-          type_content[PROPERTY_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 process_extends(type_properties, known_types)
-        if type_properties.key? PROPERTY_EXTENDS
-          check_type(type_properties[PROPERTY_EXTENDS], known_types)
-          @extends = type_properties[PROPERTY_EXTENDS]
-        end
-      end
-
-      def to_swagger
-        result = {:type => 'object'}
-
-        unless @properties.empty?
-          result[PROPERTY_PROPERTIES] = hash_to_swagger(@properties)
-        end
-
-        unless @required.empty?
-          result[PROPERTY_REQUIRED] = @required
-        end
-
-        unless @example.empty?
-          result[PROPERTY_EXAMPLE] = @example
-        end
-
-        if @extends
-          result = {
-              :allOf => [
-                ref_to_type(@extends),
-                result
-              ]
-          }
-        end
-
-        result
-      end
-
-      def to_s
-        {
-            :properties => @properties,
-            :required => @required,
-            :example => @example,
-        }.to_json
-      end
-
-
-    end
-
-  end
-end