grape 2.4.0 → 3.2.1

data/lib/grape/declared_params_handler.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+module Grape
+  class DeclaredParamsHandler
+    def initialize(include_missing: true, evaluate_given: false, stringify: false, contract_key_map: nil)
+      @include_missing = include_missing
+      @evaluate_given = evaluate_given
+      @stringify = stringify
+      @contract_key_map = contract_key_map
+    end
+
+    def call(passed_params, declared_params, route_params, renamed_params)
+      recursive_declared(
+        passed_params,
+        declared_params:,
+        route_params:,
+        renamed_params:
+      )
+    end
+
+    private
+
+    def recursive_declared(passed_params, declared_params:, route_params:, renamed_params:, params_nested_path: [])
+      res = if passed_params.is_a?(Array)
+              passed_params.map do |passed_param|
+                recursive_declared(passed_param, declared_params:, params_nested_path:, renamed_params:, route_params:)
+              end
+            else
+              declared_hash(passed_params, declared_params:, params_nested_path:, renamed_params:, route_params:)
+            end
+
+      @contract_key_map&.each { |key_map| key_map.write(passed_params, res) }
+
+      res
+    end
+
+    def declared_hash(passed_params, declared_params:, params_nested_path:, renamed_params:, route_params:)
+      declared_params.each_with_object(passed_params.class.new) do |declared_param_attr, memo|
+        next if @evaluate_given && !declared_param_attr.scope.attr_meets_dependency?(passed_params)
+
+        declared_hash_attr(
+          passed_params,
+          declared_param: declared_param_attr.key,
+          params_nested_path:,
+          memo:,
+          renamed_params:,
+          route_params:
+        )
+      end
+    end
+
+    def declared_hash_attr(passed_params, declared_param:, params_nested_path:, memo:, renamed_params:, route_params:)
+      if declared_param.is_a?(Hash)
+        declared_param.each_pair do |declared_parent_param, declared_children_params|
+          next unless @include_missing || passed_params.key?(declared_parent_param)
+
+          memo_key = build_memo_key(params_nested_path, declared_parent_param, renamed_params)
+          passed_children_params = passed_params[declared_parent_param] || passed_params.class.new
+
+          params_nested_path_dup = params_nested_path.dup
+          params_nested_path_dup << declared_parent_param.to_s
+
+          memo[memo_key] = handle_passed_param(params_nested_path_dup, route_params:, has_passed_children: passed_children_params.any?) do
+            recursive_declared(
+              passed_children_params,
+              declared_params: declared_children_params,
+              params_nested_path: params_nested_path_dup,
+              renamed_params:,
+              route_params:
+            )
+          end
+        end
+      else
+        # If it is not a Hash then it does not have children.
+        # Find its value or set it to nil.
+        return unless @include_missing || (passed_params.respond_to?(:key?) && passed_params.key?(declared_param))
+
+        memo_key = build_memo_key(params_nested_path, declared_param, renamed_params)
+        passed_param = passed_params[declared_param]
+
+        params_nested_path_dup = params_nested_path.dup
+        params_nested_path_dup << declared_param.to_s
+
+        memo[memo_key] = passed_param || handle_passed_param(params_nested_path_dup, route_params:) do
+          passed_param
+        end
+      end
+    end
+
+    def build_memo_key(params_nested_path, declared_param, renamed_params)
+      rename_path = params_nested_path + [declared_param.to_s]
+      renamed_param_name = renamed_params[rename_path]
+
+      param = renamed_param_name || declared_param
+      @stringify ? param.to_s : param.to_sym
+    end
+
+    def handle_passed_param(params_nested_path, route_params:, has_passed_children: false, &_block)
+      return yield if has_passed_children
+
+      key = params_nested_path[0]
+      key += "[#{params_nested_path[1..].join('][')}]" if params_nested_path.size > 1
+
+      type = route_params.dig(key, :type)
+      has_children = route_params.keys.any? { |k| k != key && k.start_with?("#{key}[") }
+
+      if type == 'Hash' && !has_children
+        {}
+      elsif type == 'Array' || (type&.start_with?('[') && !type.include?(','))
+        []
+      elsif type == 'Set' || type&.start_with?('#<Set', 'Set')
+        Set.new
+      else
+        yield
+      end
+    end
+  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

data/lib/grape/dsl/declared.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Grape
+  module DSL
+    module Declared
+      # Denotes a situation where a DSL method has been invoked in a
+      # filter which it should not yet be available in
+      class MethodNotYetAvailable < StandardError
+        def initialize(msg = '#declared is not available prior to parameter validation')
+          super
+        end
+      end
+
+      # A filtering method that will return a hash
+      # consisting only of keys that have been declared by a
+      # `params` statement against the current/target endpoint or parent
+      # namespaces.
+      # @param params [Hash] The initial hash to filter. Usually this will just be `params`
+      # @param options [Hash] Can pass `:include_missing`, `:stringify` and `:include_parent_namespaces`
+      # options. `:include_parent_namespaces` defaults to true, hence must be set to false if
+      # you want only to return params declared against the current/target endpoint.
+      def declared(passed_params, include_parent_namespaces: true, include_missing: true, evaluate_given: false, stringify: false)
+        raise MethodNotYetAvailable unless before_filter_passed
+
+        contract_key_map = inheritable_setting.namespace_stackable[:contract_key_map]
+        handler = DeclaredParamsHandler.new(include_missing:, evaluate_given:, stringify:, contract_key_map:)
+        declared_params = include_parent_namespaces ? inheritable_setting.route[:declared_params] : (inheritable_setting.namespace_stackable[:declared_params].last || [])
+        renamed_params = inheritable_setting.route[:renamed_params] || {}
+        route_params = options.dig(:route_options, :params) || {} # options = endpoint's option
+
+        handler.call(passed_params, declared_params, route_params, renamed_params)
+      end
+    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:)
           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, &)
+        define_boolean_in_mod(mod)
+        inject_api_helpers_to_mod(mod, &)
+        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