grape 0.13.0 → 0.14.0

data/lib/grape/middleware/error.rb

@@ -47,6 +47,7 @@ module Grape
       end
 
       def rescuable?(klass)
+        return false if klass == Grape::Exceptions::InvalidVersionHeader
         options[:rescue_all] || (options[:rescue_handlers] || []).any? { |error, _handler| klass <= error } || (options[:base_only_rescue_handlers] || []).include?(klass)
       end
 
@@ -59,7 +60,7 @@ module Grape
       end
 
       def error!(message, status = options[:default_status], headers = {}, backtrace = [])
-        headers = { Grape::Http::Headers::CONTENT_TYPE => content_type }.merge(headers)
+        headers = headers.reverse_merge(Grape::Http::Headers::CONTENT_TYPE => content_type)
         rack_response(format_message(message, backtrace), status, headers)
       end
 
@@ -82,7 +83,7 @@ module Grape
       end
 
       def format_message(message, backtrace)
-        format = env['api.format'] || options[:format]
+        format = env[Grape::Env::API_FORMAT] || options[:format]
         formatter = Grape::ErrorFormatter::Base.formatter_for(format, options)
         throw :error, status: 406, message: "The requested format '#{format}' is not supported." unless formatter
         formatter.call(message, backtrace, options, env)

data/lib/grape/middleware/filter.rb

@@ -3,7 +3,7 @@ module Grape
     # This is a simple middleware for adding before and after filters
     # to Grape APIs. It is used like so:
     #
-    #     use Grape::Middleware::Filter, before: lambda { do_something }, after: lambda { do_something }
+    #     use Grape::Middleware::Filter, before: -> { do_something }, after: -> { do_something }
     class Filter < Base
       def before
         app.instance_eval(&options[:before]) if options[:before]

data/lib/grape/middleware/formatter.rb

@@ -3,6 +3,8 @@ require 'grape/middleware/base'
 module Grape
   module Middleware
     class Formatter < Base
+      CHUNKED = 'chunked'.freeze
+
       def default_options
         {
           default_format: :txt,
@@ -19,35 +21,36 @@ module Grape
       def after
         status, headers, bodies = *@app_response
 
-        if bodies.is_a?(Grape::Util::FileResponse)
-          headers = ensure_content_type(headers)
-
-          response =
-            Rack::Response.new([], status, headers) do |resp|
-              resp.body = bodies.file
-            end
+        if Rack::Utils::STATUS_WITH_NO_ENTITY_BODY.include?(status)
+          @app_response
         else
-          # Allow content-type to be explicitly overwritten
-          api_format = mime_types[headers[Grape::Http::Headers::CONTENT_TYPE]] || env['api.format']
-          formatter = Grape::Formatter::Base.formatter_for(api_format, options)
+          build_formatted_response(status, headers, bodies)
+        end
+      end
 
-          begin
-            bodymap = bodies.collect do |body|
-              formatter.call(body, env)
-            end
+      private
 
-            headers = ensure_content_type(headers)
+      def build_formatted_response(status, headers, bodies)
+        headers = ensure_content_type(headers)
 
-            response = Rack::Response.new(bodymap, status, headers)
-          rescue Grape::Exceptions::InvalidFormatter => e
-            throw :error, status: 500, message: e.message
+        if bodies.is_a?(Grape::Util::FileResponse)
+          Rack::Response.new([], status, headers) do |resp|
+            resp.body = bodies.file
           end
+        else
+          # Allow content-type to be explicitly overwritten
+          formatter = fetch_formatter(headers, options)
+          bodymap = bodies.collect { |body| formatter.call(body, env) }
+          Rack::Response.new(bodymap, status, headers)
         end
-
-        response
+      rescue Grape::Exceptions::InvalidFormatter => e
+        throw :error, status: 500, message: e.message
       end
 
-      private
+      def fetch_formatter(headers, options)
+        api_format = mime_types[headers[Grape::Http::Headers::CONTENT_TYPE]] || env[Grape::Env::API_FORMAT]
+        Grape::Formatter::Base.formatter_for(api_format, options)
+      end
 
       # Set the content type header for the API format if it is not already present.
       #
@@ -57,7 +60,7 @@ module Grape
         if headers[Grape::Http::Headers::CONTENT_TYPE]
           headers
         else
-          headers.merge(Grape::Http::Headers::CONTENT_TYPE => content_type_for(env['api.format']))
+          headers.merge(Grape::Http::Headers::CONTENT_TYPE => content_type_for(env[Grape::Env::API_FORMAT]))
         end
       end
 
@@ -67,20 +70,20 @@ module Grape
 
       # store read input in env['api.request.input']
       def read_body_input
-        if (request.post? || request.put? || request.patch? || request.delete?) &&
-           (!request.form_data? || !request.media_type) &&
-           (!request.parseable_data?) &&
-           (request.content_length.to_i > 0 || request.env[Grape::Http::Headers::HTTP_TRANSFER_ENCODING] == 'chunked')
-
-          if (input = env['rack.input'])
-            input.rewind
-            body = env['api.request.input'] = input.read
-            begin
-              read_rack_input(body) if body && body.length > 0
-            ensure
-              input.rewind
-            end
-          end
+        return unless
+          (request.post? || request.put? || request.patch? || request.delete?) &&
+          (!request.form_data? || !request.media_type) &&
+          (!request.parseable_data?) &&
+          (request.content_length.to_i > 0 || request.env[Grape::Http::Headers::HTTP_TRANSFER_ENCODING] == CHUNKED)
+
+        return unless (input = env[Grape::Env::RACK_INPUT])
+
+        input.rewind
+        body = env[Grape::Env::API_REQUEST_INPUT] = input.read
+        begin
+          read_rack_input(body) if body && body.length > 0
+        ensure
+          input.rewind
         end
       end
 
@@ -92,14 +95,14 @@ module Grape
           parser = Grape::Parser::Base.parser_for fmt, options
           if parser
             begin
-              body = (env['api.request.body'] = parser.call(body, env))
+              body = (env[Grape::Env::API_REQUEST_BODY] = parser.call(body, env))
               if body.is_a?(Hash)
-                if env['rack.request.form_hash']
-                  env['rack.request.form_hash'] = env['rack.request.form_hash'].merge(body)
+                if env[Grape::Env::RACK_REQUEST_FORM_HASH]
+                  env[Grape::Env::RACK_REQUEST_FORM_HASH] = env[Grape::Env::RACK_REQUEST_FORM_HASH].merge(body)
                 else
-                  env['rack.request.form_hash'] = body
+                  env[Grape::Env::RACK_REQUEST_FORM_HASH] = body
                 end
-                env['rack.request.form_input'] = env['rack.input']
+                env[Grape::Env::RACK_REQUEST_FORM_INPUT] = env[Grape::Env::RACK_INPUT]
               end
             rescue Grape::Exceptions::Base => e
               raise e
@@ -107,7 +110,7 @@ module Grape
               throw :error, status: 400, message: e.message
             end
           else
-            env['api.request.body'] = body
+            env[Grape::Env::API_REQUEST_BODY] = body
           end
         else
           throw :error, status: 406, message: "The requested content-type '#{request.media_type}' is not supported."
@@ -117,7 +120,7 @@ module Grape
       def negotiate_content_type
         fmt = format_from_extension || format_from_params || options[:format] || format_from_header || options[:default_format]
         if content_type_for(fmt)
-          env['api.format'] = fmt
+          env[Grape::Env::API_FORMAT] = fmt
         else
           throw :error, status: 406, message: "The requested format '#{fmt}' is not supported."
         end
@@ -165,7 +168,7 @@ module Grape
 
         accept.scan(accept_into_mime_and_quality)
           .sort_by { |_, quality_preference| -quality_preference.to_f }
-          .map { |mime, _| mime.sub(vendor_prefix_pattern, '') }
+          .flat_map { |mime, _| [mime, mime.sub(vendor_prefix_pattern, '')] }
       end
     end
   end

data/lib/grape/middleware/globals.rb

@@ -5,9 +5,9 @@ module Grape
     class Globals < Base
       def before
         request = Grape::Request.new(@env)
-        @env['grape.request'] = request
-        @env['grape.request.headers'] = request.headers
-        @env['grape.request.params'] = request.params if @env['rack.input']
+        @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]
       end
     end
   end

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

@@ -27,14 +27,12 @@ module Grape
             end
           end
 
-          unless potential_version.empty?
-            # If the requested version is not supported:
-            unless versions.any? { |v| v.to_s == potential_version }
-              throw :error, status: 406, headers: error_headers, message: 'The requested version is not supported.'
-            end
+          return if potential_version.empty?
 
-            env['api.version'] = potential_version
-          end
+          # If the requested version is not supported:
+          throw :error, status: 406, headers: error_headers, message: 'The requested version is not supported.' unless versions.any? { |v| v.to_s == potential_version }
+
+          env[Grape::Env::API_VERSION] = potential_version
         end
 
         private

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

@@ -1,4 +1,5 @@
 require 'grape/middleware/base'
+require 'grape/middleware/versioner/parse_media_type_patch'
 
 module Grape
   module Middleware
@@ -8,13 +9,13 @@ module Grape
       # application/vnd.:vendor-:version+:format
       #
       # Example: For request header
-      #    Accept: application/vnd.mycompany-v1+json
+      #    Accept: application/vnd.mycompany.a-cool-resource-v1+json
       #
       # The following rack env variables are set:
       #
       #    env['api.type']    => 'application'
-      #    env['api.subtype'] => 'vnd.mycompany-v1+json'
-      #    env['api.vendor]   => 'mycompany'
+      #    env['api.subtype'] => 'vnd.mycompany.a-cool-resource-v1+json'
+      #    env['api.vendor]   => 'mycompany.a-cool-resource'
       #    env['api.version]  => 'v1'
       #    env['api.format]   => 'json'
       #
@@ -22,54 +23,88 @@ module Grape
       # X-Cascade header to alert Rack::Mount to attempt the next matched
       # route.
       class Header < Base
-        def before
-          header = rack_accept_header
+        VENDOR_VERSION_HEADER_REGEX =
+          /\Avnd\.([a-z0-9.\-_!#\$&\^]+?)(?:-([a-z0-9*.]+))?(?:\+([a-z0-9*\-.]+))?\z/
 
-          if strict?
-            # If no Accept header:
-            if header.qvalues.empty?
-              fail Grape::Exceptions::InvalidAcceptHeader.new('Accept header must be set.', error_headers)
-            end
-            # Remove any acceptable content types with ranges.
-            header.qvalues.reject! do |media_type, _|
-              Rack::Accept::Header.parse_media_type(media_type).find { |s| s == '*' }
-            end
-            # If all Accept headers included a range:
-            if header.qvalues.empty?
-              fail Grape::Exceptions::InvalidAcceptHeader.new('Accept header must not contain ranges ("*").',
-                                                              error_headers)
-            end
-          end
+        HAS_VENDOR_REGEX = /\Avnd\.[a-z0-9.\-_!#\$&\^]+/
+        HAS_VERSION_REGEX = /\Avnd\.([a-z0-9.\-_!#\$&\^]+?)(?:-([a-z0-9*.]+))+/
 
-          media_type = header.best_of available_media_types
+        def before
+          strict_header_checks if strict?
 
           if media_type
-            type, subtype = Rack::Accept::Header.parse_media_type media_type
-            env['api.type']    = type
-            env['api.subtype'] = subtype
-
-            if /\Avnd\.([a-z0-9*.]+)(?:-([a-z0-9*\-.]+))?(?:\+([a-z0-9*\-.+]+))?\z/ =~ subtype
-              env['api.vendor']  = Regexp.last_match[1]
-              env['api.version'] = Regexp.last_match[2]
-              env['api.format']  = Regexp.last_match[3]  # weird that Grape::Middleware::Formatter also does this
-            end
-          # If none of the available content types are acceptable:
-          elsif strict?
-            fail Grape::Exceptions::InvalidAcceptHeader.new('406 Not Acceptable', error_headers)
-          # If all acceptable content types specify a vendor or version that doesn't exist:
-          elsif header.values.all? { |header_value| has_vendor?(header_value) || version?(header_value) }
-            fail Grape::Exceptions::InvalidAcceptHeader.new('API vendor or version not found.', error_headers)
+            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 unless versions.present?
+          return if 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 =~ h.sub('application/', '')
+          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)
+          fail Grape::Exceptions::InvalidAcceptHeader
+            .new(message, error_headers)
+        end
+
+        def fail_with_invalid_version_header!(message)
+          fail Grape::Exceptions::InvalidVersionHeader
+            .new(message, error_headers)
+        end
+
         def available_media_types
           available_media_types = []
 
           content_types.each do |extension, _media_type|
             versions.reverse_each do |version|
-              available_media_types += ["application/vnd.#{vendor}-#{version}+#{extension}", "application/vnd.#{vendor}-#{version}"]
+              available_media_types += [
+                "application/vnd.#{vendor}-#{version}+#{extension}",
+                "application/vnd.#{vendor}-#{version}"
+              ]
             end
             available_media_types << "application/vnd.#{vendor}+#{extension}"
           end
@@ -83,10 +118,22 @@ module Grape
           available_media_types.flatten
         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.include?(request_version(header_value))
+          end
+        end
+
         def rack_accept_header
           Rack::Accept::MediaType.new env[Grape::Http::Headers::HTTP_ACCEPT]
         rescue RuntimeError => e
-          raise Grape::Exceptions::InvalidAcceptHeader.new(e.message, error_headers)
+          fail_with_invalid_accept_header!(e.message)
         end
 
         def versions
@@ -94,19 +141,25 @@ module Grape
         end
 
         def vendor
-          options[:version_options] && options[:version_options][:vendor]
+          version_options && version_options[:vendor]
         end
 
         def strict?
-          options[:version_options] && options[:version_options][: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 [Rack::Mount](https://github.com/josh/rack-mount) for more information). To prevent
-        # this behavior, and not add the `X-Cascade` header, one can set the `:cascade` option to `false`.
+        # By default those errors contain an `X-Cascade` header set to `pass`,
+        # which allows nesting and stacking of routes
+        # (see [Rack::Mount](https://github.com/josh/rack-mount) 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 options[:version_options] && options[:version_options].key?(:cascade)
-            !!options[:version_options][:cascade]
+          if version_options && version_options.key?(:cascade)
+            !!version_options[:cascade]
           else
             true
           end
@@ -118,16 +171,26 @@ module Grape
 
         # @param [String] media_type a content type
         # @return [Boolean] whether the content type sets a vendor
-        def has_vendor?(media_type)
-          _, subtype = Rack::Accept::Header.parse_media_type media_type
-          subtype[/\Avnd\.[a-z0-9*.]+/]
+        def vendor?(media_type)
+          _, subtype = Rack::Accept::Header.parse_media_type(media_type)
+          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[/\Avnd\.[a-z0-9*.]+-[a-z0-9*\-.]+/]
+          _, subtype = Rack::Accept::Header.parse_media_type(media_type)
+          subtype[HAS_VERSION_REGEX]
         end
       end
     end