request_handler 2.2.0 → 3.0.0

data/lib/request_handler/page_parser.rb

@@ -1,23 +1,28 @@
 # frozen_string_literal: true
 
-require 'request_handler/error'
-require 'request_handler/base_parser'
+require "request_handler/concerns/config_helper"
+require "request_handler/error"
 
 module RequestHandler
-  class PageParser < BaseParser
+  class PageParser
+    include RequestHandler::Concerns::ConfigHelper
+
     def initialize(params:, page_config:)
       missing_arguments = []
-      missing_arguments << { params: 'is missing' } if params.nil?
-      missing_arguments << { page_config: 'is missing' } if page_config.nil?
-      raise MissingArgumentError, missing_arguments unless missing_arguments.empty?
-      @page_options = params.fetch('page') { {} }
-      raise PageParamsError, page: 'must be a Hash' unless @page_options.is_a?(Hash)
+      missing_arguments << { params: "is missing" } if params.nil?
+      missing_arguments << { page_config: "is missing" } if page_config.nil?
+      raise MissingArgumentError.new(missing_arguments) unless missing_arguments.empty?
+
+      @page_options = params.fetch("page") { {} }
+      raise PageParamsError.new(page: "must be a Hash") unless @page_options.is_a?(Hash)
+
       @config = page_config
     end
 
     def run
       cfg = deep_to_h(config).keys.reduce(base_page) do |memo, key|
         next memo if TOP_LEVEL_PAGE_KEYS.include?(key)
+
         memo.merge!("#{key}#{separator}number".to_sym => extract_number(prefix: key),
                     "#{key}#{separator}size".to_sym   => extract_size(prefix: key))
       end
@@ -37,12 +42,13 @@ module RequestHandler
     def check_for_missing_options(config)
       missing_arguments = page_options.keys - config.keys.map(&:to_s)
       return if missing_arguments.empty?
-      missing_arguments.map! { |e| e.gsub(separator, '.') }
-      warn 'client sent unknown option ' + missing_arguments.to_s unless missing_arguments.empty?
+
+      missing_arguments.map! { |e| e.gsub(separator, ".") }
+      warn "client sent unknown option #{missing_arguments}" unless missing_arguments.empty?
     end
 
     def extract_number(prefix: nil)
-      number_string = lookup_nested_params_key('number', prefix) || 1
+      number_string = lookup_nested_params_key("number", prefix) || 1
       check_int(string: number_string, param: "#{prefix}.number")
     end
 
@@ -50,41 +56,43 @@ module RequestHandler
       size = fetch_and_check_size(prefix)
       default_size = fetch_and_check_default_size(prefix)
       return default_size if size.nil?
+
       apply_max_size_constraint(size, prefix)
     end
 
     def fetch_and_check_default_size(prefix)
-      default_size = lookup_nested_config_key('default_size', prefix)
+      default_size = lookup_nested_config_key("default_size", prefix)
       raise_no_default_size(prefix) if default_size.nil?
-      raise_not_positive(prefix, 'size') unless default_size.is_a?(Integer) && default_size > 0
+      raise_not_positive(prefix, "size") unless default_size.is_a?(Integer) && default_size.positive?
       default_size
     end
 
     def fetch_and_check_size(prefix)
-      size_string = lookup_nested_params_key('size', prefix)
+      size_string = lookup_nested_params_key("size", prefix)
       return nil if size_string.nil?
+
       check_int(string: size_string, param: "#{prefix}.size") unless size_string.nil?
     end
 
     def check_int(string:, param:)
       output = Integer(string)
-      raise_page_param_error!(param) unless output > 0
+      raise_page_param_error!(param) unless output.positive?
       output
     rescue ArgumentError
       raise_page_param_error!(param)
     end
 
     def raise_page_param_error!(param)
-      raise PageParamsError, [{
-        code: 'INVALID_QUERY_PARAMETER',
-        status: '400',
-        detail: 'must be a positive integer',
-        source: { parameter: "page[#{param}]" }
-      }]
+      raise PageParamsError.new([{
+                                  code:   "INVALID_QUERY_PARAMETER",
+                                  status: "400",
+                                  detail: "must be a positive integer",
+                                  source: { parameter: "page[#{param}]" }
+                                }])
     end
 
     def apply_max_size_constraint(size, prefix)
-      max_size = lookup_nested_config_key('max_size', prefix)
+      max_size = lookup_nested_config_key("max_size", prefix)
       case max_size
       when Integer
         [max_size, size].min
@@ -92,7 +100,7 @@ module RequestHandler
         warn "#{prefix} max_size config not set"
         size
       else
-        raise_not_positive(prefix, 'max_size', ' ')
+        raise_not_positive(prefix, "max_size", " ")
       end
     end
 
@@ -111,11 +119,11 @@ module RequestHandler
     end
 
     def raise_no_default_size(prefix, sep = separator)
-      raise NoConfigAvailableError, :"#{prefix}#{sep}size" => 'has no default_size'
+      raise NoConfigAvailableError.new("#{prefix}#{sep}size": "has no default_size")
     end
 
     def raise_not_positive(prefix, key, sep = separator)
-      raise InternalArgumentError, :"#{prefix}#{sep}#{key}" => 'must be a positive Integer'
+      raise InternalArgumentError.new("#{prefix}#{sep}#{key}": "must be a positive Integer")
     end
 
     def separator

data/lib/request_handler/query_parser.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-require 'request_handler/schema_parser'
-require 'request_handler/error'
+require "request_handler/schema_parser"
+require "request_handler/error"
 module RequestHandler
   class QueryParser < SchemaParser
     RESERVED_KEYS = %w[fields filter include page sort].freeze
@@ -15,13 +15,13 @@ module RequestHandler
     def run
       validate_schema(query)
     rescue SchemaValidationError => e
-      raise ExternalArgumentError, (e.errors.map do |schema_error|
+      raise ExternalArgumentError.new((e.errors.map do |schema_error|
         param = schema_error[:source][:pointer]
-        { status: '400',
-          code: "#{query[param] ? 'INVALID' : 'MISSING'}_QUERY_PARAMETER",
+        { status: "400",
+          code:   "#{query[param] ? 'INVALID' : 'MISSING'}_QUERY_PARAMETER",
           detail: schema_error[:detail],
           source: { parameter: param } }
-      end)
+      end))
     end
 
     private

data/lib/request_handler/schema_parser.rb

@@ -1,14 +1,15 @@
 # frozen_string_literal: true
 
-require 'request_handler/error'
+require "request_handler/error"
 module RequestHandler
   class SchemaParser
     def initialize(schema:, schema_options: {})
       missing_arguments = []
-      missing_arguments << { schema: 'is missing' } if schema.nil?
-      missing_arguments << { schema_options: 'is missing' } if schema_options.nil?
-      raise MissingArgumentError, missing_arguments unless missing_arguments.empty?
-      raise InternalArgumentError, schema: 'must be a Schema' unless validation_engine.valid_schema?(schema)
+      missing_arguments << { schema: "is missing" } if schema.nil?
+      missing_arguments << { schema_options: "is missing" } if schema_options.nil?
+      raise MissingArgumentError.new(missing_arguments) unless missing_arguments.empty?
+      raise InternalArgumentError.new(schema: "must be a Schema") unless validation_engine.valid_schema?(schema)
+
       @schema = schema
       @schema_options = schema_options
     end
@@ -16,7 +17,8 @@ module RequestHandler
     private
 
     def validate_schema(data, with: schema)
-      raise MissingArgumentError, data: 'is missing' if data.nil?
+      raise MissingArgumentError.new(data: "is missing") if data.nil?
+
       validator = validate(data, schema: with)
       validation_failure?(validator)
       validator.output
@@ -32,7 +34,7 @@ module RequestHandler
       errors = build_errors(validator.errors).map do |error|
         jsonapi_error(error)
       end
-      raise SchemaValidationError, errors
+      raise SchemaValidationError.new(errors)
     end
 
     def build_errors(error_hash, path = [])
@@ -46,19 +48,19 @@ module RequestHandler
     end
 
     def error(path, element, failure)
-      schema_pointer = validation_engine.error_pointer(failure) || (path + [element]).join('/')
+      schema_pointer = validation_engine.error_pointer(failure) || (path + [element]).join("/")
       {
-        schema_pointer:  schema_pointer,
-        element: element,
-        message: validation_engine.error_message(failure)
+        schema_pointer: schema_pointer,
+        element:        element,
+        message:        validation_engine.error_message(failure)
       }
     end
 
     def jsonapi_error(error)
       {
-        status: '422',
-        code: 'INVALID_RESOURCE_SCHEMA',
-        title: 'Invalid resource',
+        status: "422",
+        code:   "INVALID_RESOURCE_SCHEMA",
+        title:  "Invalid resource",
         detail: error[:message],
         source: { pointer: build_pointer(error) }
       }
@@ -69,9 +71,10 @@ module RequestHandler
     end
 
     def add_note(v, k, memo)
-      memo[k] = if v.is_a? Array
-                  v.join(' ')
-                elsif v.is_a? Hash
+      memo[k] = case v
+                when Array
+                  v.join(" ")
+                when Hash
                   v.each { |(val, key)| add_note(val, key, memo) }
                 end
       memo

data/lib/request_handler/sort_option_parser.rb

@@ -1,35 +1,39 @@
 # frozen_string_literal: true
 
-require 'request_handler/option_parser'
-require 'request_handler/error'
-require 'request_handler/sort_option'
+require "request_handler/option_parser"
+require "request_handler/error"
+require "request_handler/sort_option"
 module RequestHandler
   class SortOptionParser < OptionParser
     def run
-      return [] unless params.key?('sort')
+      return [] unless params.key?("sort")
+
       sort_options = parse_options(fetch_options)
-      raise SortParamsError, [jsonapi_error('sort options must be unique')] if duplicates?(sort_options)
+      raise SortParamsError.new([jsonapi_error("sort options must be unique")]) if duplicates?(sort_options)
+
       sort_options
     end
 
     def fetch_options
-      raise SortParamsError, [jsonapi_error('must not be empty')] if empty_param?('sort')
-      params.fetch('sort') { '' }.split(',')
+      raise SortParamsError.new([jsonapi_error("must not be empty")]) if empty_param?("sort")
+
+      params.fetch("sort", "").split(",")
     end
 
     def parse_options(options)
       options.map do |option|
         name, order = parse_option(option)
-        name.gsub!('.', ::RequestHandler.configuration.separator)
+        name.gsub!(".", ::RequestHandler.configuration.separator)
         allowed_option(name)
         SortOption.new(name, order)
       end
     end
 
     def parse_option(option)
-      raise SortParamsError, [jsonapi_error('must not contain spaces')] if option.include? ' '
-      if option.start_with?('-')
-        [option[1..-1], :desc]
+      raise SortParamsError.new([jsonapi_error("must not contain spaces")]) if option.include? " "
+
+      if option.start_with?("-")
+        [option[1..], :desc]
       else
         [option, :asc]
       end
@@ -38,7 +42,7 @@ module RequestHandler
     def allowed_option(name)
       RequestHandler.configuration.validation_engine.validate!(name, allowed_options_type).output
     rescue Validation::Error
-      raise OptionNotAllowedError, [jsonapi_error("#{name} is not an allowed sort option")]
+      raise OptionNotAllowedError.new([jsonapi_error("#{name} is not an allowed sort option")])
     end
 
     def duplicates?(options)
@@ -49,9 +53,9 @@ module RequestHandler
 
     def jsonapi_error(detail)
       {
-        code: 'INVALID_QUERY_PARAMETER',
-        status: '400',
-        source: { parameter: 'sort' },
+        code:   "INVALID_QUERY_PARAMETER",
+        status: "400",
+        source: { parameter: "sort" },
         detail: detail
       }
     end

data/lib/request_handler/validation/definition_engine.rb

@@ -1,7 +1,9 @@
-require_relative 'errors'
-require_relative 'engine'
-require_relative 'result'
-require 'active_support/core_ext/hash/keys'
+# frozen_string_literal: true
+
+require_relative "errors"
+require_relative "engine"
+require_relative "result"
+require "active_support/core_ext/hash/keys"
 
 module RequestHandler
   module Validation
@@ -17,7 +19,7 @@ module RequestHandler
       end
 
       def self.validate!(value, schema, options: {})
-        validate(value, schema, options).tap do |result|
+        validate(value, schema, options: options).tap do |result|
           valid = result.respond_to?(:valid?) ? result.valid? : result.success?
           raise Validation::Error unless valid
         end
@@ -28,7 +30,7 @@ module RequestHandler
       end
 
       def self.error_pointer(validation_error)
-        validation_error.error_path.join('/')
+        validation_error.error_path.join("/")
       end
     end
   end

data/lib/request_handler/validation/dry_engine.rb

@@ -1,7 +1,9 @@
-require_relative 'errors'
-require_relative 'engine'
-require_relative 'result'
-require 'active_support/core_ext/hash/keys'
+# frozen_string_literal: true
+
+require_relative "errors"
+require_relative "engine"
+require_relative "result"
+require "active_support/core_ext/hash/keys"
 
 module RequestHandler
   module Validation
@@ -14,14 +16,14 @@ module RequestHandler
         value = value.deep_symbolize_keys if value.is_a?(Hash)
         to_result(call_schema(value, schema, options))
       rescue Dry::Types::ConstraintError => e
-        Result.new(output: nil, errors: { '' => e })
+        Result.new(output: nil, errors: { "" => e })
       end
 
       def self.call_schema(value, schema, options)
         if options.empty?
           schema_instance?(schema) ? schema.call(value) : schema.new.call(value)
         else
-          schema_instance?(schema) ? schema.with(options).call(value) : schema.new(options).call(value)
+          schema_instance?(schema) ? schema.with(**options).call(value) : schema.new(**options).call(value)
         end
       end
 
@@ -34,7 +36,7 @@ module RequestHandler
       end
 
       def self.validate!(value, schema, options: {})
-        validate(value, schema, options).tap do |result|
+        validate(value, schema, options: options).tap do |result|
           valid = result.respond_to?(:valid?) ? result.valid? : result.success?
           raise Validation::Error unless valid
         end

data/lib/request_handler/validation/engine.rb

@@ -1,5 +1,6 @@
+# frozen_string_literal: true
 
-require_relative 'errors'
+require_relative "errors"
 
 module RequestHandler
   module Validation
@@ -8,11 +9,11 @@ module RequestHandler
         raise NotImplementedError
       end
 
-      def self.validate(_value, _schema, options: {}) # rubocop:disable Lint/UnusedMethodArgument
+      def self.validate(_value, _schema, options: {})
         raise NotImplementedError
       end
 
-      def self.validate!(_value, _schema, options: {}) # rubocop:disable Lint/UnusedMethodArgument
+      def self.validate!(_value, _schema, options: {})
         raise NotImplementedError
       end
 

data/lib/request_handler/validation/errors.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module RequestHandler
   module Validation
     class Error < StandardError; end

data/lib/request_handler/validation/result.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 
 module RequestHandler
   module Validation

data/lib/request_handler/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module RequestHandler
-  VERSION = '2.2.0'.freeze
+  VERSION = "3.0.0"
 end

data/lib/request_handler.rb

@@ -1,19 +1,19 @@
 # frozen_string_literal: true
 
-require 'request_handler/version'
-require 'request_handler/base'
-require 'request_handler/validation/dry_engine'
-require 'multi_json'
-require 'logger'
-require 'gem_config'
+require "request_handler/version"
+require "request_handler/base"
+require "request_handler/validation/dry_engine"
+require "multi_json"
+require "logger"
+require "gem_config"
 
 module RequestHandler
   include GemConfig::Base
 
   with_configuration do
     has :validation_engine
-    has :logger, default: Logger.new(STDOUT)
-    has :separator, classes: [String], default: '__'
+    has :logger, default: Logger.new($stdout)
+    has :separator, classes: [String], default: "__"
     has :raise_jsonapi_errors, default: false
   end
 end

data/request_handler.gemspec

@@ -1,48 +1,54 @@
-# coding: utf-8
 # frozen_string_literal: true
 
-lib = File.expand_path('../lib', __FILE__)
+lib = File.expand_path("lib", __dir__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require 'request_handler/version'
+require "request_handler/version"
 Gem::Specification.new do |spec|
-  spec.name          = 'request_handler'
+  spec.name          = "request_handler"
   spec.version       = RequestHandler::VERSION
-  spec.authors       = ['Andreas Eger', 'Dominik Goltermann']
-  spec.email         = ['andreas.eger@runtastic.com', 'dominik.goltermann@runtastic.com']
+  spec.authors       = ["Andreas Eger", "Dominik Goltermann"]
+  spec.email         = ["andreas.eger@runtastic.com", "dominik.goltermann@runtastic.com"]
 
-  spec.summary       = 'shared base for request_handler using dry-* gems'
-  spec.description   = 'shared base for request_handler using dry-* gems'
-  spec.homepage      = 'https://github.com/runtastic/request_handler'
-  spec.license       = 'MIT'
-  spec.required_ruby_version = '~> 2.6'
+  spec.summary       = "shared base for request_handler using dry-* gems"
+  spec.description   = "shared base for request_handler using dry-* gems"
+  spec.homepage      = "https://github.com/runtastic/request_handler"
+  spec.license       = "MIT"
+  spec.required_ruby_version = ">= 2.6"
 
   spec.files = `git ls-files -z`.split("\x0").reject do |f|
     f.match(%r{^(test|spec|features)/})
   end
-  spec.bindir        = 'exe'
+  spec.bindir        = "exe"
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
-  spec.require_paths = ['lib']
-
-  spec.add_dependency 'docile', '~> 1.3'
-  spec.add_dependency 'multi_json', '~> 1.12'
-  spec.add_dependency 'activesupport', '> 4.0'
-  spec.add_dependency 'gem_config', '~> 0.3 '
-
-  spec.add_development_dependency 'bundler'
-  spec.add_development_dependency 'rake', '~> 10.0'
-  spec.add_development_dependency 'rspec', '~> 3.5'
-  spec.add_development_dependency 'fuubar', '~> 2.2'
-  spec.add_development_dependency 'simplecov'
-  spec.add_development_dependency 'codecov'
-
-  spec.add_development_dependency 'rubocop_runner', '~> 2.0'
-  spec.add_development_dependency 'rubocop', '~> 0.48.1'
-
-  spec.add_development_dependency 'guard'
-  spec.add_development_dependency 'guard-rspec'
-  spec.add_development_dependency 'guard-rubocop'
-
-  spec.add_development_dependency 'rack'
-
-  spec.add_development_dependency 'definition', '~> 0.7'
+  spec.require_paths = ["lib"]
+
+  spec.add_runtime_dependency "activesupport", "> 4.0"
+  spec.add_runtime_dependency "docile", "~> 1.3"
+  spec.add_runtime_dependency "gem_config", "~> 0.3 "
+  spec.add_runtime_dependency "multi_json", "~> 1.12"
+
+  spec.add_development_dependency "bundler"
+  spec.add_development_dependency "codecov"
+  spec.add_development_dependency "danger"
+  spec.add_development_dependency "danger-commit_lint"
+  spec.add_development_dependency "danger-rubocop"
+  spec.add_development_dependency "definition", "~> 0.7"
+  spec.add_development_dependency "dry-types", "~> 1.0"
+  spec.add_development_dependency "dry-validation", "~> 1.0"
+  spec.add_development_dependency "fuubar", "~> 2.2"
+  spec.add_development_dependency "guard"
+  spec.add_development_dependency "guard-rspec"
+  spec.add_development_dependency "guard-rubocop"
+  spec.add_development_dependency "rack"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.5"
+  spec.add_development_dependency "rspec_junit_formatter"
+  spec.add_development_dependency "rt_rubocop_defaults", "~> 2.5"
+  spec.add_development_dependency "rubocop", "~> 1.44"
+  spec.add_development_dependency "rubocop-rake", "~> 0.6"
+  spec.add_development_dependency "rubocop-rspec", "~> 2.18"
+  spec.add_development_dependency "rubocop_runner", "~> 2.0"
+  spec.add_development_dependency "simplecov"
+
+  spec.metadata["rubygems_mfa_required"] = "true"
 end