grape 2.3.0 → 3.0.0

data/lib/grape/api/instance.rb

@@ -5,14 +5,30 @@ 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
-      include Grape::DSL::API
+      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
+        extend Forwardable
         attr_reader :instance, :base
         attr_accessor :configuration
 
+        def_delegators :base, :to_s
+
         def given(conditional_option, &block)
-          evaluate_as_instance_with_configuration(block, lazy: true) if conditional_option && block
+          return unless conditional_option
+
+          mounted(&block)
         end
 
         def mounted(&block)
@@ -24,10 +40,6 @@ module Grape
           grape_api.instances << self
         end
 
-        def to_s
-          base&.to_s || super
-        end
-
         def base_instance?
           self == base.base_instance
         end
@@ -49,11 +61,6 @@ module Grape
           @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]
@@ -70,11 +77,9 @@ module Grape
 
         # (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
+          return inheritable_setting.namespace_inheritable.key?(:cascade) ? !inheritable_setting.namespace_inheritable(:cascade).nil? : true if value.nil?
+
+          inheritable_setting.namespace_inheritable[:cascade] = value
         end
 
         def compile!
@@ -91,45 +96,6 @@ module Grape
 
         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
-        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.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
-        end
-
-        def inherited(subclass)
-          super
-          subclass.reset!
-          subclass.logger = logger.clone
-        end
-
         def inherit_settings(other_settings)
           top_level_setting.inherit_from other_settings.point_in_time_copy
 
@@ -142,6 +108,19 @@ module Grape
 
           reset_routes!
         end
+
+        # Wipe the compiled API so we can recompile after changes were made.
+        def change!
+          @instance = nil
+        end
+
+        private
+
+        def inherited(subclass)
+          super
+          subclass.reset!
+          subclass.logger logger.clone
+        end
       end
 
       attr_reader :router
@@ -164,7 +143,7 @@ module Grape
         status, headers, response = @router.call(env)
         unless cascade?
           headers = Grape::Util::Header.new.merge(headers)
-          headers.delete(Grape::Http::Headers::X_CASCADE)
+          headers.delete('X-Cascade')
         end
 
         [status, headers, response]
@@ -179,8 +158,9 @@ module Grape
       # errors from reaching upstream. This is effectivelly done by unsetting
       # X-Cascade. Default :cascade is true.
       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)
+        namespace_inheritable = self.class.inheritable_setting.namespace_inheritable
+        return namespace_inheritable[:cascade] if namespace_inheritable.key?(:cascade)
+        return namespace_inheritable[:version_options][:cascade] if namespace_inheritable[:version_options]&.key?(:cascade)
 
         true
       end
@@ -211,11 +191,12 @@ module Grape
           last_route = routes.last # Most of the configuration is taken from the last endpoint
           next if routes.any? { |route| route.request_method == '*' }
 
+          namespace_inheritable = self.class.inheritable_setting.namespace_inheritable
           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 !namespace_inheritable[: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 = namespace_inheritable[:do_not_route_options] ? allowed_methods : [Rack::OPTIONS] | allowed_methods
+          last_route.app.options[:options_route_enabled] = true unless namespace_inheritable[:do_not_route_options] || allowed_methods.include?(Rack::OPTIONS)
 
           @router.associate_routes(last_route.pattern, {
                                      endpoint: last_route.app,
@@ -224,22 +205,19 @@ module Grape
         end
       end
 
+      ROOT_PREFIX_VERSIONING_KEY = %i[version version_options root_prefix].freeze
+      private_constant :ROOT_PREFIX_VERSIONING_KEY
+
       # 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)
-
-        self.class.namespace_inheritable_to_nil(:version)
-        self.class.namespace_inheritable_to_nil(:version_options)
-        self.class.namespace_inheritable_to_nil(:root_prefix)
-
+        inheritable_setting = self.class.inheritable_setting
+        deleted_values = inheritable_setting.namespace_inheritable.delete(*ROOT_PREFIX_VERSIONING_KEY)
         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)
+      ensure
+        ROOT_PREFIX_VERSIONING_KEY.each_with_index do |key, index|
+          inheritable_setting.namespace_inheritable[key] = deleted_values[index]
+        end
       end
     end
   end

data/lib/grape/api.rb

@@ -5,7 +5,9 @@ module Grape
   # should subclass this class in order to build an API.
   class API
     # 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[call call! configuration compile! inherited recognize_path routes].freeze
+
+    Helpers = Grape::DSL::Helpers::BaseHelper
 
     class Boolean
       def self.build(val)
@@ -15,26 +17,18 @@ module Grape
       end
     end
 
-    class Instance
-      Boolean = Grape::API::Boolean
-    end
-
     class << self
+      extend Forwardable
       attr_accessor :base_instance, :instances
 
-      # Rather than initializing an object of type Grape::API, create an object of type Instance
-      def new(...)
-        base_instance.new(...)
-      end
-
-      # 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(self == Grape::API ? 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
+      def_delegators :base_instance, :new, :configuration, :call, :compile!
 
       # 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
@@ -48,8 +42,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: args, kwargs: kwargs, block: block)
           end
         end
       end
@@ -69,96 +63,69 @@ module Grape
         end
       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.
-      # NOTE: This will only be called on an API directly mounted on RACK
-      def call(...)
-        instance_for_rack.call(...)
-      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 = {})
-        instance = Class.new(@base_parent)
-        instance.configuration = Grape::Util::EndpointConfiguration.new(opts[:configuration] || {})
-        instance.base = self
-        replay_setup_on(instance)
-        instance
-      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)
+      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
       end
 
-      def respond_to?(method, include_private = false)
-        super || base_instance.respond_to?(method, include_private)
-      end
-
-      def respond_to_missing?(method, include_private = false)
-        base_instance.respond_to?(method, include_private)
-      end
+      private
 
-      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
-        end
-      end
+      # 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
 
-      def compile!
-        instance_for_rack.compile! # See API::Instance.compile!
+        api.initial_setup(self == Grape::API ? Grape::API::Instance : @base_instance)
+        api.override_all_methods!
       end
 
-      private
-
-      def instance_for_rack
-        if never_mounted?
-          base_instance
-        else
-          mounted_instances.first
+      # 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)
         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]
+      def add_setup(**step)
+        @setup << step
         last_response = nil
         @instances.each do |instance|
-          last_response = replay_step_on(instance, setup_step)
+          last_response = replay_step_on(instance, **step)
         end
 
-        # Updating all previously mounted classes in the case that new methods have been executed.
-        if method != :mount && @setup.any?
-          previous_mount_steps = @setup.select { |step| step[:method] == :mount }
-          previous_mount_steps.each do |mount_step|
-            refresh_mount_step = mount_step.merge(method: :refresh_mounted_api)
-            @setup += [refresh_mount_step]
-            @instances.each do |instance|
-              replay_step_on(instance, refresh_mount_step)
-            end
+        refresh_mount_step if step[:method] != :mount
+        last_response
+      end
+
+      # 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
+
+          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
-
-        last_response
       end
 
-      def replay_step_on(instance, setup_step)
-        return if skip_immediate_run?(instance, setup_step[:args])
+      def replay_step_on(instance, method:, args:, kwargs:, block:)
+        return if skip_immediate_run?(instance, args, kwargs)
 
-        args = evaluate_arguments(instance.configuration, *setup_step[:args])
-        response = instance.send(setup_step[:method], *args, &setup_step[:block])
-        if skip_immediate_run?(instance, [response])
+        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)
+        if skip_immediate_run?(instance, [response], kwargs)
           response
         else
           evaluate_arguments(instance.configuration, response).first
@@ -166,18 +133,18 @@ module Grape
       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? { |argument| argument.try(:lazy?) }
       end
 
       def evaluate_arguments(configuration, *args)
         args.map do |argument|
-          if argument.respond_to?(:lazy?) && argument.lazy?
+          if argument.try(:lazy?)
             argument.evaluate_from(configuration)
           elsif argument.is_a?(Hash)
             argument.transform_values { |value| evaluate_arguments(configuration, value).first }

data/lib/grape/cookies.rb

@@ -2,43 +2,49 @@
 
 module Grape
   class Cookies
-    def initialize
-      @cookies = {}
-      @send_cookies = {}
-    end
+    extend Forwardable
 
-    def read(request)
-      request.cookies.each do |name, value|
-        @cookies[name.to_s] = value
-      end
+    DELETED_COOKIES_ATTRS = {
+      max_age: '0',
+      value: '',
+      expires: Time.at(0)
+    }.freeze
+
+    def_delegators :cookies, :[], :each
+
+    def initialize(rack_cookies)
+      @cookies = rack_cookies
+      @send_cookies = nil
     end
 
-    def write(header)
-      @cookies.select { |key, _value| @send_cookies[key] == true }.each do |name, value|
-        cookie_value = value.is_a?(Hash) ? value : { value: value }
-        Rack::Utils.set_cookie_header! header, name, cookie_value
+    def response_cookies
+      return unless @send_cookies
+
+      send_cookies.each do |name|
+        yield name, cookies[name]
       end
     end
 
-    def [](name)
-      @cookies[name.to_s]
+    def []=(name, value)
+      cookies[name] = value
+      send_cookies << name
     end
 
-    def []=(name, value)
-      @cookies[name.to_s] = value
-      @send_cookies[name.to_s] = true
+    # see https://github.com/rack/rack/blob/main/lib/rack/utils.rb#L338-L340
+    def delete(name, **opts)
+      self.[]=(name, opts.merge(DELETED_COOKIES_ATTRS))
     end
 
-    def each(&block)
-      @cookies.each(&block)
+    private
+
+    def cookies
+      return @cookies unless @cookies.is_a?(Proc)
+
+      @cookies = @cookies.call.with_indifferent_access
     end
 
-    # see https://github.com/rack/rack/blob/main/lib/rack/utils.rb#L338-L340
-    # rubocop:disable Layout/SpaceBeforeBrackets
-    def delete(name, **opts)
-      options = opts.merge(max_age: '0', value: '', expires: Time.at(0))
-      self.[]=(name, options)
+    def send_cookies
+      @send_cookies ||= Set.new
     end
-    # rubocop:enable Layout/SpaceBeforeBrackets
   end
 end

data/lib/grape/dry_types.rb

@@ -2,9 +2,53 @@
 
 module Grape
   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()
+    # https://dry-rb.org/gems/dry-types/main/getting-started/
+    # limit to what Grape is using
+    include Dry.Types(:params, :coercible, :strict)
+
+    class StrictCache < Grape::Util::Cache
+      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
+        super
+        @cache = Hash.new do |h, strict_type|
+          h[strict_type] = MAPPING.fetch(strict_type) do
+            DryTypes.wrapped_dry_types_const_get(DryTypes::Strict, strict_type)
+          end
+        end
+      end
+    end
+
+    class ParamsCache < Grape::Util::Cache
+      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),
+        String => DryTypes::Coercible::String
+      }.freeze
+
+      def initialize
+        super
+        @cache = Hash.new do |h, params_type|
+          h[params_type] = MAPPING.fetch(params_type) do
+            DryTypes.wrapped_dry_types_const_get(DryTypes::Params, params_type)
+          end
+        end
+      end
+    end
+
+    def self.wrapped_dry_types_const_get(dry_type, type)
+      dry_type.const_get(type.name, false)
+    rescue NameError
+      raise ArgumentError, "type #{type} should support coercion via `[]`" unless type.respond_to?(:[])
+    end
   end
 end

data/lib/grape/dsl/callbacks.rb

@@ -2,66 +2,16 @@
 
 module Grape
   module DSL
-    # Blocks can be executed before or after every API call, using `before`, `after`,
-    # `before_validation` and `after_validation`.
-    #
-    # Before and after callbacks execute in the following order:
-    #
-    # 1. `before`
-    # 2. `before_validation`
-    # 3. _validations_
-    # 4. `after_validation`
-    # 5. _the API call_
-    # 6. `after`
-    #
-    # Steps 4, 5 and 6 only happen if validation succeeds.
     module Callbacks
-      extend ActiveSupport::Concern
+      # before: execute the given block before validation, coercion, or any endpoint
+      # before_validation: execute the given block after `before`, but prior to validation or coercion
+      # after_validation: execute the given block after validations and coercions, but before any endpoint code
+      # after: execute the given block after the endpoint code has run except in unsuccessful
+      # finally: execute the given block after the endpoint code even if unsuccessful
 
-      include Grape::DSL::Configuration
-
-      module ClassMethods
-        # Execute the given block before validation, coercion, or any endpoint
-        # code is executed.
-        def before(&block)
-          namespace_stackable(:befores, block)
-        end
-
-        # Execute the given block after `before`, but prior to validation or
-        # coercion.
-        def before_validation(&block)
-          namespace_stackable(:before_validations, block)
-        end
-
-        # Execute the given block after validations and coercions, but before
-        # any endpoint code.
-        def after_validation(&block)
-          namespace_stackable(:after_validations, block)
-        end
-
-        # Execute the given block after the endpoint code has run.
-        def after(&block)
-          namespace_stackable(:afters, block)
-        end
-
-        # Allows you to specify a something that will always be executed after a call
-        # API call. Unlike the `after` block, this code will run even on
-        # unsuccesful requests.
-        # @example
-        #   class ExampleAPI < Grape::API
-        #     before do
-        #       ApiLogger.start
-        #     end
-        #     finally do
-        #       ApiLogger.close
-        #     end
-        #   end
-        #
-        # This will make sure that the ApiLogger is opened and closed around every
-        # request
-        # @param  ensured_block [Proc] The block to be executed after every api_call
-        def finally(&block)
-          namespace_stackable(:finallies, block)
+      %w[before before_validation after_validation after finally].each do |callback_method|
+        define_method callback_method.to_sym do |&block|
+          inheritable_setting.namespace_stackable[callback_method.pluralize.to_sym] = block
         end
       end
     end