grape 1.8.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'
@@ -17,20 +16,18 @@ Gem::Specification.new do |s|
     'bug_tracker_uri' => 'https://github.com/ruby-grape/grape/issues',
     'changelog_uri' => "https://github.com/ruby-grape/grape/blob/v#{s.version}/CHANGELOG.md",
     'documentation_uri' => "https://www.rubydoc.info/gems/grape/#{s.version}",
-    'source_code_uri' => "https://github.com/ruby-grape/grape/tree/v#{s.version}"
+    'source_code_uri' => "https://github.com/ruby-grape/grape/tree/v#{s.version}",
+    'rubygems_mfa_required' => 'true'
   }
 
-  s.add_runtime_dependency 'activesupport', '>= 5'
-  s.add_runtime_dependency 'builder'
-  s.add_runtime_dependency 'dry-types', '>= 1.1'
-  s.add_runtime_dependency 'mustermann-grape', '~> 1.0.0'
-  s.add_runtime_dependency 'rack', '>= 1.3.0'
-  s.add_runtime_dependency 'rack-accept'
+  s.add_dependency 'activesupport', '>= 7.2'
+  s.add_dependency 'dry-configurable', '>= 1.0'
+  s.add_dependency 'dry-types', '>= 1.1'
+  s.add_dependency 'mustermann', '>= 4.0'
+  s.add_dependency 'rack', '>= 2.2.4'
+  s.add_dependency 'zeitwerk', '>= 2.6'
 
-  s.files         = %w[CHANGELOG.md CONTRIBUTING.md README.md grape.png UPGRADING.md LICENSE]
-  s.files        += %w[grape.gemspec]
-  s.files        += Dir['lib/**/*']
-  s.test_files    = Dir['spec/**/*']
+  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.6.0'
+  s.required_ruby_version = '>= 3.3'
 end

data/lib/grape/api/instance.rb

@@ -1,37 +1,41 @@
 # frozen_string_literal: true
 
-require 'grape/router'
-
 module Grape
   class API
     # The API Instance class, is the engine behind Grape::API. Each class that inherits
     # from this will represent a different API instance
     class Instance
-      include Grape::DSL::API
+      # 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
+
+      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
@@ -45,91 +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
-        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
+          compile!.router.recognize_path(path)
         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
-        end
-
-        def evaluate_as_instance_with_configuration(block, lazy: false)
-          lazy_block = Grape::Util::LazyBlock.new do |configuration|
-            value_for_configuration = configuration
-            self.configuration = value_for_configuration.evaluate if value_for_configuration.respond_to?(:lazy?) && value_for_configuration.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)
-          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,23 @@ module Grape
 
         @router.compile!
         @router.freeze
+        @cascade = resolve_cascade
       end
 
       # Handle a request. See Rack documentation for what `env` is.
       def call(env)
-        result = @router.call(env)
-        result[1].delete(Grape::Http::Headers::X_CASCADE) unless cascade?
-        result
+        status, headers, response = @router.call(env)
+        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
+
+        [status, headers, response]
       end
 
       # Some requests may return a HTTP 404 error if grape cannot find a matching
@@ -175,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!
@@ -191,88 +156,40 @@ module Grape
       # will return an HTTP 405 response for any HTTP method that the resource
       # cannot handle.
       def add_head_not_allowed_methods_and_options_methods
-        versioned_route_configs = collect_route_config_per_pattern
         # The paths we collected are prepared (cf. Path#prepare), so they
         # contain already versioning information when using path versioning.
-        # Disable versioning so adding a route won't prepend versioning
-        # informations again.
-        without_root_prefix do
-          without_versioning do
-            versioned_route_configs.each do |config|
-              next if config[:options][:matching_wildchar]
-
-              allowed_methods = config[:methods].dup
-
-              allowed_methods |= [Grape::Http::Headers::HEAD] if !self.class.namespace_inheritable(:do_not_route_head) && allowed_methods.include?(Grape::Http::Headers::GET)
+        all_routes = self.class.endpoints.flat_map(&:routes)
 
-              allow_header = (self.class.namespace_inheritable(:do_not_route_options) ? allowed_methods : [Grape::Http::Headers::OPTIONS] | allowed_methods)
-
-              config[:endpoint].options[:options_route_enabled] = true unless self.class.namespace_inheritable(:do_not_route_options) || allowed_methods.include?(Grape::Http::Headers::OPTIONS)
-
-              attributes = config.merge(allowed_methods: allowed_methods, allow_header: allow_header)
-              generate_not_allowed_method(config[:pattern], **attributes)
-            end
-          end
-        end
+        collect_route_config_per_pattern(all_routes)
       end
 
-      def collect_route_config_per_pattern
-        all_routes       = self.class.endpoints.map(&:routes).flatten
-        routes_by_regexp = all_routes.group_by { |route| route.pattern.to_regexp }
+      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.values.map do |routes|
-          last_route        = routes.last # Most of the configuration is taken from the last endpoint
-          matching_wildchar = routes.any? { |route| route.request_method == '*' }
-          {
-            options: { matching_wildchar: matching_wildchar },
-            pattern: last_route.pattern,
-            requirements: last_route.requirements,
-            path: last_route.origin,
-            endpoint: last_route.app,
-            methods: matching_wildchar ? Grape::Http::Headers::SUPPORTED_METHODS : routes.map(&:request_method)
-          }
-        end
-      end
-
-      # Generate a route that returns an HTTP 405 response for a user defined
-      # path on methods not specified
-      def generate_not_allowed_method(pattern, allowed_methods: [], **attributes)
-        supported_methods =
-          if self.class.namespace_inheritable(:do_not_route_options)
-            Grape::Http::Headers::SUPPORTED_METHODS
-          else
-            Grape::Http::Headers::SUPPORTED_METHODS_WITHOUT_OPTIONS
-          end
-        not_allowed_methods = supported_methods - allowed_methods
-        @router.associate_routes(pattern, not_allowed_methods: not_allowed_methods, **attributes)
-      end
+        routes_by_regexp.each_value do |routes|
+          next if routes.any? { |route| route.request_method == '*' }
 
-      # Allows definition of endpoints that ignore the versioning configuration
-      # used by the rest of your API.
-      def without_versioning(&_block)
-        old_version = self.class.namespace_inheritable(:version)
-        old_version_options = self.class.namespace_inheritable(:version_options)
+          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 !setting.do_not_route_head? && allowed_methods.include?(Rack::GET)
 
-        self.class.namespace_inheritable_to_nil(:version)
-        self.class.namespace_inheritable_to_nil(:version_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)
 
-        yield
-
-        self.class.namespace_inheritable(:version, old_version)
-        self.class.namespace_inheritable(:version_options, old_version_options)
+          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 root prefix used by the
-      # rest of your API.
-      def without_root_prefix(&_block)
-        old_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(:root_prefix)
-
-        yield
-
-        self.class.namespace_inheritable(:root_prefix, old_prefix)
+        true
       end
     end
   end

data/lib/grape/api.rb

@@ -1,49 +1,51 @@
 # frozen_string_literal: true
 
-require 'grape/router'
-require 'grape/api/instance'
-
 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].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
-      attr_accessor :base_instance, :instances
+      extend Forwardable
 
-      # Rather than initializing an object of type Grape::API, create an object of type Instance
-      def new(*args, &block)
-        base_instance.new(*args, &block)
-      end
+      attr_accessor :base_instance, :instances
 
-      # 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
+      delegate_missing_to :base_instance
 
-        api.initial_setup(Grape::API == self ? Grape::API::Instance : @base_instance)
-        api.override_all_methods!
-      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]
+      # (https://github.com/rack/rack/blob/main/SPEC.rdoc) for more.
+      # NOTE: This will only be called on an API directly mounted on RACK
+      #
+      # +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
       def initial_setup(base_instance_parent)
         @instances = []
-        @setup = Set.new
+        @setup = []
         @base_parent = base_instance_parent
         @base_instance = mount_instance
       end
@@ -51,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_override, *args, &block)
+          define_singleton_method(method_override) do |*args, **kwargs, &block|
+            add_setup(method: method_override, args:, kwargs:, block:)
           end
         end
       end
@@ -64,138 +66,104 @@ module Grape
       # `configuration` as normal.
       def configure
         config = @base_instance.configuration
-        if block_given?
-          yield config
-          self
-        else
-          config
-        end
-      end
+        return config unless block_given?
 
-      # 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.
-      # NOTE: This will only be called on an API directly mounted on RACK
-      def call(*args, &block)
-        instance_for_rack.call(*args, &block)
-      end
-
-      # Alleviates problems with autoloading by tring to search for the constant
-      def const_missing(*args)
-        if base_instance.const_defined?(*args)
-          base_instance.const_get(*args)
-        else
-          super
-        end
+        yield config
+        self
       end
 
       # The remountable class can have a configuration hash to provide some dynamic class-level variables.
       # For instance, a description could be done using: `desc configuration[:description]` if it may vary
       # 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(**opts)
+      def mount_instance(configuration: nil)
         instance = Class.new(@base_parent)
-        instance.configuration = Grape::Util::EndpointConfiguration.new(opts[:configuration] || {})
+        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)
         @setup.each do |setup_step|
-          replay_step_on(instance, setup_step)
+          replay_step_on(instance, **setup_step)
         end
       end
 
-      def respond_to?(method, include_private = false)
-        super(method, include_private) || base_instance.respond_to?(method, include_private)
-      end
-
-      def respond_to_missing?(method, include_private = false)
-        base_instance.respond_to?(method, include_private)
-      end
-
-      def method_missing(method, *args, &block)
-        # If there's a missing method, it may be defined on the base_instance instead.
-        if respond_to_missing?(method)
-          base_instance.send(method, *args, &block)
-        else
-          super
+      # Adds a new stage to the set up require to get a Grape::API up and running
+      def add_setup(**step)
+        @setup << step
+        last_response = nil
+        @instances.each do |instance|
+          last_response = replay_step_on(instance, **step)
         end
-      end
 
-      def compile!
-        require 'grape/eager_load'
-        instance_for_rack.compile! # See API::Instance.compile!
+        refresh_mount_step if step[:method] != :mount
+        last_response
       end
 
-      private
+      # Updating all previously mounted classes in the case that new methods have been executed.
+      def refresh_mount_step
+        @setup.each do |setup_step|
+          next if setup_step[:method] != :mount
 
-      def instance_for_rack
-        if never_mounted?
-          base_instance
-        else
-          mounted_instances.first
+          refresh_mount_step = setup_step.merge(method: :refresh_mounted_api)
+          @setup << refresh_mount_step
+          @instances.each do |instance|
+            replay_step_on(instance, **refresh_mount_step)
+          end
         end
       end
 
-      # Adds a new stage to the set up require to get a Grape::API up and running
-      def add_setup(method, *args, &block)
-        setup_step = { method: method, args: args, block: block }
-        @setup += [setup_step]
-        last_response = nil
-        @instances.each do |instance|
-          last_response = replay_step_on(instance, setup_step)
-        end
-        last_response
-      end
+      def replay_step_on(instance, method:, args:, kwargs:, block:)
+        return if skip_immediate_run?(instance, args, kwargs)
 
-      def replay_step_on(instance, setup_step)
-        return if skip_immediate_run?(instance, setup_step[:args])
+        eval_args = evaluate_arguments(instance.configuration, *args)
+        eval_kwargs = kwargs.deep_transform_values { |v| evaluate_arguments(instance.configuration, v).first }
+        response = instance.__send__(method, *eval_args, **eval_kwargs, &block)
 
-        args = evaluate_arguments(instance.configuration, *setup_step[:args])
-        response = instance.send(setup_step[:method], *args, &setup_step[:block])
-        if skip_immediate_run?(instance, [response])
-          response
-        else
-          evaluate_arguments(instance.configuration, response).first
-        end
+        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.respond_to?(:lazy?) && argument.lazy? }
+        args.any?(Grape::Util::Lazy::Base)
       end
 
       def evaluate_arguments(configuration, *args)
         args.map do |argument|
-          if argument.respond_to?(:lazy?) && argument.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