Add more straightforward options by type (#463)

Fixes: #347

Author: ydah

lib/committee.rb

@@ -30,10 +30,10 @@ def self.warn_deprecated_until_6(cond, message)
 require_relative "committee/utils"
 require_relative "committee/drivers"
 require_relative "committee/errors"
+require_relative "committee/validation_error"
 require_relative "committee/middleware"
 require_relative "committee/request_unpacker"
 require_relative "committee/schema_validator"
-require_relative "committee/validation_error"
 
 require_relative "committee/bin/committee_stub"
 require_relative "committee/test/methods"

lib/committee/middleware.rb

@@ -5,6 +5,7 @@ module Middleware
   end
 end
 
+require_relative "middleware/options"
 require_relative "middleware/base"
 require_relative "middleware/request_validation"
 require_relative "middleware/response_validation"

lib/committee/middleware/base.rb

@@ -5,16 +5,17 @@ module Middleware
     class Base
       def initialize(app, options = {})
         @app = app
+        @options = build_options(options)
 
-        @error_class = options.fetch(:error_class, Committee::ValidationError)
-        @error_handler = options[:error_handler]
-        @ignore_error = options.fetch(:ignore_error, false)
+        @error_class = @options.error_class
+        @error_handler = @options.error_handler
+        @ignore_error = @options.ignore_error
 
-        @raise = options[:raise]
+        @raise = @options.raise_error
         @schema = self.class.get_schema(options)
 
         @router = @schema.build_router(options)
-        @accept_request_filter = options[:accept_request_filter] || ->(_) { true }
+        @accept_request_filter = @options.accept_request_filter
       end
 
       def call(env)
@@ -49,6 +50,11 @@ def get_schema(options)
 
       private
 
+      # Subclasses should override this method to use their specific Options class
+      def build_options(options)
+        Options::Base.from(options)
+      end
+
       def build_schema_validator(request)
         @router.build_schema_validator(request)
       end

lib/committee/middleware/options.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Committee
+  module Middleware
+    module Options
+    end
+  end
+end
+
+require_relative "options/base"
+require_relative "options/request_validation"
+require_relative "options/response_validation"

lib/committee/middleware/options/base.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+module Committee
+  module Middleware
+    module Options
+      class Base
+        # Common options
+        attr_reader :schema
+        attr_reader :schema_path
+        attr_reader :error_class
+        attr_reader :error_handler
+        attr_reader :raise_error
+        attr_reader :ignore_error
+        attr_reader :prefix
+        attr_reader :accept_request_filter
+
+        # Schema loading options
+        attr_reader :strict_reference_validation
+
+        def initialize(options = {})
+          @original_options = options.dup.freeze
+
+          # Schema related
+          @schema = options[:schema]
+          @schema_path = options[:schema_path]
+          @strict_reference_validation = options.fetch(:strict_reference_validation, false)
+
+          # Error handling
+          @error_class = options.fetch(:error_class, Committee::ValidationError)
+          @error_handler = options[:error_handler]
+          @raise_error = options[:raise] || false
+          @ignore_error = options.fetch(:ignore_error, false)
+
+          # Routing
+          @prefix = options[:prefix]
+          @accept_request_filter = options[:accept_request_filter] || ->(_) { true }
+
+          validate!
+        end
+
+        # Allow Hash-like access for backward compatibility
+        def [](key)
+          to_h[key]
+        end
+
+        def fetch(key, default = nil)
+          to_h.fetch(key, default)
+        end
+
+        def to_h
+          @to_h ||= build_hash
+        end
+
+        # Create an Option object from Hash options
+        # Returns the object as-is if already an Option object
+        def self.from(options)
+          case options
+          when self
+            options
+          when Hash
+            new(options)
+          else
+            raise ArgumentError, "options must be a Hash or #{name}"
+          end
+        end
+
+        private
+
+        def validate!
+          validate_error_class!
+          validate_error_handler!
+          validate_schema_source!
+          validate_accept_request_filter!
+        end
+
+        def validate_error_handler!
+          return if @error_handler.nil? || @error_handler.respond_to?(:call)
+
+          raise ArgumentError, "error_handler must respond to #call"
+        end
+
+        def validate_error_class!
+          return if @error_class.is_a?(Class)
+
+          raise ArgumentError, "error_class must be a Class"
+        end
+
+        def validate_schema_source!
+          return if @schema || @schema_path
+
+          raise ArgumentError, "Committee: need option `schema` or `schema_path`"
+        end
+
+        def validate_accept_request_filter!
+          return if @accept_request_filter.respond_to?(:call)
+
+          raise ArgumentError, "accept_request_filter must respond to #call"
+        end
+
+        def build_hash
+          # Start with original options to preserve any options not explicitly handled
+          @original_options.dup.merge(schema: @schema, schema_path: @schema_path, strict_reference_validation: @strict_reference_validation, error_class: @error_class, error_handler: @error_handler, raise: @raise_error, ignore_error: @ignore_error, prefix: @prefix, accept_request_filter: @accept_request_filter)
+        end
+      end
+    end
+  end
+end

lib/committee/middleware/options/request_validation.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module Committee
+  module Middleware
+    module Options
+      class RequestValidation < Base
+        # RequestValidation specific options
+        attr_reader :strict
+        attr_reader :coerce_date_times
+        attr_reader :coerce_recursive
+        attr_reader :coerce_form_params
+        attr_reader :coerce_path_params
+        attr_reader :coerce_query_params
+        attr_reader :allow_form_params
+        attr_reader :allow_query_params
+        attr_reader :allow_get_body
+        attr_reader :allow_non_get_query_params
+        attr_reader :check_content_type
+        attr_reader :check_header
+        attr_reader :optimistic_json
+        attr_reader :request_body_hash_key
+        attr_reader :query_hash_key
+        attr_reader :path_hash_key
+        attr_reader :headers_key
+        attr_reader :params_key
+        attr_reader :allow_blank_structures
+        attr_reader :allow_empty_date_and_datetime
+        attr_reader :parameter_overwrite_by_rails_rule
+        attr_reader :deserialize_parameters
+
+        # Default values
+        DEFAULTS = { strict: false, coerce_recursive: true, allow_get_body: false, check_content_type: true, check_header: true, optimistic_json: false, allow_form_params: true, allow_query_params: true, allow_non_get_query_params: false, allow_blank_structures: false, allow_empty_date_and_datetime: false, parameter_overwrite_by_rails_rule: true, request_body_hash_key: "committee.request_body_hash", query_hash_key: "committee.query_hash", path_hash_key: "committee.path_hash", headers_key: "committee.headers", params_key: "committee.params" }.freeze
+
+        def initialize(options = {})
+          super(options)
+
+          # Validation related
+          @strict = options.fetch(:strict, DEFAULTS[:strict])
+          @check_content_type = options.fetch(:check_content_type, DEFAULTS[:check_content_type])
+          @check_header = options.fetch(:check_header, DEFAULTS[:check_header])
+          @optimistic_json = options.fetch(:optimistic_json, DEFAULTS[:optimistic_json])
+
+          # Type coercion related
+          @coerce_date_times = options[:coerce_date_times]
+          @coerce_recursive = options.fetch(:coerce_recursive, DEFAULTS[:coerce_recursive])
+          @coerce_form_params = options[:coerce_form_params]
+          @coerce_path_params = options[:coerce_path_params]
+          @coerce_query_params = options[:coerce_query_params]
+
+          # Parameter permission related
+          @allow_form_params = options.fetch(:allow_form_params, DEFAULTS[:allow_form_params])
+          @allow_query_params = options.fetch(:allow_query_params, DEFAULTS[:allow_query_params])
+          @allow_get_body = options.fetch(:allow_get_body, DEFAULTS[:allow_get_body])
+          @allow_non_get_query_params = options.fetch(:allow_non_get_query_params, DEFAULTS[:allow_non_get_query_params])
+          @allow_blank_structures = options.fetch(:allow_blank_structures, DEFAULTS[:allow_blank_structures])
+          @allow_empty_date_and_datetime = options.fetch(:allow_empty_date_and_datetime, DEFAULTS[:allow_empty_date_and_datetime])
+
+          # Rails compatibility
+          @parameter_overwrite_by_rails_rule = options.fetch(:parameter_overwrite_by_rails_rule, DEFAULTS[:parameter_overwrite_by_rails_rule])
+
+          # Deserialization
+          @deserialize_parameters = options[:deserialize_parameters]
+
+          # Hash keys
+          @request_body_hash_key = options.fetch(:request_body_hash_key, DEFAULTS[:request_body_hash_key])
+          @query_hash_key = options.fetch(:query_hash_key, DEFAULTS[:query_hash_key])
+          @path_hash_key = options.fetch(:path_hash_key, DEFAULTS[:path_hash_key])
+          @headers_key = options.fetch(:headers_key, DEFAULTS[:headers_key])
+          @params_key = options.fetch(:params_key, DEFAULTS[:params_key])
+        end
+
+        private
+
+        def build_hash
+          super.merge(strict: @strict, coerce_date_times: @coerce_date_times, coerce_recursive: @coerce_recursive, coerce_form_params: @coerce_form_params, coerce_path_params: @coerce_path_params, coerce_query_params: @coerce_query_params, allow_form_params: @allow_form_params, allow_query_params: @allow_query_params, allow_get_body: @allow_get_body, allow_non_get_query_params: @allow_non_get_query_params, allow_blank_structures: @allow_blank_structures, allow_empty_date_and_datetime: @allow_empty_date_and_datetime, parameter_overwrite_by_rails_rule: @parameter_overwrite_by_rails_rule, deserialize_parameters: @deserialize_parameters, check_content_type: @check_content_type, check_header: @check_header, optimistic_json: @optimistic_json, request_body_hash_key: @request_body_hash_key, query_hash_key: @query_hash_key, path_hash_key: @path_hash_key, headers_key: @headers_key, params_key: @params_key)
+        end
+      end
+    end
+  end
+end

lib/committee/middleware/options/response_validation.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Committee
+  module Middleware
+    module Options
+      class ResponseValidation < Base
+        # ResponseValidation specific options
+        attr_reader :strict
+        attr_reader :validate_success_only
+        attr_reader :parse_response_by_content_type
+        attr_reader :coerce_response_values
+        attr_reader :streaming_content_parsers
+
+        # Default values
+        DEFAULTS = { strict: false, validate_success_only: true, parse_response_by_content_type: true, coerce_response_values: false }.freeze
+
+        def initialize(options = {})
+          super(options)
+
+          # Validation related
+          @strict = options.fetch(:strict, DEFAULTS[:strict])
+          @validate_success_only = options.fetch(:validate_success_only, DEFAULTS[:validate_success_only])
+          @parse_response_by_content_type = options.fetch(:parse_response_by_content_type, DEFAULTS[:parse_response_by_content_type])
+          @coerce_response_values = options.fetch(:coerce_response_values, DEFAULTS[:coerce_response_values])
+
+          # Streaming
+          @streaming_content_parsers = options[:streaming_content_parsers] || {}
+
+          validate_response_validation_options!
+        end
+
+        private
+
+        def validate_response_validation_options!
+          return if @streaming_content_parsers.is_a?(Hash)
+
+          raise ArgumentError, "streaming_content_parsers must be a Hash"
+        end
+
+        def build_hash
+          super.merge(strict: @strict, validate_success_only: @validate_success_only, parse_response_by_content_type: @parse_response_by_content_type, coerce_response_values: @coerce_response_values, streaming_content_parsers: @streaming_content_parsers)
+        end
+      end
+    end
+  end
+end

lib/committee/middleware/request_validation.rb

@@ -6,7 +6,13 @@ class RequestValidation < Base
       def initialize(app, options = {})
         super
 
-        @strict = options[:strict]
+        @strict = @options.strict
+      end
+
+      private
+
+      def build_options(options)
+        Options::RequestValidation.from(options)
       end
 
       def handle(request)

lib/committee/middleware/response_validation.rb

@@ -7,9 +7,9 @@ class ResponseValidation < Base
 
       def initialize(app, options = {})
         super
-        @strict = options[:strict]
+        @strict = @options.strict
         @validate_success_only = @schema.validator_option.validate_success_only
-        @streaming_content_parsers = options[:streaming_content_parsers] || {}
+        @streaming_content_parsers = @options.streaming_content_parsers
       end
 
       def handle(request)
@@ -63,6 +63,10 @@ def validate?(status, validate_success_only)
 
       private
 
+      def build_options(options)
+        Options::ResponseValidation.from(options)
+      end
+
       def validate(request, status, headers, response, streaming_content_parser = nil)
         v = build_schema_validator(request)
         if v.link_exist? && self.class.validate?(status, validate_success_only)