grape 0.1.5 → 0.2.0

data/lib/grape/middleware/auth/oauth2.rb

@@ -60,13 +60,12 @@ module Grape::Middleware::Auth
     end
     
     def error_out(status, error)
-      throw :error, {
+      throw :error,
         :message => error,
         :status => status,
         :headers => {
           'WWW-Authenticate' => "OAuth realm='#{options[:realm]}', error='#{error}'"
         }
-      }
     end
   end
 end

data/lib/grape/middleware/base.rb

@@ -1,3 +1,6 @@
+require 'multi_json'
+require 'multi_xml'
+
 module Grape
   module Middleware
     class Base
@@ -9,20 +12,20 @@ module Grape
         @app = app
         @options = default_options.merge(options)
       end
-      
+
       def default_options; {} end
-      
+
       def call(env)
         dup.call!(env)
       end
-      
+
       def call!(env)
         @env = env
         before
         @app_response = @app.call(@env)
         after || @app_response
       end
-      
+
       # @abstract
       # Called before the application is called in the middleware lifecycle.
       def before; end
@@ -30,11 +33,11 @@ module Grape
       # Called after the application is called in the middleware lifecycle.
       # @return [Response, nil] a Rack SPEC response or nil to call the application afterwards.
       def after; end
-      
+
       def request
         Rack::Request.new(self.env)
       end
-      
+
       def response
         Rack::Response.new(@app_response)
       end
@@ -52,12 +55,21 @@ module Grape
         FORMATTERS = {
           :json => :encode_json,
           :txt => :encode_txt,
+          :xml => :encode_xml
+        }
+        PARSERS = {
+          :json => :decode_json,
+          :xml => :decode_xml
         }
 
         def formatters
           FORMATTERS.merge(options[:formatters] || {})
         end
 
+        def parsers
+          PARSERS.merge(options[:parsers] || {})
+        end
+
         def content_types
           CONTENT_TYPES.merge(options[:content_types] || {})
         end
@@ -82,6 +94,47 @@ module Grape
           end
         end
 
+        def parser_for(api_format)
+          spec = parsers[api_format]
+          case spec
+          when nil
+            nil
+          when Symbol
+            method(spec)
+          else
+            spec
+          end
+        end
+
+        def decode_json(object)
+          MultiJson.decode(object)
+        end
+
+        def encode_json(object)
+          return object if object.is_a?(String)
+
+          if object.respond_to? :serializable_hash
+            MultiJson.encode(object.serializable_hash)
+          elsif object.kind_of?(Array) && !object.map {|o| o.respond_to? :serializable_hash }.include?(false)
+            MultiJson.encode(object.map {|o| o.serializable_hash })
+          elsif object.respond_to? :to_json
+            object.to_json
+          else
+            MultiJson.encode(object)
+          end
+        end
+
+        def encode_txt(object)
+          object.respond_to?(:to_txt) ? object.to_txt : object.to_s
+        end
+
+        def decode_xml(object)
+          MultiXml.parse(object)
+        end
+
+        def encode_xml(object)
+          object.respond_to?(:to_xml) ? object.to_xml : object.to_s
+        end
       end
 
     end

data/lib/grape/middleware/error.rb

@@ -12,9 +12,9 @@ module Grape
         :default_message => "",
         :format => :txt,
         :formatters => {},
-
         :rescue_all => false, # true to rescue all exceptions        
-        :rescue_options => {:backtrace => false}, # true to display backtrace
+        :rescue_options => { :backtrace => false }, # true to display backtrace
+        :rescue_handlers => {}, # rescue handler blocks
         :rescued_errors => []
       }
       end
@@ -45,23 +45,32 @@ module Grape
           })
         rescue Exception => e
           raise unless options[:rescue_all] || (options[:rescued_errors] || []).include?(e.class)
-          error_response({ :message => e.message, :backtrace => e.backtrace })
+          handler = options[:rescue_handlers][e.class] || options[:rescue_handlers][:all]
+          handler.nil? ? handle_error(e) : self.instance_exec(e, &handler)
         end
         
       end
       
+      def handle_error(e)
+        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.merge!(error[:headers]) if error[:headers].is_a?(Hash)
         backtrace = error[:backtrace] || []
-        Rack::Response.new([format_message(message, backtrace, status)], status, headers).finish
+        rack_response(format_message(message, backtrace, status), status, headers)
       end
-      
+
+      def rack_response(message, status = options[:default_status], headers = { 'Content-Type' => content_type })
+        Rack::Response.new([ message ], status, headers).finish
+      end
+            
       def format_message(message, backtrace, status)
         formatter = formatter_for(options[:format])
-        throw :error, :status => 406, :message => "The requested format #{options[:format]} is not supported." unless formatter        
+        throw :error, :status => 406, :message => "The requested format #{options[:format]} is not supported." unless formatter
         formatter.call(message, backtrace)
       end
       

data/lib/grape/middleware/filter.rb

@@ -0,0 +1,17 @@
+module Grape
+  module Middleware
+    # 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 }
+    class Filter < Base
+      def before
+        app.instance_eval &options[:before] if options[:before]
+      end
+
+      def after
+        app.instance_eval &options[:after] if options[:after]
+      end
+    end
+  end
+end

data/lib/grape/middleware/formatter.rb

@@ -1,5 +1,4 @@
 require 'grape/middleware/base'
-require 'multi_json'
 
 module Grape
   module Middleware
@@ -7,22 +6,35 @@ module Grape
       include Formats
 
       def default_options
-        { 
+        {
           :default_format => :txt,
           :formatters => {},
-          :content_types => {}
+          :content_types => {},
+          :parsers => {}
         }
       end
       
       def headers
-        env.dup.inject({}){|h,(k,v)| h[k.downcase] = v; h}
+        env.dup.inject({}){|h,(k,v)| h[k.downcase[5..-1]] = v if k.downcase.start_with?('http_'); h}
       end
       
       def before
-        fmt = format_from_extension || format_from_header || options[:default_format]
-                
+        fmt = format_from_extension || options[:format] || format_from_header || options[:default_format]
         if content_types.key?(fmt)
-          env['api.format'] = fmt          
+          if !env['rack.input'].nil? and (body = env['rack.input'].read).strip.length != 0
+            parser = parser_for fmt
+            unless parser.nil?
+              begin
+                body = parser.call(body)
+                env['rack.request.form_hash'] = !env['rack.request.form_hash'].nil? ? env['rack.request.form_hash'].merge(body) : body
+                env['rack.request.form_input'] = env['rack.input']
+              rescue
+                # It's possible that it's just regular POST content -- just back off
+              end
+            end
+            env['rack.input'].rewind
+          end
+          env['api.format'] = fmt
         else
           throw :error, :status => 406, :message => 'The requested format is not supported.'
         end
@@ -40,7 +52,7 @@ module Grape
       end
       
       def format_from_header
-        mime_array.each do |t| 
+        mime_array.each do |t|
           if mime_types.key?(t)
             return mime_types[t]
           end
@@ -49,15 +61,11 @@ module Grape
       end
       
       def mime_array
-        accept = headers['accept']
-        if accept
-          accept.gsub(/\b/,'').
-            scan(/(\w+\/[\w+]+)(?:;[^,]*q=([0-9.]+)[^,]*)?/i).
-            sort_by{|a| -a[1].to_f}.
-            map{|a| a[0]}
-        else
-          []
-        end
+        accept = headers['accept'] or return []
+
+        accept.gsub(/\b/,'').scan(%r((\w+/[\w+.-]+)(?:(?:;[^,]*?)?;\s*q=([\d.]+))?)).sort_by { |_, q| -q.to_f }.map {|mime, _|
+          mime.sub(%r(vnd\.[^+]+\+), '')
+        }
       end
       
       def after
@@ -69,20 +77,6 @@ module Grape
         headers['Content-Type'] = content_types[env['api.format']]
         Rack::Response.new(bodymap, status, headers).to_a
       end
-
-      def encode_json(object)
-        if object.respond_to? :serializable_hash
-          MultiJson.encode(object.serializable_hash)
-        elsif object.respond_to? :to_json
-          object.to_json
-        else
-          MultiJson.encode(object)
-        end
-      end
-      
-      def encode_txt(object)
-        object.respond_to?(:to_txt) ? object.to_txt : object.to_s
-      end
     end
   end
 end

data/lib/grape/middleware/versioner.rb

@@ -1,25 +1,25 @@
-require 'grape/middleware/base'
-
+# Versioners set env['api.version'] when a version is defined on an API and
+# on the requests. The current methods for determining version are:
+#
+#   :header - version from HTTP Accept header.
+#   :path   - version from uri. e.g. /v1/resource
+#
+# See individual classes for details.
 module Grape
   module Middleware
-    class Versioner < Base
-      def default_options
-        {
-          :pattern => /.*/i
-        }
-      end
-      
-      def before
-        pieces = env['PATH_INFO'].split('/')
-        potential_version = pieces[1]
-        if potential_version =~ options[:pattern]
-          if options[:versions] && !options[:versions].include?(potential_version)
-            throw :error, :status => 404, :message => "404 API Version Not Found"
-          end
-          
-          truncated_path = "/#{pieces[2..-1].join('/')}"
-          env['api.version'] = potential_version
-          env['PATH_INFO'] = truncated_path
+    module Versioner
+      extend self
+
+      # @param strategy [Symbol] :path or :header
+      # @return a middleware class based on strategy
+      def using(strategy)
+        case strategy
+        when :path
+          Path
+        when :header
+          Header
+        else
+          raise ArgumentError.new("Unknown :using for versioner: #{strategy}")
         end
       end
     end

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

@@ -0,0 +1,59 @@
+require 'grape/middleware/base'
+
+module Grape
+  module Middleware
+    module Versioner
+      # This middleware sets various version related rack environment variables
+      # based on the HTTP Accept header with the pattern:
+      # application/vnd.:vendor-:version+:format
+      #
+      # Example: For request header
+      #    Accept: application/vnd.mycompany-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.version]  => 'v1'
+      #    env['api.format]   => 'format'
+      #
+      # If version does not match this route, then a 406 is throw with
+      # X-Cascade header to alert Rack::Mount to attempt the next matched
+      # route.
+      class Header < Base
+        def before
+          accept = env['HTTP_ACCEPT'] || ""
+
+          if options[:version_options] && options[:version_options].keys.include?(:strict) && options[:version_options][:strict]
+            if (is_accept_header_valid?(accept))  && options[:version_options][:using] == :header
+              throw :error, :status => 406, :headers => {'X-Cascade' => 'pass'}, :message => "406 API Version Not Found"
+            end
+          end
+          accept.strip.scan(/^(.+?)\/(.+?)$/) do |type, subtype|
+            env['api.type']    = type
+            env['api.subtype'] = subtype
+
+            subtype.scan(/vnd\.(.+)?-(.+)?\+(.*)?/) do |vendor, version, format|
+              is_vendored = options[:version_options] && options[:version_options][:vendor]
+              is_vendored_match = is_vendored ? options[:version_options][:vendor] == vendor : true
+
+              if (options[:versions] && !options[:versions].include?(version)) || !is_vendored_match
+                throw :error, :status => 406, :headers => {'X-Cascade' => 'pass'}, :message => "406 API Version Not Found"
+              end
+
+              env['api.version'] = version
+              env['api.vendor']  = vendor
+              env['api.format']  = format  # weird that Grape::Middleware::Formatter also does this
+            end
+          end
+        end
+
+        protected
+        def is_accept_header_valid?(header)
+          (header.strip =~ /application\/vnd\.(.+?)-(.+?)\+(.+?)/).nil?
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,42 @@
+require 'grape/middleware/base'
+
+module Grape
+  module Middleware
+    module Versioner
+      # This middleware sets various version related rack environment variables
+      # 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
+          }
+        end
+
+        def before
+          pieces = env['PATH_INFO'].split('/')
+          potential_version = pieces[1]
+          if potential_version =~ options[:pattern]
+            if options[:versions] && !options[:versions].include?(potential_version)
+              throw :error, :status => 404, :message => "404 API Version Not Found"
+            end
+
+            truncated_path = "/#{pieces[2..-1].join('/')}"
+            env['api.version'] = potential_version
+            env['PATH_INFO'] = truncated_path
+          end
+        end
+      end
+    end
+  end
+end

data/lib/grape/route.rb

@@ -0,0 +1,23 @@
+module Grape
+
+  # A compiled route for inspection.
+  class Route
+  
+    def initialize(options = {})
+      @options = options || {}
+    end
+    
+    def method_missing(method_id, *arguments)
+      if match = /route_([_a-zA-Z]\w*)/.match(method_id.to_s)
+        @options[match.captures.last.to_sym]
+      else
+        super
+      end
+    end
+    
+    def to_s
+      "version=#{route_version}, method=#{route_method}, path=#{route_path}"
+    end
+    
+  end
+end