openapi_parser 0.1.5 → 0.1.6

data/lib/openapi_parser/schema_validators/all_of_validator.rb

@@ -0,0 +1,16 @@
+# validate AllOf schema
+class OpenAPIParser::SchemaValidator
+  class AllOfValidator < Base
+    # coerce and validate value
+    # @param [Object] value
+    # @param [OpenAPIParser::Schemas::Schema] schema
+    def coerce_and_validate(value, schema)
+      # if any schema return error, it's not valida all of value
+      schema.all_of.each do |s|
+        _coerced, err = validatable.validate_schema(value, s)
+        return [nil, err] if err
+      end
+      [value, nil]
+    end
+  end
+end

data/lib/openapi_parser/schema_validators/any_of_validator.rb

@@ -5,7 +5,7 @@ class OpenAPIParser::SchemaValidator
     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)
+        coerced, err = validatable.validate_schema(value, s)
         return [coerced, nil] if err.nil?
       end
       [nil, OpenAPIParser::NotAnyOf.new(value, schema.object_reference)]

data/lib/openapi_parser/schema_validators/array_validator.rb

@@ -1,17 +1,15 @@
 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)
+      return OpenAPIParser::ValidateError.build_error_result(value, schema) unless value.kind_of?(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)
+        coerced, err = validatable.validate_schema(v, items_schema)
         return [nil, err] if err
 
         coerced

data/lib/openapi_parser/schema_validators/base.rb

@@ -1,16 +1,19 @@
 class OpenAPIParser::SchemaValidator
   class Base
-    def initialize(validator, coerce_value)
-      @validator = validator
+    # @param [OpenAPIParser::SchemaValidator::Validatable] validatable
+    def initialize(validatable, coerce_value)
+      @validatable = validatable
       @coerce_value = coerce_value
     end
 
-    attr_reader :validator
+    attr_reader :validatable
 
-    # @!attribute [r] validator
-    #   @return [OpenAPIParser::SchemaValidator]
+    # @!attribute [r] validatable
+    #   @return [OpenAPIParser::SchemaValidator::Validatable]
 
-    # return  [coerced_value, error]
+    # need override
+    # @param [Array] _value
+    # @param [OpenAPIParser::Schemas::Schema] _schema
     def coerce_and_validate(_value, _schema)
       raise 'need implement'
     end

data/lib/openapi_parser/schema_validators/boolean_validator.rb

@@ -1,22 +1,24 @@
 class OpenAPIParser::SchemaValidator
   class BooleanValidator < Base
+    TRUE_VALUES = ['true', '1'].freeze
+    FALSE_VALUES = ['false', '0'].freeze
+
     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)
+      return OpenAPIParser::ValidateError.build_error_result(value, schema) unless value.kind_of?(TrueClass) || value.kind_of?(FalseClass)
+
       [value, nil]
     end
 
     private
 
-    def coerce(value)
-      if value == "true" || value == "1"
-        return true
-      end
-      if value == "false" || value == "0"
-        return false
+      def coerce(value)
+        return true if TRUE_VALUES.include?(value)
+
+        return false if FALSE_VALUES.include?(value)
+
+        value
       end
-      value
-    end
   end
 end

data/lib/openapi_parser/schema_validators/float_validator.rb

@@ -5,25 +5,23 @@ class OpenAPIParser::SchemaValidator
     def coerce_and_validate(value, schema)
       value = coerce(value) if @coerce_value
 
-      return validator.validate_integer(value, schema) if value.is_a?(Integer)
+      return OpenAPIParser::ValidateError.build_error_result(value, schema) if value.kind_of?(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
+      def coercer_and_validate_numeric(value, schema)
+        return OpenAPIParser::ValidateError.build_error_result(value, schema) unless value.kind_of?(Numeric)
 
-    private
+        check_enum_include(value, schema)
+      end
 
-    def coerce(value)
-      begin
-        return Float(value)
+      def coerce(value)
+        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

@@ -5,22 +5,23 @@ class OpenAPIParser::SchemaValidator
     def coerce_and_validate(value, schema)
       value = coerce(value) if @coerce_value
 
-      return validator.validate_error(value, schema) unless value.is_a?(Integer)
+      return OpenAPIParser::ValidateError.build_error_result(value, schema) unless value.kind_of?(Integer)
+
       check_enum_include(value, schema)
     end
 
     private
 
-    def coerce(value)
-      return value if value.is_a?(Integer)
+      def coerce(value)
+        return value if value.kind_of?(Integer)
 
-      begin
-        return Integer(value)
-      rescue ArgumentError => e
-        raise e unless e.message =~ /invalid value for Integer/
-      end
+        begin
+          return Integer(value)
+        rescue ArgumentError => e
+          raise e unless e.message =~ /invalid value for Integer/
+        end
 
-      value
-    end
+        value
+      end
   end
 end

data/lib/openapi_parser/schema_validators/nil_validator.rb

@@ -4,6 +4,7 @@ class OpenAPIParser::SchemaValidator
     # @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

data/lib/openapi_parser/schema_validators/object_validator.rb

@@ -1,17 +1,17 @@
 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 OpenAPIParser::ValidateError.build_error_result(value, schema) unless value.kind_of?(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)
+        coerced, err = validatable.validate_schema(v, s)
         return [nil, err] if err
 
         required_set.delete(name)

data/lib/openapi_parser/schema_validators/string_validator.rb

@@ -8,7 +8,7 @@ class OpenAPIParser::SchemaValidator
     end
 
     def coerce_and_validate(value, schema)
-      return validator.validate_error(value, schema) unless value.is_a?(String)
+      return OpenAPIParser::ValidateError.build_error_result(value, schema) unless value.kind_of?(String)
 
       value, err = check_enum_include(value, schema)
       return [nil, err] if err
@@ -20,19 +20,19 @@ class OpenAPIParser::SchemaValidator
 
     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/
+      # @param [OpenAPIParser::Schemas::Schema] schema
+      def coerce_date_time(value, schema)
+        (schema.format == 'date-time') ? parse_date_time(value) : value
       end
 
-      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

@@ -1,6 +1,6 @@
 module OpenAPIParser::Schemas
   class Base
-    include OpenAPIParser::Parseable
+    include OpenAPIParser::Parser
     include OpenAPIParser::Findable
     include OpenAPIParser::Expandable
 
@@ -19,7 +19,6 @@ module OpenAPIParser::Schemas
 
     # override
     def after_init
-
     end
 
     def inspect

data/lib/openapi_parser/schemas/media_type.rb

@@ -5,10 +5,12 @@
 module OpenAPIParser::Schemas
   class MediaType < Base
     # @!attribute [r] schema
-    #   @return [Schema, nil]
+    #   @return [Schema, nil] OpenAPI3 Schema object
     openapi_attr_object :schema, Schema, reference: true
 
+    # validate params by schema definitions
     # @param [Hash] params
+    # @param [OpenAPIParser::SchemaValidator::Options] options
     def validate_parameter(params, options)
       OpenAPIParser::SchemaValidator.validate(params, schema, options)
     end

data/lib/openapi_parser/schemas/openapi.rb

@@ -8,7 +8,7 @@ module OpenAPIParser::Schemas
     def initialize(raw_schema, config)
       super('#', nil, self, raw_schema)
       @find_object_cache = {}
-      @path_item_finder = OpenAPIParser::PathItemFinder.new(paths)
+      @path_item_finder = OpenAPIParser::PathItemFinder.new(paths) if paths # invalid definition
       @config = config
     end
 

data/lib/openapi_parser/schemas/operation.rb

@@ -12,15 +12,18 @@ module OpenAPIParser::Schemas
     openapi_attr_list_object :parameters, Parameter, reference: true
 
     # @!attribute [r] request_body
-    #   @return [OpenAPIParser::Schemas::RequestBody, nil]
+    #   @return [OpenAPIParser::Schemas::RequestBody, nil] return OpenAPI3 object
     openapi_attr_object :request_body, RequestBody, reference: true, schema_key: :requestBody
 
+    # @!attribute [r] responses
+    #   @return [OpenAPIParser::Schemas::Responses, nil] return OpenAPI3 object
     openapi_attr_object :responses, Responses, reference: false
 
     def validate_request_body(content_type, params, options)
       request_body&.validate_request_body(content_type, params, options)
     end
 
+    # @param [Integer] status_code
     def validate_response_body(status_code, content_type, data)
       responses&.validate_response_body(status_code, content_type, data)
     end
@@ -36,18 +39,18 @@ module OpenAPIParser::Schemas
 
     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
+      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

@@ -12,11 +12,11 @@ module OpenAPIParser::Schemas
     openapi_attr_object :schema, Schema, reference: true
 
     def in_query?
-      self.in == "query"
+      self.in == 'query'
     end
 
     def in_path?
-      self.in == "path"
+      self.in == 'path'
     end
 
     # @return [Object] coerced or original params

data/lib/openapi_parser/schemas/request_body.rb

@@ -2,16 +2,23 @@
 
 module OpenAPIParser::Schemas
   class RequestBody < Base
+    include OpenAPIParser::MediaTypeSelectable
+
+    # @!attribute [r] description
+    #   @return [String] description data
+    # @!attribute [r] required
+    #   @return [Boolean] required bool data
     openapi_attr_values :description, :required
 
     # @!attribute [r] content
-    #   @return [Hash{String => MediaType}, nil]
+    #   @return [Hash{String => MediaType}, nil] content type to MediaType object
     openapi_attr_hash_object :content, MediaType, reference: false
 
-    def validate_request_body(_content_type, params, options)
-      # TODO: now support application/json only :(
-
-      media_type = content['application/json']
+    # @param [String] content_type
+    # @param [Hash] params
+    # @param [OpenAPIParser::SchemaValidator::Options] options
+    def validate_request_body(content_type, params, options)
+      media_type = select_media_type(content_type, content)
       return params unless media_type
 
       media_type.validate_parameter(params, options)

data/lib/openapi_parser/schemas/response.rb

@@ -3,16 +3,16 @@
 
 module OpenAPIParser::Schemas
   class Response < Base
+    include OpenAPIParser::MediaTypeSelectable
+
     openapi_attr_values :description
 
     # @!attribute [r] content
-    #   @return [Hash{String => MediaType}, nil]
+    #   @return [Hash{String => MediaType}, nil] content_type to MediaType hash
     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]
+      media_type = select_media_type(content_type, content)
       return nil unless media_type
 
       options = ::OpenAPIParser::SchemaValidator::Options.new # response validator not support any options

data/lib/openapi_parser/schemas/responses.rb

@@ -3,22 +3,40 @@
 module OpenAPIParser::Schemas
   class Responses < Base
     # @!attribute [r] default
-    #   @return [Response, Reference, nil]
+    #   @return [Response, Reference, nil] default response object
     openapi_attr_object :default, Response, reference: true
 
     # @!attribute [r] response
-    #   @return [Hash{String => Response, Reference}, nil]
+    #   @return [Hash{String => Response, Reference}, nil] response object indexed by status code. see: https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.0.2.md#patterned-fields-1
     openapi_attr_hash_body_objects 'response', Response, reject_keys: [:default], allow_reference: true, allow_data_type: false
 
+    # validate params data by definition
+    # find response object by status_code and content_type
+    # https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.0.2.md#patterned-fields-1
+    # @param [Integer] status_code
+    # @param [String] content_type
+    # @param [Hash] params
     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
 
+      wild_card = status_code_to_wild_card(status_code)
+      res = response[wild_card]
+      return res.validate_parameter(content_type, params) if res
 
       default&.validate_parameter(content_type, params)
     end
+
+    private
+
+      # parse 400 -> 4xx
+      # OpenAPI3 allow 1xx, 2xx, 3xx... only, don't allow 41x
+      # @param [Integer] status_code
+      def status_code_to_wild_card(status_code)
+        top = status_code / 100
+        "#{top}XX"
+      end
   end
 end