grape 1.8.0 → 2.1.0

data/lib/grape/middleware/formatter.rb

@@ -1,11 +1,10 @@
 # frozen_string_literal: true
 
-require 'grape/middleware/base'
-
 module Grape
   module Middleware
     class Formatter < Base
       CHUNKED = 'chunked'
+      FORMAT = 'format'
 
       def default_options
         {
@@ -26,7 +25,7 @@ module Grape
         status, headers, bodies = *@app_response
 
         if Rack::Utils::STATUS_WITH_NO_ENTITY_BODY.include?(status)
-          @app_response
+          [status, headers, []]
         else
           build_formatted_response(status, headers, bodies)
         end
@@ -54,7 +53,7 @@ module Grape
       end
 
       def fetch_formatter(headers, options)
-        api_format = mime_types[headers[Grape::Http::Headers::CONTENT_TYPE]] || env[Grape::Env::API_FORMAT]
+        api_format = mime_types[headers[Rack::CONTENT_TYPE]] || env[Grape::Env::API_FORMAT]
         Grape::Formatter.formatter_for(api_format, **options)
       end
 
@@ -63,10 +62,10 @@ module Grape
       # @param headers [Hash]
       # @return [Hash]
       def ensure_content_type(headers)
-        if headers[Grape::Http::Headers::CONTENT_TYPE]
+        if headers[Rack::CONTENT_TYPE]
           headers
         else
-          headers.merge(Grape::Http::Headers::CONTENT_TYPE => content_type_for(env[Grape::Env::API_FORMAT]))
+          headers.merge(Rack::CONTENT_TYPE => content_type_for(env[Grape::Env::API_FORMAT]))
         end
       end
 
@@ -82,14 +81,14 @@ module Grape
           !request.parseable_data? &&
           (request.content_length.to_i.positive? || request.env[Grape::Http::Headers::HTTP_TRANSFER_ENCODING] == CHUNKED)
 
-        return unless (input = env[Grape::Env::RACK_INPUT])
+        return unless (input = env[Rack::RACK_INPUT])
 
-        input.rewind
+        rewind_input input
         body = env[Grape::Env::API_REQUEST_INPUT] = input.read
         begin
           read_rack_input(body) if body && !body.empty?
         ensure
-          input.rewind
+          rewind_input input
         end
       end
 
@@ -103,12 +102,12 @@ module Grape
           begin
             body = (env[Grape::Env::API_REQUEST_BODY] = parser.call(body, env))
             if body.is_a?(Hash)
-              env[Grape::Env::RACK_REQUEST_FORM_HASH] = if env.key?(Grape::Env::RACK_REQUEST_FORM_HASH)
-                                                          env[Grape::Env::RACK_REQUEST_FORM_HASH].merge(body)
-                                                        else
-                                                          body
-                                                        end
-              env[Grape::Env::RACK_REQUEST_FORM_INPUT] = env[Grape::Env::RACK_INPUT]
+              env[Rack::RACK_REQUEST_FORM_HASH] = if env.key?(Rack::RACK_REQUEST_FORM_HASH)
+                                                    env[Rack::RACK_REQUEST_FORM_HASH].merge(body)
+                                                  else
+                                                    body
+                                                  end
+              env[Rack::RACK_REQUEST_FORM_INPUT] = env[Rack::RACK_INPUT]
             end
           rescue Grape::Exceptions::Base => e
             raise e
@@ -141,7 +140,7 @@ module Grape
       end
 
       def format_from_params
-        fmt = Rack::Utils.parse_nested_query(env[Grape::Http::Headers::QUERY_STRING])[Grape::Http::Headers::FORMAT]
+        fmt = Rack::Utils.parse_nested_query(env[Rack::QUERY_STRING])[FORMAT]
         # avoid symbol memory leak on an unknown format
         return fmt.to_sym if content_type_for(fmt)
 
@@ -164,16 +163,20 @@ module Grape
             \w+/[\w+.-]+)     # eg application/vnd.example.myformat+xml
           (?:
            (?:;[^,]*?)?       # optionally multiple formats in a row
-           ;\s*q=([\d.]+)     # optional "quality" preference (eg q=0.5)
+           ;\s*q=([\w.]+)     # optional "quality" preference (eg q=0.5)
           )?
         }x
 
         vendor_prefix_pattern = /vnd\.[^+]+\+/
 
         accept.scan(accept_into_mime_and_quality)
-              .sort_by { |_, quality_preference| -quality_preference.to_f }
+              .sort_by { |_, quality_preference| -(quality_preference ? quality_preference.to_f : 1.0) }
               .flat_map { |mime, _| [mime, mime.sub(vendor_prefix_pattern, '')] }
       end
+
+      def rewind_input(input)
+        input.rewind if input.respond_to?(:rewind)
+      end
     end
   end
 end

data/lib/grape/middleware/globals.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require 'grape/middleware/base'
-
 module Grape
   module Middleware
     class Globals < Base
@@ -9,7 +7,7 @@ module Grape
         request = Grape::Request.new(@env, build_params_with: @options[:build_params_with])
         @env[Grape::Env::GRAPE_REQUEST] = request
         @env[Grape::Env::GRAPE_REQUEST_HEADERS] = request.headers
-        @env[Grape::Env::GRAPE_REQUEST_PARAMS] = request.params if @env[Grape::Env::RACK_INPUT]
+        @env[Grape::Env::GRAPE_REQUEST_PARAMS] = request.params if @env[Rack::RACK_INPUT]
       end
     end
   end

data/lib/grape/middleware/stack.rb

@@ -76,11 +76,10 @@ module Grape
       end
       ruby2_keywords :insert_after if respond_to?(:ruby2_keywords, true)
 
-      def use(*args, &block)
-        middleware = self.class::Middleware.new(*args, &block)
+      def use(...)
+        middleware = self.class::Middleware.new(...)
         middlewares.push(middleware)
       end
-      ruby2_keywords :use if respond_to?(:ruby2_keywords, true)
 
       def merge_with(middleware_specs)
         middleware_specs.each do |operation, *args|

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

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require 'grape/middleware/base'
-
 module Grape
   module Middleware
     module Versioner

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

@@ -1,8 +1,5 @@
 # frozen_string_literal: true
 
-require 'grape/middleware/base'
-require 'grape/middleware/versioner/parse_media_type_patch'
-
 module Grape
   module Middleware
     module Versioner
@@ -25,169 +22,26 @@ module Grape
       # X-Cascade header to alert Grape::Router to attempt the next matched
       # route.
       class Header < Base
-        VENDOR_VERSION_HEADER_REGEX =
-          /\Avnd\.([a-z0-9.\-_!#{Regexp.last_match(0)}\^]+?)(?:-([a-z0-9*.]+))?(?:\+([a-z0-9*\-.]+))?\z/.freeze
-
-        HAS_VENDOR_REGEX = /\Avnd\.[a-z0-9.\-_!#{Regexp.last_match(0)}\^]+/.freeze
-        HAS_VERSION_REGEX = /\Avnd\.([a-z0-9.\-_!#{Regexp.last_match(0)}\^]+?)(?:-([a-z0-9*.]+))+/.freeze
-
         def before
-          strict_header_checks if strict?
-
-          if media_type || env[Grape::Env::GRAPE_ALLOWED_METHODS]
-            media_type_header_handler
-          elsif headers_contain_wrong_vendor?
-            fail_with_invalid_accept_header!('API vendor not found.')
-          elsif headers_contain_wrong_version?
-            fail_with_invalid_version_header!('API version not found.')
-          end
-        end
-
-        private
-
-        def strict_header_checks
-          strict_accept_header_presence_check
-          strict_version_vendor_accept_header_presence_check
-        end
-
-        def strict_accept_header_presence_check
-          return unless header.qvalues.empty?
-
-          fail_with_invalid_accept_header!('Accept header must be set.')
-        end
-
-        def strict_version_vendor_accept_header_presence_check
-          return if versions.blank? || an_accept_header_with_version_and_vendor_is_present?
-
-          fail_with_invalid_accept_header!('API vendor or version not found.')
-        end
-
-        def an_accept_header_with_version_and_vendor_is_present?
-          header.qvalues.keys.any? do |h|
-            VENDOR_VERSION_HEADER_REGEX.match?(h.sub('application/', ''))
+          handler = Grape::Util::AcceptHeaderHandler.new(
+            accept_header: env[Grape::Http::Headers::HTTP_ACCEPT],
+            versions: options[:versions],
+            **options.fetch(:version_options) { {} }
+          )
+
+          handler.match_best_quality_media_type!(
+            content_types: content_types,
+            allowed_methods: env[Grape::Env::GRAPE_ALLOWED_METHODS]
+          ) do |media_type|
+            env.update(
+              Grape::Env::API_TYPE => media_type.type,
+              Grape::Env::API_SUBTYPE => media_type.subtype,
+              Grape::Env::API_VENDOR => media_type.vendor,
+              Grape::Env::API_VERSION => media_type.version,
+              Grape::Env::API_FORMAT => media_type.format
+            )
           end
         end
-
-        def header
-          @header ||= rack_accept_header
-        end
-
-        def media_type
-          @media_type ||= header.best_of(available_media_types)
-        end
-
-        def media_type_header_handler
-          type, subtype = Rack::Accept::Header.parse_media_type(media_type)
-          env[Grape::Env::API_TYPE] = type
-          env[Grape::Env::API_SUBTYPE] = subtype
-
-          return unless VENDOR_VERSION_HEADER_REGEX =~ subtype
-
-          env[Grape::Env::API_VENDOR] = Regexp.last_match[1]
-          env[Grape::Env::API_VERSION] = Regexp.last_match[2]
-          # weird that Grape::Middleware::Formatter also does this
-          env[Grape::Env::API_FORMAT] = Regexp.last_match[3]
-        end
-
-        def fail_with_invalid_accept_header!(message)
-          raise Grape::Exceptions::InvalidAcceptHeader
-            .new(message, error_headers)
-        end
-
-        def fail_with_invalid_version_header!(message)
-          raise Grape::Exceptions::InvalidVersionHeader
-            .new(message, error_headers)
-        end
-
-        def available_media_types
-          [].tap do |available_media_types|
-            content_types.each_key do |extension|
-              versions.reverse_each do |version|
-                available_media_types << "application/vnd.#{vendor}-#{version}+#{extension}"
-                available_media_types << "application/vnd.#{vendor}-#{version}"
-              end
-              available_media_types << "application/vnd.#{vendor}+#{extension}"
-            end
-
-            available_media_types << "application/vnd.#{vendor}"
-            available_media_types.concat(content_types.values.flatten)
-          end
-        end
-
-        def headers_contain_wrong_vendor?
-          header.values.all? do |header_value|
-            vendor?(header_value) && request_vendor(header_value) != vendor
-          end
-        end
-
-        def headers_contain_wrong_version?
-          header.values.all? do |header_value|
-            version?(header_value) && versions.exclude?(request_version(header_value))
-          end
-        end
-
-        def rack_accept_header
-          Rack::Accept::MediaType.new env[Grape::Http::Headers::HTTP_ACCEPT]
-        rescue RuntimeError => e
-          fail_with_invalid_accept_header!(e.message)
-        end
-
-        def versions
-          options[:versions] || []
-        end
-
-        def vendor
-          version_options && version_options[:vendor]
-        end
-
-        def strict?
-          version_options && version_options[:strict]
-        end
-
-        def version_options
-          options[:version_options]
-        end
-
-        # 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?
-          if version_options&.key?(:cascade)
-            version_options[:cascade]
-          else
-            true
-          end
-        end
-
-        def error_headers
-          cascade? ? { Grape::Http::Headers::X_CASCADE => 'pass' } : {}
-        end
-
-        # @param [String] media_type a content type
-        # @return [Boolean] whether the content type sets a vendor
-        def vendor?(media_type)
-          _, subtype = Rack::Accept::Header.parse_media_type(media_type)
-          subtype.present? && subtype[HAS_VENDOR_REGEX]
-        end
-
-        def request_vendor(media_type)
-          _, subtype = Rack::Accept::Header.parse_media_type(media_type)
-          subtype.match(VENDOR_VERSION_HEADER_REGEX)[1]
-        end
-
-        def request_version(media_type)
-          _, subtype = Rack::Accept::Header.parse_media_type(media_type)
-          subtype.match(VENDOR_VERSION_HEADER_REGEX)[2]
-        end
-
-        # @param [String] media_type a content type
-        # @return [Boolean] whether the content type sets an API version
-        def version?(media_type)
-          _, subtype = Rack::Accept::Header.parse_media_type(media_type)
-          subtype.present? && subtype[HAS_VERSION_REGEX]
-        end
       end
     end
   end

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

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require 'grape/middleware/base'
-
 module Grape
   module Middleware
     module Versioner
@@ -30,12 +28,12 @@ module Grape
         end
 
         def before
-          potential_version = Rack::Utils.parse_nested_query(env[Grape::Http::Headers::QUERY_STRING])[paramkey]
+          potential_version = Rack::Utils.parse_nested_query(env[Rack::QUERY_STRING])[paramkey]
           return if potential_version.nil?
 
           throw :error, status: 404, message: '404 API Version Not Found', headers: { Grape::Http::Headers::X_CASCADE => 'pass' } if options[:versions] && !options[:versions].find { |v| v.to_s == potential_version }
           env[Grape::Env::API_VERSION] = potential_version
-          env[Grape::Env::RACK_REQUEST_QUERY_HASH].delete(paramkey) if env.key? Grape::Env::RACK_REQUEST_QUERY_HASH
+          env[Rack::RACK_REQUEST_QUERY_HASH].delete(paramkey) if env.key? Rack::RACK_REQUEST_QUERY_HASH
         end
 
         private

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

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require 'grape/middleware/base'
-
 module Grape
   module Middleware
     module Versioner
@@ -26,7 +24,7 @@ module Grape
         end
 
         def before
-          path = env[Grape::Http::Headers::PATH_INFO].dup
+          path = env[Rack::PATH_INFO].dup
           path.sub!(mount_path, '') if mounted_path?(path)
 
           if prefix && path.index(prefix) == 0 # rubocop:disable all

data/lib/grape/namespace.rb

@@ -1,7 +1,5 @@
 # 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.
@@ -33,13 +31,14 @@ module Grape
     # 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::Router.normalize_path(joined_space.join('/'))
         end
       end
     end

data/lib/grape/path.rb

@@ -1,14 +1,8 @@
 # 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
-
     attr_reader :raw_path, :namespace, :settings
 
     def initialize(raw_path, namespace, settings)
@@ -22,31 +16,27 @@ module Grape
     end
 
     def root_prefix
-      split_setting(:root_prefix)
+      settings[:root_prefix]
     end
 
     def uses_specific_format?
-      if settings.key?(:format) && settings.key?(:content_types)
-        (settings[:format] && Array(settings[:content_types]).size == 1)
-      else
-        false
-      end
+      return false unless settings.key?(:format) && settings.key?(:content_types)
+
+      settings[:format] && Array(settings[:content_types]).size == 1
     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
-      end
+      return false unless settings.key?(:version) && settings[:version_options]&.key?(:using)
+
+      settings[:version] && settings[:version_options][:using] == :path
     end
 
     def namespace?
-      namespace&.match?(/^\S/) && namespace != '/'
+      namespace&.match?(/^\S/) && not_slash?(namespace)
     end
 
     def path?
-      raw_path&.match?(/^\S/) && raw_path != '/'
+      raw_path&.match?(/^\S/) && not_slash?(raw_path)
     end
 
     def suffix
@@ -60,7 +50,7 @@ module Grape
     end
 
     def path
-      Grape::Router.normalize_path(PartsCache[parts])
+      PartsCache[parts]
     end
 
     def path_with_suffix
@@ -75,24 +65,29 @@ module Grape
 
     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 == '/' }
+      [].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 split_setting(key)
-      return if settings[key].nil?
+    def add_part(parts, value)
+      parts << value if value && not_slash?(value)
+    end
 
-      settings[key].to_s.split('/')
+    def not_slash?(value)
+      value != '/'
     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,7 +1,5 @@
 # frozen_string_literal: true
 
-require 'grape/util/lazy_object'
-
 module Grape
   class Request < Rack::Request
     HTTP_PREFIX = 'HTTP_'
@@ -36,8 +34,8 @@ module Grape
     end
 
     def build_headers
-      Grape::Util::LazyObject.new do
-        env.each_pair.with_object({}) do |(k, v), 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
 
           transformed_header = Grape::Http::Headers::HTTP_HEADERS[k] || transform_header(k)
@@ -47,7 +45,7 @@ module Grape
     end
 
     def transform_header(header)
-      -header[5..].split('_').each(&:capitalize!).join('-')
+      -header[5..].tr('_', '-').downcase
     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 = 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