grape 2.2.0 → 2.4.0

data/lib/grape/path.rb

@@ -3,65 +3,66 @@
 module Grape
   # Represents a path to an endpoint.
   class Path
-    attr_reader :raw_path, :namespace, :settings
+    DEFAULT_FORMAT_SEGMENT = '(/.:format)'
+    NO_VERSIONING_WITH_VALID_PATH_FORMAT_SEGMENT = '(.:format)'
+    VERSION_SEGMENT = ':version'
 
-    def initialize(raw_path, namespace, settings)
-      @raw_path = raw_path
-      @namespace = namespace
-      @settings = settings
-    end
+    attr_reader :origin, :suffix
 
-    def mount_path
-      settings[:mount_path]
+    def initialize(raw_path, raw_namespace, settings)
+      @origin = PartsCache[build_parts(raw_path, raw_namespace, settings)]
+      @suffix = build_suffix(raw_path, raw_namespace, settings)
     end
 
-    def root_prefix
-      settings[:root_prefix]
+    def to_s
+      "#{origin}#{suffix}"
     end
 
-    def uses_specific_format?
-      return false unless settings.key?(:format) && settings.key?(:content_types)
+    private
 
-      settings[:format] && Array(settings[:content_types]).size == 1
+    def build_suffix(raw_path, raw_namespace, settings)
+      if uses_specific_format?(settings)
+        "(.#{settings[:format]})"
+      elsif !uses_path_versioning?(settings) || (valid_part?(raw_namespace) || valid_part?(raw_path))
+        NO_VERSIONING_WITH_VALID_PATH_FORMAT_SEGMENT
+      else
+        DEFAULT_FORMAT_SEGMENT
+      end
     end
 
-    def uses_path_versioning?
-      return false unless settings.key?(:version) && settings[:version_options]&.key?(:using)
-
-      settings[:version] && settings[:version_options][:using] == :path
+    def build_parts(raw_path, raw_namespace, settings)
+      [].tap do |parts|
+        add_part(parts, settings[:mount_path])
+        add_part(parts, settings[:root_prefix])
+        parts << VERSION_SEGMENT if uses_path_versioning?(settings)
+        add_part(parts, raw_namespace)
+        add_part(parts, raw_path)
+      end
     end
 
-    def namespace?
-      namespace&.match?(/^\S/) && not_slash?(namespace)
+    def add_part(parts, value)
+      parts << value if value && not_slash?(value)
     end
 
-    def path?
-      raw_path&.match?(/^\S/) && not_slash?(raw_path)
+    def not_slash?(value)
+      value != '/'
     end
 
-    def suffix
-      if uses_specific_format?
-        "(.#{settings[:format]})"
-      elsif !uses_path_versioning? || (namespace? || path?)
-        '(.:format)'
-      else
-        '(/.:format)'
-      end
-    end
+    def uses_specific_format?(settings)
+      return false unless settings.key?(:format) && settings.key?(:content_types)
 
-    def path
-      PartsCache[parts]
+      settings[:format] && Array(settings[:content_types]).size == 1
     end
 
-    def path_with_suffix
-      "#{path}#{suffix}"
-    end
+    def uses_path_versioning?(settings)
+      return false unless settings.key?(:version) && settings[:version_options]&.key?(:using)
 
-    def to_s
-      path_with_suffix
+      settings[:version] && settings[:version_options][:using] == :path
     end
 
-    private
+    def valid_part?(part)
+      part&.match?(/^\S/) && not_slash?(part)
+    end
 
     class PartsCache < Grape::Util::Cache
       def initialize
@@ -71,23 +72,5 @@ module Grape
         end
       end
     end
-
-    def parts
-      [].tap do |parts|
-        add_part(parts, mount_path)
-        add_part(parts, root_prefix)
-        parts << ':version' if uses_path_versioning?
-        add_part(parts, namespace)
-        add_part(parts, raw_path)
-      end
-    end
-
-    def add_part(parts, value)
-      parts << value if value && not_slash?(value)
-    end
-
-    def not_slash?(value)
-      value != '/'
-    end
   end
 end

data/lib/grape/request.rb

@@ -2,50 +2,189 @@
 
 module Grape
   class Request < Rack::Request
-    HTTP_PREFIX = 'HTTP_'
+    # Based on rack 3 KNOWN_HEADERS
+    # https://github.com/rack/rack/blob/4f15e7b814922af79605be4b02c5b7c3044ba206/lib/rack/headers.rb#L10
+
+    KNOWN_HEADERS = %w[
+      Accept
+      Accept-CH
+      Accept-Encoding
+      Accept-Language
+      Accept-Patch
+      Accept-Ranges
+      Accept-Version
+      Access-Control-Allow-Credentials
+      Access-Control-Allow-Headers
+      Access-Control-Allow-Methods
+      Access-Control-Allow-Origin
+      Access-Control-Expose-Headers
+      Access-Control-Max-Age
+      Age
+      Allow
+      Alt-Svc
+      Authorization
+      Cache-Control
+      Client-Ip
+      Connection
+      Content-Disposition
+      Content-Encoding
+      Content-Language
+      Content-Length
+      Content-Location
+      Content-MD5
+      Content-Range
+      Content-Security-Policy
+      Content-Security-Policy-Report-Only
+      Content-Type
+      Cookie
+      Date
+      Delta-Base
+      Dnt
+      ETag
+      Expect-CT
+      Expires
+      Feature-Policy
+      Forwarded
+      Host
+      If-Modified-Since
+      If-None-Match
+      IM
+      Last-Modified
+      Link
+      Location
+      NEL
+      P3P
+      Permissions-Policy
+      Pragma
+      Preference-Applied
+      Proxy-Authenticate
+      Public-Key-Pins
+      Range
+      Referer
+      Referrer-Policy
+      Refresh
+      Report-To
+      Retry-After
+      Sec-Fetch-Dest
+      Sec-Fetch-Mode
+      Sec-Fetch-Site
+      Sec-Fetch-User
+      Server
+      Set-Cookie
+      Status
+      Strict-Transport-Security
+      Timing-Allow-Origin
+      Tk
+      Trailer
+      Transfer-Encoding
+      Upgrade
+      Upgrade-Insecure-Requests
+      User-Agent
+      Vary
+      Version
+      Via
+      Warning
+      WWW-Authenticate
+      X-Accel-Buffering
+      X-Accel-Charset
+      X-Accel-Expires
+      X-Accel-Limit-Rate
+      X-Accel-Mapping
+      X-Accel-Redirect
+      X-Access-Token
+      X-Auth-Request-Access-Token
+      X-Auth-Request-Email
+      X-Auth-Request-Groups
+      X-Auth-Request-Preferred-Username
+      X-Auth-Request-Redirect
+      X-Auth-Request-Token
+      X-Auth-Request-User
+      X-Cascade
+      X-Client-Ip
+      X-Content-Duration
+      X-Content-Security-Policy
+      X-Content-Type-Options
+      X-Correlation-Id
+      X-Download-Options
+      X-Forwarded-Access-Token
+      X-Forwarded-Email
+      X-Forwarded-For
+      X-Forwarded-Groups
+      X-Forwarded-Host
+      X-Forwarded-Port
+      X-Forwarded-Preferred-Username
+      X-Forwarded-Proto
+      X-Forwarded-Scheme
+      X-Forwarded-Ssl
+      X-Forwarded-Uri
+      X-Forwarded-User
+      X-Frame-Options
+      X-HTTP-Method-Override
+      X-Permitted-Cross-Domain-Policies
+      X-Powered-By
+      X-Real-IP
+      X-Redirect-By
+      X-Request-Id
+      X-Requested-With
+      X-Runtime
+      X-Sendfile
+      X-Sendfile-Type
+      X-UA-Compatible
+      X-WebKit-CS
+      X-XSS-Protection
+    ].each_with_object({}) do |header, response|
+      response["HTTP_#{header.upcase.tr('-', '_')}"] = header
+    end.freeze
 
     alias rack_params params
+    alias rack_cookies cookies
 
-    def initialize(env, **options)
-      extend options[:build_params_with] || Grape.config.param_builder
+    def initialize(env, build_params_with: nil)
       super(env)
+      @params_builder = Grape::ParamsBuilder.params_builder_for(build_params_with || Grape.config.param_builder)
     end
 
     def params
-      @params ||= build_params
-    rescue EOFError
-      raise Grape::Exceptions::EmptyMessageBody.new(content_type)
-    rescue Rack::Multipart::MultipartPartLimitError
-      raise Grape::Exceptions::TooManyMultipartFiles.new(Rack::Utils.multipart_part_limit)
+      @params ||= make_params
     end
 
     def headers
       @headers ||= build_headers
     end
 
-    private
+    def cookies
+      @cookies ||= Grape::Cookies.new(-> { rack_cookies })
+    end
 
+    # needs to be public until extensions param_builder are removed
     def grape_routing_args
-      args = env[Grape::Env::GRAPE_ROUTING_ARGS].dup
       # preserve version from query string parameters
-      args.delete(:version)
-      args.delete(:route_info)
-      args
+      env[Grape::Env::GRAPE_ROUTING_ARGS]&.except(:version, :route_info) || {}
     end
 
-    def build_headers
-      Grape::Util::Lazy::Object.new do
-        env.each_pair.with_object(Grape::Util::Header.new) do |(k, v), headers|
-          next unless k.to_s.start_with? HTTP_PREFIX
+    private
 
-          transformed_header = Grape::Http::Headers::HTTP_HEADERS[k] || transform_header(k)
-          headers[transformed_header] = v
-        end
-      end
+    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
     end
 
-    def transform_header(header)
-      -header[5..].tr('_', '-').downcase
+    def build_headers
+      each_header.with_object(Grape::Util::Header.new) do |(k, v), headers|
+        next unless k.start_with? 'HTTP_'
+
+        transformed_header = KNOWN_HEADERS.fetch(k) { -k[5..].tr('_', '-').downcase }
+        headers[transformed_header] = v
+      end
     end
   end
 end

data/lib/grape/router/base_route.rb

@@ -7,8 +7,8 @@ module Grape
 
       attr_reader :index, :pattern, :options
 
-      def initialize(**options)
-        @options = ActiveSupport::OrderedOptions.new.update(options)
+      def initialize(options)
+        @options = options.is_a?(ActiveSupport::OrderedOptions) ? options : ActiveSupport::OrderedOptions.new.update(options)
       end
 
       alias attributes options

data/lib/grape/router/greedy_route.rb

@@ -6,9 +6,9 @@
 module Grape
   class Router
     class GreedyRoute < BaseRoute
-      def initialize(pattern:, **options)
+      def initialize(pattern, options)
         @pattern = pattern
-        super(**options)
+        super(options)
       end
 
       # Grape::Router:Route defines params as a function

data/lib/grape/router/pattern.rb

@@ -9,14 +9,14 @@ module Grape
 
       attr_reader :origin, :path, :pattern, :to_regexp
 
-      def_delegators :pattern, :named_captures, :params
+      def_delegators :pattern, :params
       def_delegators :to_regexp, :===
       alias match? ===
 
-      def initialize(pattern, **options)
-        @origin = pattern
-        @path = build_path(pattern, anchor: options[:anchor], suffix: options[:suffix])
-        @pattern = build_pattern(@path, options)
+      def initialize(origin, suffix, options)
+        @origin = origin
+        @path = build_path(origin, options[:anchor], suffix)
+        @pattern = build_pattern(@path, options[:params], options[:format], options[:version], options[:requirements])
         @to_regexp = @pattern.to_regexp
       end
 
@@ -28,30 +28,31 @@ module Grape
 
       private
 
-      def build_pattern(path, options)
+      def build_pattern(path, params, format, version, requirements)
         Mustermann::Grape.new(
           path,
           uri_decode: true,
-          params: options[:params],
-          capture: extract_capture(**options)
+          params: params,
+          capture: extract_capture(format, version, requirements)
         )
       end
 
-      def build_path(pattern, anchor: false, suffix: nil)
-        PatternCache[[build_path_from_pattern(pattern, anchor: anchor), suffix]]
+      def build_path(pattern, anchor, suffix)
+        PatternCache[[build_path_from_pattern(pattern, anchor), suffix]]
       end
 
-      def extract_capture(**options)
-        sliced_options = options
-                         .slice(:format, :version)
-                         .delete_if { |_k, v| v.blank? }
-                         .transform_values { |v| Array.wrap(v).map(&:to_s) }
-        return sliced_options if options[:requirements].blank?
+      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
+
+        return capture if requirements.blank?
 
-        options[:requirements].merge(sliced_options)
+        requirements.merge(capture)
       end
 
-      def build_path_from_pattern(pattern, anchor: false)
+      def build_path_from_pattern(pattern, anchor)
         if pattern.end_with?('*path')
           pattern.dup.insert(pattern.rindex('/') + 1, '?')
         elsif anchor
@@ -63,6 +64,10 @@ module Grape
         end
       end
 
+      def map_str(value)
+        Array.wrap(value).map(&:to_s)
+      end
+
       class PatternCache < Grape::Util::Cache
         def initialize
           super

data/lib/grape/router/route.rb

@@ -5,14 +5,22 @@ module Grape
     class Route < BaseRoute
       extend Forwardable
 
+      FORWARD_MATCH_METHOD = ->(input, pattern) { input.start_with?(pattern.origin) }
+      NON_FORWARD_MATCH_METHOD = ->(input, pattern) { pattern.match?(input) }
+
       attr_reader :app, :request_method
 
       def_delegators :pattern, :path, :origin
 
-      def initialize(method, pattern, **options)
+      def initialize(method, origin, path, options)
         @request_method = upcase_method(method)
-        @pattern = Grape::Router::Pattern.new(pattern, **options)
-        super(**options)
+        @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)
@@ -27,7 +35,7 @@ module Grape
       def match?(input)
         return false if input.blank?
 
-        options[:forward_match] ? input.start_with?(pattern.origin) : pattern.match?(input)
+        @match_function.call(input, pattern)
       end
 
       def params(input = nil)
@@ -42,12 +50,12 @@ module Grape
       private
 
       def params_without_input
-        pattern.captures_default.merge(attributes.params)
+        @params_without_input ||= pattern.captures_default.merge(attributes.params)
       end
 
       def upcase_method(method)
         method_s = method.to_s
-        Grape::Http::Headers::SUPPORTED_METHODS.detect { |m| m.casecmp(method_s).zero? } || method_s.upcase
+        Grape::HTTP_SUPPORTED_METHODS.detect { |m| m.casecmp(method_s).zero? } || method_s.upcase
       end
     end
   end

data/lib/grape/router.rb

@@ -4,12 +4,30 @@ module Grape
   class Router
     attr_reader :map, :compiled
 
+    # Taken from Rails
+    #     normalize_path("/foo")  # => "/foo"
+    #     normalize_path("/foo/") # => "/foo"
+    #     normalize_path("foo")   # => "/foo"
+    #     normalize_path("")      # => "/"
+    #     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
+
+      # 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{%|//})))
+
+      # Slow path
+      encoding = path.encoding
       path = +"/#{path}"
       path.squeeze!('/')
-      path.sub!(%r{/+\Z}, '')
-      path = '/' if path == ''
-      path
+
+      unless path == '/'
+        path.delete_suffix!('/')
+        path.gsub!(/(%[a-f0-9]{2})/) { ::Regexp.last_match(1).upcase }
+      end
+
+      path.force_encoding(encoding)
     end
 
     def initialize
@@ -24,7 +42,7 @@ module Grape
 
       @union = Regexp.union(@neutral_regexes)
       @neutral_regexes = nil
-      (Grape::Http::Headers::SUPPORTED_METHODS + ['*']).each do |method|
+      (Grape::HTTP_SUPPORTED_METHODS + ['*']).each do |method|
         next unless map.key?(method)
 
         routes = map[method]
@@ -38,8 +56,8 @@ module Grape
       map[route.request_method] << route
     end
 
-    def associate_routes(pattern, **options)
-      Grape::Router::GreedyRoute.new(pattern: pattern, **options).then do |greedy_route|
+    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
@@ -93,7 +111,7 @@ module Grape
             return response unless cascade
 
             # we need to close the body if possible before dismissing
-            response[2].close if response[2].respond_to?(:close)
+            response[2].try(:close)
           end
         end
       end
@@ -107,7 +125,7 @@ module Grape
 
       route = match?(input, '*')
 
-      return last_neighbor_route.endpoint.call(env) if last_neighbor_route && last_response_cascade && route
+      return last_neighbor_route.options[:endpoint].call(env) if last_neighbor_route && last_response_cascade && route
 
       last_response_cascade = cascade_or_return_response.call(process_route(route, env)) if route
 
@@ -138,7 +156,7 @@ module Grape
     end
 
     def default_response
-      headers = Grape::Util::Header.new.merge(Grape::Http::Headers::X_CASCADE => 'pass')
+      headers = Grape::Util::Header.new.merge('X-Cascade' => 'pass')
       [404, headers, ['404 Not Found']]
     end
 
@@ -152,8 +170,8 @@ module Grape
 
     def call_with_allow_headers(env, route)
       prepare_env_from_route(env, route)
-      env[Grape::Env::GRAPE_ALLOWED_METHODS] = route.allow_header.join(', ').freeze
-      route.endpoint.call(env)
+      env[Grape::Env::GRAPE_ALLOWED_METHODS] = route.options[:allow_header]
+      route.options[:endpoint].call(env)
     end
 
     def prepare_env_from_route(env, route)
@@ -162,7 +180,7 @@ module Grape
     end
 
     def cascade?(response)
-      response && response[1][Grape::Http::Headers::X_CASCADE] == 'pass'
+      response && response[1]['X-Cascade'] == 'pass'
     end
 
     def string_for(input)

data/lib/grape/util/registry.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Grape
+  module Util
+    module Registry
+      def register(klass)
+        short_name = build_short_name(klass)
+        return if short_name.nil?
+
+        warn "#{short_name} is already registered with class #{klass}" if registry.key?(short_name)
+        registry[short_name] = klass
+      end
+
+      private
+
+      def build_short_name(klass)
+        return if klass.name.blank?
+
+        klass.name.demodulize.underscore
+      end
+
+      def registry
+        @registry ||= {}.with_indifferent_access
+      end
+    end
+  end
+end

data/lib/grape/validations/contract_scope.rb

@@ -23,49 +23,12 @@ module Grape
         api.namespace_stackable(:contract_key_map, key_map)
 
         validator_options = {
-          validator_class: Validator,
-          opts: { schema: contract }
+          validator_class: Grape::Validations.require_validator(:contract_scope),
+          opts: { schema: contract, fail_fast: false }
         }
 
         api.namespace_stackable(:validations, validator_options)
       end
-
-      class Validator
-        attr_reader :schema
-
-        def initialize(*_args, schema:)
-          @schema = schema
-        end
-
-        # Validates a given request.
-        # @param request [Grape::Request] the request currently being handled
-        # @raise [Grape::Exceptions::ValidationArrayErrors] if validation failed
-        # @return [void]
-        def validate(request)
-          res = schema.call(request.params)
-
-          if res.success?
-            request.params.deep_merge!(res.to_h)
-            return
-          end
-
-          errors = []
-
-          res.errors.messages.each do |message|
-            full_name = message.path.first.to_s
-
-            full_name += "[#{message.path[1..].join('][')}]" if message.path.size > 1
-
-            errors << Grape::Exceptions::Validation.new(params: [full_name], message: message.text)
-          end
-
-          raise Grape::Exceptions::ValidationArrayErrors.new(errors)
-        end
-
-        def fail_fast?
-          false
-        end
-      end
     end
   end
 end