grape 2.4.0 → 3.0.0

data/lib/grape/namespace.rb

@@ -28,6 +28,17 @@ module Grape
       settings&.map(&:space)
     end
 
+    def eql?(other)
+      other.class == self.class &&
+        other.space == space &&
+        other.options == options
+    end
+    alias == eql?
+
+    def hash
+      [self.class, space, options].hash
+    end
+
     # Join the namespaces from a list of settings to create a path prefix.
     # @param settings [Array] list of Grape::Util::InheritableSettings.
     def self.joined_space_path(settings)

data/lib/grape/params_builder/base.rb

@@ -8,6 +8,8 @@ module Grape
           raise NotImplementedError
         end
 
+        private
+
         def inherited(klass)
           super
           ParamsBuilder.register(klass)

data/lib/grape/router.rb

@@ -12,14 +12,15 @@ module Grape
     #     normalize_path("/%ab")  # => "/%AB"
     # https://github.com/rails/rails/blob/00cc4ff0259c0185fe08baadaa40e63ea2534f6e/actionpack/lib/action_dispatch/journey/router/utils.rb#L19
     def self.normalize_path(path)
-      return +'/' unless path
+      return '/' unless path
+      return path if path == '/'
 
       # Fast path for the overwhelming majority of paths that don't need to be normalized
-      return path.dup if path == '/' || (path.start_with?('/') && !(path.end_with?('/') || path.match?(%r{%|//})))
+      return path.dup if path.start_with?('/') && !(path.end_with?('/') || path.match?(%r{%|//}))
 
       # Slow path
       encoding = path.encoding
-      path = +"/#{path}"
+      path = "/#{path}"
       path.squeeze!('/')
 
       unless path == '/'

data/lib/grape/util/api_description.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Grape
+  module Util
+    class ApiDescription
+      def initialize(description, endpoint_configuration, &block)
+        @endpoint_configuration = endpoint_configuration
+        @attributes = { description: description }
+        instance_eval(&block)
+      end
+
+      %i[
+        body_name
+        consumes
+        default
+        deprecated
+        detail
+        entity
+        headers
+        hidden
+        http_codes
+        is_array
+        named
+        nickname
+        params
+        produces
+        security
+        summary
+        tags
+      ].each do |attribute|
+        define_method attribute do |value|
+          @attributes[attribute] = value
+        end
+      end
+
+      alias success entity
+      alias failure http_codes
+
+      def configuration
+        @configuration ||= eval_endpoint_config(@endpoint_configuration)
+      end
+
+      def settings
+        @attributes
+      end
+
+      private
+
+      def eval_endpoint_config(configuration)
+        return configuration if configuration.is_a?(Hash)
+
+        configuration.evaluate
+      end
+    end
+  end
+end

data/lib/grape/util/base_inheritable.rb

@@ -14,8 +14,11 @@ module Grape
         @new_values = {}
       end
 
-      def delete(key)
-        new_values.delete key
+      def delete(*keys)
+        keys.map do |key|
+          # since delete returns the deleted value, seems natural to `map` the result
+          new_values.delete key
+        end
       end
 
       def initialize_copy(other)

data/lib/grape/util/inheritable_setting.rb

@@ -95,6 +95,13 @@ module Grape
           namespace_reverse_stackable: namespace_reverse_stackable.to_hash
         }
       end
+
+      def namespace_stackable_with_hash(key)
+        data = namespace_stackable[key]
+        return if data.blank?
+
+        data.each_with_object({}) { |value, result| result.deep_merge!(value) }
+      end
     end
   end
 end

data/lib/grape/util/media_type.rb

@@ -7,7 +7,7 @@ module Grape
 
       # based on the HTTP Accept header with the pattern:
       # application/vnd.:vendor-:version+:format
-      VENDOR_VERSION_HEADER_REGEX = /\Avnd\.(?<vendor>[a-z0-9.\-_!^]+?)(?:-(?<version>[a-z0-9*.]+))?(?:\+(?<format>[a-z0-9*\-.]+))?\z/.freeze
+      VENDOR_VERSION_HEADER_REGEX = /\Avnd\.(?<vendor>[a-z0-9.\-_!^]+?)(?:-(?<version>[a-z0-9*.]+))?(?:\+(?<format>[a-z0-9*\-.]+))?\z/
 
       def initialize(type:, subtype:)
         @type = type

data/lib/grape/util/registry.rb

@@ -7,7 +7,7 @@ module Grape
         short_name = build_short_name(klass)
         return if short_name.nil?
 
-        warn "#{short_name} is already registered with class #{klass}" if registry.key?(short_name)
+        warn "#{short_name} is already registered with class #{registry[short_name]}. It will be overridden globally with the following: #{klass.name}" if registry.key?(short_name)
         registry[short_name] = klass
       end
 

data/lib/grape/validations/contract_scope.rb

@@ -20,14 +20,14 @@ module Grape
           key_map = contract.key_map
         end
 
-        api.namespace_stackable(:contract_key_map, key_map)
+        api.inheritable_setting.namespace_stackable[:contract_key_map] = key_map
 
         validator_options = {
           validator_class: Grape::Validations.require_validator(:contract_scope),
           opts: { schema: contract, fail_fast: false }
         }
 
-        api.namespace_stackable(:validations, validator_options)
+        api.inheritable_setting.namespace_stackable[:validations] = validator_options
       end
     end
   end

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

@@ -7,6 +7,7 @@ module Grape
       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,
@@ -210,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
 
@@ -243,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
 
@@ -260,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)
@@ -271,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,
@@ -315,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
@@ -323,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
 
@@ -436,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)
@@ -446,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)
@@ -462,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)
@@ -527,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

@@ -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/version.rb

@@ -2,5 +2,5 @@
 
 module Grape
   # The current version of Grape.
-  VERSION = '2.4.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'
@@ -28,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'
@@ -57,7 +57,10 @@ 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,
@@ -72,12 +75,6 @@ module Grape
   def self.deprecator
     @deprecator ||= ActiveSupport::Deprecation.new('2.0', 'Grape')
   end
-
-  configure do |config|
-    config.param_builder = :hash_with_indifferent_access
-    config.lint = false
-    config.compile_methods!
-  end
 end
 
 # https://api.rubyonrails.org/classes/ActiveSupport/Deprecation.html