openapi_parser 0.1.2 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1f0397e692b94ed93a1ddea1b86020f4ba38c53c7f62b2c97f67ca30ea15a209
-  data.tar.gz: fcf39298f2a36666354248f10389852c51ced48daafacb21d90d4960cdf3739d
+  metadata.gz: ddf9e2711b22d6b164e2bccd23ec3d06a2bd66918b61213a2f0d5c84eb0f5fa5
+  data.tar.gz: 908dc71a0e892164a987968587c0a4899e91207c27bbd8a4e65d27b517398d8e
 SHA512:
-  metadata.gz: c877e1f8b4029aa7da1acceeb11ad0f4f4d35a9f95e00f194d21a048991e64bd2b7ad002bc7949c2f9a31a67ed10c51b74d5dd26460ab2c3d2351170e6150a57
-  data.tar.gz: 0eb513c8deef047edc07c5aa6a3b2c3f622c4c64a75998adfc03a8609f7a91cf077b52c79d923db93e47bed8fb226175584d84217907ea60079f572588abbd4b
+  metadata.gz: 1e38fba425316e75580b5dbfd2f2e012890e4d4d9ad9e0abd83f74c8500176d21b1ddee533cf9120accd9355e60b8d5307fb3913d9678d6e3239c9fcbb3727f1
+  data.tar.gz: a7e22a6b8248fb0931c396ba1a8b07b8f9cea6a7e0f6832a1a2b1af4eba82bf673357044d9d0f8bb0c9c5bf5929106d47356e97411412bab60ef5fcc5efac703

data/lib/openapi_parser.rb

@@ -1,15 +1,26 @@
+require 'time'
+
 require 'openapi_parser/version'
+require 'openapi_parser/config'
+require 'openapi_parser/errors'
 require 'openapi_parser/concern'
 require 'openapi_parser/schemas'
 require 'openapi_parser/path_item_finder'
 require 'openapi_parser/request_operation'
 require 'openapi_parser/schema_validator'
+require 'openapi_parser/parameter_validator'
+require 'openapi_parser/reference_expander'
 
 module OpenAPIParser
   class << self
-    # @param [OpenAPIParser::Schemas::OpenAPI]
-    def parse(schema)
-      Schemas::OpenAPI.new(schema)
+    # @return [OpenAPIParser::Schemas::OpenAPI]
+    def parse(schema, config = {})
+      c = Config.new(config)
+      root = Schemas::OpenAPI.new(schema, c)
+
+      OpenAPIParser::ReferenceExpander.expand(root) if c.expand_reference
+
+      root
     end
   end
 end

data/lib/openapi_parser/concern.rb

@@ -1,2 +1,3 @@
 require_relative 'concerns/parseable'
 require_relative 'concerns/findable'
+require_relative 'concerns/expandable'

data/lib/openapi_parser/concerns/expandable.rb

@@ -0,0 +1,76 @@
+module OpenAPIParser::Expandable
+  def expand_reference(root)
+    expand_list_objects(root, self.class._openapi_attr_list_objects&.keys)
+    expand_objects(root, self.class._openapi_attr_objects&.keys)
+    expand_hash_objects(root, self.class._openapi_attr_hash_objects&.keys)
+    expand_hash_objects(root, self.class._openapi_attr_hash_body_objects&.keys)
+  end
+
+  private
+
+  def expand_hash_objects(root, attribute_names)
+    return unless attribute_names
+
+    attribute_names.each do |name|
+      h = send(name)
+      next if h.nil?
+
+      update_values = h.map do |k, v|
+        next [k, referenced_object(root, v)] if v.is_a?(OpenAPIParser::Schemas::Reference)
+        v.expand_reference(root) if v.is_a?(OpenAPIParser::Expandable)
+
+        nil
+      end
+
+      update_values.compact.each do |k, v|
+        _update_child_object(h[k], v)
+        h[k] = v
+      end
+    end
+  end
+
+  def expand_objects(root, attribute_names)
+    return unless attribute_names
+
+    attribute_names.each do |name|
+      v = send(name)
+      next if v.nil?
+
+      if v.is_a?(OpenAPIParser::Schemas::Reference)
+        obj = referenced_object(root, v)
+        _update_child_object(v, obj)
+        self.instance_variable_set("@#{name}", obj)
+      elsif v.is_a?(OpenAPIParser::Expandable)
+        v.expand_reference(root)
+      end
+    end
+  end
+
+  def expand_list_objects(root, attribute_names)
+    return unless attribute_names
+
+    attribute_names.each do |name|
+      l = send(name)
+      next if l.nil?
+
+      l.each_with_index do |v, idx|
+        if v.is_a?(OpenAPIParser::Schemas::Reference)
+          obj = referenced_object(root, v)
+          _update_child_object(v, obj)
+          l[idx] = obj
+        elsif v.is_a?(OpenAPIParser::Expandable)
+          v.expand_reference(root)
+        end
+      end
+    end
+  end
+
+
+  # @param [OpenAPIParser::Schemas::OpenAPI] root
+  # @param [OpenAPIParser::Schemas::Reference] reference
+  def referenced_object(root, reference)
+    obj = root.find_object(reference.ref)
+
+    obj.is_a?(OpenAPIParser::Schemas::Reference) ? referenced_object(root, obj) : obj
+  end
+end

data/lib/openapi_parser/concerns/findable.rb

@@ -10,7 +10,12 @@ module OpenAPIParser::Findable
       return obj
     end
 
-    _openapi_all_child_objects.each do |c|
+    if (child = _openapi_all_child_objects[reference])
+      @find_object_cache[reference] = child
+      return child
+    end
+
+    _openapi_all_child_objects.values.each do |c|
       if (obj = c.find_object(reference))
         @find_object_cache[reference] = obj
         return obj
@@ -19,4 +24,10 @@ module OpenAPIParser::Findable
 
     nil
   end
+
+  def purge_object_cache
+    @find_object_cache = {}
+
+    _openapi_all_child_objects.values.each(&:purge_object_cache)
+  end
 end

data/lib/openapi_parser/concerns/parseable.rb

@@ -57,16 +57,22 @@ module OpenAPIParser::Parseable
     end
   end
 
+  def child_from_reference(reference)
+    _openapi_all_child_objects[reference]
+  end
 
   def _openapi_all_child_objects
-    @_openapi_all_child_objects ||= []
+    @_openapi_all_child_objects ||= {}
   end
 
   def _add_child_object(object)
     return unless object.is_a?(OpenAPIParser::Parseable)
-    _openapi_all_child_objects << object
+    _openapi_all_child_objects[object.object_reference] = object
   end
 
+  def _update_child_object(old, new)
+    _openapi_all_child_objects[old.object_reference] = new
+  end
 
   def load_data
     create_attr_values(self.class._openapi_attr_values)

data/lib/openapi_parser/config.rb

@@ -0,0 +1,24 @@
+class OpenAPIParser::Config
+  def initialize(config)
+    @config = config
+  end
+
+  def datetime_coerce_class
+    @config[:datetime_coerce_class]
+  end
+
+  def coerce_value
+    @config[:coerce_value]
+  end
+
+  def expand_reference
+    @config.fetch(:expand_reference, true)
+  end
+
+  def request_validator_options
+    @request_options ||= OpenAPIParser::SchemaValidator::Options.new(coerce_value: coerce_value, datetime_coerce_class: datetime_coerce_class)
+  end
+
+  alias_method :request_body_options, :request_validator_options
+  alias_method :path_params_options, :request_validator_options
+end

data/lib/openapi_parser/errors.rb

@@ -0,0 +1,58 @@
+module OpenAPIParser
+  class OpenAPIError < StandardError
+    def initialize(reference)
+      @reference = reference
+    end
+  end
+
+  class ValidateError < OpenAPIError
+    def initialize(data, type, reference)
+      super(reference)
+      @data = data
+      @type = type
+    end
+
+    def message
+      "#{@data} class is #{@data.class} but it's not valid #{@type} in #{@reference}"
+    end
+  end
+
+  class NotNullError < OpenAPIError
+    def message
+      "#{@reference} don't allow null"
+    end
+  end
+
+  class NotExistRequiredKey < OpenAPIError
+    def initialize(keys, reference)
+      super(reference)
+      @keys = keys
+    end
+
+    def message
+      "required parameters #{@keys.join(",")} not exist in #{@reference}"
+    end
+  end
+
+  class NotAnyOf < OpenAPIError
+    def initialize(value, reference)
+      super(reference)
+      @value = value
+    end
+
+    def message
+      "#{@value} isn't any of in #{@reference}"
+    end
+  end
+
+  class NotEnumInclude < OpenAPIError
+    def initialize(value, reference)
+      super(reference)
+      @value = value
+    end
+
+    def message
+      "#{@value} isn't include enum in #{@reference}"
+    end
+  end
+end

data/lib/openapi_parser/parameter_validator.rb

@@ -0,0 +1,23 @@
+class OpenAPIParser::ParameterValidator
+  class << self
+    # @param [Hash{String => Parameter}] parameters_hash
+    # @param [Hash] params
+    # @param [String] object_reference
+    # @param [OpenAPIParser::SchemaValidator::Options] options
+    def validate_parameter(parameters_hash, params, object_reference, options)
+      no_exist_required_key = []
+      parameters_hash.each do |k, v|
+        if (data = params[k])
+          coerced = v.validate_params(data, options)
+          params[k] = coerced if options.coerce_value
+        elsif v.required
+          no_exist_required_key << k
+        end
+      end
+
+      raise OpenAPIParser::NotExistRequiredKey.new(no_exist_required_key, object_reference) unless no_exist_required_key.empty?
+
+      params
+    end
+  end
+end

data/lib/openapi_parser/path_item_finder.rb

@@ -9,11 +9,11 @@ class OpenAPIParser::PathItemFinder
 
   # @param [String, Symbol] http_method like (get, post .... allow symbol)
   # @param [String] request_path
-  # @return [OpenAPIParser::Schemas::Paths]
+  # return operation_object, original_path, path_params
   def operation_object(http_method, request_path)
     if (path_item_object = @paths.path[request_path])
       if (op = path_item_object.operation(http_method))
-        return op, {} # find no path_params path
+        return op, request_path, {} # find no path_params path
       end
     end
 
@@ -83,11 +83,11 @@ class OpenAPIParser::PathItemFinder
 
   def parse_request_path(http_method, request_path)
     original_path, path_params = @root.find_full_path(request_path.split("/"))
-    return nil, path_params unless original_path
+    return nil, nil, {} unless original_path # # can't find
 
     path_item_object = @paths.path[original_path]
     obj = path_item_object.operation(http_method.to_s)
 
-    [obj, path_params]
+    [obj, original_path, path_params]
   end
 end

data/lib/openapi_parser/reference_expander.rb

@@ -0,0 +1,9 @@
+class OpenAPIParser::ReferenceExpander
+  class << self
+    # @param [OpenAPIParser::Schemas::OpenAPI] openapi
+    def expand(openapi)
+      openapi.expand_reference(openapi)
+      openapi.purge_object_cache
+    end
+  end
+end

data/lib/openapi_parser/request_operation.rb

@@ -2,29 +2,56 @@
 
 class OpenAPIParser::RequestOperation
   class << self
+    # @param [OpenAPIParser::Config] config
     # @param [OpenAPIParser::PathItemFinder] path_item_finder
-    def create(http_method, request_path, path_item_finder)
-      endpoint, path_params = path_item_finder.operation_object(http_method, request_path)
+    # @return [OpenAPIParser::RequestOperation, nil]
+    def create(http_method, request_path, path_item_finder, config)
+      operation, original_path, path_params = path_item_finder.operation_object(http_method, request_path)
 
-      return nil unless endpoint
+      return nil unless operation
 
-      self.new(endpoint, path_params)
+      self.new(http_method, original_path, operation, path_params, config)
     end
   end
 
   # @!attribute [r] operation_object
-  #   @return [OpenAPIParser::Schemas::Operation, nil]
+  #   @return [OpenAPIParser::Schemas::Operation]
   # @!attribute [r] path_params
   #   @return [Hash{String => String}]
-  attr_reader :operation_object, :path_params
+  # @!attribute [r] config
+  #   #   @return [OpenAPIParser::Config]
+  # @!attribute [r] http_method
+  #   @return [String]
+  # @!attribute [r] original_path
+  #   @return [String]
+  attr_reader :operation_object, :path_params, :config, :http_method, :original_path
 
-  def initialize(operation_object, path_params)
+  # @param [OpenAPIParser::Config] config
+  def initialize(http_method, original_path, operation_object, path_params, config)
+    @http_method = http_method.to_s
+    @original_path = original_path
     @operation_object = operation_object
     @path_params = path_params || {}
+    @config = config
+  end
+
+  def validate_path_params(options = nil)
+    options = config.path_params_options unless options
+    operation_object&.validate_path_params(path_params, options)
   end
 
   # support application/json only :(
-  def validate_request_body(content_type, params)
-    operation_object&.validate_request_body(content_type, params)
+  def validate_request_body(content_type, params, options = nil)
+    options = config.request_body_options unless options
+    operation_object&.validate_request_body(content_type, params, options)
+  end
+
+  def validate_response_body(status_code, content_type, data)
+    operation_object&.validate_response_body(status_code, content_type, data)
+  end
+
+  def validate_request_parameter(params, options = nil)
+    options = config.request_validator_options unless options
+    operation_object&.validate_request_parameter(params, options)
   end
 end

data/lib/openapi_parser/schema_validator.rb

@@ -1,172 +1,109 @@
-class OpenAPIParser::SchemaValidator
-  class ValidateError < StandardError
-    def initialize(data, type, reference)
-      @data = data
-      @type = type
-      @reference = reference
-    end
-
-    def message
-      "#{@data} class is #{@data.class} but it's not valid #{@type} in #{@reference}"
-    end
-  end
-
-  class NotNullError < StandardError
-    def initialize(reference)
-      @reference = reference
-    end
-
-    def message
-      "#{@reference} don't allow null"
-    end
-  end
+require_relative 'schema_validators/options'
+require_relative 'schema_validators/enumable'
+require_relative 'schema_validators/base'
+require_relative 'schema_validators/string_validator'
+require_relative 'schema_validators/integer_validator'
+require_relative 'schema_validators/float_validator'
+require_relative 'schema_validators/boolean_validator'
+require_relative 'schema_validators/object_validator'
+require_relative 'schema_validators/array_validator'
+require_relative 'schema_validators/any_of_validator'
+require_relative 'schema_validators/nil_validator'
 
-  class NotExistRequiredKey < StandardError
-    def initialize(keys, reference)
-      @keys = keys
-      @reference = reference
-    end
-
-    def message
-      "required parameters #{@keys.join(",")} not exist in #{@reference}"
-    end
-  end
-
-  class NotAnyOf < StandardError
-    def initialize(value, reference)
-      @value = value
-      @reference = reference
-    end
-
-    def message
-      "#{@value} isn't any of in #{@reference}"
-    end
-  end
-
-  class NotEnumInclude < StandardError
-    def initialize(value, reference)
-      @value = value
-      @reference = reference
-    end
+class OpenAPIParser::SchemaValidator
+  class ValidatorOption
 
-    def message
-      "#{@value} isn't include enum in #{@reference}"
-    end
   end
 
   class << self
     # @param [Hash] value
     # @param [OpenAPIParser::Schemas::Schema]
-    def validate(value, schema)
-      new(value, schema).validate_data
+    # @param [OpenAPIParser::SchemaValidator::Options] options
+    # @return [Object] coerced or original params
+    def validate(value, schema, options)
+      new(value, schema, options).validate_data
     end
   end
 
   # @param [Hash] value
   # @param [OpenAPIParser::Schemas::Schema] schema
-  def initialize(value, schema)
+  # @param [OpenAPIParser::SchemaValidator::Options] options
+  def initialize(value, schema, options)
     @value = value
     @schema = schema
+    @coerce_value = options.coerce_value
+    @datetime_coerce_class = options.datetime_coerce_class
   end
 
+  # @return [Object] coerced or original params
   def validate_data
-    err = validate_schema(@value, @schema)
+    coerced, err = validate_schema(@value, @schema)
     raise err if err
-    nil
+    coerced
   end
 
-  private
-
-  # @param [Object] value
-  # @param [OpenAPIParser::Schemas::Schema] schema
-  def validate_schema(value, schema)
-    return unless schema
-    return validate_any_of(value, schema) if schema.any_of
-
-    if value.nil?
-      return if schema.nullable
-      return NotNullError.new(schema.object_reference)
-    end
-
-    case schema.type
-    when "string"
-      return validate_string(value, schema) if value.is_a?(String)
-    when "integer"
-      return validate_integer(value, schema) if value.is_a?(Integer)
-    when "boolean"
-      return if value.is_a?(TrueClass)
-      return if value.is_a?(FalseClass)
-    when "number"
-      return validate_integer(value, schema) if value.is_a?(Integer)
-      return validate_number(value, schema) if value.is_a?(Numeric)
-    when "object"
-      return validate_object(value, schema) if value.is_a?(Hash)
-    when "array"
-      return validate_array(value, schema) if value.is_a?(Array)
-    else
-      # TODO: unknown type support
-    end
-
-    ValidateError.new(value, schema.type, schema.object_reference)
-  end
-
-  # @param [Object] value
-  # @param [OpenAPIParser::Schemas::Schema] schema
-  def validate_any_of(value, schema)
-    # in all schema return error (=true) not any of data
-    schema.any_of.all? { |s| validate_schema(value, s) } ? NotAnyOf.new(value, schema.object_reference) : nil
+  def validate_error(value, schema)
+    [nil, OpenAPIParser::ValidateError.new(value, schema.type, schema.object_reference)]
   end
 
   def validate_string(value, schema)
-    check_enum_include(value, schema)
+    (@string_validator ||= OpenAPIParser::SchemaValidator::StringValidator.new(self, @coerce_value, @datetime_coerce_class)).coerce_and_validate(value, schema)
   end
 
   def validate_integer(value, schema)
-    check_enum_include(value, schema)
+    (@integer_validator ||= OpenAPIParser::SchemaValidator::IntegerValidator.new(self, @coerce_value)).coerce_and_validate(value, schema)
   end
 
-  def validate_number(value, schema)
-    check_enum_include(value, schema)
+  def validate_float(value, schema)
+    (@float_validator ||= OpenAPIParser::SchemaValidator::FloatValidator.new(self, @coerce_value)).coerce_and_validate(value, schema)
   end
 
-  # @param [Object] value
-  # @param [OpenAPIParser::Schemas::Schema] schema
-  def check_enum_include(value, schema)
-    return unless schema.enum
-    return if schema.enum.include?(value)
-
-    NotEnumInclude.new(value, schema.object_reference)
+  def validate_boolean(value, schema)
+    (@boolean_validator ||= OpenAPIParser::SchemaValidator::BooleanValidator.new(self, @coerce_value)).coerce_and_validate(value, schema)
   end
 
-  # @param [Hash] value
-  # @param [OpenAPIParser::Schemas::Schema] schema
   def validate_object(value, schema)
-    return unless schema.properties
-    required_set = schema.required ? schema.required.to_set : Set.new
+    (@object_validator ||= OpenAPIParser::SchemaValidator::ObjectValidator.new(self, @coerce_value)).coerce_and_validate(value, schema)
+  end
 
-    value.each do |name, v|
-      s = schema.properties[name]
-      err = validate_schema(v, s)
-      return err if err
+  def validate_array(value, schema)
+    (@array_validator ||= OpenAPIParser::SchemaValidator::ArrayValidator.new(self, @coerce_value)).coerce_and_validate(value, schema)
+  end
 
-      required_set.delete(name)
-    end
+  def validate_any_of(value, schema)
+    (@any_of_validator ||= OpenAPIParser::SchemaValidator::AnyOfValidator.new(self, @coerce_value)).coerce_and_validate(value, schema)
+  end
 
-    return NotExistRequiredKey.new(required_set.to_a, schema.object_reference) unless required_set.empty?
-    nil
+  def validate_nil(value, schema)
+    (@nil_validator ||= OpenAPIParser::SchemaValidator::NilValidator.new(self, @coerce_value)).coerce_and_validate(value, schema)
   end
 
-  # @param [Array] value
+  # @param [Object] value
   # @param [OpenAPIParser::Schemas::Schema] schema
-  def validate_array(value, schema)
-    # array type have an schema in items property
-    items_schema = schema.items
+  def validate_schema(value, schema)
+    return [value, nil] unless schema # no schema
+
+    return validate_any_of(value, schema) if schema.any_of
+
+    return validate_nil(value, schema) if value.nil?
 
-    value.each do |v|
-      err = validate_schema(v, items_schema)
-      return err if err
+    case schema.type
+    when "string"
+      return validate_string(value, schema)
+    when "integer"
+      return validate_integer(value, schema)
+    when "boolean"
+      return validate_boolean(value, schema)
+    when "number"
+      return validate_float(value, schema)
+    when "object"
+      return validate_object(value, schema)
+    when "array"
+      return validate_array(value, schema)
+    else
+      # TODO: unknown type support
     end
 
-    nil
+    validate_error(value, schema)
   end
 end

data/lib/openapi_parser/schema_validators/any_of_validator.rb

@@ -0,0 +1,14 @@
+class OpenAPIParser::SchemaValidator
+  class AnyOfValidator < Base
+    # @param [Object] value
+    # @param [OpenAPIParser::Schemas::Schema] schema
+    def coerce_and_validate(value, schema)
+      # in all schema return error (=true) not any of data
+      schema.any_of.each do |s|
+        coerced, err = validator.validate_schema(value, s)
+        return [coerced, nil] if err.nil?
+      end
+      [nil, OpenAPIParser::NotAnyOf.new(value, schema.object_reference)]
+    end
+  end
+end

data/lib/openapi_parser/schema_validators/array_validator.rb

@@ -0,0 +1,25 @@
+class OpenAPIParser::SchemaValidator
+  class ArrayValidator < Base
+
+    # @param [Array] value
+    # @param [OpenAPIParser::Schemas::Schema] schema
+    def coerce_and_validate(value, schema)
+      return validator.validate_error(value, schema) unless value.is_a?(Array)
+
+      # array type have an schema in items property
+      items_schema = schema.items
+
+
+      coerced_values = value.map do |v|
+        coerced, err = validator.validate_schema(v, items_schema)
+        return [nil, err] if err
+
+        coerced
+      end
+
+      value.each_index { |idx| value[idx] = coerced_values[idx] } if @coerce_value
+
+      [value, nil]
+    end
+  end
+end

data/lib/openapi_parser/schema_validators/base.rb

@@ -0,0 +1,18 @@
+class OpenAPIParser::SchemaValidator
+  class Base
+    def initialize(validator, coerce_value)
+      @validator = validator
+      @coerce_value = coerce_value
+    end
+
+    attr_reader :validator
+
+    # @!attribute [r] validator
+    #   @return [OpenAPIParser::SchemaValidator]
+
+    # return  [coerced_value, error]
+    def coerce_and_validate(_value, _schema)
+      raise 'need implement'
+    end
+  end
+end

data/lib/openapi_parser/schema_validators/boolean_validator.rb

@@ -0,0 +1,22 @@
+class OpenAPIParser::SchemaValidator
+  class BooleanValidator < Base
+    def coerce_and_validate(value, schema)
+      value = coerce(value) if @coerce_value
+
+      return validator.validate_error(value, schema) unless value.is_a?(TrueClass) || value.is_a?(FalseClass)
+      [value, nil]
+    end
+
+    private
+
+    def coerce(value)
+      if value == "true" || value == "1"
+        return true
+      end
+      if value == "false" || value == "0"
+        return false
+      end
+      value
+    end
+  end
+end

data/lib/openapi_parser/schema_validators/enumable.rb

@@ -0,0 +1,10 @@
+class OpenAPIParser::SchemaValidator
+  module Enumable
+    def check_enum_include(value, schema)
+      return [value, nil] unless schema.enum
+      return [value, nil] if schema.enum.include?(value)
+
+      [nil, OpenAPIParser::NotEnumInclude.new(value, schema.object_reference)]
+    end
+  end
+end

data/lib/openapi_parser/schema_validators/float_validator.rb

@@ -0,0 +1,29 @@
+class OpenAPIParser::SchemaValidator
+  class FloatValidator < Base
+    include ::OpenAPIParser::SchemaValidator::Enumable
+
+    def coerce_and_validate(value, schema)
+      value = coerce(value) if @coerce_value
+
+      return validator.validate_integer(value, schema) if value.is_a?(Integer)
+      coercer_and_validate_numeric(value, schema)
+    end
+
+    private
+
+    def coercer_and_validate_numeric(value, schema)
+      return validator.validate_error(value, schema) unless value.is_a?(Numeric)
+      check_enum_include(value, schema)
+    end
+
+    private
+
+    def coerce(value)
+      begin
+        return Float(value)
+      rescue ArgumentError => e
+        raise e unless e.message =~ /invalid value for Float/
+      end
+    end
+  end
+end

data/lib/openapi_parser/schema_validators/integer_validator.rb

@@ -0,0 +1,26 @@
+class OpenAPIParser::SchemaValidator
+  class IntegerValidator < Base
+    include ::OpenAPIParser::SchemaValidator::Enumable
+
+    def coerce_and_validate(value, schema)
+      value = coerce(value) if @coerce_value
+
+      return validator.validate_error(value, schema) unless value.is_a?(Integer)
+      check_enum_include(value, schema)
+    end
+
+    private
+
+    def coerce(value)
+      return value if value.is_a?(Integer)
+
+      begin
+        return Integer(value)
+      rescue ArgumentError => e
+        raise e unless e.message =~ /invalid value for Integer/
+      end
+
+      value
+    end
+  end
+end

data/lib/openapi_parser/schema_validators/nil_validator.rb

@@ -0,0 +1,10 @@
+class OpenAPIParser::SchemaValidator
+  class NilValidator < Base
+    # @param [Object] value
+    # @param [OpenAPIParser::Schemas::Schema] schema
+    def coerce_and_validate(value, schema)
+      return [value, nil] if schema.nullable
+      [nil, OpenAPIParser::NotNullError.new(schema.object_reference)]
+    end
+  end
+end

data/lib/openapi_parser/schema_validators/object_validator.rb

@@ -0,0 +1,28 @@
+class OpenAPIParser::SchemaValidator
+  class ObjectValidator < Base
+
+    # @param [Hash] value
+    # @param [OpenAPIParser::Schemas::Schema] schema
+    def coerce_and_validate(value, schema)
+      return validator.validate_error(value, schema) unless value.is_a?(Hash)
+
+      return [value, nil] unless schema.properties
+      required_set = schema.required ? schema.required.to_set : Set.new
+
+      coerced_values = value.map do |name, v|
+        s = schema.properties[name]
+        coerced, err = validator.validate_schema(v, s)
+        return [nil, err] if err
+
+        required_set.delete(name)
+        [name, coerced]
+      end
+
+      return [nil, OpenAPIParser::NotExistRequiredKey.new(required_set.to_a, schema.object_reference)] unless required_set.empty?
+
+      value = value.merge(coerced_values.to_h) if @coerce_value
+
+      [value, nil]
+    end
+  end
+end

data/lib/openapi_parser/schema_validators/options.rb

@@ -0,0 +1,10 @@
+class OpenAPIParser::SchemaValidator
+  class Options
+    attr_reader :coerce_value, :datetime_coerce_class
+
+    def initialize(coerce_value: nil, datetime_coerce_class: nil)
+      @coerce_value = coerce_value
+      @datetime_coerce_class = datetime_coerce_class
+    end
+  end
+end

data/lib/openapi_parser/schema_validators/string_validator.rb

@@ -0,0 +1,38 @@
+class OpenAPIParser::SchemaValidator
+  class StringValidator < Base
+    include ::OpenAPIParser::SchemaValidator::Enumable
+
+    def initialize(validator, coerce_value, datetime_coerce_class)
+      super(validator, coerce_value)
+      @datetime_coerce_class = datetime_coerce_class
+    end
+
+    def coerce_and_validate(value, schema)
+      return validator.validate_error(value, schema) unless value.is_a?(String)
+
+      value, err = check_enum_include(value, schema)
+      return [nil, err] if err
+
+      value = coerce_date_time(value, schema) unless @datetime_coerce_class.nil?
+
+      [value, nil]
+    end
+
+    private
+
+    # @param [OpenAPIParser::Schemas::Schema] schema
+    def coerce_date_time(value, schema)
+      schema.format == "date-time" ? parse_date_time(value) : value
+    end
+
+    def parse_date_time(value)
+      begin
+        return @datetime_coerce_class.parse(value)
+      rescue ArgumentError => e
+        raise e unless e.message =~ /invalid date/
+      end
+
+      value
+    end
+  end
+end

data/lib/openapi_parser/schemas/base.rb

@@ -2,6 +2,7 @@ module OpenAPIParser::Schemas
   class Base
     include OpenAPIParser::Parseable
     include OpenAPIParser::Findable
+    include OpenAPIParser::Expandable
 
     attr_reader :parent, :raw_schema, :object_reference, :root
 

data/lib/openapi_parser/schemas/media_type.rb

@@ -9,8 +9,8 @@ module OpenAPIParser::Schemas
     openapi_attr_object :schema, Schema, reference: true
 
     # @param [Hash] params
-    def validate_parameter(params)
-      OpenAPIParser::SchemaValidator.validate(params, schema)
+    def validate_parameter(params, options)
+      OpenAPIParser::SchemaValidator.validate(params, schema, options)
     end
   end
 end

data/lib/openapi_parser/schemas/openapi.rb

@@ -5,10 +5,11 @@
 
 module OpenAPIParser::Schemas
   class OpenAPI < Base
-    def initialize(raw_schema)
+    def initialize(raw_schema, config)
       super('#', nil, self, raw_schema)
       @find_object_cache = {}
       @path_item_finder = OpenAPIParser::PathItemFinder.new(paths)
+      @config = config
     end
 
     # @!attribute [r] openapi
@@ -23,9 +24,9 @@ module OpenAPIParser::Schemas
     #   @return [Components, nil]
     openapi_attr_object :components, Components, reference: false
 
-    # @return [OpenAPIParser::RequestOperation]
+    # @return [OpenAPIParser::RequestOperation, nil]
     def request_operation(http_method, request_path)
-      OpenAPIParser::RequestOperation.create(http_method, request_path, @path_item_finder)
+      OpenAPIParser::RequestOperation.create(http_method, request_path, @path_item_finder, @config)
     end
   end
 end

data/lib/openapi_parser/schemas/operation.rb

@@ -17,8 +17,37 @@ module OpenAPIParser::Schemas
 
     openapi_attr_object :responses, Responses, reference: false
 
-    def validate_request_body(content_type, params)
-      request_body&.validate_request_body(content_type, params)
+    def validate_request_body(content_type, params, options)
+      request_body&.validate_request_body(content_type, params, options)
+    end
+
+    def validate_response_body(status_code, content_type, data)
+      responses&.validate_response_body(status_code, content_type, data)
+    end
+
+    # @param [OpenAPIParser::SchemaValidator::Options] options
+    def validate_request_parameter(params, options)
+      OpenAPIParser::ParameterValidator.validate_parameter(query_parameter_hash, params, object_reference, options)
+    end
+
+    def validate_path_params(path_params, options)
+      OpenAPIParser::ParameterValidator.validate_parameter(path_parameter_hash, path_params, object_reference, options)
+    end
+
+    private
+
+    def path_parameter_hash
+      @path_parameter_hash ||= (parameters || []).
+          select(&:in_path?).
+          map{ |param| [param.name, param] }.
+          to_h
+    end
+
+    def query_parameter_hash
+      @query_parameter_hash ||= (parameters || []).
+          select(&:in_query?).
+          map{ |param| [param.name, param] }.
+          to_h
     end
   end
 end

data/lib/openapi_parser/schemas/parameter.rb

@@ -7,6 +7,22 @@ module OpenAPIParser::Schemas
     openapi_attr_value :allow_empty_value, schema_key: :allowEmptyValue
     openapi_attr_value :allow_reserved, schema_key: :allowReserved
 
+    # @!attribute [r] schema
+    #   @return [Schema, Reference, nil]
     openapi_attr_object :schema, Schema, reference: true
+
+    def in_query?
+      self.in == "query"
+    end
+
+    def in_path?
+      self.in == "path"
+    end
+
+    # @return [Object] coerced or original params
+    # @param [OpenAPIParser::SchemaValidator::Options] options
+    def validate_params(params, options)
+      ::OpenAPIParser::SchemaValidator.validate(params, schema, options)
+    end
   end
 end

data/lib/openapi_parser/schemas/reference.rb

@@ -1,5 +1,7 @@
 module OpenAPIParser::Schemas
   class Reference < Base
+    # @!attribute [r] ref
+    #   @return [Base]
     openapi_attr_value :ref, schema_key: '$ref'
   end
 end

data/lib/openapi_parser/schemas/request_body.rb

@@ -8,13 +8,13 @@ module OpenAPIParser::Schemas
     #   @return [Hash{String => MediaType}, nil]
     openapi_attr_hash_object :content, MediaType, reference: false
 
-    def validate_request_body(_content_type, params)
+    def validate_request_body(_content_type, params, options)
       # TODO: now support application/json only :(
 
       media_type = content['application/json']
-      return nil unless media_type
+      return params unless media_type
 
-      media_type.validate_parameter(params)
+      media_type.validate_parameter(params, options)
     end
   end
 end

data/lib/openapi_parser/schemas/response.rb

@@ -8,5 +8,15 @@ module OpenAPIParser::Schemas
     # @!attribute [r] content
     #   @return [Hash{String => MediaType}, nil]
     openapi_attr_hash_object :content, MediaType, reference: false
+
+    def validate_parameter(content_type, params)
+      # TODO: support wildcard type like application/* (OpenAPI3 definition)
+
+      media_type = content[content_type]
+      return nil unless media_type
+
+      options = ::OpenAPIParser::SchemaValidator::Options.new # response validator not support any options
+      media_type.validate_parameter(params, options)
+    end
   end
 end

data/lib/openapi_parser/schemas/responses.rb

@@ -9,5 +9,16 @@ module OpenAPIParser::Schemas
     # @!attribute [r] response
     #   @return [Hash{String => Response, Reference}, nil]
     openapi_attr_hash_body_objects 'response', Response, reject_keys: [:default], allow_reference: true, allow_data_type: false
+
+    def validate_response_body(status_code, content_type, params)
+      # TODO: support wildcard status code like 2XX
+      return nil unless response
+
+      res = response[status_code.to_s]
+      return res.validate_parameter(content_type, params) if res
+
+
+      default&.validate_parameter(content_type, params)
+    end
   end
 end

data/lib/openapi_parser/version.rb

@@ -1,3 +1,3 @@
 module OpenAPIParser
-  VERSION = '0.1.2'.freeze
+  VERSION = '0.1.3'.freeze
 end

data/openapi_parser.gemspec

@@ -28,4 +28,5 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency 'rspec', '~> 3.0'
   spec.add_development_dependency 'pry'
   spec.add_development_dependency 'pry-byebug'
+  spec.add_development_dependency 'rspec-parameterized'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: openapi_parser
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.1.3
 platform: ruby
 authors:
 - ota42y
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-12-14 00:00:00.000000000 Z
+date: 2018-12-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -94,6 +94,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec-parameterized
+  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: parser for OpenAPI 3.0 or later
 email:
 - ota42y@gmail.com
@@ -114,11 +128,27 @@ files:
 - bin/setup
 - lib/openapi_parser.rb
 - lib/openapi_parser/concern.rb
+- lib/openapi_parser/concerns/expandable.rb
 - lib/openapi_parser/concerns/findable.rb
 - lib/openapi_parser/concerns/parseable.rb
+- lib/openapi_parser/config.rb
+- lib/openapi_parser/errors.rb
+- lib/openapi_parser/parameter_validator.rb
 - lib/openapi_parser/path_item_finder.rb
+- lib/openapi_parser/reference_expander.rb
 - lib/openapi_parser/request_operation.rb
 - lib/openapi_parser/schema_validator.rb
+- lib/openapi_parser/schema_validators/any_of_validator.rb
+- lib/openapi_parser/schema_validators/array_validator.rb
+- lib/openapi_parser/schema_validators/base.rb
+- lib/openapi_parser/schema_validators/boolean_validator.rb
+- lib/openapi_parser/schema_validators/enumable.rb
+- lib/openapi_parser/schema_validators/float_validator.rb
+- lib/openapi_parser/schema_validators/integer_validator.rb
+- lib/openapi_parser/schema_validators/nil_validator.rb
+- lib/openapi_parser/schema_validators/object_validator.rb
+- lib/openapi_parser/schema_validators/options.rb
+- lib/openapi_parser/schema_validators/string_validator.rb
 - lib/openapi_parser/schemas.rb
 - lib/openapi_parser/schemas/base.rb
 - lib/openapi_parser/schemas/classes.rb