grape 2.4.0 → 3.0.0

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

data/lib/grape/dsl/desc.rb

@@ -3,28 +3,7 @@
 module Grape
   module DSL
     module Desc
-      include Grape::DSL::Settings
-
-      ROUTE_ATTRIBUTES = %i[
-        body_name
-        consumes
-        default
-        deprecated
-        description
-        detail
-        entity
-        headers
-        hidden
-        http_codes
-        is_array
-        named
-        nickname
-        params
-        produces
-        security
-        summary
-        tags
-      ].freeze
+      extend Grape::DSL::Settings
 
       # Add a description to the next namespace or function.
       # @param description [String] descriptive string for this endpoint
@@ -70,54 +49,16 @@ module Grape
       #       # ...
       #     end
       #
-      def desc(description, options = nil, &config_block)
-        opts =
+      def desc(description, options = {}, &config_block)
+        settings =
           if config_block
-            desc_container(endpoint_configuration).then do |config_class|
-              config_class.configure do
-                description(description)
-              end
-
-              config_class.configure(&config_block)
-              config_class.settings
-            end
+            endpoint_config = defined?(configuration) ? configuration : nil
+            Grape::Util::ApiDescription.new(description, endpoint_config, &config_block).settings
           else
-            options&.merge(description: description) || { description: description }
-          end
-
-        namespace_setting :description, opts
-        route_setting :description, opts
-      end
-
-      # Returns an object which configures itself via an instance-context DSL.
-      def desc_container(endpoint_configuration)
-        Module.new do
-          include Grape::Util::StrictHashConfiguration.module(*ROUTE_ATTRIBUTES)
-          config_context.define_singleton_method(:configuration) do
-            endpoint_configuration
-          end
-
-          def config_context.success(*args)
-            entity(*args)
-          end
-
-          def config_context.failure(*args)
-            http_codes(*args)
+            options.merge(description: description)
           end
-        end
-      end
-
-      private
-
-      def endpoint_configuration
-        return {} unless defined?(configuration)
-
-        if configuration.respond_to?(:evaluate)
-          configuration.evaluate
-          # Within `given` or `mounted blocks` the configuration is already evaluated
-        elsif configuration.is_a?(Hash)
-          configuration
-        end
+        inheritable_setting.namespace[:description] = settings
+        inheritable_setting.route[:description] = settings
       end
     end
   end

data/lib/grape/dsl/helpers.rb

@@ -3,81 +3,76 @@
 module Grape
   module DSL
     module Helpers
-      extend ActiveSupport::Concern
-      include Grape::DSL::Configuration
-
-      module ClassMethods
-        # Add helper methods that will be accessible from any
-        # endpoint within this namespace (and child namespaces).
-        #
-        # When called without a block, all known helpers within this scope
-        # are included.
-        #
-        # @param [Array] new_modules optional array of modules to include
-        # @param [Block] block optional block of methods to include
-        #
-        # @example Define some helpers.
-        #
-        #     class ExampleAPI < Grape::API
-        #       helpers do
-        #         def current_user
-        #           User.find_by_id(params[:token])
-        #         end
-        #       end
-        #     end
-        #
-        # @example Include many modules
-        #
-        #     class ExampleAPI < Grape::API
-        #       helpers Authentication, Mailer, OtherModule
-        #     end
-        #
-        def helpers(*new_modules, &block)
-          include_new_modules(new_modules)
-          include_block(block)
-          include_all_in_scope if !block && new_modules.empty?
-        end
+      # Add helper methods that will be accessible from any
+      # endpoint within this namespace (and child namespaces).
+      #
+      # When called without a block, all known helpers within this scope
+      # are included.
+      #
+      # @param [Array] new_modules optional array of modules to include
+      # @param [Block] block optional block of methods to include
+      #
+      # @example Define some helpers.
+      #
+      #     class ExampleAPI < Grape::API
+      #       helpers do
+      #         def current_user
+      #           User.find_by_id(params[:token])
+      #         end
+      #       end
+      #     end
+      #
+      # @example Include many modules
+      #
+      #     class ExampleAPI < Grape::API
+      #       helpers Authentication, Mailer, OtherModule
+      #     end
+      #
+      def helpers(*new_modules, &block)
+        include_new_modules(new_modules)
+        include_block(block)
+        include_all_in_scope if !block && new_modules.empty?
+      end
 
-        protected
+      private
 
-        def include_new_modules(modules)
-          return if modules.empty?
+      def include_new_modules(modules)
+        return if modules.empty?
 
-          modules.each { |mod| make_inclusion(mod) }
-        end
+        modules.each { |mod| make_inclusion(mod) }
+      end
 
-        def include_block(block)
-          return unless block
+      def include_block(block)
+        return unless block
 
-          Module.new.tap do |mod|
-            make_inclusion(mod) { mod.class_eval(&block) }
-          end
+        Module.new.tap do |mod|
+          make_inclusion(mod) { mod.class_eval(&block) }
         end
+      end
 
-        def make_inclusion(mod, &block)
-          define_boolean_in_mod(mod)
-          inject_api_helpers_to_mod(mod, &block)
-          namespace_stackable(:helpers, mod)
-        end
+      def make_inclusion(mod, &block)
+        define_boolean_in_mod(mod)
+        inject_api_helpers_to_mod(mod, &block)
+        inheritable_setting.namespace_stackable[:helpers] = mod
+      end
 
-        def include_all_in_scope
-          Module.new.tap do |mod|
-            namespace_stackable(:helpers).each { |mod_to_include| mod.include mod_to_include }
-            change!
-          end
+      def include_all_in_scope
+        Module.new.tap do |mod|
+          namespace_stackable(:helpers).each { |mod_to_include| mod.include mod_to_include }
+          change!
         end
+      end
 
-        def define_boolean_in_mod(mod)
-          return if defined? mod::Boolean
+      def define_boolean_in_mod(mod)
+        return if defined? mod::Boolean
 
-          mod.const_set(:Boolean, Grape::API::Boolean)
-        end
+        mod.const_set(:Boolean, Grape::API::Boolean)
+      end
 
-        def inject_api_helpers_to_mod(mod, &block)
-          mod.extend(BaseHelper) unless mod.is_a?(BaseHelper)
-          yield if block
-          mod.api_changed(self)
-        end
+      def inject_api_helpers_to_mod(mod, &block)
+        mod.extend(BaseHelper) unless mod.is_a?(BaseHelper)
+        yield if block
+        mod.api_changed(self)
       end
 
       # This module extends user defined helpers
@@ -100,7 +95,7 @@ module Grape
         def process_named_params
           return if @named_params.blank?
 
-          api.namespace_stackable(:named_params, @named_params)
+          api.inheritable_setting.namespace_stackable[:named_params] = @named_params
         end
       end
     end

data/lib/grape/dsl/inside_route.rb

@@ -3,10 +3,6 @@
 module Grape
   module DSL
     module InsideRoute
-      extend ActiveSupport::Concern
-      include Grape::DSL::Settings
-      include Grape::DSL::Headers
-
       # Denotes a situation where a DSL method has been invoked in a
       # filter which it should not yet be available in
       class MethodNotYetAvailable < StandardError; end
@@ -35,7 +31,7 @@ module Grape
                   declared_hash(passed_params, options, declared_params, params_nested_path)
                 end
 
-          if (key_maps = namespace_stackable(:contract_key_map))
+          if (key_maps = inheritable_setting.namespace_stackable[:contract_key_map])
             key_maps.each { |key_map| key_map.write(passed_params, res) }
           end
 
@@ -59,7 +55,7 @@ module Grape
         end
 
         def declared_hash_attr(passed_params, options, declared_param, params_nested_path, memo)
-          renamed_params = route_setting(:renamed_params) || {}
+          renamed_params = inheritable_setting.route[:renamed_params] || {}
           if declared_param.is_a?(Hash)
             declared_param.each_pair do |declared_parent_param, declared_children_params|
               params_nested_path_dup = params_nested_path.dup
@@ -123,10 +119,10 @@ module Grape
         def optioned_declared_params(include_parent_namespaces)
           declared_params = if include_parent_namespaces
                               # Declared params including parent namespaces
-                              route_setting(:declared_params)
+                              inheritable_setting.route[:declared_params]
                             else
                               # Declared params at current namespace
-                              namespace_stackable(:declared_params).last || []
+                              inheritable_setting.namespace_stackable[:declared_params].last || []
                             end
 
           raise ArgumentError, 'Tried to filter for declared parameters but none exist.' unless declared_params
@@ -168,7 +164,7 @@ module Grape
       # @param backtrace [Array<String>] The backtrace of the exception that caused the error.
       # @param original_exception [Exception] The original exception that caused the error.
       def error!(message, status = nil, additional_headers = nil, backtrace = nil, original_exception = nil)
-        status = self.status(status || namespace_inheritable(:default_error_status))
+        status = self.status(status || inheritable_setting.namespace_inheritable[:default_error_status])
         headers = additional_headers.present? ? header.merge(additional_headers) : header
         throw :error,
               message: message,
@@ -178,24 +174,6 @@ module Grape
               original_exception: original_exception
       end
 
-      # Creates a Rack response based on the provided message, status, and headers.
-      # The content type in the headers is set to the default content type unless provided.
-      # The message is HTML-escaped if the content type is 'text/html'.
-      #
-      # @param message [String] The content of the response.
-      # @param status [Integer] The HTTP status code.
-      # @params headers [Hash] (optional) Headers for the response
-      #                      (default: {Rack::CONTENT_TYPE => content_type}).
-      #
-      # Returns:
-      # A Rack::Response object containing the specified message, status, and headers.
-      #
-      def rack_response(message, status = 200, headers = { Rack::CONTENT_TYPE => content_type })
-        Grape.deprecator.warn('The rack_response method has been deprecated, use error! instead.')
-        message = Rack::Utils.escape_html(message) if headers[Rack::CONTENT_TYPE] == 'text/html'
-        Rack::Response.new(Array.wrap(message), Rack::Utils.status_code(status), headers)
-      end
-
       # Redirect to a new url.
       #
       # @param url [String] The url to be redirect.
@@ -359,8 +337,7 @@ module Grape
       #       with: API::Entities::User,
       #       admin: current_user.admin?
       #   end
-      def present(*args)
-        options = args.count > 1 ? args.extract_options! : {}
+      def present(*args, **options)
         key, object = if args.count == 2 && args.first.is_a?(Symbol)
                         args
                       else
@@ -411,22 +388,22 @@ module Grape
       # @return [Class] the located Entity class, or nil if none is found
       def entity_class_for_obj(object, options)
         entity_class = options.delete(:with)
-
-        if entity_class.nil?
-          # entity class not explicitly defined, auto-detect from relation#klass or first object in the collection
-          object_class = if object.respond_to?(:klass)
-                           object.klass
-                         else
-                           object.respond_to?(:first) ? object.first.class : object.class
-                         end
-
-          object_class.ancestors.each do |potential|
-            entity_class ||= (namespace_stackable_with_hash(:representations) || {})[potential]
-          end
-
-          entity_class ||= object_class.const_get(:Entity) if object_class.const_defined?(:Entity) && object_class.const_get(:Entity).respond_to?(:represent)
+        return entity_class if entity_class
+
+        # entity class not explicitly defined, auto-detect from relation#klass or first object in the collection
+        object_class = if object.respond_to?(:klass)
+                         object.klass
+                       else
+                         object.respond_to?(:first) ? object.first.class : object.class
+                       end
+
+        representations = inheritable_setting.namespace_stackable_with_hash(:representations)
+        if representations
+          potential = object_class.ancestors.detect { |potential| representations.key?(potential) }
+          entity_class = representations[potential] if potential
         end
 
+        entity_class = object_class.const_get(:Entity) if !entity_class && object_class.const_defined?(:Entity) && object_class.const_get(:Entity).respond_to?(:represent)
         entity_class
       end
 

data/lib/grape/dsl/logger.rb

@@ -3,18 +3,15 @@
 module Grape
   module DSL
     module Logger
-      include Grape::DSL::Settings
-
-      attr_writer :logger
-
       # Set or retrive the configured logger. If none was configured, this
       # method will create a new one, logging to stdout.
       # @param logger [Object] the new logger to use
       def logger(logger = nil)
+        global_settings = inheritable_setting.global
         if logger
-          global_setting(:logger, logger)
+          global_settings[:logger] = logger
         else
-          global_setting(:logger) || global_setting(:logger, ::Logger.new($stdout))
+          global_settings[:logger] || global_settings[:logger] = ::Logger.new($stdout)
         end
       end
     end

data/lib/grape/dsl/middleware.rb

@@ -3,51 +3,33 @@
 module Grape
   module DSL
     module Middleware
-      extend ActiveSupport::Concern
-
-      include Grape::DSL::Configuration
-
-      module ClassMethods
-        # Apply a custom middleware to the API. Applies
-        # to the current namespace and any children, but
-        # not parents.
-        #
-        # @param middleware_class [Class] The class of the middleware you'd like
-        #   to inject.
-        def use(middleware_class, *args, &block)
-          arr = [:use, middleware_class, *args]
-          arr << block if block
-
-          namespace_stackable(:middleware, arr)
-        end
-
-        def insert(*args, &block)
-          arr = [:insert, *args]
-          arr << block if block
-
-          namespace_stackable(:middleware, arr)
-        end
-
-        def insert_before(*args, &block)
-          arr = [:insert_before, *args]
-          arr << block if block
-
-          namespace_stackable(:middleware, arr)
-        end
+      # Apply a custom middleware to the API. Applies
+      # to the current namespace and any children, but
+      # not parents.
+      #
+      # @param middleware_class [Class] The class of the middleware you'd like
+      #   to inject.
+      def use(middleware_class, *args, &block)
+        arr = [:use, middleware_class, *args]
+        arr << block if block
+
+        inheritable_setting.namespace_stackable[:middleware] = arr
+      end
 
-        def insert_after(*args, &block)
-          arr = [:insert_after, *args]
+      %i[insert insert_before insert_after].each do |method_name|
+        define_method method_name do |*args, &block|
+          arr = [method_name, *args]
           arr << block if block
 
-          namespace_stackable(:middleware, arr)
+          inheritable_setting.namespace_stackable[:middleware] = arr
         end
+      end
 
-        # Retrieve an array of the middleware classes
-        # and arguments that are currently applied to the
-        # application.
-        def middleware
-          namespace_stackable(:middleware) || []
-        end
+      # Retrieve an array of the middleware classes
+      # and arguments that are currently applied to the
+      # application.
+      def middleware
+        inheritable_setting.namespace_stackable[:middleware] || []
       end
     end
   end

data/lib/grape/dsl/parameters.rb

@@ -6,8 +6,6 @@ module Grape
     # and describe the parameters accepted by an endpoint, or all endpoints
     # within a namespace.
     module Parameters
-      extend ActiveSupport::Concern
-
       # Set the module used to build the request.params.
       #
       # @param build_with the ParamBuilder module to use when building request.params
@@ -31,7 +29,7 @@ module Grape
       #       end
       #     end
       def build_with(build_with)
-        @api.namespace_inheritable(:build_params_with, build_with)
+        @api.inheritable_setting.namespace_inheritable[:build_params_with] = build_with
       end
 
       # Include reusable params rules among current.
@@ -55,9 +53,8 @@ module Grape
       #         Collection.page(params[:page]).per(params[:per_page])
       #       end
       #     end
-      def use(*names)
-        named_params = @api.namespace_stackable_with_hash(:named_params) || {}
-        options = names.extract_options!
+      def use(*names, **options)
+        named_params = @api.inheritable_setting.namespace_stackable_with_hash(:named_params) || {}
         names.each do |name|
           params_block = named_params.fetch(name) do
             raise "Params :#{name} not found!"
@@ -125,10 +122,7 @@ module Grape
       #         requires :name, type: String
       #       end
       #     end
-      def requires(*attrs, &block)
-        orig_attrs = attrs.clone
-
-        opts = attrs.extract_options!.clone
+      def requires(*attrs, **opts, &block)
         opts[:presence] = { value: true, message: opts[:message] }
         opts = @group.deep_merge(opts) if instance_variable_defined?(:@group) && @group
 
@@ -136,7 +130,7 @@ module Grape
           require_required_and_optional_fields(attrs.first, opts)
         else
           validate_attributes(attrs, opts, &block)
-          block ? new_scope(orig_attrs, &block) : push_declared_params(attrs, opts.slice(:as))
+          block ? new_scope(attrs, opts, &block) : push_declared_params(attrs, opts.slice(:as))
         end
       end
 
@@ -144,10 +138,7 @@ module Grape
       #   endpoint.
       # @param (see #requires)
       # @option (see #requires)
-      def optional(*attrs, &block)
-        orig_attrs = attrs.clone
-
-        opts = attrs.extract_options!.clone
+      def optional(*attrs, **opts, &block)
         type = opts[:type]
         opts = @group.deep_merge(opts) if instance_variable_defined?(:@group) && @group
 
@@ -162,7 +153,7 @@ module Grape
         else
           validate_attributes(attrs, opts, &block)
 
-          block ? new_scope(orig_attrs, true, &block) : push_declared_params(attrs, opts.slice(:as))
+          block ? new_scope(attrs, opts, true, &block) : push_declared_params(attrs, opts.slice(:as))
         end
       end