committee 3.1.0 → 3.1.1

data/lib/committee/schema_validator/hyper_schema/string_params_coercer.rb

@@ -1,99 +1,105 @@
+# frozen_string_literal: true
+
 module Committee
-  # StringParamsCoercer takes parameters that are specified over a medium that
-  # can only accept strings (for example in a URL path or in query parameters)
-  # and attempts to coerce them into known types based of a link's schema
-  # definition.
-  #
-  # Currently supported types: null, integer, number and boolean.
-  #
-  # +call+ returns a hash of all params which could be coerced - coercion
-  # errors are simply ignored and expected to be handled later by schema
-  # validation.
-  class SchemaValidator::HyperSchema::StringParamsCoercer
-    def initialize(query_hash, schema, options = {})
-      @query_hash = query_hash
-      @schema = schema
+  module SchemaValidator
+    class HyperSchema
+      # StringParamsCoercer takes parameters that are specified over a medium that
+      # can only accept strings (for example in a URL path or in query parameters)
+      # and attempts to coerce them into known types based of a link's schema
+      # definition.
+      #
+      # Currently supported types: null, integer, number and boolean.
+      #
+      # +call+ returns a hash of all params which could be coerced - coercion
+      # errors are simply ignored and expected to be handled later by schema
+      # validation.
+      class StringParamsCoercer
+        def initialize(query_hash, schema, options = {})
+          @query_hash = query_hash
+          @schema = schema
 
-      @coerce_recursive = options.fetch(:coerce_recursive, false)
-    end
+          @coerce_recursive = options.fetch(:coerce_recursive, false)
+        end
 
-    def call!
-      coerce_object!(@query_hash, @schema)
-    end
+        def call!
+          coerce_object!(@query_hash, @schema)
+        end
 
-    private
+        private
 
-      def coerce_object!(hash, schema)
-        return false unless schema.respond_to?(:properties)
+          def coerce_object!(hash, schema)
+            return false unless schema.respond_to?(:properties)
 
-        is_coerced = false
-        schema.properties.each do |k, s|
-          original_val = hash[k]
-          unless original_val.nil?
-            new_value, is_changed = coerce_value!(original_val, s)
-            if is_changed
-              hash[k] = new_value
-              is_coerced = true
+            is_coerced = false
+            schema.properties.each do |k, s|
+              original_val = hash[k]
+              unless original_val.nil?
+                new_value, is_changed = coerce_value!(original_val, s)
+                if is_changed
+                  hash[k] = new_value
+                  is_coerced = true
+                end
+              end
             end
-          end
-        end
 
-        is_coerced
-      end
+            is_coerced
+          end
 
-      def coerce_value!(original_val, s)
-        unless original_val.nil?
-          s.type.each do |to_type|
-            case to_type
-              when "null"
-                return nil, true if original_val.empty?
-              when "integer"
-                begin
-                  return Integer(original_val), true
-                rescue ArgumentError => e
-                  raise e unless e.message =~ /invalid value for Integer/
-                end
-              when "number"
-                begin
-                  return Float(original_val), true
-                rescue ArgumentError => e
-                  raise e unless e.message =~ /invalid value for Float/
-                end
-              when "boolean"
-                if original_val == "true" || original_val == "1"
-                  return true, true
-                end
-                if original_val == "false" || original_val == "0"
-                  return false, true
-                end
-              when "array"
-                if @coerce_recursive && coerce_array_data!(original_val, s)
-                  return original_val, true # change original value
-                end
-              when "object"
-                if @coerce_recursive && coerce_object!(original_val, s)
-                  return original_val, true # change original value
+          def coerce_value!(original_val, s)
+            unless original_val.nil?
+              s.type.each do |to_type|
+                case to_type
+                  when "null"
+                    return nil, true if original_val.empty?
+                  when "integer"
+                    begin
+                      return Integer(original_val), true
+                    rescue ArgumentError => e
+                      raise e unless e.message =~ /invalid value for Integer/
+                    end
+                  when "number"
+                    begin
+                      return Float(original_val), true
+                    rescue ArgumentError => e
+                      raise e unless e.message =~ /invalid value for Float/
+                    end
+                  when "boolean"
+                    if original_val == "true" || original_val == "1"
+                      return true, true
+                    end
+                    if original_val == "false" || original_val == "0"
+                      return false, true
+                    end
+                  when "array"
+                    if @coerce_recursive && coerce_array_data!(original_val, s)
+                      return original_val, true # change original value
+                    end
+                  when "object"
+                    if @coerce_recursive && coerce_object!(original_val, s)
+                      return original_val, true # change original value
+                    end
                 end
+              end
             end
+            return nil, false
           end
-        end
-        return nil, false
-      end
 
-      def coerce_array_data!(original_val, schema)
-        return false unless schema.respond_to?(:items)
-        return false unless original_val.is_a?(Array)
+          def coerce_array_data!(original_val, schema)
+            return false unless schema.respond_to?(:items)
+            return false unless original_val.is_a?(Array)
 
-        is_coerced = false
-        original_val.each_with_index do |d, index|
-          new_value, is_changed = coerce_value!(d, schema.items)
-          if is_changed
-            original_val[index] = new_value
-            is_coerced = true
-          end
-        end
+            is_coerced = false
+            original_val.each_with_index do |d, index|
+              new_value, is_changed = coerce_value!(d, schema.items)
+              if is_changed
+                original_val[index] = new_value
+                is_coerced = true
+              end
+            end
 
-        is_coerced
+            is_coerced
+          end
       end
+    end
   end
 end

data/lib/committee/schema_validator/open_api_3.rb

@@ -1,84 +1,94 @@
-class Committee::SchemaValidator
-  class OpenAPI3
-    # @param [Committee::SchemaValidator::Option] validator_option
-    def initialize(router, request, validator_option)
-      @router = router
-      @request = request
-      @operation_object = router.operation_object(request)
-      @validator_option = validator_option
-    end
+# frozen_string_literal: true
+
+module Committee
+  module SchemaValidator
+    class OpenAPI3
+      # @param [Committee::SchemaValidator::Option] validator_option
+      def initialize(router, request, validator_option)
+        @router = router
+        @request = request
+        @operation_object = router.operation_object(request)
+        @validator_option = validator_option
+      end
 
-    def request_validate(request)
-      path_params = validator_option.coerce_path_params ? coerce_path_params : {}
+      def request_validate(request)
+        return unless link_exist?
 
-      request_unpack(request)
+        path_params = validator_option.coerce_path_params ? coerce_path_params : {}
 
-      request.env[validator_option.params_key]&.merge!(path_params) unless path_params.empty?
+        request_unpack(request)
 
-      request_schema_validation(request)
+        request.env[validator_option.params_key]&.merge!(path_params) unless path_params.empty?
 
-      copy_coerced_data_to_query_hash(request)
-    end
+        request_schema_validation(request)
 
-    def response_validate(status, headers, response, test_method = false)
-      full_body = ""
-      response.each do |chunk|
-        full_body << chunk
+        copy_coerced_data_to_query_hash(request)
       end
-      data = full_body.empty? ? {} : JSON.parse(full_body)
 
-      strict = test_method
-      Committee::SchemaValidator::OpenAPI3::ResponseValidator.
-          new(@operation_object, validator_option).
-          call(status, headers, data, strict)
-    end
+      def response_validate(status, headers, response, test_method = false)
+        full_body = +""
+        response.each do |chunk|
+          full_body << chunk
+        end
+        data = full_body.empty? ? {} : JSON.parse(full_body)
+
+        strict = test_method
+        Committee::SchemaValidator::OpenAPI3::ResponseValidator.
+            new(@operation_object, validator_option).
+            call(status, headers, data, strict)
+      end
 
-    def link_exist?
-      !@operation_object.nil?
-    end
+      def link_exist?
+        !@operation_object.nil?
+      end
 
-    def coerce_form_params(_parameter)
-      # Empty because request_schema_validation checks and coerces
-    end
+      def coerce_form_params(_parameter)
+        # Empty because request_schema_validation checks and coerces
+      end
 
-    private
+      private
 
-    attr_reader :validator_option
+      attr_reader :validator_option
 
-    def coerce_path_params
-      return {} unless link_exist?
-      @operation_object.coerce_path_parameter(@validator_option)
-    end
+      def coerce_path_params
+        @operation_object.coerce_path_parameter(@validator_option)
+      end
 
-    def request_schema_validation(request)
-      return unless @operation_object
+      def request_schema_validation(request)
+        return unless @operation_object
 
-      validator = Committee::SchemaValidator::OpenAPI3::RequestValidator.new(@operation_object, validator_option: validator_option)
-      validator.call(request, request.env[validator_option.params_key], header(request))
-    end
+        validator = Committee::SchemaValidator::OpenAPI3::RequestValidator.new(@operation_object, validator_option: validator_option)
+        validator.call(request, request.env[validator_option.params_key], header(request))
+      end
 
-    def header(request)
-      request.env[validator_option.headers_key]
-    end
+      def header(request)
+        request.env[validator_option.headers_key]
+      end
 
-    def request_unpack(request)
-      request.env[validator_option.params_key], request.env[validator_option.headers_key] = Committee::RequestUnpacker.new(
-          request,
-          allow_form_params:  validator_option.allow_form_params,
-          allow_get_body:     validator_option.allow_get_body,
-          allow_query_params: validator_option.allow_query_params,
-          coerce_form_params: validator_option.coerce_form_params,
-          optimistic_json:    validator_option.optimistic_json,
-          schema_validator:   self
-      ).call
-    end
+      def request_unpack(request)
+        request.env[validator_option.params_key], request.env[validator_option.headers_key] = Committee::RequestUnpacker.new(
+            request,
+            allow_form_params:  validator_option.allow_form_params,
+            allow_get_body:     validator_option.allow_get_body,
+            allow_query_params: validator_option.allow_query_params,
+            coerce_form_params: validator_option.coerce_form_params,
+            optimistic_json:    validator_option.optimistic_json,
+            schema_validator:   self
+        ).call
+      end
 
-    def copy_coerced_data_to_query_hash(request)
-      return if request.env["rack.request.query_hash"].nil? || request.env["rack.request.query_hash"].empty?
+      def copy_coerced_data_to_query_hash(request)
+        return if request.env["rack.request.query_hash"].nil? || request.env["rack.request.query_hash"].empty?
 
-      request.env["rack.request.query_hash"].keys.each do |k|
-        request.env["rack.request.query_hash"][k] = request.env[validator_option.params_key][k]
+        request.env["rack.request.query_hash"].keys.each do |k|
+          request.env["rack.request.query_hash"][k] = request.env[validator_option.params_key][k]
+        end
       end
     end
   end
 end
+
+require_relative "open_api_3/router"
+require_relative "open_api_3/operation_wrapper"
+require_relative "open_api_3/request_validator"
+require_relative "open_api_3/response_validator"

data/lib/committee/schema_validator/open_api_3/operation_wrapper.rb

@@ -1,120 +1,126 @@
-module Committee
-  class SchemaValidator::OpenAPI3::OperationWrapper
-    # # @param request_operation [OpenAPIParser::RequestOperation]
-    def initialize(request_operation)
-      @request_operation = request_operation
-    end
-
-    def path_params
-      request_operation.path_params
-    end
-
-    def original_path
-      request_operation.original_path
-    end
-
-    def coerce_path_parameter(validator_option)
-      options = build_openapi_parser_path_option(validator_option)
-      return {} unless options.coerce_value
-
-      request_operation.validate_path_params(options)
-    rescue OpenAPIParser::OpenAPIError => e
-      raise Committee::InvalidRequest.new(e.message)
-    end
-
-    # @param [Boolean] strict when not content_type or status code definition, raise error
-    def validate_response_params(status_code, headers, response_data, strict, check_header)
-      request_body = OpenAPIParser::RequestOperation::ValidatableResponseBody.new(status_code, response_data, headers)
-
-      return request_operation.validate_response_body(request_body, response_validate_options(strict, check_header))
-    rescue OpenAPIParser::OpenAPIError => e
-      raise Committee::InvalidResponse.new(e.message)
-    end
-
-    def validate_request_params(params, headers, validator_option)
-      ret, err = case request_operation.http_method
-            when 'get'
-              validate_get_request_params(params, headers, validator_option)
-            when 'post'
-              validate_post_request_params(params, headers, validator_option)
-            when 'put'
-              validate_post_request_params(params, headers, validator_option)
-            when 'patch'
-              validate_post_request_params(params, headers, validator_option)
-            when 'delete'
-              validate_get_request_params(params, headers, validator_option)
-            else
-              raise "Committee OpenAPI3 not support #{request_operation.http_method} method"
-            end
-      raise err if err
-      ret
-    end
+# frozen_string_literal: true
 
-    def valid_request_content_type?(content_type)
-      if (request_body = request_operation.operation_object&.request_body)
-        !request_body.select_media_type(content_type).nil?
-      else
-        # if not exist request body object, all content_type allow.
-        # because request body object required content field so when it exists there're content type definition.
-        true
+module Committee
+  module SchemaValidator
+    class OpenAPI3
+      class OperationWrapper
+        # # @param request_operation [OpenAPIParser::RequestOperation]
+        def initialize(request_operation)
+          @request_operation = request_operation
+        end
+
+        def path_params
+          request_operation.path_params
+        end
+
+        def original_path
+          request_operation.original_path
+        end
+
+        def coerce_path_parameter(validator_option)
+          options = build_openapi_parser_path_option(validator_option)
+          return {} unless options.coerce_value
+
+          request_operation.validate_path_params(options)
+        rescue OpenAPIParser::OpenAPIError => e
+          raise Committee::InvalidRequest.new(e.message)
+        end
+
+        # @param [Boolean] strict when not content_type or status code definition, raise error
+        def validate_response_params(status_code, headers, response_data, strict, check_header)
+          response_body = OpenAPIParser::RequestOperation::ValidatableResponseBody.new(status_code, response_data, headers)
+
+          return request_operation.validate_response_body(response_body, response_validate_options(strict, check_header))
+        rescue OpenAPIParser::OpenAPIError => e
+          raise Committee::InvalidResponse.new(e.message)
+        end
+
+        def validate_request_params(params, headers, validator_option)
+          ret, err = case request_operation.http_method
+                when 'get'
+                  validate_get_request_params(params, headers, validator_option)
+                when 'post'
+                  validate_post_request_params(params, headers, validator_option)
+                when 'put'
+                  validate_post_request_params(params, headers, validator_option)
+                when 'patch'
+                  validate_post_request_params(params, headers, validator_option)
+                when 'delete'
+                  validate_get_request_params(params, headers, validator_option)
+                else
+                  raise "Committee OpenAPI3 not support #{request_operation.http_method} method"
+                end
+          raise err if err
+          ret
+        end
+
+        def valid_request_content_type?(content_type)
+          if (request_body = request_operation.operation_object&.request_body)
+            !request_body.select_media_type(content_type).nil?
+          else
+            # if not exist request body object, all content_type allow.
+            # because request body object required content field so when it exists there're content type definition.
+            true
+          end
+        end
+
+        private
+
+        attr_reader :request_operation
+
+        # @!attribute [r] request_operation
+        #   @return [OpenAPIParser::RequestOperation]
+
+        # @return [OpenAPIParser::SchemaValidator::Options]
+        def build_openapi_parser_path_option(validator_option)
+          coerce_value = validator_option.coerce_path_params
+          datetime_coerce_class = validator_option.coerce_date_times ? DateTime : nil
+          validate_header = validator_option.check_header
+          OpenAPIParser::SchemaValidator::Options.new(coerce_value: coerce_value,
+                                                      datetime_coerce_class: datetime_coerce_class,
+                                                      validate_header: validate_header)
+        end
+
+        # @return [OpenAPIParser::SchemaValidator::Options]
+        def build_openapi_parser_post_option(validator_option)
+          coerce_value = validator_option.coerce_form_params
+          datetime_coerce_class = validator_option.coerce_date_times ? DateTime : nil
+          validate_header = validator_option.check_header
+          OpenAPIParser::SchemaValidator::Options.new(coerce_value: coerce_value,
+                                                      datetime_coerce_class: datetime_coerce_class,
+                                                      validate_header: validate_header)
+        end
+
+        # @return [OpenAPIParser::SchemaValidator::Options]
+        def build_openapi_parser_get_option(validator_option)
+          coerce_value = validator_option.coerce_query_params
+          datetime_coerce_class = validator_option.coerce_date_times ? DateTime : nil
+          validate_header = validator_option.check_header
+          OpenAPIParser::SchemaValidator::Options.new(coerce_value: coerce_value,
+                                                      datetime_coerce_class: datetime_coerce_class,
+                                                      validate_header: validate_header)
+        end
+
+        def validate_get_request_params(params, headers, validator_option)
+          # bad performance because when we coerce value, same check
+          request_operation.validate_request_parameter(params, headers, build_openapi_parser_get_option(validator_option))
+        rescue OpenAPIParser::OpenAPIError => e
+          raise Committee::InvalidRequest.new(e.message)
+        end
+
+        def validate_post_request_params(params, headers, validator_option)
+          content_type = headers['Content-Type'].to_s.split(";").first.to_s
+
+          # bad performance because when we coerce value, same check
+          return request_operation.validate_request_body(content_type, params, build_openapi_parser_post_option(validator_option))
+        rescue => e
+          raise Committee::InvalidRequest.new(e.message)
+        end
+
+        def response_validate_options(strict, check_header)
+          ::OpenAPIParser::SchemaValidator::ResponseValidateOptions.new(strict: strict, validate_header: check_header)
+        end
       end
     end
-
-    private
-
-    attr_reader :request_operation
-
-    # @!attribute [r] request_operation
-    #   @return [OpenAPIParser::RequestOperation]
-    
-    # @return [OpenAPIParser::SchemaValidator::Options]
-    def build_openapi_parser_path_option(validator_option)
-      coerce_value = validator_option.coerce_path_params
-      datetime_coerce_class = validator_option.coerce_date_times ? DateTime : nil
-      validate_header = validator_option.check_header
-      OpenAPIParser::SchemaValidator::Options.new(coerce_value: coerce_value,
-                                                  datetime_coerce_class: datetime_coerce_class,
-                                                  validate_header: validate_header)
-    end
-
-    # @return [OpenAPIParser::SchemaValidator::Options]
-    def build_openapi_parser_post_option(validator_option)
-      coerce_value = validator_option.coerce_form_params
-      datetime_coerce_class = validator_option.coerce_date_times ? DateTime : nil
-      validate_header = validator_option.check_header
-      OpenAPIParser::SchemaValidator::Options.new(coerce_value: coerce_value,
-                                                  datetime_coerce_class: datetime_coerce_class,
-                                                  validate_header: validate_header)
-    end
-
-    # @return [OpenAPIParser::SchemaValidator::Options]
-    def build_openapi_parser_get_option(validator_option)
-      coerce_value = validator_option.coerce_query_params
-      datetime_coerce_class = validator_option.coerce_date_times ? DateTime : nil
-      validate_header = validator_option.check_header
-      OpenAPIParser::SchemaValidator::Options.new(coerce_value: coerce_value,
-                                                  datetime_coerce_class: datetime_coerce_class,
-                                                  validate_header: validate_header)
-    end
-
-    def validate_get_request_params(params, headers, validator_option)
-      # bad performance because when we coerce value, same check
-      request_operation.validate_request_parameter(params, headers, build_openapi_parser_get_option(validator_option))
-    rescue OpenAPIParser::OpenAPIError => e
-      raise Committee::InvalidRequest.new(e.message)
-    end
-
-    def validate_post_request_params(params, headers, validator_option)
-      content_type = headers['Content-Type'].to_s.split(";").first.to_s
-
-      # bad performance because when we coerce value, same check
-      return request_operation.validate_request_body(content_type, params, build_openapi_parser_post_option(validator_option))
-    rescue => e
-      raise Committee::InvalidRequest.new(e.message)
-    end
-
-    def response_validate_options(strict, check_header)
-      ::OpenAPIParser::SchemaValidator::ResponseValidateOptions.new(strict: strict, validate_header: check_header)
-    end
   end
 end