openapi_parser 0.1.5 → 0.1.6

data/lib/openapi_parser/concerns/schema_loader.rb

@@ -0,0 +1,58 @@
+class OpenAPIParser::SchemaLoader
+end
+
+require_relative './schema_loader/base'
+require_relative './schema_loader/creator'
+require_relative './schema_loader/values_loader'
+require_relative './schema_loader/list_loader'
+require_relative './schema_loader/objects_loader'
+require_relative './schema_loader/hash_objects_loader'
+require_relative './schema_loader/hash_body_loader'
+
+# load data to target_object by schema definition in core
+class OpenAPIParser::SchemaLoader
+  # @param [OpenAPIParser::Schemas::Base] target_object
+  # @param [OpenAPIParser::Parser::Core] core
+  def initialize(target_object, core)
+    @target_object = target_object
+    @core = core
+    @children = {}
+  end
+
+  # @!attribute [r] children
+  #   @return [Array<OpenAPIParser::Schemas::Base>]
+  attr_reader :children
+
+  # execute load data
+  # return data is equal to :children
+  # @return [Array<OpenAPIParser::Schemas::Base>]
+  def load_data
+    all_loader.each { |l| load_data_by_schema_loader(l) }
+    children
+  end
+
+  private
+
+    attr_reader :core, :target_object
+
+    # @param [OpenAPIParser::SchemaLoader::Base] schema_loader
+    def load_data_by_schema_loader(schema_loader)
+      children = schema_loader.load_data(target_object, target_object.raw_schema)
+
+      children.each { |c| register_child(c) } if children
+    end
+
+    def register_child(object)
+      return unless object.kind_of?(OpenAPIParser::Parser)
+
+      @children[object.object_reference] = object
+    end
+
+    def all_loader
+      core._openapi_attr_values.values +
+        core._openapi_attr_objects.values +
+        core._openapi_attr_list_objects.values +
+        core._openapi_attr_hash_objects.values +
+        core._openapi_attr_hash_body_objects.values
+    end
+end

data/lib/openapi_parser/concerns/schema_loader/base.rb

@@ -0,0 +1,28 @@
+# loader base class
+class OpenAPIParser::SchemaLoader::Base
+  # @param [String] variable_name
+  # @param [Hash] options
+  def initialize(variable_name, options)
+    @variable_name = variable_name
+    @schema_key = options[:schema_key] || variable_name
+  end
+
+  # @param [OpenAPIParser::Schemas::Base] _target_object
+  # @param [Hash] _raw_schema
+  # @return [Array<OpenAPIParser::Schemas::Base>, nil]
+  def load_data(_target_object, _raw_schema)
+    raise 'need implement'
+  end
+
+  private
+
+    attr_reader :variable_name, :schema_key
+
+    # create instance variable @variable_name using data
+    # @param [OpenAPIParser::Schemas::Base] target
+    # @param [String] variable_name
+    # @param [Object] data
+    def variable_set(target, variable_name, data)
+      target.instance_variable_set("@#{variable_name}", data)
+    end
+end

data/lib/openapi_parser/concerns/schema_loader/creator.rb

@@ -0,0 +1,48 @@
+# loader base class for create OpenAPI::Schemas::Base object
+class OpenAPIParser::SchemaLoader::Creator < OpenAPIParser::SchemaLoader::Base
+  # @param [String] variable_name
+  # @param [Hash] options
+  def initialize(variable_name, options)
+    super(variable_name, options)
+
+    @klass = options[:klass]
+    @allow_reference = options[:reference] || false
+    @allow_data_type = options[:allow_data_type]
+  end
+
+  private
+
+    attr_reader :klass, :allow_reference, :allow_data_type
+
+    def build_object_reference_from_base(base, names)
+      names = [names] unless names.kind_of?(Array)
+      ref = names.map { |n| escape_reference(n) }.join('/')
+
+      "#{base}/#{ref}"
+    end
+
+    # @return Boolean
+    def check_reference_schema?(check_schema)
+      check_object_schema?(check_schema) && !check_schema['$ref'].nil?
+    end
+
+    def check_object_schema?(check_schema)
+      check_schema.kind_of?(::Hash)
+    end
+
+    def escape_reference(str)
+      str.to_s.gsub('/', '~1')
+    end
+
+    def build_openapi_object_from_option(target_object, ref, schema)
+      return nil unless schema
+
+      if @allow_data_type && !check_object_schema?(schema)
+        schema
+      elsif @allow_reference && check_reference_schema?(schema)
+        OpenAPIParser::Schemas::Reference.new(ref, target_object, target_object.root, schema)
+      else
+        @klass.new(ref, target_object, target_object.root, schema)
+      end
+    end
+end

data/lib/openapi_parser/concerns/schema_loader/hash_body_loader.rb

@@ -0,0 +1,37 @@
+# hash body object loader
+class OpenAPIParser::SchemaLoader::HashBodyLoader < OpenAPIParser::SchemaLoader::Creator
+  # @param [String] variable_name
+  # @param [Hash] options
+  def initialize(variable_name, options)
+    super(variable_name, options)
+
+    @reject_keys = options[:reject_keys] ? options[:reject_keys].map(&:to_s) : []
+  end
+
+  # @param [OpenAPIParser::Schemas::Base] target_object
+  # @param [Hash] raw_schema
+  # @return [Array<OpenAPIParser::Schemas::Base>, nil]
+  def load_data(target_object, raw_schema)
+    # raw schema always exist because if not exist' this object don't create
+    create_hash_body_objects(target_object, raw_schema)
+  end
+
+  private
+
+    # for responses and paths object
+    def create_hash_body_objects(target_object, raw_schema)
+      object_list = raw_schema.reject { |k, _| reject_keys.include?(k) }.map do |child_name, child_schema|
+        ref = build_object_reference_from_base(target_object.object_reference, escape_reference(child_name))
+        [
+          child_name.to_s, # support string key only in OpenAPI3
+          build_openapi_object_from_option(target_object, ref, child_schema),
+        ]
+      end
+
+      objects = object_list.to_h
+      variable_set(target_object, variable_name, objects)
+      objects.values
+    end
+
+    attr_reader :reject_keys
+end

data/lib/openapi_parser/concerns/schema_loader/hash_objects_loader.rb

@@ -0,0 +1,29 @@
+# hash object loader
+class OpenAPIParser::SchemaLoader::HashObjectsLoader < OpenAPIParser::SchemaLoader::Creator
+  # @param [OpenAPIParser::Schemas::Base] target_object
+  # @param [Hash] raw_schema
+  # @return [Array<OpenAPIParser::Schemas::Base>, nil]
+  def load_data(target_object, raw_schema)
+    create_attr_hash_object(target_object, raw_schema[ref_name_base.to_s])
+  end
+
+  private
+
+    def create_attr_hash_object(target_object, hash_schema)
+      unless hash_schema
+        variable_set(target_object, variable_name, nil)
+        return
+      end
+
+      data_list = hash_schema.map do |key, s|
+        ref = build_object_reference_from_base(target_object.object_reference, [ref_name_base, key])
+        [key, build_openapi_object_from_option(target_object, ref, s)]
+      end
+
+      data = data_list.to_h
+      variable_set(target_object, variable_name, data)
+      data.values
+    end
+
+    alias_method :ref_name_base, :schema_key
+end

data/lib/openapi_parser/concerns/schema_loader/list_loader.rb

@@ -0,0 +1,28 @@
+# list object loader
+class OpenAPIParser::SchemaLoader::ListLoader < OpenAPIParser::SchemaLoader::Creator
+  # @param [OpenAPIParser::Schemas::Base] target_object
+  # @param [Hash] raw_schema
+  # @return [Array<OpenAPIParser::Schemas::Base>, nil]
+  def load_data(target_object, raw_schema)
+    create_attr_list_object(target_object, raw_schema[ref_name_base.to_s])
+  end
+
+  private
+
+    def create_attr_list_object(target_object, array_schema)
+      unless array_schema
+        variable_set(target_object, variable_name, nil)
+        return
+      end
+
+      data = array_schema.map.with_index do |s, idx|
+        ref = build_object_reference_from_base(target_object.object_reference, [ref_name_base, idx])
+        build_openapi_object_from_option(target_object, ref, s)
+      end
+
+      variable_set(target_object, variable_name, data)
+      data
+    end
+
+    alias_method :ref_name_base, :schema_key
+end

data/lib/openapi_parser/concerns/schema_loader/objects_loader.rb

@@ -0,0 +1,21 @@
+# Specific Object loader (defined by klass option)
+class OpenAPIParser::SchemaLoader::ObjectsLoader < OpenAPIParser::SchemaLoader::Creator
+  # @param [OpenAPIParser::Schemas::Base] target_object
+  # @param [Hash] raw_schema
+  # @return [Array<OpenAPIParser::Schemas::Base>, nil]
+  def load_data(target_object, raw_schema)
+    obj = create_attr_object(target_object, raw_schema[schema_key.to_s])
+    [obj]
+  end
+
+  private
+
+    # @return [OpenAPIParser::Schemas::Base]
+    def create_attr_object(target_object, schema)
+      ref = build_object_reference_from_base(target_object.object_reference, schema_key)
+
+      data = build_openapi_object_from_option(target_object, ref, schema)
+      variable_set(target_object, variable_name, data)
+      data
+    end
+end

data/lib/openapi_parser/concerns/schema_loader/values_loader.rb

@@ -0,0 +1,10 @@
+# data type values loader
+class OpenAPIParser::SchemaLoader::ValuesLoader < OpenAPIParser::SchemaLoader::Base
+  # @param [OpenAPIParser::Schemas::Base] target_object
+  # @param [Hash] raw_schema
+  # @return [Array<OpenAPIParser::Schemas::Base>, nil]
+  def load_data(target_object, raw_schema)
+    variable_set(target_object, variable_name, raw_schema[schema_key.to_s])
+    nil # this loader not return schema object
+  end
+end

data/lib/openapi_parser/config.rb

@@ -16,7 +16,7 @@ class OpenAPIParser::Config
   end
 
   def request_validator_options
-    @request_options ||= OpenAPIParser::SchemaValidator::Options.new(coerce_value: coerce_value, datetime_coerce_class: datetime_coerce_class)
+    @request_validator_options ||= OpenAPIParser::SchemaValidator::Options.new(coerce_value: coerce_value, datetime_coerce_class: datetime_coerce_class)
   end
 
   alias_method :request_body_options, :request_validator_options

data/lib/openapi_parser/errors.rb

@@ -15,6 +15,15 @@ module OpenAPIParser
     def message
       "#{@data} class is #{@data.class} but it's not valid #{@type} in #{@reference}"
     end
+
+    class << self
+      # create ValidateError for SchemaValidator return data
+      # @param [Object] value
+      # @param [OpenAPIParser::Schemas::Base] schema
+      def build_error_result(value, schema)
+        [nil, OpenAPIParser::ValidateError.new(value, schema.type, schema.object_reference)]
+      end
+    end
   end
 
   class NotNullError < OpenAPIError

data/lib/openapi_parser/path_item_finder.rb

@@ -4,7 +4,7 @@ class OpenAPIParser::PathItemFinder
     @root = PathNode.new('/')
     @paths = paths
 
-    @paths.path.each { |path, _path_item_object| @root.register_path_node(path.split("/"), path) }
+    @paths.path.each { |path, _path_item_object| @root.register_path_node(path.split('/'), path) }
   end
 
   # @param [String, Symbol] http_method like (get, post .... allow symbol)
@@ -26,7 +26,7 @@ class OpenAPIParser::PathItemFinder
 
     def initialize(name)
       @name = name
-      @children = Hash.new {|h, k| h[k] = PathNode.new(k) }
+      @children = Hash.new { |h, k| h[k] = PathNode.new(k) }
       @path_template_node = nil # we can't initialize because recursive initialize...
       @full_path = nil
     end
@@ -55,11 +55,11 @@ class OpenAPIParser::PathItemFinder
       # OpenAPI3 depend on the tooling so we use concrete one (using /books/)
 
       path_params = {}
-      if children.key?(path_name)
+      if children.has_key?(path_name)
         child = children[path_name]
       else
         child = path_template_node(path_name)
-        path_params = {"#{child.name}" =>path_name}
+        path_params = { child.name.to_s => path_name }
       end
 
       ret, other_path_params = child.find_full_path(splited_path)
@@ -68,26 +68,26 @@ class OpenAPIParser::PathItemFinder
 
     private
 
-    attr_reader :children
+      attr_reader :children
 
-    def path_template_node(path_name)
-      @path_template_node ||= PathNode.new(path_name[1..(path_name.length-2)]) # delete {} from {name}
-    end
+      def path_template_node(path_name)
+        @path_template_node ||= PathNode.new(path_name[1..(path_name.length - 2)]) # delete {} from {name}
+      end
 
-    def path_template?(path_name)
-      path_name.start_with?('{') && path_name.end_with?('}')
-    end
+      def path_template?(path_name)
+        path_name.start_with?('{') && path_name.end_with?('}')
+      end
   end
 
   private
 
-  def parse_request_path(http_method, request_path)
-    original_path, path_params = @root.find_full_path(request_path.split("/"))
-    return nil, nil, {} unless original_path # # can't find
+    def parse_request_path(http_method, request_path)
+      original_path, path_params = @root.find_full_path(request_path.split('/'))
+      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)
+      path_item_object = @paths.path[original_path]
+      obj = path_item_object.operation(http_method.to_s)
 
-    [obj, original_path, path_params]
-  end
+      [obj, original_path, path_params]
+    end
 end

data/lib/openapi_parser/request_operation.rb

@@ -36,22 +36,22 @@ class OpenAPIParser::RequestOperation
   end
 
   def validate_path_params(options = nil)
-    options = config.path_params_options unless options
+    options ||= config.path_params_options
     operation_object&.validate_path_params(path_params, options)
   end
 
-  # support application/json only :(
   def validate_request_body(content_type, params, options = nil)
-    options = config.request_body_options unless options
+    options ||= config.request_body_options
     operation_object&.validate_request_body(content_type, params, options)
   end
 
+  # @param [Integer] status_code
   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
+    options ||= config.request_validator_options
     operation_object&.validate_request_parameter(params, options)
   end
 end

data/lib/openapi_parser/schema_validator.rb

@@ -8,14 +8,24 @@ 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/all_of_validator'
 require_relative 'schema_validators/nil_validator'
 
 class OpenAPIParser::SchemaValidator
-  class ValidatorOption
-
+  # validate value by schema
+  # this module for SchemaValidators::Base
+  # @param [Object] value
+  # @param [OpenAPIParser::Schemas::Schema] schema
+  module Validatable
+    def validate_schema(value, schema)
+      raise 'implement'
+    end
   end
 
+  include Validatable
+
   class << self
+    # validate schema data
     # @param [Hash] value
     # @param [OpenAPIParser::Schemas::Schema]
     # @param [OpenAPIParser::SchemaValidator::Options] options
@@ -35,75 +45,88 @@ class OpenAPIParser::SchemaValidator
     @datetime_coerce_class = options.datetime_coerce_class
   end
 
+  # execute validate data
   # @return [Object] coerced or original params
   def validate_data
     coerced, err = validate_schema(@value, @schema)
     raise err if err
+
     coerced
   end
 
-  def validate_error(value, schema)
-    [nil, OpenAPIParser::ValidateError.new(value, schema.type, schema.object_reference)]
-  end
+  # validate value eby schema
+  # @param [Object] value
+  # @param [OpenAPIParser::Schemas::Schema] schema
+  def validate_schema(value, schema)
+    return [value, nil] unless schema
 
-  def validate_string(value, schema)
-    (@string_validator ||= OpenAPIParser::SchemaValidator::StringValidator.new(self, @coerce_value, @datetime_coerce_class)).coerce_and_validate(value, schema)
-  end
+    if (v = validator(value, schema))
+      return v.coerce_and_validate(value, schema)
+    end
 
-  def validate_integer(value, schema)
-    (@integer_validator ||= OpenAPIParser::SchemaValidator::IntegerValidator.new(self, @coerce_value)).coerce_and_validate(value, schema)
+    # unknown return error
+    OpenAPIParser::ValidateError.build_error_result(value, schema)
   end
 
-  def validate_float(value, schema)
-    (@float_validator ||= OpenAPIParser::SchemaValidator::FloatValidator.new(self, @coerce_value)).coerce_and_validate(value, schema)
-  end
+  private
+
+    # @return [OpenAPIParser::SchemaValidator::Base, nil]
+    def validator(value, schema)
+      return any_of_validator if schema.any_of
+      return all_of_validator if schema.all_of
+      return nil_validator if value.nil?
+
+      case schema.type
+      when 'string'
+        string_validator
+      when 'integer'
+        integer_validator
+      when 'boolean'
+        boolean_validator
+      when 'number'
+        float_validator
+      when 'object'
+        object_validator
+      when 'array'
+        array_validator
+      else
+        nil
+      end
+    end
 
-  def validate_boolean(value, schema)
-    (@boolean_validator ||= OpenAPIParser::SchemaValidator::BooleanValidator.new(self, @coerce_value)).coerce_and_validate(value, schema)
-  end
+    def string_validator
+      @string_validator ||= OpenAPIParser::SchemaValidator::StringValidator.new(self, @coerce_value, @datetime_coerce_class)
+    end
 
-  def validate_object(value, schema)
-    (@object_validator ||= OpenAPIParser::SchemaValidator::ObjectValidator.new(self, @coerce_value)).coerce_and_validate(value, schema)
-  end
+    def integer_validator
+      @integer_validator ||= OpenAPIParser::SchemaValidator::IntegerValidator.new(self, @coerce_value)
+    end
 
-  def validate_array(value, schema)
-    (@array_validator ||= OpenAPIParser::SchemaValidator::ArrayValidator.new(self, @coerce_value)).coerce_and_validate(value, schema)
-  end
+    def float_validator
+      @float_validator ||= OpenAPIParser::SchemaValidator::FloatValidator.new(self, @coerce_value)
+    end
 
-  def validate_any_of(value, schema)
-    (@any_of_validator ||= OpenAPIParser::SchemaValidator::AnyOfValidator.new(self, @coerce_value)).coerce_and_validate(value, schema)
-  end
+    def boolean_validator
+      @boolean_validator ||= OpenAPIParser::SchemaValidator::BooleanValidator.new(self, @coerce_value)
+    end
 
-  def validate_nil(value, schema)
-    (@nil_validator ||= OpenAPIParser::SchemaValidator::NilValidator.new(self, @coerce_value)).coerce_and_validate(value, schema)
-  end
+    def object_validator
+      @object_validator ||= OpenAPIParser::SchemaValidator::ObjectValidator.new(self, @coerce_value)
+    end
 
-  # @param [Object] value
-  # @param [OpenAPIParser::Schemas::Schema] schema
-  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?
-
-    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
+    def array_validator
+      @array_validator ||= OpenAPIParser::SchemaValidator::ArrayValidator.new(self, @coerce_value)
     end
 
-    validate_error(value, schema)
-  end
+    def any_of_validator
+      @any_of_validator ||= OpenAPIParser::SchemaValidator::AnyOfValidator.new(self, @coerce_value)
+    end
+
+    def all_of_validator
+      @all_of_validator ||= OpenAPIParser::SchemaValidator::AllOfValidator.new(self, @coerce_value)
+    end
+
+    def nil_validator
+      @nil_validator ||= OpenAPIParser::SchemaValidator::NilValidator.new(self, @coerce_value)
+    end
 end