grape 2.3.0 → 3.0.0

data/lib/grape/validations/params_documentation.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Grape
+  module Validations
+    # Documents parameters of an endpoint. If documentation isn't needed (for instance, it is an
+    # internal API), the class only cleans up attributes to avoid junk in RAM.
+
+    module ParamsDocumentation
+      def document_params(attrs, validations, type = nil, values = nil, except_values = nil)
+        return validations.except!(:desc, :description, :documentation) if @api.inheritable_setting.namespace_inheritable[:do_not_document]
+
+        documented_attrs = attrs.each_with_object({}) do |name, memo|
+          memo[full_name(name)] = extract_details(validations, type, values, except_values)
+        end
+        @api.inheritable_setting.namespace_stackable[:params] = documented_attrs
+      end
+
+      private
+
+      def extract_details(validations, type, values, except_values)
+        {}.tap do |details|
+          details[:required] = validations.key?(:presence)
+          details[:type] = TypeCache[type] if type
+          details[:values] = values if values
+          details[:except_values] = except_values if except_values
+          details[:default] = validations[:default] if validations.key?(:default)
+          if validations.key?(:length)
+            details[:min_length] = validations[:length][:min] if validations[:length].key?(:min)
+            details[:max_length] = validations[:length][:max] if validations[:length].key?(:max)
+          end
+
+          desc = validations.delete(:desc) || validations.delete(:description)
+          details[:desc] = desc if desc
+
+          documentation = validations.delete(:documentation)
+          details[:documentation] = documentation if documentation
+        end
+      end
+
+      class TypeCache < Grape::Util::Cache
+        def initialize
+          super
+          @cache = Hash.new do |h, type|
+            h[type] = type.to_s
+          end
+        end
+      end
+    end
+  end
+end

data/lib/grape/validations/params_scope.rb

@@ -4,9 +4,10 @@ module Grape
   module Validations
     class ParamsScope
       attr_accessor :element, :parent, :index
-      attr_reader :type
+      attr_reader :type, :params_meeting_dependency
 
       include Grape::DSL::Parameters
+      include Grape::Validations::ParamsDocumentation
 
       # There are a number of documentation options on entities that don't have
       # corresponding validators. Since there is nowhere that enumerates them all,
@@ -67,6 +68,7 @@ module Grape
         @type             = opts[:type]
         @group            = opts[:group]
         @dependent_on     = opts[:dependent_on]
+        @params_meeting_dependency = []
         @declared_params = []
         @index = nil
 
@@ -94,7 +96,11 @@ module Grape
       def meets_dependency?(params, request_params)
         return true unless @dependent_on
         return false if @parent.present? && !@parent.meets_dependency?(@parent.params(request_params), request_params)
-        return params.any? { |param| meets_dependency?(param, request_params) } if params.is_a?(Array)
+
+        if params.is_a?(Array)
+          @params_meeting_dependency = params.flatten.filter { |param| meets_dependency?(param, request_params) }
+          return @params_meeting_dependency.present?
+        end
 
         meets_hash_dependency?(params)
       end
@@ -127,7 +133,7 @@ module Grape
       def full_name(name, index: nil)
         if nested?
           # Find our containing element's name, and append ours.
-          "#{@parent.full_name(@element)}#{brackets(@index || index)}#{brackets(name)}"
+          "#{@parent.full_name(@element)}#{brackets(index || @index)}#{brackets(name)}"
         elsif lateral?
           # Find the name of the element as if it was at the same nesting level
           # as our parent. We need to forward our index upward to achieve this.
@@ -205,28 +211,32 @@ module Grape
       # @param new_name [String, Symbol] the new name of the parameter (the
       #   renamed name, with the +as: ...+ semantic)
       def push_renamed_param(path, new_name)
-        base = @api.route_setting(:renamed_params) || {}
+        api_route_setting = @api.inheritable_setting.route
+        base = api_route_setting[:renamed_params] || {}
         base[Array(path).map(&:to_s)] = new_name.to_s
-        @api.route_setting(:renamed_params, base)
+        api_route_setting[:renamed_params] = base
       end
 
       def require_required_and_optional_fields(context, opts)
+        except_fields = Array.wrap(opts[:except])
+        using_fields = opts[:using].keys.delete_if { |f| except_fields.include?(f) }
+
         if context == :all
-          optional_fields = Array.wrap(opts[:except])
-          required_fields = opts[:using].keys.delete_if { |f| optional_fields.include?(f) }
+          optional_fields = except_fields
+          required_fields = using_fields
         else # context == :none
-          required_fields = Array.wrap(opts[:except])
-          optional_fields = opts[:using].keys.delete_if { |f| required_fields.include?(f) }
+          required_fields = except_fields
+          optional_fields = using_fields
         end
         required_fields.each do |field|
           field_opts = opts[:using][field]
           raise ArgumentError, "required field not exist: #{field}" unless field_opts
 
-          requires(field, field_opts)
+          requires(field, **field_opts)
         end
         optional_fields.each do |field|
           field_opts = opts[:using][field]
-          optional(field, field_opts) if field_opts
+          optional(field, **field_opts) if field_opts
         end
       end
 
@@ -238,7 +248,7 @@ module Grape
         end
         optional_fields.each do |field|
           field_opts = opts[:using][field]
-          optional(field, field_opts) if field_opts
+          optional(field, **field_opts) if field_opts
         end
       end
 
@@ -255,9 +265,9 @@ module Grape
       # @param optional [Boolean] whether the parameter this are nested under
       #   is optional or not (and hence, whether this block's params will be).
       # @yield parameter scope
-      def new_scope(attrs, optional = false, &block)
+      def new_scope(attrs, opts, optional = false, &block)
         # if required params are grouped and no type or unsupported type is provided, raise an error
-        type = attrs[1] ? attrs[1][:type] : nil
+        type = opts[:type]
         if attrs.first && !optional
           raise Grape::Exceptions::MissingGroupType if type.nil?
           raise Grape::Exceptions::UnsupportedGroupType unless Grape::Validations::Types.group?(type)
@@ -266,7 +276,7 @@ module Grape
         self.class.new(
           api: @api,
           element: attrs.first,
-          element_renamed: attrs[1][:as],
+          element_renamed: opts[:as],
           parent: self,
           optional: optional,
           type: type || Array,
@@ -310,7 +320,7 @@ module Grape
         if nested?
           @parent.push_declared_params [element => @declared_params]
         else
-          @api.namespace_stackable(:declared_params, @declared_params)
+          @api.inheritable_setting.namespace_stackable[:declared_params] = @declared_params
         end
 
         # params were stored in settings, it can be cleaned from the params scope
@@ -318,56 +328,40 @@ module Grape
       end
 
       def validates(attrs, validations)
-        doc = AttributesDoc.new @api, self
-        doc.extract_details validations
-
         coerce_type = infer_coercion(validations)
-
-        doc.type = coerce_type
-
+        required = validations.key?(:presence)
         default = validations[:default]
-
-        if (values_hash = validations[:values]).is_a? Hash
-          values = values_hash[:value]
-          # NB: excepts is deprecated
-          excepts = values_hash[:except]
-        else
-          values = validations[:values]
-        end
-
-        doc.values = values
-
-        except_values = options_key?(:except_values, :value, validations) ? validations[:except_values][:value] : validations[:except_values]
+        values = validations[:values].is_a?(Hash) ? validations.dig(:values, :value) : validations[:values]
+        except_values = validations[:except_values].is_a?(Hash) ? validations.dig(:except_values, :value) : validations[:except_values]
 
         # NB. values and excepts should be nil, Proc, Array, or Range.
         # Specifically, values should NOT be a Hash
-
         # use values or excepts to guess coerce type when stated type is Array
-        coerce_type = guess_coerce_type(coerce_type, values, except_values, excepts)
+        coerce_type = guess_coerce_type(coerce_type, values, except_values)
 
         # default value should be present in values array, if both exist and are not procs
-        check_incompatible_option_values(default, values, except_values, excepts)
+        check_incompatible_option_values(default, values, except_values)
 
         # type should be compatible with values array, if both exist
-        validate_value_coercion(coerce_type, values, except_values, excepts)
+        validate_value_coercion(coerce_type, values, except_values)
 
-        doc.document attrs
+        document_params attrs, validations, coerce_type, values, except_values
 
         opts = derive_validator_options(validations)
 
         # Validate for presence before any other validators
-        validates_presence(validations, attrs, doc, opts)
+        validates_presence(validations, attrs, opts)
 
         # Before we run the rest of the validators, let's handle
         # whatever coercion so that we are working with correctly
         # type casted values
-        coerce_type validations, attrs, doc, opts
+        coerce_type validations, attrs, required, opts
 
         validations.each do |type, options|
           # Don't try to look up validators for documentation params that don't have one.
           next if RESERVED_DOCUMENTATION_KEYWORDS.include?(type)
 
-          validate(type, options, attrs, doc, opts)
+          validate(type, options, attrs, required, opts)
         end
       end
 
@@ -431,7 +425,7 @@ module Grape
       # composited from more than one +requires+/+optional+
       # parameter, and needs to be run before most other
       # validations.
-      def coerce_type(validations, attrs, doc, opts)
+      def coerce_type(validations, attrs, required, opts)
         check_coerce_with(validations)
 
         return unless validations.key?(:coerce)
@@ -441,7 +435,7 @@ module Grape
           method: validations[:coerce_with],
           message: validations[:coerce_message]
         }
-        validate('coerce', coerce_options, attrs, doc, opts)
+        validate('coerce', coerce_options, attrs, required, opts)
         validations.delete(:coerce_with)
         validations.delete(:coerce)
         validations.delete(:coerce_message)
@@ -457,30 +451,26 @@ module Grape
         coerce_type
       end
 
-      def check_incompatible_option_values(default, values, except_values, excepts)
+      def check_incompatible_option_values(default, values, except_values)
         return unless default && !default.is_a?(Proc)
 
         raise Grape::Exceptions::IncompatibleOptionValues.new(:default, default, :values, values) if values && !values.is_a?(Proc) && !Array(default).all? { |def_val| values.include?(def_val) }
 
-        if except_values && !except_values.is_a?(Proc) && Array(default).any? { |def_val| except_values.include?(def_val) }
-          raise Grape::Exceptions::IncompatibleOptionValues.new(:default, default, :except, except_values)
-        end
+        return unless except_values && !except_values.is_a?(Proc) && Array(default).any? { |def_val| except_values.include?(def_val) }
 
-        return unless excepts && !excepts.is_a?(Proc)
-        raise Grape::Exceptions::IncompatibleOptionValues.new(:default, default, :except, excepts) \
-          unless Array(default).none? { |def_val| excepts.include?(def_val) }
+        raise Grape::Exceptions::IncompatibleOptionValues.new(:default, default, :except, except_values)
       end
 
-      def validate(type, options, attrs, doc, opts)
+      def validate(type, options, attrs, required, opts)
         validator_options = {
           attributes: attrs,
           options: options,
-          required: doc.required,
+          required: required,
           params_scope: self,
           opts: opts,
           validator_class: Validations.require_validator(type)
         }
-        @api.namespace_stackable(:validations, validator_options)
+        @api.inheritable_setting.namespace_stackable[:validations] = validator_options
       end
 
       def validate_value_coercion(coerce_type, *values_list)
@@ -522,10 +512,10 @@ module Grape
         }
       end
 
-      def validates_presence(validations, attrs, doc, opts)
+      def validates_presence(validations, attrs, opts)
         return unless validations.key?(:presence) && validations[:presence]
 
-        validate('presence', validations.delete(:presence), attrs, doc, opts)
+        validate('presence', validations.delete(:presence), attrs, true, opts)
         validations.delete(:message) if validations.key?(:message)
       end
     end

data/lib/grape/validations/types/array_coercer.rb

@@ -7,15 +7,14 @@ module Grape
       # an array of arrays of integers.
       #
       # It could've been possible to use an +of+
-      # method (https://dry-rb.org/gems/dry-types/1.2/array-with-member/)
+      # method (https://dry-rb.org/gems/dry-types/main/array-with-member/)
       # provided by dry-types. Unfortunately, it doesn't work for Grape because of
       # behavior of Virtus which was used earlier, a `Grape::Validations::Types::PrimitiveCoercer`
       # maintains Virtus behavior in coercing.
       class ArrayCoercer < DryTypeCoercer
         def initialize(type, strict = false)
           super
-
-          @coercer = scope::Array
+          @coercer = strict ? DryTypes::Strict::Array : DryTypes::Params::Array
           @subtype = type.first
         end
 

data/lib/grape/validations/types/dry_type_coercer.rb

@@ -1,19 +1,12 @@
 # frozen_string_literal: true
 
-module DryTypes
-  # Call +Dry.Types()+ to add all registered types to +DryTypes+ which is
-  # a container in this case. Check documentation for more information
-  # https://dry-rb.org/gems/dry-types/1.2/getting-started/
-  include Dry.Types()
-end
-
 module Grape
   module Validations
     module Types
       # A base class for classes which must identify a coercer to be used.
       # If the +strict+ argument is true, it won't coerce the given value
       # but check its type. More information there
-      # https://dry-rb.org/gems/dry-types/1.2/built-in-types/
+      # https://dry-rb.org/gems/dry-types/main/built-in-types/
       class DryTypeCoercer
         class << self
           # Returns a collection coercer which corresponds to a given type.
@@ -42,7 +35,7 @@ module Grape
         def initialize(type, strict = false)
           @type = type
           @strict = strict
-          @scope = strict ? DryTypes::Strict : DryTypes::Params
+          @cache_coercer = strict ? DryTypes::StrictCache : DryTypes::ParamsCache
         end
 
         # Coerces the given value to a type which was specified during
@@ -53,13 +46,13 @@ module Grape
           return if val.nil?
 
           @coercer[val]
-        rescue Dry::Types::CoercionError => _e
+        rescue Dry::Types::CoercionError
           InvalidValue.new
         end
 
         protected
 
-        attr_reader :scope, :type, :strict
+        attr_reader :type, :strict, :cache_coercer
       end
     end
   end

data/lib/grape/validations/types/primitive_coercer.rb

@@ -7,37 +7,10 @@ module Grape
       # initialization. When +strict+ is true, it doesn't coerce a value but check
       # that it has the proper type.
       class PrimitiveCoercer < DryTypeCoercer
-        MAPPING = {
-          Grape::API::Boolean => DryTypes::Params::Bool,
-          BigDecimal => DryTypes::Params::Decimal,
-          Numeric => DryTypes::Params::Integer | DryTypes::Params::Float | DryTypes::Params::Decimal,
-          TrueClass => DryTypes::Params::Bool.constrained(eql: true),
-          FalseClass => DryTypes::Params::Bool.constrained(eql: false),
-
-          # unfortunately, a +Params+ scope doesn't contain String
-          String => DryTypes::Coercible::String
-        }.freeze
-
-        STRICT_MAPPING = {
-          Grape::API::Boolean => DryTypes::Strict::Bool,
-          BigDecimal => DryTypes::Strict::Decimal,
-          Numeric => DryTypes::Strict::Integer | DryTypes::Strict::Float | DryTypes::Strict::Decimal,
-          TrueClass => DryTypes::Strict::Bool.constrained(eql: true),
-          FalseClass => DryTypes::Strict::Bool.constrained(eql: false)
-        }.freeze
-
         def initialize(type, strict = false)
           super
 
-          @type = type
-
-          @coercer = (strict ? STRICT_MAPPING : MAPPING).fetch(type) do
-            scope.const_get(type.name, false)
-          rescue NameError
-            raise ArgumentError, "type #{type} should support coercion via `[]`" unless type.respond_to?(:[])
-
-            type
-          end
+          @coercer = cache_coercer[type]
         end
 
         def call(val)

data/lib/grape/validations/types.rb

@@ -155,9 +155,10 @@ module Grape
       # @return [Object] object to be used
       #   for coercion and type validation
       def build_coercer(type, method: nil, strict: false)
-        cache_instance(type, method, strict) do
-          create_coercer_instance(type, method, strict)
-        end
+        # no cache since unique
+        return create_coercer_instance(type, method, strict) if method.respond_to?(:call)
+
+        CoercerCache[[type, method, strict]]
       end
 
       def create_coercer_instance(type, method, strict)
@@ -184,30 +185,14 @@ module Grape
         end
       end
 
-      def cache_instance(type, method, strict, &_block)
-        key = cache_key(type, method, strict)
-
-        return @__cache[key] if @__cache.key?(key)
-
-        instance = yield
-
-        @__cache_write_lock.synchronize do
-          @__cache[key] = instance
+      class CoercerCache < Grape::Util::Cache
+        def initialize
+          super
+          @cache = Hash.new do |h, (type, method, strict)|
+            h[[type, method, strict]] = Grape::Validations::Types.create_coercer_instance(type, method, strict)
+          end
         end
-
-        instance
       end
-
-      def cache_key(type, method, strict)
-        [type, method, strict].each_with_object(+'_') do |val, memo|
-          next if val.nil?
-
-          memo << '_' << val.to_s
-        end
-      end
-
-      instance_variable_set(:@__cache,            {})
-      instance_variable_set(:@__cache_write_lock, Mutex.new)
     end
   end
 end

data/lib/grape/validations/validators/base.rb

@@ -49,7 +49,7 @@ module Grape
             next if !@scope.required? && empty_val
             next unless @scope.meets_dependency?(val, params)
 
-            validate_param!(attr_name, val) if @required || (val.respond_to?(:key?) && val.key?(attr_name))
+            validate_param!(attr_name, val) if @required || val.try(:key?, attr_name)
           rescue Grape::Exceptions::Validation => e
             array_errors << e
           end
@@ -69,7 +69,7 @@ module Grape
 
         def options_key?(key, options = nil)
           options = instance_variable_get(:@option) if options.nil?
-          options.respond_to?(:key?) && options.key?(key) && !options[key].nil?
+          options.try(:key?, key) && !options[key].nil?
         end
 
         def fail_fast?
@@ -79,10 +79,3 @@ module Grape
     end
   end
 end
-
-Grape::Validations::Base = Class.new(Grape::Validations::Validators::Base) do
-  def self.inherited(*)
-    Grape.deprecator.warn 'Grape::Validations::Base is deprecated! Use Grape::Validations::Validators::Base instead.'
-    super
-  end
-end

data/lib/grape/validations/validators/except_values_validator.rb

@@ -10,7 +10,7 @@ module Grape
         end
 
         def validate_param!(attr_name, params)
-          return unless params.respond_to?(:key?) && params.key?(attr_name)
+          return unless params.try(:key?, attr_name)
 
           excepts = @except.is_a?(Proc) ? @except.call : @except
           return if excepts.nil?

data/lib/grape/validations/validators/presence_validator.rb

@@ -5,7 +5,7 @@ module Grape
     module Validators
       class PresenceValidator < Base
         def validate_param!(attr_name, params)
-          return if params.respond_to?(:key?) && params.key?(attr_name)
+          return if params.try(:key?, attr_name)
 
           raise Grape::Exceptions::Validation.new(params: [@scope.full_name(attr_name)], message: message(:presence))
         end

data/lib/grape/validations/validators/regexp_validator.rb

@@ -5,7 +5,7 @@ module Grape
     module Validators
       class RegexpValidator < Base
         def validate_param!(attr_name, params)
-          return unless params.respond_to?(:key?) && params.key?(attr_name)
+          return unless params.try(:key?, attr_name)
           return if Array.wrap(params[attr_name]).all? { |param| param.nil? || param.to_s.scrub.match?((options_key?(:value) ? @option[:value] : @option)) }
 
           raise Grape::Exceptions::Validation.new(params: [@scope.full_name(attr_name)], message: message(:regexp))

data/lib/grape/version.rb

@@ -2,5 +2,5 @@
 
 module Grape
   # The current version of Grape.
-  VERSION = '2.3.0'
+  VERSION = '3.0.0'
 end

data/lib/grape.rb

@@ -3,15 +3,14 @@
 require 'logger'
 require 'active_support'
 require 'active_support/concern'
-require 'active_support/configurable'
 require 'active_support/version'
-require 'active_support/isolated_execution_state' if ActiveSupport::VERSION::MAJOR > 6
+require 'active_support/isolated_execution_state'
 require 'active_support/core_ext/array/conversions'
-require 'active_support/core_ext/array/extract_options'
 require 'active_support/core_ext/array/wrap'
 require 'active_support/core_ext/enumerable'
 require 'active_support/core_ext/hash/conversions'
 require 'active_support/core_ext/hash/deep_merge'
+require 'active_support/core_ext/hash/deep_transform_values'
 require 'active_support/core_ext/hash/except'
 require 'active_support/core_ext/hash/indifferent_access'
 require 'active_support/core_ext/hash/keys'
@@ -20,6 +19,7 @@ require 'active_support/core_ext/hash/slice'
 require 'active_support/core_ext/module/delegation'
 require 'active_support/core_ext/object/blank'
 require 'active_support/core_ext/object/deep_dup'
+require 'active_support/core_ext/object/try'
 require 'active_support/core_ext/object/duplicable'
 require 'active_support/core_ext/string/output_safety'
 require 'active_support/core_ext/string/exclude'
@@ -27,6 +27,7 @@ require 'active_support/deprecation'
 require 'active_support/inflector'
 require 'active_support/ordered_options'
 require 'active_support/notifications'
+require 'dry-configurable'
 
 require 'English'
 require 'bigdecimal'
@@ -56,16 +57,24 @@ loader.setup
 I18n.load_path << File.expand_path('grape/locale/en.yml', __dir__)
 
 module Grape
-  include ActiveSupport::Configurable
+  extend Dry::Configurable
+
+  setting :param_builder, default: :hash_with_indifferent_access
+  setting :lint, default: false
+
+  HTTP_SUPPORTED_METHODS = [
+    Rack::GET,
+    Rack::POST,
+    Rack::PUT,
+    Rack::PATCH,
+    Rack::DELETE,
+    Rack::HEAD,
+    Rack::OPTIONS
+  ].freeze
 
   def self.deprecator
     @deprecator ||= ActiveSupport::Deprecation.new('2.0', 'Grape')
   end
-
-  configure do |config|
-    config.param_builder = Grape::Extensions::ActiveSupport::HashWithIndifferentAccess::ParamBuilder
-    config.compile_methods!
-  end
 end
 
 # https://api.rubyonrails.org/classes/ActiveSupport/Deprecation.html