grape 0.12.0 → 0.14.0

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,
@@ -11,13 +13,6 @@ module Grape
         }
       end
 
-      def headers
-        env.dup.inject({}) do |h, (k, v)|
-          h[k.to_s.downcase[5..-1]] = v if k.to_s.downcase.start_with?('http_')
-          h
-        end
-      end
-
       def before
         negotiate_content_type
         read_body_input
@@ -25,46 +20,70 @@ module Grape
 
       def after
         status, headers, bodies = *@app_response
-        # 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
-        begin
-          bodymap = if bodies.respond_to?(:collect)
-                      bodies.collect do |body|
-                        formatter.call body, env
-                      end
-                    else
-                      bodies
-                    end
-        rescue Grape::Exceptions::InvalidFormatter => e
-          throw :error, status: 500, message: e.message
+
+        if Rack::Utils::STATUS_WITH_NO_ENTITY_BODY.include?(status)
+          @app_response
+        else
+          build_formatted_response(status, headers, bodies)
         end
-        headers[Grape::Http::Headers::CONTENT_TYPE] = content_type_for(env['api.format']) unless headers[Grape::Http::Headers::CONTENT_TYPE]
-        Rack::Response.new(bodymap, status, headers)
       end
 
       private
 
+      def build_formatted_response(status, headers, bodies)
+        headers = ensure_content_type(headers)
+
+        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
+      rescue Grape::Exceptions::InvalidFormatter => e
+        throw :error, status: 500, message: e.message
+      end
+
+      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.
+      #
+      # @param headers [Hash]
+      # @return [Hash]
+      def ensure_content_type(headers)
+        if headers[Grape::Http::Headers::CONTENT_TYPE]
+          headers
+        else
+          headers.merge(Grape::Http::Headers::CONTENT_TYPE => content_type_for(env[Grape::Env::API_FORMAT]))
+        end
+      end
+
       def request
         @request ||= Rack::Request.new(env)
       end
 
       # 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
 
@@ -76,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
@@ -91,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."
@@ -101,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
@@ -133,7 +152,7 @@ module Grape
       end
 
       def mime_array
-        accept = headers[Grape::Http::Headers::ACCEPT]
+        accept = env[Grape::Http::Headers::HTTP_ACCEPT]
         return [] unless accept
 
         accept_into_mime_and_quality = %r{
@@ -149,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

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

@@ -21,20 +21,17 @@ module Grape
       class Param < Base
         def default_options
           {
-            parameter: 'apiver'
+            parameter: 'apiver'.freeze
           }
         end
 
         def before
           paramkey = options[:parameter]
           potential_version = Rack::Utils.parse_nested_query(env[Grape::Http::Headers::QUERY_STRING])[paramkey]
-          unless potential_version.nil?
-            if options[:versions] && !options[:versions].find { |v| v.to_s == potential_version }
-              throw :error, status: 404, message: '404 API Version Not Found', headers: { Grape::Http::Headers::X_CASCADE => 'pass' }
-            end
-            env['api.version'] = potential_version
-            env['rack.request.query_hash'].delete(paramkey) if env.key? 'rack.request.query_hash'
-          end
+          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
         end
       end
     end

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

@@ -0,0 +1,20 @@
+module Rack
+  module Accept
+    module Header
+      class << self
+        # Corrected version of https://github.com/mjackson/rack-accept/blob/master/lib/rack/accept/header.rb#L40-L44
+        def parse_media_type(media_type)
+          # see http://tools.ietf.org/html/rfc6838#section-4.2 for allowed characters in media type names
+          m = media_type.to_s.match(%r{^([a-z*]+)\/([a-z0-9*\&\^\-_#\$!.+]+)(?:;([a-z0-9=;]+))?$})
+          m ? [m[1], m[2], m[3] || ''] : []
+        end
+      end
+    end
+
+    class MediaType
+      def parse_media_type(media_type)
+        Header.parse_media_type(media_type)
+      end
+    end
+  end
+end

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

@@ -33,12 +33,9 @@ module Grape
 
           pieces = path.split('/')
           potential_version = pieces[1]
-          if potential_version =~ options[:pattern]
-            if options[:versions] && !options[:versions].find { |v| v.to_s == potential_version }
-              throw :error, status: 404, message: '404 API Version Not Found'
-            end
-            env['api.version'] = potential_version
-          end
+          return unless potential_version =~ options[:pattern]
+          throw :error, status: 404, message: '404 API Version Not Found' if options[:versions] && !options[:versions].find { |v| v.to_s == potential_version }
+          env[Grape::Env::API_VERSION] = potential_version
         end
 
         private

data/lib/grape/namespace.rb

@@ -1,22 +1,33 @@
 module Grape
+  # A container for endpoints or other namespaces, which allows for both
+  # logical grouping of endpoints as well as sharing commonconfiguration.
+  # May also be referred to as group, segment, or resource.
   class Namespace
     attr_reader :space, :options
 
-    # options:
-    #   requirements: a hash
+    # @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 = {})
       @space = space.to_s
       @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).join('/')
     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)
       Rack::Mount::Utils.normalize_path(joined_space(settings))
     end

data/lib/grape/path.rb

@@ -1,4 +1,5 @@
 module Grape
+  # Represents a path to an endpoint.
   class Path
     def self.prepare(raw_path, namespace, settings)
       Path.new(raw_path, namespace, settings).path_with_suffix
@@ -28,18 +29,18 @@ module Grape
       !!(settings[:version] && settings[:version_options][:using] == :path)
     end
 
-    def has_namespace?
+    def namespace?
       namespace && namespace.to_s =~ /^\S/ && namespace != '/'
     end
 
-    def has_path?
+    def path?
       raw_path && raw_path.to_s =~ /^\S/ && raw_path != '/'
     end
 
     def suffix
       if uses_specific_format?
         "(.#{settings[:format]})"
-      elsif !uses_path_versioning? || (has_namespace? || has_path?)
+      elsif !uses_path_versioning? || (namespace? || path?)
         '(.:format)'
       else
         '(/.:format)'

data/lib/grape/request.rb

@@ -0,0 +1,40 @@
+module Grape
+  class Request < Rack::Request
+    HTTP_PREFIX = 'HTTP_'.freeze
+
+    alias_method :rack_params, :params
+
+    def params
+      @params ||= build_params
+    end
+
+    def headers
+      @headers ||= build_headers
+    end
+
+    private
+
+    def build_params
+      params = Hashie::Mash.new(rack_params)
+      if env[Grape::Env::RACK_ROUTING_ARGS]
+        args = env[Grape::Env::RACK_ROUTING_ARGS].dup
+        # preserve version from query string parameters
+        args.delete(:version)
+        args.delete(:route_info)
+        params.deep_merge!(args)
+      end
+      params
+    end
+
+    def build_headers
+      headers = {}
+      env.each_pair do |k, v|
+        next unless k.to_s.start_with? HTTP_PREFIX
+
+        k = k[5..-1].split('_').each(&:capitalize!).join('-')
+        headers[k] = v
+      end
+      headers
+    end
+  end
+end

data/lib/grape/route.rb

@@ -1,10 +1,12 @@
 module Grape
   # A compiled route for inspection.
   class Route
+    # @api private
     def initialize(options = {})
       @options = options || {}
     end
 
+    # @api private
     def method_missing(method_id, *arguments)
       match = /route_([_a-zA-Z]\w*)/.match(method_id.to_s)
       if match
@@ -14,12 +16,15 @@ module Grape
       end
     end
 
+    # Generate a short, human-readable representation of this route.
     def to_s
       "version=#{route_version}, method=#{route_method}, path=#{route_path}"
     end
 
     private
 
+    # This is defined so that certain Ruby methods which attempt to call #to_ary
+    # on objects, e.g. Array#join, will not hit #method_missing.
     def to_ary
       nil
     end

data/lib/grape/util/content_types.rb

@@ -1,18 +1,18 @@
 module Grape
   module ContentTypes
     # Content types are listed in order of preference.
-    CONTENT_TYPES = ActiveSupport::OrderedHash[
-                    :xml,  'application/xml',
-                    :serializable_hash, 'application/json',
-                    :json, 'application/json',
-                    :binary, 'application/octet-stream',
-                    :txt,  'text/plain'
-   ]
+    CONTENT_TYPES = {
+      xml: 'application/xml',
+      serializable_hash: 'application/json',
+      json: 'application/json',
+      binary: 'application/octet-stream',
+      txt: 'text/plain'
+    }
 
     def self.content_types_for_settings(settings)
-      return nil if settings.nil? || settings.blank?
+      return if settings.blank?
 
-      settings.each_with_object(ActiveSupport::OrderedHash.new) { |value, result| result.merge!(value) }
+      settings.each_with_object({}) { |value, result| result.merge!(value) }
     end
 
     def self.content_types_for(from_settings)