openapi_parser_firetail 1.0.0

data/lib/openapi_parser/concerns/parameter_validatable.rb

@@ -0,0 +1,62 @@
+module OpenAPIParser::ParameterValidatable
+  # @param [Hash] path_params path parameters
+  # @param [OpenAPIParser::SchemaValidator::Options] options request validator options
+  def validate_path_params(path_params, options)
+    OpenAPIParser::ParameterValidator.validate_parameter(path_parameter_hash, path_params, object_reference, options)
+  end
+
+  # @param [Hash] params parameter hash
+  # @param [Hash] headers headers hash
+  # @param [OpenAPIParser::SchemaValidator::Options] options request validator options
+  def validate_request_parameter(params, headers, options)
+    validate_header_parameter(headers, object_reference, options) if options.validate_header
+    validate_query_parameter(params, object_reference, options)
+  end
+
+  # @param [PathItem] path_item parent
+  def set_parent_path_item(path_item)
+    @merged_parameter = (parameters || []) + (path_item.parameters || [])
+    nil
+  end
+
+  private
+
+    # @param [Hash] params query parameter hash
+    # @param [String] object_reference
+    # @param [OpenAPIParser::SchemaValidator::Options] options request validator options
+    def validate_query_parameter(params, object_reference, options)
+      OpenAPIParser::ParameterValidator.validate_parameter(query_parameter_hash, params, object_reference, options)
+    end
+
+    # @param [Hash] headers header hash
+    # @param [String] object_reference
+    # @param [OpenAPIParser::SchemaValidator::Options] options request validator options
+    def validate_header_parameter(headers, object_reference, options)
+      OpenAPIParser::ParameterValidator.validate_parameter(header_parameter_hash, headers, object_reference, options, true)
+    end
+
+    def header_parameter_hash
+      divided_parameter_hash['header'] || []
+    end
+
+    def path_parameter_hash
+      divided_parameter_hash['path'] || []
+    end
+
+    def query_parameter_hash
+      divided_parameter_hash['query'] || []
+    end
+
+    # @return [Hash{String => Hash{String => Parameter}}] hash[in][name] => Parameter
+    def divided_parameter_hash
+      @divided_parameter_hash ||=
+        (@merged_parameter || []).
+          group_by(&:in).
+          map { |in_type, params| # rubocop:disable Style/BlockDelimiters
+          [
+            in_type,
+            params.map { |param| [param.name, param] }.to_h,
+          ]
+        }.to_h
+    end
+end

data/lib/openapi_parser/concerns/parser/core.rb

@@ -0,0 +1,21 @@
+require_relative './value'
+require_relative './object'
+require_relative './list'
+require_relative './hash'
+require_relative './hash_body'
+
+class OpenAPIParser::Parser::Core
+  include OpenAPIParser::Parser::Value
+  include OpenAPIParser::Parser::Object
+  include OpenAPIParser::Parser::List
+  include OpenAPIParser::Parser::Hash
+  include OpenAPIParser::Parser::HashBody
+
+  def initialize(target_klass)
+    @target_klass = target_klass
+  end
+
+  private
+
+    attr_reader :target_klass
+end

data/lib/openapi_parser/concerns/parser/hash.rb

@@ -0,0 +1,10 @@
+module OpenAPIParser::Parser::Hash
+  def _openapi_attr_hash_objects
+    @_openapi_attr_hash_objects ||= {}
+  end
+
+  def openapi_attr_hash_object(name, klass, options = {})
+    target_klass.send(:attr_reader, name)
+    _openapi_attr_hash_objects[name] = ::OpenAPIParser::SchemaLoader::HashObjectsLoader.new(name, options.merge(klass: klass))
+  end
+end

data/lib/openapi_parser/concerns/parser/hash_body.rb

@@ -0,0 +1,12 @@
+module OpenAPIParser::Parser::HashBody
+  def _openapi_attr_hash_body_objects
+    @_openapi_attr_hash_body_objects ||= {}
+  end
+
+  def openapi_attr_hash_body_objects(name, klass, options = {})
+    # options[:reject_keys] = options[:reject_keys] ? options[:reject_keys].map(&:to_s) : []
+
+    target_klass.send(:attr_reader, name)
+    _openapi_attr_hash_body_objects[name] = ::OpenAPIParser::SchemaLoader::HashBodyLoader.new(name, options.merge(klass: klass))
+  end
+end

data/lib/openapi_parser/concerns/parser/list.rb

@@ -0,0 +1,10 @@
+module OpenAPIParser::Parser::List
+  def _openapi_attr_list_objects
+    @_openapi_attr_list_objects ||= {}
+  end
+
+  def openapi_attr_list_object(name, klass, options = {})
+    target_klass.send(:attr_reader, name)
+    _openapi_attr_list_objects[name] = OpenAPIParser::SchemaLoader::ListLoader.new(name, options.merge(klass: klass))
+  end
+end

data/lib/openapi_parser/concerns/parser/object.rb

@@ -0,0 +1,14 @@
+module OpenAPIParser::Parser::Object
+  def _openapi_attr_objects
+    @_openapi_attr_objects ||= {}
+  end
+
+  def openapi_attr_objects(*names, klass)
+    names.each { |name| openapi_attr_object(name, klass) }
+  end
+
+  def openapi_attr_object(name, klass, options = {})
+    target_klass.send(:attr_reader, name)
+    _openapi_attr_objects[name] = OpenAPIParser::SchemaLoader::ObjectsLoader.new(name, options.merge(klass: klass))
+  end
+end

data/lib/openapi_parser/concerns/parser/value.rb

@@ -0,0 +1,14 @@
+module OpenAPIParser::Parser::Value
+  def _openapi_attr_values
+    @_openapi_attr_values ||= {}
+  end
+
+  def openapi_attr_values(*names)
+    names.each { |name| openapi_attr_value(name) }
+  end
+
+  def openapi_attr_value(name, options = {})
+    target_klass.send(:attr_reader, name)
+    _openapi_attr_values[name] = OpenAPIParser::SchemaLoader::ValuesLoader.new(name, options)
+  end
+end

data/lib/openapi_parser/concerns/parser.rb

@@ -0,0 +1,45 @@
+module OpenAPIParser::Parser
+end
+
+require 'forwardable'
+
+require_relative './parser/core'
+require_relative './schema_loader'
+
+module OpenAPIParser::Parser
+  def self.included(base)
+    base.extend(ClassMethods)
+  end
+  module ClassMethods
+    extend Forwardable
+
+    def_delegators :_parser_core, :_openapi_attr_values, :openapi_attr_value, :openapi_attr_values
+    def_delegators :_parser_core, :_openapi_attr_objects, :openapi_attr_objects, :openapi_attr_object
+    def_delegators :_parser_core, :_openapi_attr_list_objects, :openapi_attr_list_object
+    def_delegators :_parser_core, :_openapi_attr_hash_objects, :openapi_attr_hash_object
+    def_delegators :_parser_core, :_openapi_attr_hash_body_objects, :openapi_attr_hash_body_objects
+
+    def _parser_core
+      @_parser_core ||= OpenAPIParser::Parser::Core.new(self)
+    end
+  end
+
+  # @param [OpenAPIParser::Schemas::Base] old
+  # @param [OpenAPIParser::Schemas::Base] new
+  def _update_child_object(old, new)
+    _openapi_all_child_objects[old.object_reference] = new
+  end
+
+  # @return [Hash{String => OpenAPIParser::Schemas::Base}]
+  def _openapi_all_child_objects
+    @_openapi_all_child_objects ||= {}
+  end
+
+  # load data by schema definition in core and set children to _openapi_all_child_objects
+  # @return nil
+  def load_data
+    loader = ::OpenAPIParser::SchemaLoader.new(self, self.class._parser_core)
+    @_openapi_all_child_objects = loader.load_data
+    nil
+  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 if schema.nil?
+
+      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/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/config.rb

@@ -0,0 +1,55 @@
+class OpenAPIParser::Config
+  def initialize(config)
+    # TODO: This deprecation warning can be removed after we set the default to `true`
+    # in a later (major?) version update.
+    unless config.key?(:strict_reference_validation)
+      msg = "[DEPRECATION] strict_reference_validation config is not set. It defaults to `false` now, " +
+          "but will be `true` in a future version. Please explicitly set to `false` " +
+          "if you want to skip reference validation on schema load."
+      warn(msg)
+    end
+    @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 strict_response_validation
+    # TODO: in a major version update, change this to default to `true`.
+    # https://github.com/ota42y/openapi_parser/pull/123/files#r767142217
+    @config.fetch(:strict_response_validation, false)
+  end
+
+  def strict_reference_validation
+    @config.fetch(:strict_reference_validation, false)
+  end
+
+  def validate_header
+    @config.fetch(:validate_header, true)
+  end
+
+  # @return [OpenAPIParser::SchemaValidator::Options]
+  def request_validator_options
+    @request_validator_options ||= OpenAPIParser::SchemaValidator::Options.new(coerce_value: coerce_value,
+                                                                               datetime_coerce_class: datetime_coerce_class,
+                                                                               validate_header: validate_header)
+  end
+
+  alias_method :request_body_options, :request_validator_options
+  alias_method :path_params_options, :request_validator_options
+
+  # @return [OpenAPIParser::SchemaValidator::ResponseValidateOptions]
+  def response_validate_options
+    @response_validate_options ||= OpenAPIParser::SchemaValidator::ResponseValidateOptions.
+                                     new(strict: strict_response_validation, validate_header: validate_header)
+  end
+end