grape 2.4.0 → 3.2.1

data/lib/grape/middleware/versioner/base.rb

@@ -5,68 +5,70 @@ module Grape
     module Versioner
       class Base < Grape::Middleware::Base
         DEFAULT_OPTIONS = {
-          pattern: /.*/i.freeze,
+          pattern: /.*/i,
+          prefix: nil,
+          mount_path: nil,
           version_options: {
             strict: false,
             cascade: true,
-            parameter: 'apiver'
+            parameter: 'apiver',
+            vendor: nil
           }.freeze
         }.freeze
 
-        def self.inherited(klass)
-          super
-          Versioner.register(klass)
-        end
-
-        def versions
-          options[:versions]
-        end
-
-        def prefix
-          options[:prefix]
-        end
+        CASCADE_PASS_HEADER = { 'X-Cascade' => 'pass' }.freeze
 
-        def mount_path
-          options[:mount_path]
+        DEFAULT_OPTIONS.each_key do |key|
+          define_method key do
+            options[key]
+          end
         end
 
-        def pattern
-          options[:pattern]
+        DEFAULT_OPTIONS[:version_options].each_key do |key|
+          define_method key do
+            options[:version_options][key]
+          end
         end
 
-        def version_options
-          options[:version_options]
+        def self.inherited(klass)
+          super
+          Versioner.register(klass)
         end
 
-        def strict?
-          version_options[:strict]
-        end
+        attr_reader :error_headers, :versions
 
-        # By default those errors contain an `X-Cascade` header set to `pass`, which allows nesting and stacking
-        # of routes (see Grape::Router) for more information). To prevent
-        # this behavior, and not add the `X-Cascade` header, one can set the `:cascade` option to `false`.
-        def cascade?
-          version_options[:cascade]
+        def initialize(app, **options)
+          super
+          @error_headers = cascade ? CASCADE_PASS_HEADER : {}
+          @versions = options[:versions]&.map(&:to_s) # making sure versions are strings to ease potential match
         end
 
-        def parameter_key
-          version_options[:parameter]
+        def potential_version_match?(potential_version)
+          versions.blank? || versions.include?(potential_version)
         end
 
-        def vendor
-          version_options[:vendor]
+        def version_not_found!
+          throw :error, status: 404, message: '404 API Version Not Found', headers: CASCADE_PASS_HEADER
         end
 
-        def error_headers
-          cascade? ? { 'X-Cascade' => 'pass' } : {}
-        end
+        private
 
-        def potential_version_match?(potential_version)
-          versions.blank? || versions.any? { |v| v.to_s == potential_version }
-        end
+        def available_media_types
+          @available_media_types ||= begin
+            media_types = []
+            base_media_type = "application/vnd.#{vendor}"
+            content_types.each_key do |extension|
+              versions&.reverse_each do |version|
+                media_types << "#{base_media_type}-#{version}+#{extension}"
+                media_types << "#{base_media_type}-#{version}"
+              end
+              media_types << "#{base_media_type}+#{extension}"
+            end
 
-        def version_not_found!
-          throw :error, status: 404, message: '404 API Version Not Found', headers: { 'X-Cascade' => 'pass' }
+            media_types << base_media_type
+            media_types.concat(content_types.values.flatten)
+            media_types
+          end
         end
       end
     end

data/lib/grape/middleware/versioner/header.rb

@@ -53,7 +53,7 @@ module Grape
         end
 
         def strict_header_checks!
-          return unless strict?
+          return unless strict
 
           accept_header_check!
           version_and_vendor_check!
@@ -101,26 +101,10 @@ module Grape
         end
 
         def version_not_found!(media_types)
-          return unless media_types.all? { |media_type| media_type&.version && versions&.exclude?(media_type.version) }
+          return unless media_types.all? { |media_type| media_type&.version && versions && !versions.include?(media_type.version) }
 
           invalid_version_header!('API version not found.')
         end
-
-        def available_media_types
-          [].tap do |available_media_types|
-            base_media_type = "application/vnd.#{vendor}"
-            content_types.each_key do |extension|
-              versions&.reverse_each do |version|
-                available_media_types << "#{base_media_type}-#{version}+#{extension}"
-                available_media_types << "#{base_media_type}-#{version}"
-              end
-              available_media_types << "#{base_media_type}+#{extension}"
-            end
-
-            available_media_types << base_media_type
-            available_media_types.concat(content_types.values.flatten)
-          end
-        end
       end
     end
   end

data/lib/grape/middleware/versioner/param.rb

@@ -20,11 +20,11 @@ module Grape
       #   env['api.version'] => 'v1'
       class Param < Base
         def before
-          potential_version = query_params[parameter_key]
+          potential_version = query_params[parameter]
           return if potential_version.blank?
 
           version_not_found! unless potential_version_match?(potential_version)
-          env[Grape::Env::API_VERSION] = env[Rack::RACK_REQUEST_QUERY_HASH].delete(parameter_key)
+          env[Grape::Env::API_VERSION] = env[Rack::RACK_REQUEST_QUERY_HASH].delete(parameter)
         end
       end
     end

data/lib/grape/middleware/versioner/path.rb

@@ -22,13 +22,13 @@ module Grape
           return if path_info == '/'
 
           [mount_path, Grape::Router.normalize_path(prefix)].each do |path|
-            path_info.delete_prefix!(path) if path.present? && path != '/' && path_info.start_with?(path)
+            path_info = path_info.delete_prefix(path) if path.present? && path != '/' && path_info.start_with?(path)
           end
 
           slash_position = path_info.index('/', 1) # omit the first one
           return unless slash_position
 
-          potential_version = path_info[1..slash_position - 1]
+          potential_version = path_info[1..(slash_position - 1)]
           return unless potential_version.match?(pattern)
 
           version_not_found! unless potential_version_match?(potential_version)

data/lib/grape/namespace.rb

@@ -5,29 +5,36 @@ 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)
     end
 
+    def eql?(other)
+      other.class == self.class &&
+        other.space == space &&
+        other.requirements == requirements &&
+        other.options == options
+    end
+    alias == eql?
+
+    def hash
+      [self.class, space, requirements, options].hash
+    end
+
     # Join the namespaces from a list of settings to create a path prefix.
     # @param settings [Array] list of Grape::Util::InheritableSettings.
     def self.joined_space_path(settings)

data/lib/grape/params_builder/base.rb

@@ -8,6 +8,8 @@ module Grape
           raise NotImplementedError
         end
 
+        private
+
         def inherited(klass)
           super
           ParamsBuilder.register(klass)

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/request.rb

@@ -166,16 +166,8 @@ module Grape
 
     def make_params
       @params_builder.call(rack_params).deep_merge!(grape_routing_args)
-    rescue EOFError
-      raise Grape::Exceptions::EmptyMessageBody.new(content_type)
-    rescue Rack::Multipart::MultipartPartLimitError, Rack::Multipart::MultipartTotalPartLimitError
-      raise Grape::Exceptions::TooManyMultipartFiles.new(Rack::Utils.multipart_part_limit)
-    rescue Rack::QueryParser::ParamsTooDeepError
-      raise Grape::Exceptions::TooDeepParameters.new(Rack::Utils.param_depth_limit)
-    rescue Rack::Utils::ParameterTypeError
-      raise Grape::Exceptions::ConflictingTypes
-    rescue Rack::Utils::InvalidParameterError
-      raise Grape::Exceptions::InvalidParameters
+    rescue *Grape::RACK_ERRORS
+      raise Grape::Exceptions::RequestError
     end
 
     def build_headers

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:, 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"
@@ -12,14 +10,15 @@ module Grape
     #     normalize_path("/%ab")  # => "/%AB"
     # https://github.com/rails/rails/blob/00cc4ff0259c0185fe08baadaa40e63ea2534f6e/actionpack/lib/action_dispatch/journey/router/utils.rb#L19
     def self.normalize_path(path)
-      return +'/' unless path
+      return '/' unless path
+      return path if path == '/'
 
       # Fast path for the overwhelming majority of paths that don't need to be normalized
-      return path.dup if path == '/' || (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
-      path = +"/#{path}"
+      path = "/#{path}"
       path.squeeze!('/')
 
       unless path == '/'
@@ -38,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
@@ -53,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
 
@@ -77,33 +76,33 @@ module Grape
       any.endpoint
     end
 
+    DEFAULT_RESPONSE_HEADERS = Grape::Util::Header.new.merge('X-Cascade' => 'pass').freeze
+    DEFAULT_RESPONSE_BODY = ['404 Not Found'].freeze
+
     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
@@ -111,53 +110,46 @@ 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
 
     def default_response
-      headers = Grape::Util::Header.new.merge('X-Cascade' => 'pass')
-      [404, headers, ['404 Not Found']]
+      [404, DEFAULT_RESPONSE_HEADERS.dup, DEFAULT_RESPONSE_BODY.dup]
     end
 
     def match?(input, method)
@@ -168,23 +160,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