grape 1.8.0 → 3.3.5

data/lib/grape/namespace.rb

@@ -1,45 +1,51 @@
 # frozen_string_literal: true
 
-require 'grape/util/cache'
-
 module Grape
   # A container for endpoints or other namespaces, which allows for both
   # 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 ==(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)
-      Grape::Router.normalize_path(JoinedSpaceCache[joined_space(settings)])
+      JoinedSpaceCache[joined_space(settings)]
     end
 
     class JoinedSpaceCache < Grape::Util::Cache
       def initialize
+        super
         @cache = Hash.new do |h, joined_space|
-          h[joined_space] = -joined_space.join('/')
+          h[joined_space] = Grape::Util::PathNormalizer.call(joined_space.join('/'))
         end
       end
     end

data/lib/grape/params_builder/base.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Grape
+  module ParamsBuilder
+    class Base
+      class << self
+        def call(_params)
+          raise NotImplementedError
+        end
+
+        private
+
+        def inherited(klass)
+          super
+          ParamsBuilder.register(klass)
+        end
+      end
+    end
+  end
+end

data/lib/grape/params_builder/hash.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Grape
+  module ParamsBuilder
+    class Hash < Base
+      def self.call(params)
+        params.deep_symbolize_keys
+      end
+    end
+  end
+end

data/lib/grape/params_builder/hash_with_indifferent_access.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Grape
+  module ParamsBuilder
+    class HashWithIndifferentAccess < Base
+      def self.call(params)
+        ActiveSupport::HashWithIndifferentAccess.new(params)
+      end
+    end
+  end
+end

data/lib/grape/params_builder/hashie_mash.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Grape
+  module ParamsBuilder
+    class HashieMash < Base
+      def self.call(params)
+        ::Hashie::Mash.new(params)
+      end
+    end
+  end
+end

data/lib/grape/params_builder.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Grape
+  module ParamsBuilder
+    extend Grape::Util::Registry
+
+    module_function
+
+    def params_builder_for(short_name)
+      raise Grape::Exceptions::UnknownParamsBuilder, short_name unless registry.key?(short_name)
+
+      registry[short_name]
+    end
+  end
+end

data/lib/grape/parser/base.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Grape
+  module Parser
+    class Base
+      def self.call(_object, _env)
+        raise NotImplementedError
+      end
+
+      def self.inherited(klass)
+        super
+        Parser.register(klass)
+      end
+    end
+  end
+end

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.parse(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,73 @@
 # 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)
-      else
-        false
-      end
-    end
+    def build_suffix(raw_path, raw_namespace, settings)
+      return "(.#{settings[:format]})" if uses_specific_format?(settings)
+      return NO_VERSIONING_WITH_VALID_PATH_FORMAT_SEGMENT if !uses_path_versioning?(settings) || valid_part?(raw_namespace) || valid_part?(raw_path)
 
-    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
-      end
+      DEFAULT_FORMAT_SEGMENT
     end
 
-    def namespace?
-      namespace&.match?(/^\S/) && namespace != '/'
+    def build_parts(raw_path, raw_namespace, settings)
+      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)
+      parts
     end
 
-    def path?
-      raw_path&.match?(/^\S/) && raw_path != '/'
+    def add_part(parts, value)
+      parts << value if value && not_slash?(value)
     end
 
-    def suffix
-      if uses_specific_format?
-        "(.#{settings[:format]})"
-      elsif !uses_path_versioning? || (namespace? || path?)
-        '(.:format)'
-      else
-        '(/.:format)'
-      end
+    def not_slash?(value)
+      value != '/'
     end
 
-    def path
-      Grape::Router.normalize_path(PartsCache[parts])
-    end
+    def uses_specific_format?(settings)
+      return false unless settings.key?(:format) && settings.key?(:content_types)
 
-    def path_with_suffix
-      "#{path}#{suffix}"
+      settings[:format] && Array(settings[:content_types]).size == 1
     end
 
-    def to_s
-      path_with_suffix
+    def uses_path_versioning?(settings)
+      return false unless settings.key?(:version) && settings[:version_options]
+
+      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::Util::PathNormalizer.call(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/railtie.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Grape
+  class Railtie < ::Rails::Railtie
+    initializer 'grape.deprecator' do |app|
+      app.deprecators[:grape] = Grape.deprecator
+    end
+  end
+end

data/lib/grape/request.rb

@@ -1,53 +1,195 @@
 # 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
+    ].to_h do |header|
+      ["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
 
+    def cookies
+      @cookies ||= Grape::Cookies.new(rack_cookies)
+    end
+
+    # True once the cookie jar has been materialized (a cookie was read or
+    # written this request). Lets the endpoint skip response-cookie flushing,
+    # and the Grape::Cookies allocation it triggers, when no cookie was
+    # touched on the request.
+    def cookies?
+      !@cookies.nil?
+    end
+
     private
 
-    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
+    def make_params
+      params = @params_builder.call(rack_params)
+      routing_args = env[Grape::Env::GRAPE_ROUTING_ARGS]
+      filtered = routing_args&.except(:version, :route_info)
+      return params if filtered.blank?
+
+      params.deep_merge!(filtered)
+    rescue *Grape::RACK_ERRORS
+      raise Grape::Exceptions::RequestError
     end
 
+    # Uses a plain `each_header` block instead of `each_header.with_object`:
+    # `with_object` can only pass the block one value plus the memo, so the
+    # `k, v` pair would be boxed into a throwaway Array on every header. A
+    # two-arg block receives `k`/`v` directly and allocates nothing extra.
     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
+      headers = Grape::Util::Header.new
+      each_header do |k, v|
+        next unless k.start_with? 'HTTP_'
 
-          transformed_header = Grape::Http::Headers::HTTP_HEADERS[k] || transform_header(k)
-          headers[transformed_header] = v
-        end
+        transformed_header = KNOWN_HEADERS.fetch(k) { -k[5..].tr('_', '-').downcase }
+        headers[transformed_header] = v
       end
-    end
-
-    def transform_header(header)
-      -header[5..].split('_').each(&:capitalize!).join('-')
+      headers
     end
   end
 end

data/lib/grape/router/base_route.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Grape
+  class Router
+    class BaseRoute
+      extend Forwardable
+
+      delegate_missing_to :@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(pattern, options = {})
+        @pattern = pattern
+        @options = options.is_a?(ActiveSupport::OrderedOptions) ? options : ActiveSupport::OrderedOptions.new.update(options)
+      end
+
+      # see https://github.com/ruby-grape/grape/issues/1348
+      def namespace
+        @namespace ||= @options[:namespace]
+      end
+
+      def regexp_capture_index
+        @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,26 @@
+# frozen_string_literal: true
+
+# Act like a Grape::Router::Route but for greedy_match
+# see @neutral_map
+
+module Grape
+  class Router
+    class GreedyRoute < BaseRoute
+      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
+
+      def params(_input = nil)
+        nil
+      end
+    end
+  end
+end