request_handler 1.3.0 → 2.0.0

data/lib/request_handler/builder/options_builder.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+require 'request_handler/builder/base'
+require 'request_handler/builder/page_builder'
+require 'request_handler/builder/include_options_builder'
+require 'request_handler/builder/sort_options_builder'
+require 'request_handler/builder/filter_builder'
+require 'request_handler/builder/query_builder'
+require 'request_handler/builder/body_builder'
+require 'request_handler/builder/multipart_builder'
+require 'request_handler/builder/fieldsets_builder'
+
+module RequestHandler
+  module Builder
+    class OptionsBuilder < Base
+      Options = Struct.new(:page, :include_options, :sort_options, :filter, :query, :body,
+                           :multipart, :fieldsets)
+
+      def create_klass_struct
+        @result = Options.new
+      end
+
+      def page(&block)
+        @result.page = build_page(&block)
+      end
+
+      def include_options(&block)
+        @result.include_options = build_include_options(&block)
+      end
+
+      def sort_options(&block)
+        @result.sort_options = build_sort_options(&block)
+      end
+
+      def filter(&block)
+        @result.filter = build_filter(&block)
+      end
+
+      def query(&block)
+        @result.query = build_query(&block)
+      end
+
+      def body(&block)
+        @result.body = build_body(&block)
+      end
+
+      def multipart(&block)
+        @result.multipart = build_multipart(&block)
+      end
+
+      def fieldsets(&block)
+        @result.fieldsets = build_fieldsets(&block)
+      end
+
+      def build_page(&block)
+        Docile.dsl_eval(PageBuilder.new, &block).build
+      end
+
+      def build_include_options(&block)
+        Docile.dsl_eval(IncludeOptionsBuilder.new, &block).build
+      end
+
+      def build_sort_options(&block)
+        Docile.dsl_eval(SortOptionsBuilder.new, &block).build
+      end
+
+      def build_filter(&block)
+        Docile.dsl_eval(FilterBuilder.new, &block).build
+      end
+
+      def build_query(&block)
+        Docile.dsl_eval(QueryBuilder.new, &block).build
+      end
+
+      def build_body(&block)
+        Docile.dsl_eval(BodyBuilder.new, &block).build
+      end
+
+      def build_multipart(&block)
+        Docile.dsl_eval(MultipartBuilder.new, &block).build
+      end
+
+      def build_fieldsets(&block)
+        Docile.dsl_eval(FieldsetsBuilder.new, &block).build
+      end
+    end
+  end
+end

data/lib/request_handler/builder/page_builder.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require 'request_handler/builder/base'
+require 'request_handler/builder/page_resource_builder'
+
+module RequestHandler
+  module Builder
+    class PageBuilder < Base
+      def create_klass_struct
+        @result = OpenStruct.new
+      end
+
+      def default_size(value)
+        @result.default_size = value
+      end
+
+      def max_size(value)
+        @result.max_size = value
+      end
+
+      def resource(name, &block)
+        @result[name.to_sym] = build_page_resource(&block)
+      end
+
+      def build_page_resource(&block)
+        Docile.dsl_eval(PageResourceBuilder.new, &block).build
+      end
+    end
+  end
+end

data/lib/request_handler/builder/page_resource_builder.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require 'request_handler/builder/base'
+
+module RequestHandler
+  module Builder
+    class PageResourceBuilder < Base
+      PageResource = Struct.new(:default_size, :max_size)
+
+      def create_klass_struct
+        @result = PageResource.new
+      end
+
+      def default_size(value)
+        @result.default_size = value
+      end
+
+      def max_size(value)
+        @result.max_size = value
+      end
+    end
+  end
+end

data/lib/request_handler/builder/query_builder.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require 'request_handler/builder/base'
+
+module RequestHandler
+  module Builder
+    class QueryBuilder < Base
+      Query = Struct.new(:schema, :options)
+
+      def create_klass_struct
+        @result = Query.new
+      end
+
+      def schema(value)
+        @result.schema = value
+      end
+
+      def options(value)
+        @result.options = value
+      end
+    end
+  end
+end

data/lib/request_handler/builder/sort_options_builder.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require 'request_handler/builder/base'
+
+module RequestHandler
+  module Builder
+    class SortOptionsBuilder < Base
+      SortOptions = Struct.new(:allowed, :defaults)
+
+      def create_klass_struct
+        @result = SortOptions.new
+      end
+
+      def allowed(value)
+        @result.allowed = value
+      end
+
+      def defaults(value)
+        @result.defaults = value
+      end
+    end
+  end
+end

data/lib/request_handler/concerns/config_helper.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module RequestHandler
+  module Concerns
+    module ConfigHelper
+      def lookup!(hash, key)
+        lookup(hash, key) || (raise NoConfigAvailableError, key.to_sym => 'is not configured')
+      end
+
+      def lookup(config, key)
+        config.dig(*symbolize_key(key))
+      end
+
+      def symbolize_key(key)
+        key.split('.').map(&:to_sym)
+      end
+
+      def deep_to_h(obj)
+        obj.to_h.transform_values do |v|
+          v.is_a?(OpenStruct) || v.is_a?(Struct) ? deep_to_h(v) : v
+        end
+      end
+    end
+  end
+end

data/lib/request_handler/config.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require 'docile'
+
+module RequestHandler
+  class Config
+    def initialize(&block)
+      @config = Docile.dsl_eval(RequestHandler::Builder::OptionsBuilder.new, &block).build
+    end
+
+    attr_accessor :config
+
+    def lookup!(key)
+      lookup(key) || (raise NoConfigAvailableError, key.to_sym => 'is not configured')
+    end
+
+    def lookup(key)
+      @config.dig(*symbolize_key(key))
+    end
+
+    private
+
+    def symbolize_key(key)
+      key.split('.').map(&:to_sym)
+    end
+
+    def deep_to_h(obj)
+      obj.to_h.transform_values do |v|
+        v.is_a?(OpenStruct) || v.is_a?(Struct) ? deep_to_h(v) : v
+      end
+    end
+  end
+end

data/lib/request_handler/fieldsets_parser.rb

@@ -7,9 +7,10 @@ module RequestHandler
     def initialize(params:, allowed: {}, required: [])
       @params = params
       allowed.reject! { |_k, v| v == false }
-      allowed.each_value do |option|
+      allowed.each_pair do |_key, value|
         raise InternalArgumentError, allowed: 'must be a Schema or a Boolean' unless
-          RequestHandler.engine.valid_schema?(option) || option.is_a?(TrueClass)
+          RequestHandler.configuration.validation_engine.valid_schema?(value) ||
+          value.is_a?(TrueClass) || value.is_a?(FalseClass)
       end
       @allowed = allowed
       raise InternalArgumentError, required: 'must be an Array' unless required.is_a?(Array)
@@ -39,7 +40,7 @@ module RequestHandler
       if allowed[type] == true
         option.to_sym
       else
-        RequestHandler.engine.validate!(option, allowed[type]).output.to_sym
+        RequestHandler.configuration.validation_engine.validate!(option, allowed[type]).output.to_sym
       end
     rescue Validation::Error
       raise FieldsetsParamsError, [{ code: 'INVALID_QUERY_PARAMETER',
@@ -55,7 +56,7 @@ module RequestHandler
     end
 
     def raise_invalid_field_option(type)
-      return if allowed.key?(type)
+      return if allowed.dig(type)
       raise OptionNotAllowedError, [
         {
           code: 'INVALID_QUERY_PARAMETER',

data/lib/request_handler/include_option_parser.rb

@@ -13,9 +13,9 @@ module RequestHandler
 
     def allowed_options(options)
       options.map do |option|
-        option.gsub!('.', ::RequestHandler.separator)
+        option.gsub!('.', ::RequestHandler.configuration.separator)
         begin
-          RequestHandler.engine.validate!(option, allowed_options_type).output.to_sym
+          RequestHandler.configuration.validation_engine.validate!(option, allowed_options_type).output.to_sym
         rescue Validation::Error
           raise_error('OPTION_NOT_ALLOWED', "#{option} is not an allowed include option", OptionNotAllowedError)
         end

data/lib/request_handler/multipart_parser.rb

@@ -1,11 +1,12 @@
 # frozen_string_literal: true
 
 require 'request_handler/error'
+require 'request_handler/base_parser'
 require 'request_handler/schema_parser'
 require 'request_handler/document_parser'
 
 module RequestHandler
-  class MultipartsParser
+  class MultipartsParser < BaseParser
     def initialize(request:, multipart_config:)
       @request = request
       @params = request.params
@@ -14,10 +15,10 @@ module RequestHandler
     end
 
     def run
-      multipart_config.each_with_object({}) do |(name, config), memo|
+      deep_to_h(multipart_config).each_with_object({}) do |(name, config), indexed_parts|
         validate_presence!(name) if config[:required]
         next if params[name.to_s].nil?
-        memo[name] = parse_part(name.to_s)
+        indexed_parts[name] = parse_part(name.to_s)
       end
     end
 
@@ -38,7 +39,7 @@ module RequestHandler
 
     def parse_part(name)
       params[name].fetch(:tempfile) { raise MultipartParamsError, [{ multipart_file: 'missing' }] }
-      if lookup("#{name}.schema")
+      if lookup(multipart_config, "#{name}.schema")
         parse_data(name)
       else
         params[name]
@@ -47,12 +48,12 @@ module RequestHandler
 
     def parse_data(name)
       data = load_json(name)
-      type = lookup("#{name}.type")
+      type = lookup(multipart_config, "#{name}.type")
       DocumentParser.new(
         type:             type,
         document:         data,
-        schema:           lookup("#{name}.schema"),
-        schema_options:   execute_options(lookup("#{name}.options"))
+        schema:           lookup(multipart_config, "#{name}.schema"),
+        schema_options:   execute_options(lookup(multipart_config, "#{name}.options"))
       ).run
     end
 
@@ -69,10 +70,6 @@ module RequestHandler
       params[name][:tempfile]
     end
 
-    def lookup(key)
-      multipart_config.lookup!(key)
-    end
-
     def execute_options(options)
       return {} if options.nil?
       return options unless options.respond_to?(:call)

data/lib/request_handler/option_parser.rb

@@ -12,7 +12,7 @@ module RequestHandler
     private
 
     def schema?
-      RequestHandler.engine.valid_schema?(@allowed_options_type)
+      RequestHandler.configuration.validation_engine.valid_schema?(@allowed_options_type)
     end
 
     def empty_param?(param)

data/lib/request_handler/page_parser.rb

@@ -1,8 +1,10 @@
 # frozen_string_literal: true
 
 require 'request_handler/error'
+require 'request_handler/base_parser'
+
 module RequestHandler
-  class PageParser
+  class PageParser < BaseParser
     def initialize(params:, page_config:)
       missing_arguments = []
       missing_arguments << { params: 'is missing' } if params.nil?
@@ -14,11 +16,10 @@ module RequestHandler
     end
 
     def run
-      base = { number: extract_number, size: extract_size }
-      cfg = config.keys.reduce(base) do |memo, key|
+      cfg = deep_to_h(config).keys.reduce(base_page) do |memo, key|
         next memo if TOP_LEVEL_PAGE_KEYS.include?(key)
-        memo.merge!("#{key}#{::RequestHandler.separator}number".to_sym => extract_number(prefix: key),
-                    "#{key}#{::RequestHandler.separator}size".to_sym   => extract_size(prefix: key))
+        memo.merge!("#{key}#{separator}number".to_sym => extract_number(prefix: key),
+                    "#{key}#{separator}size".to_sym   => extract_size(prefix: key))
       end
       check_for_missing_options(cfg)
       cfg
@@ -29,10 +30,14 @@ module RequestHandler
     TOP_LEVEL_PAGE_KEYS = Set.new(%i[default_size max_size])
     attr_reader :page_options, :config
 
+    def base_page
+      { number: extract_number, size: extract_size }
+    end
+
     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(::RequestHandler.separator, '.') }
+      missing_arguments.map! { |e| e.gsub(separator, '.') }
       warn 'client sent unknown option ' + missing_arguments.to_s unless missing_arguments.empty?
     end
 
@@ -93,11 +98,11 @@ module RequestHandler
 
     def lookup_nested_config_key(key, prefix)
       key = prefix ? "#{prefix}.#{key}" : key
-      config.lookup!(key)
+      lookup(config, key)
     end
 
     def lookup_nested_params_key(key, prefix)
-      key = prefix ? "#{prefix}#{::RequestHandler.separator}#{key}" : key
+      key = prefix ? "#{prefix}#{separator}#{key}" : key
       page_options.fetch(key, nil)
     end
 
@@ -105,12 +110,16 @@ module RequestHandler
       ::RequestHandler.configuration.logger.warn(message)
     end
 
-    def raise_no_default_size(prefix, sep = ::RequestHandler.separator)
+    def raise_no_default_size(prefix, sep = separator)
       raise NoConfigAvailableError, :"#{prefix}#{sep}size" => 'has no default_size'
     end
 
-    def raise_not_positive(prefix, key, sep = ::RequestHandler.separator)
+    def raise_not_positive(prefix, key, sep = separator)
       raise InternalArgumentError, :"#{prefix}#{sep}#{key}" => 'must be a positive Integer'
     end
+
+    def separator
+      ::RequestHandler.configuration.separator
+    end
   end
 end

data/lib/request_handler/schema_parser.rb

@@ -8,7 +8,7 @@ module RequestHandler
       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 RequestHandler.engine.valid_schema?(schema)
+      raise InternalArgumentError, schema: 'must be a Schema' unless validation_engine.valid_schema?(schema)
       @schema = schema
       @schema_options = schema_options
     end
@@ -23,7 +23,7 @@ module RequestHandler
     end
 
     def validate(data, schema:)
-      RequestHandler.engine.validate(data, schema, options: schema_options)
+      validation_engine.validate(data, schema, options: schema_options)
     end
 
     def validation_failure?(validator)
@@ -46,11 +46,11 @@ module RequestHandler
     end
 
     def error(path, element, failure)
-      schema_pointer = RequestHandler.engine.error_pointer(failure) || (path + [element]).join('/')
+      schema_pointer = validation_engine.error_pointer(failure) || (path + [element]).join('/')
       {
         schema_pointer:  schema_pointer,
         element: element,
-        message: RequestHandler.engine.error_message(failure)
+        message: validation_engine.error_message(failure)
       }
     end
 
@@ -77,6 +77,10 @@ module RequestHandler
       memo
     end
 
+    def validation_engine
+      RequestHandler.configuration.validation_engine
+    end
+
     attr_reader :schema, :schema_options
   end
 end

data/lib/request_handler/sort_option_parser.rb

@@ -20,7 +20,7 @@ module RequestHandler
     def parse_options(options)
       options.map do |option|
         name, order = parse_option(option)
-        name.gsub!('.', ::RequestHandler.separator)
+        name.gsub!('.', ::RequestHandler.configuration.separator)
         allowed_option(name)
         SortOption.new(name, order)
       end
@@ -36,7 +36,7 @@ module RequestHandler
     end
 
     def allowed_option(name)
-      RequestHandler.engine.validate!(name, allowed_options_type).output
+      RequestHandler.configuration.validation_engine.validate!(name, allowed_options_type).output
     rescue Validation::Error
       raise OptionNotAllowedError, [jsonapi_error("#{name} is not an allowed sort option")]
     end

data/lib/request_handler/validation/definition_engine.rb

@@ -18,7 +18,8 @@ module RequestHandler
 
       def self.validate!(value, schema, options: {})
         validate(value, schema, options).tap do |result|
-          raise Validation::Error unless result.valid?
+          valid = result.respond_to?(:valid?) ? result.valid? : result.success?
+          raise Validation::Error unless valid
         end
       end
 

data/lib/request_handler/validation/dry_engine.rb

@@ -7,35 +7,43 @@ module RequestHandler
   module Validation
     class DryEngine < Engine
       def self.valid_schema?(schema)
-        schema.respond_to?(:call)
+        schema_instance?(schema) || schema_class?(schema)
       end
 
       def self.validate(value, schema, options: {})
-        value = value.deep_symbolize_keys if schema.respond_to?(:rules) &&
-                                             schema.rules.keys.first.is_a?(Symbol)
-        result = if options.empty?
-                   schema.call(value)
-                 else
-                   schema.with(options).call(value)
-                 end
-
-        to_result(result)
+        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 })
       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)
+        end
+      end
+
+      def self.schema_instance?(schema)
+        schema.respond_to?(:call)
+      end
+
+      def self.schema_class?(schema)
+        schema.respond_to?(:schema)
+      end
+
       def self.validate!(value, schema, options: {})
         validate(value, schema, options).tap do |result|
-          raise Validation::Error unless result.valid?
+          valid = result.respond_to?(:valid?) ? result.valid? : result.success?
+          raise Validation::Error unless valid
         end
       end
 
       def self.to_result(result)
-        if result.is_a?(Dry::Validation::Result)
-          Result.new(output: result.output, errors: result.errors)
-        else
-          Result.new(output: result, errors: {})
-        end
+        output = result.respond_to?(:to_h) ? result.to_h : result
+        errors = result.respond_to?(:errors) ? result.errors.to_h : {}
+        Result.new(output: output, errors: errors)
       end
 
       def self.error_message(validation_error)

data/lib/request_handler/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module RequestHandler
-  VERSION = '1.3.0'.freeze
+  VERSION = '2.0.0'.freeze
 end

data/lib/request_handler.rb

@@ -3,32 +3,17 @@
 require 'request_handler/version'
 require 'request_handler/base'
 require 'request_handler/validation/dry_engine'
-require 'confstruct'
-require 'dry-validation'
 require 'multi_json'
 require 'logger'
+require 'gem_config'
 
 module RequestHandler
-  class << self
-    def configure(&block)
-      configuration.configure(&block)
-    end
+  include GemConfig::Base
 
-    def configuration
-      @configuration ||= ::Confstruct::Configuration.new do
-        logger Logger.new(STDOUT)
-        separator '__'
-        validation_engine Validation::DryEngine
-        raise_jsonapi_errors false
-      end
-    end
-
-    def separator
-      configuration.separator
-    end
-
-    def engine
-      configuration.validation_engine
-    end
+  with_configuration do
+    has :validation_engine
+    has :logger, default: Logger.new(STDOUT)
+    has :separator, classes: [String], default: '__'
+    has :raise_jsonapi_errors, default: false
   end
 end

data/request_handler.gemspec

@@ -23,12 +23,10 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ['lib']
 
-  spec.add_dependency 'dry-validation', '~> 0.11', '>= 0.11.0'
-  spec.add_dependency 'dry-types', '~> 0.11', '>= 0.11.0'
-
-  spec.add_dependency 'confstruct', '~> 1.0.2'
+  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'