grape 3.3.4 → 4.0.0

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

@@ -7,10 +7,18 @@ module Grape
       # initialization. When +strict+ is true, it doesn't coerce a value but check
       # that it has the proper type.
       class PrimitiveCoercer < DryTypeCoercer
+        # The input classes Virtus refused for a given declared type, keyed by
+        # that type. Resolved once in #initialize rather than re-derived from
+        # +type+ on every value: the answer only ever depends on the
+        # declaration, and every coerced attribute of every request asks.
+        REJECTED_INPUTS = { String => [Array, Hash].freeze, Hash => [String].freeze }.freeze
+
         def initialize(type, strict: false)
           super
 
           @coercer = cache_coercer[type]
+          @rejected_inputs = REJECTED_INPUTS[type]
+          @treat_empty_as_nil = type != String
         end
 
         def call(val)
@@ -29,21 +37,16 @@ module Grape
         # but Virtus wouldn't accept it. So, this method only exists to not introduce
         # breaking changes.
         def reject?(val)
-          case val
-          when Array, Hash
-            type == String
-          when String
-            type == Hash
-          else
-            false
-          end
+          return false unless @rejected_inputs
+
+          @rejected_inputs.any? { |klass| val.is_a?(klass) }
         end
 
         # Dry-Types treats an empty string as invalid. However, Grape considers an empty string as
         # absence of a value and coerces it into nil. See a discussion there
         # https://github.com/ruby-grape/grape/pull/2045
         def treat_as_nil?(val)
-          val == '' && type != String
+          @treat_empty_as_nil && val == ''
         end
       end
     end

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

@@ -6,6 +6,11 @@ module Grape
       # This class wraps {MultipleTypeCoercer}, for use with collections
       # that allow members of more than one type.
       class VariantCollectionCoercer
+        extend Grape::Util::FreezeOnNew
+
+        # @return [Array<Class>,Set<Class>] the member types as declared in the DSL
+        attr_reader :types
+
         # Construct a new coercer that will attempt to coerce
         # a list of values such that all members are of one of
         # the given types. The container may also optionally be
@@ -43,15 +48,15 @@ module Grape
         def call(value)
           return unless value.is_a? Array
 
-          value =
+          coerced =
             if @method
               @method.call(value)
             else
               value.map { |v| @member_coercer.call(v) }
             end
-          return Set.new value if @types.is_a? Set
+          return Set.new coerced if @types.is_a? Set
 
-          value
+          coerced
         end
       end
     end

data/lib/grape/validations/types.rb

@@ -162,20 +162,20 @@ module Grape
 
       def create_coercer_instance(type, method, strict)
         # map_special doesn't recurse into collections — applied only to the top-level type here.
-        type = map_special(type)
+        mapped = map_special(type)
 
         # Multiply-typed parameters, e.g. types: [Integer, String].
-        return MultipleTypeCoercer.new(type, method) if multiple?(type)
+        return MultipleTypeCoercer.new(mapped, method) if multiple?(mapped)
 
         # User-supplied coercion method, or a custom type with its own #parse.
-        return CustomTypeCoercer.new(type, method) if method || custom?(type)
+        return CustomTypeCoercer.new(mapped, method) if method || custom?(mapped)
 
         # Array/Set of a custom type — CustomTypeCoercer already handles single
         # custom types when an explicit coercion method is supplied.
-        return CustomTypeCollectionCoercer.new(map_special(type.first), set: type.is_a?(Set)) if collection_of_custom?(type)
+        return CustomTypeCollectionCoercer.new(map_special(mapped.first), set: mapped.is_a?(Set)) if collection_of_custom?(mapped)
 
         # Fallback: let dry-types handle primitives, structures, and known specials.
-        DryTypeCoercer.coercer_instance_for(type, strict:)
+        DryTypeCoercer.coercer_instance_for(mapped, strict:)
       end
 
       class CoercerCache < Grape::Util::Cache

data/lib/grape/validations/validations_spec.rb

@@ -51,7 +51,7 @@ module Grape
         @allow_blank = resolve_value(raw[:allow_blank])
         @fail_fast = raw[:fail_fast] || false
 
-        @guessed_coerce_type = guess_coerce_type(@coerce_type, @values, @except_values)
+        @guessed_coerce_type = guess_coerce_type(declared_coerce_type, @values, @except_values)
         @shared_opts = { allow_blank: @allow_blank, fail_fast: @fail_fast }.freeze
         @validator_entries = build_validator_entries(raw)
 
@@ -97,13 +97,13 @@ module Grape
       def validate_value_coercion(coerce_type, *values_list)
         return unless coerce_type
 
-        coerce_type = coerce_type.first if coerce_type.is_a?(Enumerable)
+        element_type = coerce_type.is_a?(Enumerable) ? coerce_type.first : coerce_type
         values_list.each do |values|
           next if !values || values.is_a?(Proc)
 
           value_types = values.is_a?(Range) ? [values.begin, values.end].compact : values
-          value_types = value_types.map { |type| Grape::API::Boolean.build(type) } if coerce_type == Grape::API::Boolean
-          raise Grape::Exceptions::IncompatibleOptionValues.new(:type, coerce_type, :values, values) unless value_types.all?(coerce_type)
+          value_types = value_types.map { |type| Grape::API::Boolean.build(type) } if element_type == Grape::API::Boolean
+          raise Grape::Exceptions::IncompatibleOptionValues.new(:type, element_type, :values, values) unless value_types.all?(element_type)
         end
       end
 
@@ -140,6 +140,16 @@ module Grape
         opt.is_a?(Hash) ? opt[:value] : opt
       end
 
+      # The type as written in the DSL. Identical to +@coerce_type+ except for
+      # a multiple-type declaration (+type: [Integer, String]+), where
+      # {#parse_coerce} wraps the declared list in a
+      # {Types::VariantCollectionCoercer} for runtime coercion — the
+      # definition-time coherence checks need the list back, since the wrapper
+      # matches nothing under +===+.
+      def declared_coerce_type
+        @coerce_type.is_a?(Types::VariantCollectionCoercer) ? @coerce_type.types : @coerce_type
+      end
+
       def guess_coerce_type(coerce_type, *values_list)
         return coerce_type unless coerce_type == Array
 

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

@@ -13,6 +13,7 @@ module Grape
       # (e.g. +memoize+, <tt>||=</tt>) will raise +FrozenError+ at request time.
       class Base
         extend Forwardable
+        extend Grape::Util::FreezeOnNew
         include Grape::Util::Translation
 
         attr_reader :attrs
@@ -45,10 +46,6 @@ module Grape
             end
           end
 
-          def new(...)
-            super.freeze
-          end
-
           def inherited(klass)
             super
             Validations.register(klass)
@@ -67,7 +64,6 @@ module Grape
         def initialize(attrs, options, required, scope, opts)
           @attrs = Array(attrs).freeze
           @options = Grape::Util::DeepFreeze.deep_freeze(options)
-          @option = @options # TODO: remove in next major release
           @required = required
           @scope = scope
           @opts = SharedOptions.new(**opts.slice(:allow_blank, :fail_fast))
@@ -81,9 +77,10 @@ module Grape
         # @raise [Grape::Exceptions::Validation] if validation failed
         # @return [void]
         def validate(request)
-          return unless scope.should_validate?(request.params)
+          params = request.params
+          return unless scope.should_validate?(params)
 
-          validate!(request.params)
+          validate!(params)
         end
 
         # Validates a given parameter hash.

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

@@ -21,10 +21,16 @@ module Grape
             end
         end
 
+        # The attribute is read once and held: +coerce_value+ only ever sees the
+        # value, never the Hash, so the two further reads the identity check
+        # used to make came back with the same object -- through a
+        # HashWithIndifferentAccess key conversion each time, for every coerced
+        # attribute of every request.
         def validate_param!(attr_name, params)
           validation_error!(attr_name) unless hash_like?(params)
 
-          new_value = coerce_value(params[attr_name])
+          value = params[attr_name]
+          new_value = coerce_value(value)
 
           validation_error!(attr_name, new_value.message || exception_message) if new_value.is_a?(Types::InvalidValue)
 
@@ -37,7 +43,7 @@ module Grape
           #     h[:list] = list
           #     h
           #     => #<Hashie::Mash list=[1, 2, 3, 4]>
-          return if params[attr_name].instance_of?(new_value.class) && params[attr_name] == new_value
+          return if value.instance_of?(new_value.class) && value == new_value
 
           params[attr_name] = new_value
         end

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

@@ -4,11 +4,12 @@ module Grape
   module Validations
     module Validators
       class ContractScopeValidator
+        extend Grape::Util::FreezeOnNew
+
         attr_reader :schema
 
         def initialize(schema:)
           @schema = schema
-          freeze
         end
 
         # Validates a given request.

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

@@ -10,7 +10,7 @@ module Grape
           @min, @max, @is = options.values_at(:min, :max, :is)
           validate_boundary!(:min, @min)
           validate_boundary!(:max, @max)
-          raise ArgumentError, "min #{@min} cannot be greater than max #{@max}" if @min && @max && @min > @max
+          raise ArgumentError, "min `#{@min}` cannot be greater than max `#{@max}`" if @min && @max && @min > @max
 
           return if @is.nil?
           raise ArgumentError, 'is must be an integer greater than zero' unless @is.is_a?(Integer) && @is.positive?
@@ -18,6 +18,8 @@ module Grape
         end
 
         def validate_param!(attr_name, params)
+          return unless hash_like?(params)
+
           param = params[attr_name]
 
           return unless param.respond_to?(:length)
@@ -40,7 +42,7 @@ module Grape
         private
 
         def validate_boundary!(name, val)
-          raise ArgumentError, "#{name} must be an integer greater than or equal to zero" if !val.nil? && (!val.is_a?(Integer) || val.negative?)
+          raise ArgumentError, "`#{name}` must be an integer greater than or equal to zero" if !val.nil? && (!val.is_a?(Integer) || val.negative?)
         end
       end
     end

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

@@ -18,6 +18,8 @@ module Grape
         end
 
         def validate_param!(attr_name, params)
+          return unless hash_like?(params)
+
           value = params[attr_name]
           return if value.nil? && !required?
 

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

@@ -10,6 +10,7 @@ module Grape
         end
 
         def validate_param!(attr_name, params)
+          return unless hash_like?(params)
           return if params[attr_name] == params[@value]
 
           validation_error!(attr_name, message { translate(:same_as, parameter: @value) })

data/lib/grape/version.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
 module Grape
-  VERSION = '3.3.4'
+  # The current version of Grape.
+  VERSION = '4.0.0'
 end

data/lib/grape.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'logger'
+require 'monitor'
 require 'active_support'
 require 'active_support/isolated_execution_state'
 require 'active_support/core_ext/array/conversions' # to_xml
@@ -41,7 +42,12 @@ loader.inflector.inflect(
   'dsl' => 'DSL'
 )
 railtie = "#{__dir__}/grape/railtie.rb"
-loader.do_not_eager_load(railtie)
+# Grape::Testing is a test-environment helper -- it extends Grape::Endpoint with
+# `before_each` and prepends a hook to Grape::Endpoint#run. It is documented as
+# opt-in (`require 'grape/testing'`), which eager loading quietly contradicted
+# by installing it in every process.
+testing = "#{__dir__}/grape/testing.rb"
+loader.do_not_eager_load(railtie, testing)
 loader.setup
 
 I18n.load_path << File.expand_path('grape/locale/en.yml', __dir__)
@@ -52,9 +58,17 @@ module Grape
   setting :param_builder, default: :hash_with_indifferent_access
   setting :lint, default: false
   setting :warn_on_helper_overrides, default: false
+  # Let an error response that cannot be rendered propagate out of the
+  # middleware stack instead of being answered with a failsafe 500.
+  setting :raise_rendering_errors, default: false
+
+  # The HTTP QUERY method (RFC 10008): a safe, idempotent request whose content
+  # carries the query. Rack has no constant for it yet, hence the literal.
+  QUERY = 'QUERY'
 
   HTTP_SUPPORTED_METHODS = [
     Rack::GET,
+    QUERY,
     Rack::POST,
     Rack::PUT,
     Rack::PATCH,
@@ -81,8 +95,15 @@ module Grape
       ]
     end.freeze
 
+  # The deprecation horizon is the version a deprecation announces as its
+  # removal point, so it is the *next* major rather than the current one, and
+  # it is derived from VERSION rather than written out. Written out, it went
+  # stale: it said '2.0' from 2023 (#2353) through all of 2.x, 3.x and 4.x, so
+  # a method deprecated through this deprecator announced a removal version
+  # that had already shipped, and every custom `behavior` lambda -- how a Rails
+  # app consumes deprecations -- was handed the same wrong number.
   def self.deprecator
-    @deprecator ||= ActiveSupport::Deprecation.new('2.0', 'Grape')
+    @deprecator ||= ActiveSupport::Deprecation.new("#{Gem::Version.new(VERSION).segments.first + 1}.0", 'Grape')
   end
 end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: grape
 version: !ruby/object:Gem::Version
-  version: 3.3.4
+  version: 4.0.0
 platform: ruby
 authors:
 - Michael Bleigh
@@ -156,6 +156,7 @@ files:
 - lib/grape/exceptions/missing_vendor_option.rb
 - lib/grape/exceptions/request_error.rb
 - lib/grape/exceptions/unknown_auth_strategy.rb
+- lib/grape/exceptions/unknown_error_formatter.rb
 - lib/grape/exceptions/unknown_parameter.rb
 - lib/grape/exceptions/unknown_params_builder.rb
 - lib/grape/exceptions/unknown_validator.rb
@@ -176,7 +177,6 @@ files:
 - lib/grape/middleware/auth/strategies.rb
 - lib/grape/middleware/auth/strategy_info.rb
 - lib/grape/middleware/base.rb
-- lib/grape/middleware/deprecated_options_hash_access.rb
 - lib/grape/middleware/error.rb
 - lib/grape/middleware/filter.rb
 - lib/grape/middleware/formatter.rb
@@ -200,6 +200,7 @@ files:
 - lib/grape/parser/json.rb
 - lib/grape/parser/xml.rb
 - lib/grape/path.rb
+- lib/grape/precompiled_json.rb
 - lib/grape/presenters/presenter.rb
 - lib/grape/railtie.rb
 - lib/grape/request.rb
@@ -208,19 +209,19 @@ files:
 - lib/grape/router/greedy_route.rb
 - lib/grape/router/mustermann_pattern.rb
 - lib/grape/router/pattern.rb
+- lib/grape/router/pattern/path.rb
 - lib/grape/router/route.rb
 - lib/grape/serve_stream/file_body.rb
 - lib/grape/serve_stream/sendfile_response.rb
 - lib/grape/serve_stream/stream_response.rb
 - lib/grape/testing.rb
 - lib/grape/util/api_description.rb
-- lib/grape/util/base_inheritable.rb
 - lib/grape/util/cache.rb
 - lib/grape/util/deep_freeze.rb
 - lib/grape/util/endpoint_configuration.rb
+- lib/grape/util/freeze_on_new.rb
 - lib/grape/util/header.rb
 - lib/grape/util/inheritable_setting.rb
-- lib/grape/util/inheritable_values.rb
 - lib/grape/util/lazy/base.rb
 - lib/grape/util/lazy/block.rb
 - lib/grape/util/lazy/value.rb
@@ -230,7 +231,7 @@ files:
 - lib/grape/util/media_type.rb
 - lib/grape/util/path_normalizer.rb
 - lib/grape/util/registry.rb
-- lib/grape/util/reverse_stackable_values.rb
+- lib/grape/util/shadowed_rescue_handlers.rb
 - lib/grape/util/stackable_values.rb
 - lib/grape/util/translation.rb
 - lib/grape/validations.rb
@@ -282,9 +283,9 @@ licenses:
 - MIT
 metadata:
   bug_tracker_uri: https://github.com/ruby-grape/grape/issues
-  changelog_uri: https://github.com/ruby-grape/grape/blob/v3.3.4/CHANGELOG.md
-  documentation_uri: https://www.rubydoc.info/gems/grape/3.3.4
-  source_code_uri: https://github.com/ruby-grape/grape/tree/v3.3.4
+  changelog_uri: https://github.com/ruby-grape/grape/blob/v4.0.0/CHANGELOG.md
+  documentation_uri: https://www.rubydoc.info/gems/grape/4.0.0
+  source_code_uri: https://github.com/ruby-grape/grape/tree/v4.0.0
   rubygems_mfa_required: 'true'
 rdoc_options: []
 require_paths:
@@ -300,7 +301,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.14
+rubygems_version: 4.0.16
 specification_version: 4
 summary: A simple Ruby framework for building REST-like APIs.
 test_files: []

data/lib/grape/middleware/deprecated_options_hash_access.rb

@@ -1,19 +0,0 @@
-# frozen_string_literal: true
-
-module Grape
-  module Middleware
-    # Mixin for per-middleware +Options+ +Data+ classes that need to keep
-    # accepting legacy +data[:key]+ Hash-style access while nudging callers
-    # toward the named accessor. Emits a +Grape.deprecator+ warning then
-    # forwards to +public_send(key)+.
-    module DeprecatedOptionsHashAccess
-      def [](key)
-        Grape.deprecator.warn(
-          "`#{self.class.name}#[]` is deprecated. " \
-          "Use the named accessor `#{key}` instead."
-        )
-        public_send(key) if members.include?(key)
-      end
-    end
-  end
-end

data/lib/grape/util/base_inheritable.rb

@@ -1,43 +0,0 @@
-# frozen_string_literal: true
-
-module Grape
-  module Util
-    # Base for classes which need to operate with own values kept
-    # in the hash and inherited values kept in a Hash-like object.
-    #
-    # +@new_values+ is lazily allocated on first write so settings layers
-    # that only inherit (never override) don't carry an empty Hash each.
-    class BaseInheritable
-      attr_accessor :inherited_values, :new_values
-
-      # @param inherited_values [Object] An object implementing an interface
-      #   of the Hash class.
-      def initialize(inherited_values = nil)
-        @inherited_values = inherited_values || {}
-        # @new_values stays nil until the first write.
-      end
-
-      def delete(*keys)
-        return [] unless @new_values
-
-        keys.map { |key| @new_values.delete(key) }
-      end
-
-      def initialize_copy(other)
-        super
-        @inherited_values = other.inherited_values
-        @new_values = other.new_values&.dup
-      end
-
-      def keys
-        return @inherited_values.keys if @new_values.nil? || @new_values.empty?
-
-        (@inherited_values.keys + @new_values.keys).uniq
-      end
-
-      def key?(name)
-        @inherited_values.key?(name) || @new_values&.key?(name) || false
-      end
-    end
-  end
-end

data/lib/grape/util/inheritable_values.rb

@@ -1,33 +0,0 @@
-# frozen_string_literal: true
-
-module Grape
-  module Util
-    class InheritableValues < BaseInheritable
-      def [](name)
-        return @inherited_values[name] unless @new_values
-
-        @new_values.fetch(name) { @inherited_values[name] }
-      end
-
-      def []=(name, value)
-        (@new_values ||= {})[name] = value
-      end
-
-      def merge(new_hash)
-        values.merge!(new_hash)
-      end
-
-      def to_hash
-        values
-      end
-
-      protected
-
-      def values
-        return @inherited_values.merge(@new_values) if @new_values && !@new_values.empty?
-
-        @inherited_values.is_a?(Hash) ? @inherited_values.dup : @inherited_values.to_hash
-      end
-    end
-  end
-end

data/lib/grape/util/reverse_stackable_values.rb

@@ -1,15 +0,0 @@
-# frozen_string_literal: true
-
-module Grape
-  module Util
-    class ReverseStackableValues < StackableValues
-      protected
-
-      def concat_values(inherited_value, new_value)
-        return inherited_value unless new_value
-
-        new_value + inherited_value
-      end
-    end
-  end
-end