grape 0.3.0 → 0.7.0

data/lib/grape/middleware/error.rb

@@ -3,18 +3,18 @@ require 'grape/middleware/base'
 module Grape
   module Middleware
     class Error < Base
-
       def default_options
         {
-          :default_status => 403, # default status returned on error
-          :default_message => "",
-          :format => :txt,
-          :formatters => {},
-          :error_formatters => {},
-          :rescue_all => false, # true to rescue all exceptions
-          :rescue_options => { :backtrace => false }, # true to display backtrace
-          :rescue_handlers => {}, # rescue handler blocks
-          :rescued_errors => []
+          default_status: 500, # default status returned on error
+          default_message: "",
+          format: :txt,
+          formatters: {},
+          error_formatters: {},
+          rescue_all: false, # true to rescue all exceptions
+          rescue_subclasses: true, # rescue subclasses of exceptions listed
+          rescue_options: { backtrace: false }, # true to display backtrace
+          rescue_handlers: {}, # rescue handler blocks
+          base_only_rescue_handlers: {} # rescue handler blocks rescuing only the base class
         }
       end
 
@@ -22,49 +22,63 @@ module Grape
         @env = env
 
         begin
-          error_response(catch(:error){
+          error_response(catch(:error) do
             return @app.call(@env)
-          })
-        rescue Exception => e
+          end)
+        rescue StandardError => e
           is_rescuable = rescuable?(e.class)
           if e.is_a?(Grape::Exceptions::Base) && !is_rescuable
-            handler = lambda {|e| error_response(e) }
+            handler = lambda { |arg| error_response(arg) }
           else
             raise unless is_rescuable
-            handler = options[:rescue_handlers][e.class] || options[:rescue_handlers][:all]
+            handler = find_handler(e.class)
           end
-          handler.nil? ? handle_error(e) : self.instance_exec(e, &handler)
+
+          handler.nil? ? handle_error(e) : exec_handler(e, &handler)
         end
       end
 
+      def find_handler(klass)
+        handler = options[:rescue_handlers].find(-> { [] }) { |error, _| klass <= error }[1]
+        handler = options[:base_only_rescue_handlers][klass] || options[:base_only_rescue_handlers][:all] unless handler
+        handler
+      end
+
       def rescuable?(klass)
-        options[:rescue_all] || (options[:rescued_errors] || []).include?(klass)
+        options[:rescue_all] || (options[:rescue_handlers] || []).any? { |error, handler| klass <= error } || (options[:base_only_rescue_handlers] || []).include?(klass)
+      end
+
+      def exec_handler(e, &handler)
+        if handler.lambda? && handler.arity == 0
+          instance_exec(&handler)
+        else
+          instance_exec(e, &handler)
+        end
       end
 
       def handle_error(e)
-        error_response({ :message => e.message, :backtrace => e.backtrace })
+        error_response(message: e.message, backtrace: e.backtrace)
       end
 
       def error_response(error = {})
         status = error[:status] || options[:default_status]
         message = error[:message] || options[:default_message]
-        headers = {'Content-Type' => content_type}
+        headers = { 'Content-Type' => content_type }
         headers.merge!(error[:headers]) if error[:headers].is_a?(Hash)
         backtrace = error[:backtrace] || []
         rack_response(format_message(message, backtrace), status, headers)
       end
 
       def rack_response(message, status = options[:default_status], headers = { 'Content-Type' => content_type })
-        Rack::Response.new([ message ], status, headers).finish
+        Rack::Response.new([message], status, headers).finish
       end
 
       def format_message(message, backtrace)
         format = 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
+        throw :error, status: 406, message: "The requested format '#{format}' is not supported." unless formatter
         formatter.call(message, backtrace, options, env)
       end
-
     end
   end
 end

data/lib/grape/middleware/filter.rb

@@ -3,14 +3,14 @@ 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: lambda { do_something }, after: lambda { do_something }
     class Filter < Base
       def before
-        app.instance_eval &options[:before] if options[:before]
+        app.instance_eval(&options[:before]) if options[:before]
       end
 
       def after
-        app.instance_eval &options[:after] if options[:after]
+        app.instance_eval(&options[:after]) if options[:after]
       end
     end
   end

data/lib/grape/middleware/formatter.rb

@@ -3,17 +3,19 @@ require 'grape/middleware/base'
 module Grape
   module Middleware
     class Formatter < Base
-
       def default_options
         {
-          :default_format => :txt,
-          :formatters => {},
-          :parsers => {}
+          default_format: :txt,
+          formatters: {},
+          parsers: {}
         }
       end
 
       def headers
-        env.dup.inject({}){|h,(k,v)| h[k.to_s.downcase[5..-1]] = v if k.to_s.downcase.start_with?('http_'); h}
+        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
@@ -23,13 +25,15 @@ module Grape
 
       def after
         status, headers, bodies = *@app_response
-        formatter = Grape::Formatter::Base.formatter_for env['api.format'], options
+        # allow content-type to be explicitly overwritten
+        api_format = mime_types[headers["Content-Type"]] || env['api.format']
+        formatter = Grape::Formatter::Base.formatter_for api_format, options
         begin
           bodymap = bodies.collect do |body|
             formatter.call body, env
           end
-        rescue Exception => e
-          throw :error, :status => 500, :message => e.message
+        rescue Grape::Exceptions::InvalidFormatter => e
+          throw :error, status: 500, message: e.message
         end
         headers['Content-Type'] = content_type_for(env['api.format']) unless headers['Content-Type']
         Rack::Response.new(bodymap, status, headers).to_a
@@ -37,76 +41,110 @@ module Grape
 
       private
 
-        def read_body_input
-          if (request.post? || request.put? || request.patch?) && (! request.form_data?) && (! request.parseable_data?) && (request.content_length.to_i > 0)
-            if env['rack.input'] && (body = env['rack.input'].read).length > 0
-              begin
-                fmt = mime_types[request.media_type] if request.media_type
-                if content_type_for(fmt)
-                  parser = Grape::Parser::Base.parser_for fmt, options
-                  unless parser.nil?
-                    begin
-                      body = parser.call body, env
-                      env['rack.request.form_hash'] = env['rack.request.form_hash'] ? env['rack.request.form_hash'].merge(body) : body
-                      env['rack.request.form_input'] = env['rack.input']
-                    rescue Exception => e
-                      throw :error, :status => 400, :message => e.message
-                    end
-                  end
-                else
-                  throw :error, :status => 406, :message => "The requested content-type '#{request.media_type}' is not supported."
-                end
-              ensure
-                env['rack.input'].rewind
-              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['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
         end
+      end
 
-        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
+      # store parsed input in env['api.request.body']
+      def read_rack_input(body)
+        fmt = mime_types[request.media_type] if request.media_type
+        fmt ||= options[:default_format]
+        if content_type_for(fmt)
+          parser = Grape::Parser::Base.parser_for fmt, options
+          if parser
+            begin
+              body = (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)
+                else
+                  env['rack.request.form_hash'] = body
+                end
+                env['rack.request.form_input'] = env['rack.input']
+              end
+            rescue StandardError => e
+              throw :error, status: 400, message: e.message
+            end
           else
-            throw :error, :status => 406, :message => "The requested format '#{fmt}' is not supported."
+            env['api.request.body'] = body
           end
+        else
+          throw :error, status: 406, message: "The requested content-type '#{request.media_type}' is not supported."
         end
+      end
 
-        def format_from_extension
-          parts = request.path.split('.')
-
-          if parts.size > 1
-            extension = parts.last
-            # avoid symbol memory leak on an unknown format
-            return extension.to_sym if content_type_for(extension)
-          end
-          nil
+      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
+        else
+          throw :error, status: 406, message: "The requested format '#{fmt}' is not supported."
         end
+      end
+
+      def format_from_extension
+        parts = request.path.split('.')
 
-        def format_from_params
-          fmt = Rack::Utils.parse_nested_query(env['QUERY_STRING'])["format"]
+        if parts.size > 1
+          extension = parts.last
           # avoid symbol memory leak on an unknown format
-          return fmt.to_sym if content_type_for(fmt)
-          fmt
+          return extension.to_sym if content_type_for(extension)
         end
+        nil
+      end
 
-        def format_from_header
-          mime_array.each do |t|
-            if mime_types.key?(t)
-              return mime_types[t]
-            end
-          end
-          nil
+      def format_from_params
+        fmt = Rack::Utils.parse_nested_query(env['QUERY_STRING'])["format"]
+        # avoid symbol memory leak on an unknown format
+        return fmt.to_sym if content_type_for(fmt)
+        fmt
+      end
+
+      def format_from_header
+        mime_array.each do |t|
+          return mime_types[t] if mime_types.key?(t)
         end
+        nil
+      end
 
-        def mime_array
-          accept = headers['accept'] or return []
+      def mime_array
+        accept = headers['accept']
+        return [] unless accept
 
-          accept.gsub(/\b/,'').scan(%r((\w+/[\w+.-]+)(?:(?:;[^,]*?)?;\s*q=([\d.]+))?)).sort_by { |_, q| -q.to_f }.map {|mime, _|
-            mime.sub(%r(vnd\.[^+]+\+), '')
-          }
-        end
+        accept_into_mime_and_quality = %r(
+          (
+            \w+/[\w+.-]+)     # eg application/vnd.example.myformat+xml
+          (?:
+           (?:;[^,]*?)?       # optionally multiple formats in a row
+           ;\s*q=([\d.]+)     # 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 }
+          .map { |mime, _| mime.sub(vendor_prefix_pattern, '') }
+      end
     end
   end
 end

data/lib/grape/middleware/globals.rb

@@ -0,0 +1,13 @@
+require 'grape/middleware/base'
+
+module Grape
+  module Middleware
+    class Globals < Base
+      def before
+        @env['grape.request'] = Grape::Request.new(@env)
+        @env['grape.request.headers'] = request.headers
+        @env['grape.request.params'] = request.params if @env['rack.input']
+      end
+    end
+  end
+end

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

@@ -0,0 +1,67 @@
+require 'grape/middleware/base'
+
+module Grape
+  module Middleware
+    module Versioner
+      # This middleware sets various version related rack environment variables
+      # based on the HTTP Accept-Version header
+      #
+      # Example: For request header
+      #    Accept-Version: v1
+      #
+      # The following rack env variables are set:
+      #
+      #    env['api.version']  => 'v1'
+      #
+      # If version does not match this route, then a 406 is raised with
+      # X-Cascade header to alert Rack::Mount to attempt the next matched
+      # route.
+      class AcceptVersionHeader < Base
+        def before
+          potential_version = (env['HTTP_ACCEPT_VERSION'] || '').strip
+
+          if strict?
+            # If no Accept-Version header:
+            if potential_version.empty?
+              throw :error, status: 406, headers: error_headers, message: 'Accept-Version header must be set.'
+            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
+
+            env['api.version'] = potential_version
+          end
+        end
+
+        private
+
+        def versions
+          options[:versions] || []
+        end
+
+        def strict?
+          options[:version_options] && options[:version_options][:strict]
+        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`.
+        def cascade?
+          if options[:version_options] && options[:version_options].has_key?(:cascade)
+            !!options[:version_options][:cascade]
+          else
+            true
+          end
+        end
+
+        def error_headers
+          cascade? ? { 'X-Cascade' => 'pass' } : {}
+        end
+      end
+    end
+  end
+end

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

@@ -22,22 +22,25 @@ module Grape
       # X-Cascade header to alert Rack::Mount to attempt the next matched
       # route.
       class Header < Base
-
         def before
-          header = Rack::Accept::MediaType.new env['HTTP_ACCEPT']
+          begin
+            header = Rack::Accept::MediaType.new env['HTTP_ACCEPT']
+          rescue RuntimeError => e
+            throw :error, status: 406, headers: error_headers, message: e.message
+          end
 
           if strict?
             # If no Accept header:
             if header.qvalues.empty?
-              throw :error, :status => 406, :headers => error_headers, :message => 'Accept header must be set.'
+              throw :error, status: 406, headers: error_headers, message: 'Accept header must be set.'
             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 == '*'}
+            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?
-              throw :error, :status => 406, :headers => error_headers, :message => 'Accept header must not contain ranges ("*").'
+              throw :error, status: 406, headers: error_headers, message: 'Accept header must not contain ranges ("*").'
             end
           end
 
@@ -55,19 +58,19 @@ module Grape
             end
           # If none of the available content types are acceptable:
           elsif strict?
-            throw :error, :status => 406, :headers => error_headers, :message => '406 Not Acceptable'
+            throw :error, status: 406, headers: error_headers, message: '406 Not Acceptable'
           # If all acceptable content types specify a vendor or version that doesn't exist:
-          elsif header.values.all?{ |media_type| has_vendor?(media_type) || has_version?(media_type)}
-            throw :error, :status => 406, :headers => error_headers, :message => 'API vendor or version not found.'
+          elsif header.values.all? { |header_value| has_vendor?(header_value) || has_version?(header_value) }
+            throw :error, status: 406, headers: error_headers, message: 'API vendor or version not found.'
           end
         end
 
-      private
+        private
 
         def available_media_types
           available_media_types = []
 
-          content_types.each do |extension,media_type|
+          content_types.each do |extension, media_type|
             versions.reverse.each do |version|
               available_media_types += ["application/vnd.#{vendor}-#{version}+#{extension}", "application/vnd.#{vendor}-#{version}"]
             end
@@ -76,7 +79,7 @@ module Grape
 
           available_media_types << "application/vnd.#{vendor}"
 
-          content_types.each do |_,media_type|
+          content_types.each do |_, media_type|
             available_media_types << media_type
           end
 
@@ -99,7 +102,11 @@ module Grape
         # 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?
-          options[:version_options] && (options[:version_options].has_key?(:cascade) ? options[:version_options][:cascade] : true)
+          if options[:version_options] && options[:version_options].has_key?(:cascade)
+            !!options[:version_options][:cascade]
+          else
+            true
+          end
         end
 
         def error_headers
@@ -109,17 +116,16 @@ module Grape
         # @param [String] media_type a content type
         # @return [Boolean] whether the content type sets a vendor
         def has_vendor?(media_type)
-          type, subtype = Rack::Accept::Header.parse_media_type media_type
+          _, subtype = Rack::Accept::Header.parse_media_type media_type
           subtype[/\Avnd\.[a-z0-9*.]+/]
         end
 
         # @param [String] media_type a content type
         # @return [Boolean] whether the content type sets an API version
         def has_version?(media_type)
-          type, subtype = Rack::Accept::Header.parse_media_type media_type
+          _, subtype = Rack::Accept::Header.parse_media_type media_type
           subtype[/\Avnd\.[a-z0-9*.]+-[a-z0-9*\-.]+/]
         end
-
       end
     end
   end

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

@@ -4,40 +4,38 @@ module Grape
   module Middleware
     module Versioner
       # This middleware sets various version related rack environment variables
-      # based on the request parameters and removes that parameter from the 
+      # based on the request parameters and removes that parameter from the
       # request parameters for subsequent middleware and API.
       # If the version substring does not match any potential initialized
       # versions, a 404 error is thrown.
       # If the version substring is not passed the version (highest mounted)
       # version will be used.
-      # 
+      #
       # Example: For a uri path
       #   /resource?apiver=v1
-      # 
+      #
       # The following rack env variables are set and path is rewritten to
       # '/resource':
-      # 
+      #
       #   env['api.version'] => 'v1'
       class Param < Base
         def default_options
           {
-            :parameter => "apiver"
+            parameter: "apiver"
           }
         end
 
         def before
           paramkey = options[:parameter]
-          potential_version = request.params[paramkey]
-
+          potential_version = Rack::Utils.parse_nested_query(env['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 => {'X-Cascade' => 'pass'}
+            if options[:versions] && !options[:versions].find { |v| v.to_s == potential_version }
+              throw :error, status: 404, message: "404 API Version Not Found", headers: { 'X-Cascade' => 'pass' }
             end
             env['api.version'] = potential_version
-            env['rack.request.query_hash'].delete(paramkey)
+            env['rack.request.query_hash'].delete(paramkey) if env.key? 'rack.request.query_hash'
           end
         end
-
       end
     end
   end

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

@@ -7,19 +7,19 @@ module Grape
       # based on the uri path and removes the version substring from the uri
       # path. If the version substring does not match any potential initialized
       # versions, a 404 error is thrown.
-      # 
+      #
       # Example: For a uri path
       #   /v1/resource
-      # 
+      #
       # The following rack env variables are set and path is rewritten to
       # '/resource':
-      # 
+      #
       #   env['api.version'] => 'v1'
-      # 
+      #
       class Path < Base
         def default_options
           {
-            :pattern => /.*/i
+            pattern: /.*/i
           }
         end
 
@@ -34,21 +34,18 @@ 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"
+            if options[:versions] && !options[:versions].find { |v| v.to_s == potential_version }
+              throw :error, status: 404, message: "404 API Version Not Found"
             end
-
-            truncated_path = "/#{pieces[2..-1].join('/')}"
             env['api.version'] = potential_version
           end
         end
 
         private
 
-          def prefix
-            Rack::Mount::Utils.normalize_path(options[:prefix].to_s) if options[:prefix]
-          end
-
+        def prefix
+          Rack::Mount::Utils.normalize_path(options[:prefix].to_s) if options[:prefix]
+        end
       end
     end
   end

data/lib/grape/middleware/versioner.rb

@@ -9,7 +9,7 @@
 module Grape
   module Middleware
     module Versioner
-      extend self
+      module_function
 
       # @param strategy [Symbol] :path, :header or :param
       # @return a middleware class based on strategy
@@ -21,6 +21,8 @@ module Grape
           Header
         when :param
           Param
+        when :accept_version_header
+          AcceptVersionHeader
         else
           raise Grape::Exceptions::InvalidVersionerOption.new(strategy)
         end

data/lib/grape/namespace.rb

@@ -0,0 +1,23 @@
+module Grape
+  class Namespace
+    attr_reader :space, :options
+
+    # options:
+    #   requirements: a hash
+    def initialize(space, options = {})
+      @space, @options = space.to_s, options
+    end
+
+    def requirements
+      options[:requirements] || {}
+    end
+
+    def self.joined_space(settings)
+      settings.gather(:namespace).map(&:space).join("/")
+    end
+
+    def self.joined_space_path(settings)
+      Rack::Mount::Utils.normalize_path(joined_space(settings))
+    end
+  end
+end