grape 2.4.0 → 4.0.1

data/grape.gemspec

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
-$LOAD_PATH.unshift File.expand_path('lib', __dir__)
-require 'grape/version'
+require_relative 'lib/grape/version'
 
 Gem::Specification.new do |s|
   s.name        = 'grape'
@@ -21,13 +20,14 @@ Gem::Specification.new do |s|
     'rubygems_mfa_required' => 'true'
   }
 
-  s.add_dependency 'activesupport', '>= 6.1'
+  s.add_dependency 'activesupport', '>= 7.2'
+  s.add_dependency 'dry-configurable', '>= 1.0'
   s.add_dependency 'dry-types', '>= 1.1'
-  s.add_dependency 'mustermann-grape', '~> 1.1.0'
-  s.add_dependency 'rack', '>= 2'
-  s.add_dependency 'zeitwerk'
+  s.add_dependency 'mustermann', '>= 4.0'
+  s.add_dependency 'rack', '>= 2.2.4'
+  s.add_dependency 'zeitwerk', '>= 2.6'
 
   s.files = Dir['lib/**/*', 'CHANGELOG.md', 'CONTRIBUTING.md', 'README.md', 'grape.png', 'UPGRADING.md', 'LICENSE', 'grape.gemspec']
   s.require_paths = ['lib']
-  s.required_ruby_version = '>= 2.7.0'
+  s.required_ruby_version = '>= 3.3'
 end

data/lib/grape/api/instance.rb

@@ -5,32 +5,37 @@ module Grape
     # The API Instance class, is the engine behind Grape::API. Each class that inherits
     # from this will represent a different API instance
     class Instance
+      # Marks this and every mounted instance as a mountable Grape app (see Grape::Mountable).
+      extend Grape::Mountable
+      extend Grape::DSL::Settings
+      extend Grape::DSL::Desc
+      extend Grape::DSL::Validations
+      extend Grape::DSL::Callbacks
+      extend Grape::DSL::Logger
+      extend Grape::DSL::Middleware
+      extend Grape::DSL::RequestResponse
+      extend Grape::DSL::Routing
+      extend Grape::DSL::Helpers
       extend Grape::Middleware::Auth::DSL
-      include Grape::DSL::API
+
+      Boolean = Grape::API::Boolean
 
       class << self
-        attr_reader :instance, :base
         attr_accessor :configuration
 
-        def given(conditional_option, &block)
-          evaluate_as_instance_with_configuration(block, lazy: true) if conditional_option && block
+        def to_s
+          @base&.to_s || super
         end
 
-        def mounted(&block)
-          evaluate_as_instance_with_configuration(block, lazy: true)
-        end
+        attr_reader :base
 
         def base=(grape_api)
           @base = grape_api
           grape_api.instances << self
         end
 
-        def to_s
-          base&.to_s || super
-        end
-
         def base_instance?
-          self == base.base_instance
+          self == @base.base_instance
         end
 
         # A class-level lock to ensure the API is not compiled by multiple
@@ -44,92 +49,32 @@ module Grape
           reset_validations!
         end
 
-        # Parses the API's definition and compiles it into an instance of
-        # Grape::API.
-        def compile
-          @instance ||= new # rubocop:disable Naming/MemoizedInstanceVariableName
-        end
-
-        # Wipe the compiled API so we can recompile after changes were made.
-        def change!
-          @instance = nil
-        end
-
         # This is the interface point between Rack and Grape; it accepts a request
         # from Rack and ultimately returns an array of three values: the status,
         # the headers, and the body. See [the rack specification]
         # (http://www.rubydoc.info/github/rack/rack/master/file/SPEC) for more.
         def call(env)
-          compile!
-          call!(env)
-        end
-
-        # A non-synchronized version of ::call.
-        def call!(env)
-          instance.call(env)
-        end
-
-        # (see #cascade?)
-        def cascade(value = nil)
-          if value.nil?
-            inheritable_setting.namespace_inheritable.key?(:cascade) ? !namespace_inheritable(:cascade).nil? : true
-          else
-            namespace_inheritable(:cascade, value)
-          end
+          compile!.call(env)
         end
 
+        # Returns the compiled instance, so callers serve the one they
+        # compiled rather than re-reading @instance — +change!+ can nil it
+        # between the two reads (see #call / #recognize_path).
         def compile!
-          return if instance
-
-          LOCK.synchronize { compile unless instance }
+          @instance || LOCK.synchronize { @instance ||= new }
         end
 
         # see Grape::Router#recognize_path
         def recognize_path(path)
-          compile!
-          instance.router.recognize_path(path)
-        end
-
-        protected
-
-        def prepare_routes
-          endpoints.map(&:routes).flatten
-        end
-
-        # Execute first the provided block, then each of the
-        # block passed in. Allows for simple 'before' setups
-        # of settings stack pushes.
-        def nest(*blocks, &block)
-          blocks.compact!
-          if blocks.any?
-            evaluate_as_instance_with_configuration(block) if block
-            blocks.each { |b| evaluate_as_instance_with_configuration(b) }
-            reset_validations!
-          else
-            instance_eval(&block)
-          end
+          compile!.router.recognize_path(path)
         end
 
-        def evaluate_as_instance_with_configuration(block, lazy: false)
-          lazy_block = Grape::Util::Lazy::Block.new do |configuration|
-            value_for_configuration = configuration
-            self.configuration = value_for_configuration.evaluate if value_for_configuration.try(:lazy?)
-            response = instance_eval(&block)
-            self.configuration = value_for_configuration
-            response
-          end
-          if base && base_instance? && lazy
-            lazy_block
-          else
-            lazy_block.evaluate_from(configuration)
-          end
+        # Wipe the compiled API so we can recompile after changes were made.
+        def change!
+          @instance = nil
         end
 
-        def inherited(subclass)
-          super
-          subclass.reset!
-          subclass.logger = logger.clone
-        end
+        protected
 
         def inherit_settings(other_settings)
           top_level_setting.inherit_from other_settings.point_in_time_copy
@@ -137,12 +82,20 @@ module Grape
           # Propagate any inherited params down to our endpoints, and reset any
           # compiled routes.
           endpoints.each do |e|
-            e.inherit_settings(top_level_setting.namespace_stackable)
+            e.inherit_settings(top_level_setting)
             e.reset_routes!
           end
 
           reset_routes!
         end
+
+        private
+
+        def inherited(subclass)
+          super
+          subclass.reset!
+          subclass.logger logger.clone
+        end
       end
 
       attr_reader :router
@@ -158,13 +111,19 @@ module Grape
 
         @router.compile!
         @router.freeze
+        @cascade = resolve_cascade
       end
 
       # Handle a request. See Rack documentation for what `env` is.
       def call(env)
         status, headers, response = @router.call(env)
-        unless cascade?
-          headers = Grape::Util::Header.new.merge(headers)
+        unless @cascade
+          # +merge!+, not +merge+: the latter is a `dup` plus a `merge!`, so the
+          # Header built on this line would be allocated only to be discarded.
+          # The copy stays because +headers+ can come from a mounted Rack app,
+          # which is free to hand back a frozen or shared Hash that the delete
+          # below must not reach into.
+          headers = Grape::Util::Header.new.merge!(headers)
           headers.delete('X-Cascade')
         end
 
@@ -179,11 +138,13 @@ module Grape
       # In some applications (e.g. mounting grape on rails), one might need to trap
       # errors from reaching upstream. This is effectivelly done by unsetting
       # X-Cascade. Default :cascade is true.
+      #
+      # Resolved in the constructor rather than per request: answering it walks
+      # the whole scope chain twice, and it reads the same settings the routes
+      # were compiled and frozen from -- changing those has to go through
+      # +change!+, which discards this instance.
       def cascade?
-        return self.class.namespace_inheritable(:cascade) if self.class.inheritable_setting.namespace_inheritable.key?(:cascade)
-        return self.class.namespace_inheritable(:version_options)[:cascade] if self.class.namespace_inheritable(:version_options)&.key?(:cascade)
-
-        true
+        @cascade
       end
 
       reset!
@@ -197,50 +158,38 @@ module Grape
       def add_head_not_allowed_methods_and_options_methods
         # The paths we collected are prepared (cf. Path#prepare), so they
         # contain already versioning information when using path versioning.
-        all_routes = self.class.endpoints.map(&:routes).flatten
+        all_routes = self.class.endpoints.flat_map(&:routes)
 
-        # Disable versioning so adding a route won't prepend versioning
-        # informations again.
-        without_root_prefix_and_versioning { collect_route_config_per_pattern(all_routes) }
+        collect_route_config_per_pattern(all_routes)
       end
 
       def collect_route_config_per_pattern(all_routes)
+        setting = self.class.inheritable_setting
         routes_by_regexp = all_routes.group_by(&:pattern_regexp)
 
         # Build the configuration based on the first endpoint and the collection of methods supported.
         routes_by_regexp.each_value do |routes|
-          last_route = routes.last # Most of the configuration is taken from the last endpoint
           next if routes.any? { |route| route.request_method == '*' }
 
+          last_route = routes.last # Most of the configuration is taken from the last endpoint
           allowed_methods = routes.map(&:request_method)
-          allowed_methods |= [Rack::HEAD] if !self.class.namespace_inheritable(:do_not_route_head) && allowed_methods.include?(Rack::GET)
+          allowed_methods |= [Rack::HEAD] if !setting.do_not_route_head? && allowed_methods.include?(Rack::GET)
 
-          allow_header = self.class.namespace_inheritable(:do_not_route_options) ? allowed_methods : [Rack::OPTIONS] | allowed_methods
-          last_route.app.options[:options_route_enabled] = true unless self.class.namespace_inheritable(:do_not_route_options) || allowed_methods.include?(Rack::OPTIONS)
+          allow_header = setting.do_not_route_options? ? allowed_methods : [Rack::OPTIONS] | allowed_methods
+          last_route.app.options_route_enabled = true unless setting.do_not_route_options? || allowed_methods.include?(Rack::OPTIONS)
 
-          @router.associate_routes(last_route.pattern, {
-                                     endpoint: last_route.app,
-                                     allow_header: allow_header
-                                   })
+          greedy_route = Grape::Router::GreedyRoute.new(last_route.pattern, endpoint: last_route.app, allow_header:)
+          @router.associate_routes(greedy_route)
         end
       end
 
-      # Allows definition of endpoints that ignore the versioning configuration
-      # used by the rest of your API.
-      def without_root_prefix_and_versioning
-        old_version = self.class.namespace_inheritable(:version)
-        old_version_options = self.class.namespace_inheritable(:version_options)
-        old_root_prefix = self.class.namespace_inheritable(:root_prefix)
+      # Backs {#cascade?}; called once, from the constructor.
+      def resolve_cascade
+        setting = self.class.inheritable_setting
+        return setting.cascade if setting.cascade_defined?
+        return setting.version_options.cascade if setting.version_options
 
-        self.class.namespace_inheritable_to_nil(:version)
-        self.class.namespace_inheritable_to_nil(:version_options)
-        self.class.namespace_inheritable_to_nil(:root_prefix)
-
-        yield
-
-        self.class.namespace_inheritable(:version, old_version)
-        self.class.namespace_inheritable(:version_options, old_version_options)
-        self.class.namespace_inheritable(:root_prefix, old_root_prefix)
+        true
       end
     end
   end

data/lib/grape/api.rb

@@ -4,43 +4,42 @@ module Grape
   # The API class is the primary entry point for creating Grape APIs. Users
   # should subclass this class in order to build an API.
   class API
+    # Marks this and every subclass as a mountable Grape app (see Grape::Mountable).
+    extend Grape::Mountable
+
     # Class methods that we want to call on the API rather than on the API object
-    NON_OVERRIDABLE = %i[call call! configuration compile! inherited recognize_path].freeze
+    NON_OVERRIDABLE = %i[base base= base_instance? call change! configuration compile! inherit_settings recognize_path reset! routes top_level_setting= top_level_setting].freeze
+
+    Helpers = Grape::DSL::Helpers::BaseHelper
 
     class Boolean
+      VALUES = [true, false].freeze
+      private_constant :VALUES
+
       def self.build(val)
-        return nil if val != true && val != false
+        return unless VALUES.include?(val)
 
         new
       end
     end
 
-    class Instance
-      Boolean = Grape::API::Boolean
-    end
-
     class << self
       extend Forwardable
+
       attr_accessor :base_instance, :instances
 
       delegate_missing_to :base_instance
-      def_delegators :base_instance, :new, :configuration
 
       # This is the interface point between Rack and Grape; it accepts a request
       # from Rack and ultimately returns an array of three values: the status,
       # the headers, and the body. See [the rack specification]
-      # (http://www.rubydoc.info/github/rack/rack/master/file/SPEC) for more.
+      # (https://github.com/rack/rack/blob/main/SPEC.rdoc) for more.
       # NOTE: This will only be called on an API directly mounted on RACK
-      def_delegators :instance_for_rack, :call, :compile!
-
-      # When inherited, will create a list of all instances (times the API was mounted)
-      # It will listen to the setup required to mount that endpoint, and replicate it on any new instance
-      def inherited(api)
-        super
-
-        api.initial_setup(self == Grape::API ? Grape::API::Instance : @base_instance)
-        api.override_all_methods!
-      end
+      #
+      # +inherit_settings+ is left out: it is protected on the base instance, so
+      # a delegator would raise NoMethodError just as the missing one does.
+      def_delegators :base_instance, :new, :configuration, :call, :change!, :compile!, :recognize_path, :routes,
+                     :base, :base=, :base_instance?, :reset!, :top_level_setting
 
       # Initialize the instance variables on the remountable class, and the base_instance
       # an instance that will be used to create the set up but will not be mounted
@@ -54,8 +53,8 @@ module Grape
       # Redefines all methods so that are forwarded to add_setup and be recorded
       def override_all_methods!
         (base_instance.methods - Class.methods - NON_OVERRIDABLE).each do |method_override|
-          define_singleton_method(method_override) do |*args, &block|
-            add_setup(method: method_override, args: args, block: block)
+          define_singleton_method(method_override) do |*args, **kwargs, &block|
+            add_setup(method: method_override, args:, kwargs:, block:)
           end
         end
       end
@@ -67,12 +66,10 @@ module Grape
       # `configuration` as normal.
       def configure
         config = @base_instance.configuration
-        if block_given?
-          yield config
-          self
-        else
-          config
-        end
+        return config unless block_given?
+
+        yield config
+        self
       end
 
       # The remountable class can have a configuration hash to provide some dynamic class-level variables.
@@ -80,15 +77,24 @@ module Grape
       # depending on where the endpoint is mounted. Use with care, if you find yourself using configuration
       # too much, you may actually want to provide a new API rather than remount it.
       def mount_instance(configuration: nil)
-        Class.new(@base_parent).tap do |instance|
-          instance.configuration = Grape::Util::EndpointConfiguration.new(configuration || {})
-          instance.base = self
-          replay_setup_on(instance)
-        end
+        instance = Class.new(@base_parent)
+        instance.configuration = Grape::Util::EndpointConfiguration.new(configuration || {})
+        instance.base = self
+        replay_setup_on(instance)
+        instance
       end
 
       private
 
+      # When inherited, will create a list of all instances (times the API was mounted)
+      # It will listen to the setup required to mount that endpoint, and replicate it on any new instance
+      def inherited(api)
+        super
+
+        api.initial_setup(self == Grape::API ? Grape::API::Instance : @base_instance)
+        api.override_all_methods!
+      end
+
       # Replays the set up to produce an API as defined in this class, can be called
       # on classes that inherit from Grape::API
       def replay_setup_on(instance)
@@ -97,16 +103,8 @@ module Grape
         end
       end
 
-      def instance_for_rack
-        if never_mounted?
-          base_instance
-        else
-          mounted_instances.first
-        end
-      end
-
       # Adds a new stage to the set up require to get a Grape::API up and running
-      def add_setup(step)
+      def add_setup(**step)
         @setup << step
         last_response = nil
         @instances.each do |instance|
@@ -130,49 +128,42 @@ module Grape
         end
       end
 
-      def replay_step_on(instance, method:, args:, block:)
-        return if skip_immediate_run?(instance, args)
+      def replay_step_on(instance, method:, args:, kwargs:, block:)
+        return if skip_immediate_run?(instance, args, kwargs)
 
         eval_args = evaluate_arguments(instance.configuration, *args)
-        response = instance.send(method, *eval_args, &block)
-        if skip_immediate_run?(instance, [response])
-          response
-        else
-          evaluate_arguments(instance.configuration, response).first
-        end
+        eval_kwargs = kwargs.deep_transform_values { |v| evaluate_arguments(instance.configuration, v).first }
+        response = instance.__send__(method, *eval_args, **eval_kwargs, &block)
+
+        return response if skip_immediate_run?(instance, [response], kwargs)
+
+        evaluate_arguments(instance.configuration, response).first
       end
 
       # Skips steps that contain arguments to be lazily executed (on re-mount time)
-      def skip_immediate_run?(instance, args)
+      def skip_immediate_run?(instance, args, kwargs)
         instance.base_instance? &&
-          (any_lazy?(args) || args.any? { |arg| arg.is_a?(Hash) && any_lazy?(arg.values) })
+          (any_lazy?(args) || args.any? { |arg| arg.is_a?(Hash) && any_lazy?(arg.values) } || any_lazy?(kwargs.values))
       end
 
       def any_lazy?(args)
-        args.any? { |argument| argument.try(:lazy?) }
+        args.any?(Grape::Util::Lazy::Base)
       end
 
       def evaluate_arguments(configuration, *args)
         args.map do |argument|
-          if argument.try(:lazy?)
+          case argument
+          when Grape::Util::Lazy::Base
             argument.evaluate_from(configuration)
-          elsif argument.is_a?(Hash)
+          when Hash
             argument.transform_values { |value| evaluate_arguments(configuration, value).first }
-          elsif argument.is_a?(Array)
+          when Array
             evaluate_arguments(configuration, *argument)
           else
             argument
           end
         end
       end
-
-      def never_mounted?
-        mounted_instances.empty?
-      end
-
-      def mounted_instances
-        instances - [base_instance]
-      end
     end
   end
 end

data/lib/grape/content_types.rb

@@ -22,9 +22,64 @@ module Grape
     def mime_types_for(from_settings)
       return MIME_TYPES if from_settings == Grape::ContentTypes::DEFAULTS
 
-      from_settings.each_with_object({}) do |(k, v), types_without_params|
-        # remove optional parameter
-        types_without_params[v.split(';', 2).first] = k
+      MimeTypesCache[from_settings]
+    end
+
+    # Every format under both spellings in one plain Hash, so a lookup is a
+    # single +Hash#[]+. +HashWithIndifferentAccess+ converted the key on every
+    # read instead, and this is read two or three times per request — to
+    # negotiate the format, and again to set the response content type.
+    #
+    # Keys arrive as Symbols: the +content_type+ DSL symbolizes what it is
+    # given and the defaults are Symbols. The key is stored as it came too,
+    # so a middleware constructed directly with String keys still answers to
+    # either spelling, as the indifferent hash did.
+    def lookup_for(from_settings)
+      LookupCache[from_settings]
+    end
+
+    # The media type of a content-type header: the part before any `;`
+    # parameters, with surrounding whitespace removed
+    # (e.g. `'text/html'` for `'text/html; charset=utf-8'`). Returns nil for a
+    # nil content type. Skips the split (and its allocation) when there are no
+    # parameters, which is the common case.
+    def media_type(content_type)
+      return if content_type.nil?
+
+      base = content_type.include?(';') ? content_type.split(';', 2).first : content_type
+      base.strip
+    end
+
+    # Both tables below are derived from nothing but the content-type registry,
+    # and one content-type-aware middleware is built per API instance — so an
+    # app mounting N APIs held N copies of tables it only ever reads. Keying
+    # the cache on the registry itself collapses them: Hash keys compare by
+    # value, so every API that registers the same content types shares one
+    # table.
+    #
+    # Both the key and the table are frozen: the caller's registry stays
+    # reachable (through +middleware.options[:content_types]+, among others)
+    # and mutating a live key would corrupt a cache that is now shared
+    # process-wide.
+
+    class MimeTypesCache < Grape::Util::Cache
+      def initialize
+        super
+        @cache = Hash.new do |h, from_settings|
+          h[from_settings.dup.freeze] = from_settings.invert.transform_keys! { |mime_type| Grape::ContentTypes.media_type(mime_type) }.freeze
+        end
+      end
+    end
+
+    class LookupCache < Grape::Util::Cache
+      def initialize
+        super
+        @cache = Hash.new do |h, from_settings|
+          h[from_settings.dup.freeze] = from_settings.each_with_object({}) do |(format, media_type), lookup|
+            lookup[format] = media_type
+            lookup[format.is_a?(String) ? format.to_sym : format.to_s] = media_type
+          end.freeze
+        end
       end
     end
   end

data/lib/grape/cookies.rb

@@ -13,7 +13,7 @@ module Grape
     def_delegators :cookies, :[], :each
 
     def initialize(rack_cookies)
-      @cookies = rack_cookies
+      @cookies = ActiveSupport::HashWithIndifferentAccess.new(rack_cookies)
       @send_cookies = nil
     end
 
@@ -37,11 +37,7 @@ module Grape
 
     private
 
-    def cookies
-      return @cookies unless @cookies.is_a?(Proc)
-
-      @cookies = @cookies.call.with_indifferent_access
-    end
+    attr_reader :cookies
 
     def send_cookies
       @send_cookies ||= Set.new