grape 2.0.0 → 2.4.0

data/lib/grape/parser/json.rb

@@ -2,14 +2,12 @@
 
 module Grape
   module Parser
-    module Json
-      class << self
-        def call(object, _env)
-          ::Grape::Json.load(object)
-        rescue ::Grape::Json::ParseError
-          # handle JSON parsing errors via the rescue handlers or provide error message
-          raise Grape::Exceptions::InvalidMessageBody.new('application/json')
-        end
+    class Json < Base
+      def self.call(object, _env)
+        ::Grape::Json.load(object)
+      rescue ::Grape::Json::ParseError
+        # handle JSON parsing errors via the rescue handlers or provide error message
+        raise Grape::Exceptions::InvalidMessageBody.new('application/json')
       end
     end
   end

data/lib/grape/parser/xml.rb

@@ -2,14 +2,12 @@
 
 module Grape
   module Parser
-    module Xml
-      class << self
-        def call(object, _env)
-          ::Grape::Xml.parse(object)
-        rescue ::Grape::Xml::ParseError
-          # handle XML parsing errors via the rescue handlers or provide error message
-          raise Grape::Exceptions::InvalidMessageBody.new('application/xml')
-        end
+    class Xml < Base
+      def self.call(object, _env)
+        ::Grape::Xml.parse(object)
+      rescue ::Grape::Xml::ParseError
+        # handle XML parsing errors via the rescue handlers or provide error message
+        raise Grape::Exceptions::InvalidMessageBody.new('application/xml')
       end
     end
   end

data/lib/grape/parser.rb

@@ -2,32 +2,14 @@
 
 module Grape
   module Parser
-    extend Util::Registrable
+    extend Grape::Util::Registry
 
-    class << self
-      def builtin_parsers
-        @builtin_parsers ||= {
-          json: Grape::Parser::Json,
-          jsonapi: Grape::Parser::Json,
-          xml: Grape::Parser::Xml
-        }
-      end
+    module_function
 
-      def parsers(**options)
-        builtin_parsers.merge(default_elements).merge!(options[:parsers] || {})
-      end
+    def parser_for(format, parsers = nil)
+      return parsers[format] if parsers&.key?(format)
 
-      def parser_for(api_format, **options)
-        spec = parsers(**options)[api_format]
-        case spec
-        when nil
-          nil
-        when Symbol
-          method(spec)
-        else
-          spec
-        end
-      end
+      registry[format]
     end
   end
 end

data/lib/grape/path.rb

@@ -1,98 +1,76 @@
 # frozen_string_literal: true
 
-require 'grape/util/cache'
-
 module Grape
   # Represents a path to an endpoint.
   class Path
-    def self.prepare(raw_path, namespace, settings)
-      Path.new(raw_path, namespace, settings)
-    end
+    DEFAULT_FORMAT_SEGMENT = '(/.:format)'
+    NO_VERSIONING_WITH_VALID_PATH_FORMAT_SEGMENT = '(.:format)'
+    VERSION_SEGMENT = ':version'
 
-    attr_reader :raw_path, :namespace, :settings
+    attr_reader :origin, :suffix
 
-    def initialize(raw_path, namespace, settings)
-      @raw_path = raw_path
-      @namespace = namespace
-      @settings = settings
+    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 mount_path
-      settings[:mount_path]
+    def to_s
+      "#{origin}#{suffix}"
     end
 
-    def root_prefix
-      split_setting(:root_prefix)
-    end
+    private
 
-    def uses_specific_format?
-      if settings.key?(:format) && settings.key?(:content_types)
-        (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
-        false
+        DEFAULT_FORMAT_SEGMENT
       end
     end
 
-    def uses_path_versioning?
-      if settings.key?(:version) && settings[:version_options] && settings[:version_options].key?(:using)
-        (settings[:version] && settings[:version_options][:using] == :path)
-      else
-        false
+    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/) && namespace != '/'
+    def add_part(parts, value)
+      parts << value if value && not_slash?(value)
     end
 
-    def path?
-      raw_path&.match?(/^\S/) && 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
-      Grape::Router.normalize_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
+        super
         @cache = Hash.new do |h, parts|
-          h[parts] = -parts.join('/')
+          h[parts] = Grape::Router.normalize_path(parts.join('/'))
         end
       end
     end
-
-    def parts
-      parts = [mount_path, root_prefix].compact
-      parts << ':version' if uses_path_versioning?
-      parts << namespace.to_s
-      parts << raw_path.to_s
-      parts.flatten.reject { |part| part == '/' }
-    end
-
-    def split_setting(key)
-      return if settings[key].nil?
-
-      settings[key].to_s.split('/')
-    end
   end
 end

data/lib/grape/request.rb

@@ -1,58 +1,189 @@
 # frozen_string_literal: true
 
-require 'grape/util/lazy_object'
-
 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::LazyObject.new do
-        env.each_pair.with_object({}) 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
 
-    if Grape.lowercase_headers?
-      def transform_header(header)
-        -header[5..].tr('_', '-').downcase
-      end
-    else
-      def transform_header(header)
-        -header[5..].split('_').map(&:capitalize).join('-')
+    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

data/lib/grape/router/base_route.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Grape
+  class Router
+    class BaseRoute
+      delegate_missing_to :@options
+
+      attr_reader :index, :pattern, :options
+
+      def initialize(options)
+        @options = options.is_a?(ActiveSupport::OrderedOptions) ? options : ActiveSupport::OrderedOptions.new.update(options)
+      end
+
+      alias attributes options
+
+      def regexp_capture_index
+        CaptureIndexCache[index]
+      end
+
+      def pattern_regexp
+        pattern.to_regexp
+      end
+
+      def to_regexp(index)
+        @index = index
+        Regexp.new("(?<#{regexp_capture_index}>#{pattern_regexp})")
+      end
+
+      class CaptureIndexCache < Grape::Util::Cache
+        def initialize
+          super
+          @cache = Hash.new do |h, index|
+            h[index] = "_#{index}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/grape/router/greedy_route.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+# Act like a Grape::Router::Route but for greedy_match
+# see @neutral_map
+
+module Grape
+  class Router
+    class GreedyRoute < BaseRoute
+      def initialize(pattern, options)
+        @pattern = pattern
+        super(options)
+      end
+
+      # Grape::Router:Route defines params as a function
+      def params(_input = nil)
+        options[:params] || {}
+      end
+    end
+  end
+end

data/lib/grape/router/pattern.rb

@@ -1,62 +1,76 @@
 # frozen_string_literal: true
 
-require 'forwardable'
-require 'mustermann/grape'
-require 'grape/util/cache'
-
 module Grape
   class Router
     class Pattern
-      DEFAULT_PATTERN_OPTIONS   = { uri_decode: true }.freeze
-      DEFAULT_SUPPORTED_CAPTURE = %i[format version].freeze
+      extend Forwardable
+
+      DEFAULT_CAPTURES = %w[format version].freeze
 
       attr_reader :origin, :path, :pattern, :to_regexp
 
-      extend Forwardable
-      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, **options)
-        @pattern = Mustermann::Grape.new(@path, **pattern_options(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
 
+      def captures_default
+        to_regexp.names
+                 .delete_if { |n| DEFAULT_CAPTURES.include?(n) }
+                 .to_h { |k| [k, ''] }
+      end
+
       private
 
-      def pattern_options(options)
-        capture = extract_capture(**options)
-        options = DEFAULT_PATTERN_OPTIONS.dup
-        options[:capture] = capture if capture.present?
-        options
+      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 build_path(pattern, anchor: false, suffix: nil, **_options)
-        unless anchor || pattern.end_with?('*path')
-          pattern = +pattern
-          pattern << '/' unless pattern.end_with?('/')
-          pattern << '*path'
+      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
 
-        pattern = -pattern.split('/').tap do |parts|
-          parts[parts.length - 1] = "?#{parts.last}"
-        end.join('/') if pattern.end_with?('*path')
+        return capture if requirements.blank?
 
-        PatternCache[[pattern, suffix]]
+        requirements.merge(capture)
       end
 
-      def extract_capture(requirements: {}, **options)
-        requirements = {}.merge(requirements)
-        DEFAULT_SUPPORTED_CAPTURE.each_with_object(requirements) do |field, capture|
-          option = Array(options[field])
-          capture[field] = option.map(&:to_s) if option.present?
+      def build_path_from_pattern(pattern, anchor)
+        if pattern.end_with?('*path')
+          pattern.dup.insert(pattern.rindex('/') + 1, '?')
+        elsif anchor
+          pattern
+        elsif pattern.end_with?('/')
+          "#{pattern}?*path"
+        else
+          "#{pattern}/?*path"
         end
       end
 
+      def map_str(value)
+        Array.wrap(value).map(&:to_s)
+      end
+
       class PatternCache < Grape::Util::Cache
         def initialize
+          super
           @cache = Hash.new do |h, (pattern, suffix)|
             h[[pattern, suffix]] = -"#{pattern}#{suffix}"
           end