grape 3.0.1 → 3.1.0

data/lib/grape/namespace.rb

@@ -5,24 +5,19 @@ module Grape
   # logical grouping of endpoints as well as sharing common configuration.
   # May also be referred to as group, segment, or resource.
   class Namespace
-    attr_reader :space, :options
+    attr_reader :space, :requirements, :options
 
     # @param space [String] the name of this namespace
     # @param options [Hash] options hash
     # @option options :requirements [Hash] param-regex pairs, all of which must
     #   be met by a request's params for all endpoints in this namespace, or
     #   validation will fail and return a 422.
-    def initialize(space, options)
+    def initialize(space, requirements: nil, **options)
       @space = space.to_s
+      @requirements = requirements
       @options = options
     end
 
-    # Retrieves the requirements from the options hash, if given.
-    # @return [Hash]
-    def requirements
-      options[:requirements] || {}
-    end
-
     # (see ::joined_space_path)
     def self.joined_space(settings)
       settings&.map(&:space)
@@ -31,12 +26,13 @@ module Grape
     def eql?(other)
       other.class == self.class &&
         other.space == space &&
+        other.requirements == requirements &&
         other.options == options
     end
     alias == eql?
 
     def hash
-      [self.class, space, options].hash
+      [self.class, space, requirements, options].hash
     end
 
     # Join the namespaces from a list of settings to create a path prefix.

data/lib/grape/params_builder.rb

@@ -4,29 +4,12 @@ module Grape
   module ParamsBuilder
     extend Grape::Util::Registry
 
-    SHORT_NAME_LOOKUP = {
-      'Grape::Extensions::Hash::ParamBuilder' => :hash,
-      'Grape::Extensions::ActiveSupport::HashWithIndifferentAccess::ParamBuilder' => :hash_with_indifferent_access,
-      'Grape::Extensions::Hashie::Mash::ParamBuilder' => :hashie_mash
-    }.freeze
-
     module_function
 
     def params_builder_for(short_name)
-      verified_short_name = verify_short_name!(short_name)
-
-      raise Grape::Exceptions::UnknownParamsBuilder, verified_short_name unless registry.key?(verified_short_name)
-
-      registry[verified_short_name]
-    end
-
-    def verify_short_name!(short_name)
-      return short_name if short_name.is_a?(Symbol)
+      raise Grape::Exceptions::UnknownParamsBuilder, short_name unless registry.key?(short_name)
 
-      class_name = short_name.name
-      SHORT_NAME_LOOKUP[class_name].tap do |real_short_name|
-        Grape.deprecator.warn "#{class_name} has been deprecated. Use short name :#{real_short_name} instead."
-      end
+      registry[short_name]
     end
   end
 end

data/lib/grape/router/base_route.rb

@@ -3,22 +3,31 @@
 module Grape
   class Router
     class BaseRoute
+      extend Forwardable
+
       delegate_missing_to :@options
 
-      attr_reader :index, :pattern, :options
+      attr_reader :options, :pattern
+
+      def_delegators :@pattern, :path, :origin
+      def_delegators :@options, :description, :version, :requirements, :prefix, :anchor, :settings, :forward_match, *Grape::Util::ApiDescription::DSL_METHODS
 
-      def initialize(options)
+      def initialize(pattern, options = {})
+        @pattern = pattern
         @options = options.is_a?(ActiveSupport::OrderedOptions) ? options : ActiveSupport::OrderedOptions.new.update(options)
       end
 
-      alias attributes options
+      # see https://github.com/ruby-grape/grape/issues/1348
+      def namespace
+        @namespace ||= @options[:namespace]
+      end
 
       def regexp_capture_index
-        CaptureIndexCache[index]
+        @regexp_capture_index ||= CaptureIndexCache[@index]
       end
 
       def pattern_regexp
-        pattern.to_regexp
+        @pattern.to_regexp
       end
 
       def to_regexp(index)

data/lib/grape/router/greedy_route.rb

@@ -6,14 +6,20 @@
 module Grape
   class Router
     class GreedyRoute < BaseRoute
-      def initialize(pattern, options)
-        @pattern = pattern
-        super(options)
+      extend Forwardable
+
+      def_delegators :@endpoint, :call
+
+      attr_reader :endpoint, :allow_header
+
+      def initialize(pattern, endpoint:, allow_header:)
+        super(pattern)
+        @endpoint = endpoint
+        @allow_header = allow_header
       end
 
-      # Grape::Router:Route defines params as a function
       def params(_input = nil)
-        options[:params] || {}
+        nil
       end
     end
   end

data/lib/grape/router/pattern.rb

@@ -13,10 +13,10 @@ module Grape
       def_delegators :to_regexp, :===
       alias match? ===
 
-      def initialize(origin, suffix, options)
+      def initialize(origin:, suffix:, anchor:, params:, format:, version:, requirements:)
         @origin = origin
-        @path = build_path(origin, options[:anchor], suffix)
-        @pattern = build_pattern(@path, options[:params], options[:format], options[:version], options[:requirements])
+        @path = PatternCache[[build_path_from_pattern(@origin, anchor), suffix]]
+        @pattern = Mustermann::Grape.new(@path, uri_decode: true, params: params, capture: extract_capture(format, version, requirements))
         @to_regexp = @pattern.to_regexp
       end
 
@@ -28,24 +28,10 @@ module Grape
 
       private
 
-      def build_pattern(path, params, format, version, requirements)
-        Mustermann::Grape.new(
-          path,
-          uri_decode: true,
-          params: params,
-          capture: extract_capture(format, version, requirements)
-        )
-      end
-
-      def build_path(pattern, anchor, suffix)
-        PatternCache[[build_path_from_pattern(pattern, anchor), suffix]]
-      end
-
       def extract_capture(format, version, requirements)
-        capture = {}.tap do |h|
-          h[:format] = map_str(format) if format.present?
-          h[:version] = map_str(version) if version.present?
-        end
+        capture = {}
+        capture[:format] = map_str(format) if format.present?
+        capture[:version] = map_str(version) if version.present?
 
         return capture if requirements.blank?
 

data/lib/grape/router/route.rb

@@ -8,25 +8,21 @@ module Grape
       FORWARD_MATCH_METHOD = ->(input, pattern) { input.start_with?(pattern.origin) }
       NON_FORWARD_MATCH_METHOD = ->(input, pattern) { pattern.match?(input) }
 
-      attr_reader :app, :request_method
+      attr_reader :app, :request_method, :index
 
-      def_delegators :pattern, :path, :origin
+      def_delegators :@app, :call
 
-      def initialize(method, origin, path, options)
+      def initialize(endpoint, method, pattern, options)
+        super(pattern, options)
+        @app = endpoint
         @request_method = upcase_method(method)
-        @pattern = Grape::Router::Pattern.new(origin, path, options)
         @match_function = options[:forward_match] ? FORWARD_MATCH_METHOD : NON_FORWARD_MATCH_METHOD
-        super(options)
       end
 
       def convert_to_head_request!
         @request_method = Rack::HEAD
       end
 
-      def exec(env)
-        @app.call(env)
-      end
-
       def apply(app)
         @app = app
         self
@@ -42,7 +38,7 @@ module Grape
         return params_without_input if input.blank?
 
         parsed = pattern.params(input)
-        return {} unless parsed
+        return unless parsed
 
         parsed.compact.symbolize_keys
       end
@@ -50,7 +46,7 @@ module Grape
       private
 
       def params_without_input
-        @params_without_input ||= pattern.captures_default.merge(attributes.params)
+        @params_without_input ||= pattern.captures_default.merge(options[:params])
       end
 
       def upcase_method(method)

data/lib/grape/router.rb

@@ -2,8 +2,6 @@
 
 module Grape
   class Router
-    attr_reader :map, :compiled
-
     # Taken from Rails
     #     normalize_path("/foo")  # => "/foo"
     #     normalize_path("/foo/") # => "/foo"
@@ -16,7 +14,7 @@ module Grape
       return path if path == '/'
 
       # Fast path for the overwhelming majority of paths that don't need to be normalized
-      return path.dup if path.start_with?('/') && !(path.end_with?('/') || path.match?(%r{%|//}))
+      return path if path.start_with?('/') && !(path.end_with?('/') || path.match?(%r{%|//}))
 
       # Slow path
       encoding = path.encoding
@@ -39,14 +37,14 @@ module Grape
     end
 
     def compile!
-      return if compiled
+      return if @compiled
 
       @union = Regexp.union(@neutral_regexes)
       @neutral_regexes = nil
       (Grape::HTTP_SUPPORTED_METHODS + ['*']).each do |method|
-        next unless map.key?(method)
+        next unless @map.key?(method)
 
-        routes = map[method]
+        routes = @map[method]
         optimized_map = routes.map.with_index { |route, index| route.to_regexp(index) }
         @optimized_map[method] = Regexp.union(optimized_map)
       end
@@ -54,20 +52,20 @@ module Grape
     end
 
     def append(route)
-      map[route.request_method] << route
+      @map[route.request_method] << route
     end
 
-    def associate_routes(pattern, options)
-      Grape::Router::GreedyRoute.new(pattern, options).then do |greedy_route|
-        @neutral_regexes << greedy_route.to_regexp(@neutral_map.length)
-        @neutral_map << greedy_route
-      end
+    def associate_routes(greedy_route)
+      @neutral_regexes << greedy_route.to_regexp(@neutral_map.length)
+      @neutral_map << greedy_route
     end
 
     def call(env)
       with_optimization do
-        response, route = identity(env)
-        response || rotation(env, route)
+        input = Router.normalize_path(env[Rack::PATH_INFO])
+        method = env[Rack::REQUEST_METHOD]
+        response, route = identity(input, method, env)
+        response || rotation(input, method, env, route)
       end
     end
 
@@ -80,31 +78,28 @@ module Grape
 
     private
 
-    def identity(env)
+    def identity(input, method, env)
       route = nil
-      response = transaction(env) do |input, method|
+      response = transaction(input, method, env) do
         route = match?(input, method)
-        process_route(route, env) if route
+        process_route(route, input, env) if route
       end
       [response, route]
     end
 
-    def rotation(env, exact_route = nil)
+    def rotation(input, method, env, exact_route)
       response = nil
-      input, method = *extract_input_and_method(env)
-      map[method].each do |route|
+      @map[method].each do |route|
         next if exact_route == route
         next unless route.match?(input)
 
-        response = process_route(route, env)
+        response = process_route(route, input, env)
         break unless cascade?(response)
       end
       response
     end
 
-    def transaction(env)
-      input, method = *extract_input_and_method(env)
-
+    def transaction(input, method, env)
       # using a Proc is important since `return` will exit the enclosing function
       cascade_or_return_response = proc do |response|
         if response
@@ -112,47 +107,41 @@ module Grape
             return response unless cascade
 
             # we need to close the body if possible before dismissing
-            response[2].try(:close)
+            response[2].close if response[2].respond_to?(:close)
           end
         end
       end
 
-      last_response_cascade = cascade_or_return_response.call(yield(input, method))
+      response = yield
+      last_response_cascade = cascade_or_return_response.call(response)
       last_neighbor_route = greedy_match?(input)
 
       # If last_neighbor_route exists and request method is OPTIONS,
-      # return response by using #call_with_allow_headers.
-      return call_with_allow_headers(env, last_neighbor_route) if last_neighbor_route && method == Rack::OPTIONS && !last_response_cascade
+      # return response by using #include_allow_header.
+      return process_route(last_neighbor_route, input, env, include_allow_header: true) if !last_response_cascade && method == Rack::OPTIONS && last_neighbor_route
 
       route = match?(input, '*')
 
-      return last_neighbor_route.options[:endpoint].call(env) if last_neighbor_route && last_response_cascade && route
+      return last_neighbor_route.call(env) if last_neighbor_route && last_response_cascade && route
 
-      last_response_cascade = cascade_or_return_response.call(process_route(route, env)) if route
+      last_response_cascade = cascade_or_return_response.call(process_route(route, input, env)) if route
 
-      return call_with_allow_headers(env, last_neighbor_route) if !last_response_cascade && last_neighbor_route
+      return process_route(last_neighbor_route, input, env, include_allow_header: true) if !last_response_cascade && last_neighbor_route
 
       nil
     end
 
-    def process_route(route, env)
-      prepare_env_from_route(env, route)
-      route.exec(env)
-    end
-
-    def make_routing_args(default_args, route, input)
-      args = default_args || { route_info: route }
-      args.merge(route.params(input))
-    end
-
-    def extract_input_and_method(env)
-      input = string_for(env[Rack::PATH_INFO])
-      method = env[Rack::REQUEST_METHOD]
-      [input, method]
+    def process_route(route, input, env, include_allow_header: false)
+      args = env[Grape::Env::GRAPE_ROUTING_ARGS] || { route_info: route }
+      route_params = route.params(input)
+      routing_args = args.merge(route_params || {})
+      env[Grape::Env::GRAPE_ROUTING_ARGS] = routing_args
+      env[Grape::Env::GRAPE_ALLOWED_METHODS] = route.allow_header if include_allow_header
+      route.call(env)
     end
 
     def with_optimization
-      compile! unless compiled
+      compile!
       yield || default_response
     end
 
@@ -169,23 +158,8 @@ module Grape
       @union.match(input) { |m| @neutral_map.detect { |route| m[route.regexp_capture_index] } }
     end
 
-    def call_with_allow_headers(env, route)
-      prepare_env_from_route(env, route)
-      env[Grape::Env::GRAPE_ALLOWED_METHODS] = route.options[:allow_header]
-      route.options[:endpoint].call(env)
-    end
-
-    def prepare_env_from_route(env, route)
-      input, = *extract_input_and_method(env)
-      env[Grape::Env::GRAPE_ROUTING_ARGS] = make_routing_args(env[Grape::Env::GRAPE_ROUTING_ARGS], route, input)
-    end
-
     def cascade?(response)
       response && response[1]['X-Cascade'] == 'pass'
     end
-
-    def string_for(input)
-      self.class.normalize_path(input)
-    end
   end
 end

data/lib/grape/util/api_description.rb

@@ -3,13 +3,7 @@
 module Grape
   module Util
     class ApiDescription
-      def initialize(description, endpoint_configuration, &block)
-        @endpoint_configuration = endpoint_configuration
-        @attributes = { description: description }
-        instance_eval(&block)
-      end
-
-      %i[
+      DSL_METHODS = %i[
         body_name
         consumes
         default
@@ -27,7 +21,15 @@ module Grape
         security
         summary
         tags
-      ].each do |attribute|
+      ].freeze
+
+      def initialize(description, endpoint_configuration, &)
+        @endpoint_configuration = endpoint_configuration
+        @attributes = { description: description }
+        instance_eval(&)
+      end
+
+      DSL_METHODS.each do |attribute|
         define_method attribute do |value|
           @attributes[attribute] = value
         end

data/lib/grape/validations/attributes_iterator.rb

@@ -14,8 +14,8 @@ module Grape
         @params = Array.wrap(@original_params)
       end
 
-      def each(&block)
-        do_each(@params, &block) # because we need recursion for nested arrays
+      def each(&)
+        do_each(@params, &) # because we need recursion for nested arrays
       end
 
       private

data/lib/grape/validations/params_scope.rb

@@ -14,6 +14,8 @@ module Grape
       # we maintain a list of them here and skip looking up validators for them.
       RESERVED_DOCUMENTATION_KEYWORDS = %i[as required param_type is_array format example].freeze
 
+      SPECIAL_JSON = [JSON, Array[JSON]].freeze
+
       class Attr
         attr_accessor :key, :scope
 
@@ -78,7 +80,7 @@ module Grape
       end
 
       def configuration
-        @api.configuration.respond_to?(:evaluate) ? @api.configuration.evaluate : @api.configuration
+        (@api.configuration.respond_to?(:evaluate) && @api.configuration.evaluate) || @api.configuration
       end
 
       # @return [Boolean] whether or not this entire scope needs to be
@@ -120,8 +122,8 @@ module Grape
           if dependency.is_a?(Hash)
             dependency_key = dependency.keys[0]
             proc = dependency.values[0]
-            return false unless proc.call(params.try(:[], dependency_key))
-          elsif params.respond_to?(:key?) && params.try(:[], dependency).blank?
+            return false unless proc.call(params[dependency_key])
+          elsif params[dependency].blank?
             return false
           end
         end
@@ -265,7 +267,7 @@ module Grape
       # @param optional [Boolean] whether the parameter this are nested under
       #   is optional or not (and hence, whether this block's params will be).
       # @yield parameter scope
-      def new_scope(attrs, opts, optional = false, &block)
+      def new_scope(attrs, opts, optional = false, &)
         # if required params are grouped and no type or unsupported type is provided, raise an error
         type = opts[:type]
         if attrs.first && !optional
@@ -281,7 +283,7 @@ module Grape
           optional: optional,
           type: type || Array,
           group: @group,
-          &block
+          &
         )
       end
 
@@ -292,7 +294,7 @@ module Grape
       #   scope should only validate if this parameter from the above scope is
       #   present
       # @yield parameter scope
-      def new_lateral_scope(options, &block)
+      def new_lateral_scope(options, &)
         self.class.new(
           api: @api,
           element: nil,
@@ -300,7 +302,7 @@ module Grape
           options: @optional,
           type: type == Array ? Array : Hash,
           dependent_on: options[:dependent_on],
-          &block
+          &
         )
       end
 
@@ -309,8 +311,8 @@ module Grape
       # @param attrs [Array] the attributes passed to the `requires` or
       #   `optional` invocation that opened this scope.
       # @yield parameter scope
-      def new_group_scope(attrs, &block)
-        self.class.new(api: @api, parent: self, group: attrs.first, &block)
+      def new_group_scope(attrs, &)
+        self.class.new(api: @api, parent: self, group: attrs.first, &)
       end
 
       # Pushes declared params to parent or settings
@@ -414,7 +416,7 @@ module Grape
 
         # but not special JSON types, which
         # already imply coercion method
-        return if [JSON, Array[JSON]].exclude? validations[:coerce]
+        return unless SPECIAL_JSON.include?(validations[:coerce])
 
         raise ArgumentError, 'coerce_with disallowed for type: JSON'
       end

data/lib/grape/validations/validators/allow_blank_validator.rb

@@ -8,7 +8,7 @@ module Grape
           return if (options_key?(:value) ? @option[:value] : @option) || !params.is_a?(Hash)
 
           value = params[attr_name]
-          value = value.scrub if value.respond_to?(:scrub)
+          value = value.scrub if value.respond_to?(:valid_encoding?) && !value.valid_encoding?
 
           return if value == false || value.present?
 

data/lib/grape/validations/validators/base.rb

@@ -49,7 +49,7 @@ module Grape
             next if !@scope.required? && empty_val
             next unless @scope.meets_dependency?(val, params)
 
-            validate_param!(attr_name, val) if @required || val.try(:key?, attr_name)
+            validate_param!(attr_name, val) if @required || (val.respond_to?(:key?) && val.key?(attr_name))
           rescue Grape::Exceptions::Validation => e
             array_errors << e
           end
@@ -69,7 +69,7 @@ module Grape
 
         def options_key?(key, options = nil)
           options = instance_variable_get(:@option) if options.nil?
-          options.try(:key?, key) && !options[key].nil?
+          options.respond_to?(:key?) && options.key?(key) && !options[key].nil?
         end
 
         def fail_fast?

data/lib/grape/validations/validators/except_values_validator.rb

@@ -10,7 +10,7 @@ module Grape
         end
 
         def validate_param!(attr_name, params)
-          return unless params.try(:key?, attr_name)
+          return unless params.respond_to?(:key?) && params.key?(attr_name)
 
           excepts = @except.is_a?(Proc) ? @except.call : @except
           return if excepts.nil?

data/lib/grape/validations/validators/{mutual_exclusion_validator.rb → mutually_exclusive_validator.rb}

@@ -3,7 +3,7 @@
 module Grape
   module Validations
     module Validators
-      class MutualExclusionValidator < MultipleParamsBase
+      class MutuallyExclusiveValidator < MultipleParamsBase
         def validate_params!(params)
           keys = keys_in_common(params)
           return if keys.length <= 1

data/lib/grape/validations/validators/presence_validator.rb

@@ -5,7 +5,7 @@ module Grape
     module Validators
       class PresenceValidator < Base
         def validate_param!(attr_name, params)
-          return if params.try(:key?, attr_name)
+          return if params.respond_to?(:key?) && params.key?(attr_name)
 
           raise Grape::Exceptions::Validation.new(params: [@scope.full_name(attr_name)], message: message(:presence))
         end

data/lib/grape/validations/validators/regexp_validator.rb

@@ -5,11 +5,21 @@ module Grape
     module Validators
       class RegexpValidator < Base
         def validate_param!(attr_name, params)
-          return unless params.try(:key?, attr_name)
-          return if Array.wrap(params[attr_name]).all? { |param| param.nil? || param.to_s.scrub.match?((options_key?(:value) ? @option[:value] : @option)) }
+          return unless params.respond_to?(:key) && params.key?(attr_name)
+
+          value = options_key?(:value) ? @option[:value] : @option
+          return if Array.wrap(params[attr_name]).all? { |param| param.nil? || scrub(param.to_s).match?(value) }
 
           raise Grape::Exceptions::Validation.new(params: [@scope.full_name(attr_name)], message: message(:regexp))
         end
+
+        private
+
+        def scrub(param)
+          return param if param.valid_encoding?
+
+          param.scrub
+        end
       end
     end
   end

data/lib/grape/validations/validators/values_validator.rb

@@ -16,7 +16,7 @@ module Grape
 
           return if val.nil? && !required_for_root_scope?
 
-          val = val.scrub if val.respond_to?(:scrub)
+          val = val.scrub if val.respond_to?(:valid_encoding?) && !val.valid_encoding?
 
           # don't forget that +false.blank?+ is true
           return if val != false && val.blank? && @allow_blank

data/lib/grape/version.rb

@@ -2,5 +2,5 @@
 
 module Grape
   # The current version of Grape.
-  VERSION = '3.0.1'
+  VERSION = '3.1.0'
 end