Adds before/after filters. Closes ruby-grape#58

Author: Michael Bleigh

README.markdown

@@ -48,6 +48,14 @@ Grape APIs are Rack applications that are created by subclassing `Grape::API`. B
           )
         end
       end
+
+      resource :account do
+        before{ authenticate! }
+
+        get '/private' do
+          "Congratulations, you found the secret!"
+        end
+      end
     end
 
 This would create a Rack application that could be used like so (in a Rackup config.ru file):

lib/grape/api.rb

@@ -150,7 +150,7 @@ def helpers(&block)
           m
         end
       end
-      
+
       # Add an authentication type to the API. Currently
       # only `:http_basic`, `:http_digest` and `:oauth2` are supported.
       def auth(type = nil, options = {}, &block)
@@ -160,7 +160,7 @@ def auth(type = nil, options = {}, &block)
           settings[:auth]
         end
       end
-      
+
       # Add HTTP Basic authorization to the API.
       #
       # @param [Hash] options A hash of options.
@@ -175,7 +175,7 @@ def http_digest(options = {}, &block)
         options[:opaque] ||= "secret"
         auth :http_digest, options, &block
       end
-      
+
       # Defines a route that will be recognized
       # by the Grape API.
       #
@@ -190,17 +190,17 @@ def http_digest(options = {}, &block)
       #   end
       def route(methods, paths = ['/'], route_options = {}, &block)
         methods = Array(methods)
-        
+
         paths = ['/'] if ! paths || paths == []
         paths = Array(paths)
-        
-        endpoint = build_endpoint(&block)        
-        
+
+        endpoint = build_endpoint(&block)
+
         endpoint_options = {}
         endpoint_options[:version] = /#{version.join('|')}/ if version
-        
+
         route_options ||= {}
-        
+
         methods.each do |method|
           paths.each do |path|
 
@@ -226,13 +226,23 @@ def route(methods, paths = ['/'], route_options = {}, &block)
           end
         end
       end
+
+      def before(&block)
+        settings_stack.last[:befores] ||= []
+        settings_stack.last[:befores] << block
+      end
 
+      def after(&block) 
+        settings_stack.last[:afters] ||= []
+        settings_stack.last[:afters] << block
+      end
+
       def get(paths = ['/'], options = {}, &block); route('GET', paths, options, &block) end
       def post(paths = ['/'], options = {}, &block); route('POST', paths, options, &block) end
       def put(paths = ['/'], options = {}, &block); route('PUT', paths, options, &block) end
       def head(paths = ['/'], options = {}, &block); route('HEAD', paths, options, &block) end
       def delete(paths = ['/'], options = {}, &block); route('DELETE', paths, options, &block) end
-      
+
       def namespace(space = nil, &block)
         if space || block_given?
           nest(block) do
@@ -296,7 +306,13 @@ def nest(*blocks, &block)
           instance_eval &block
         end
       end
-      
+
+      def aggregate_setting(key)
+        settings_stack.inject([]) do |befores, settings|
+          befores += (settings[key] || [])
+        end
+      end
+
       def build_endpoint(&block)
         b = Rack::Builder.new
         b.use Grape::Middleware::Error, 
@@ -313,7 +329,10 @@ def build_endpoint(&block)
         b.use Grape::Middleware::Formatter, :default_format => default_format || :json
         middleware.each{|m| b.use *m }
 
-        endpoint = Grape::Endpoint.generate(&block)
+        befores = aggregate_setting(:befores)
+        afters =  aggregate_setting(:afters)
+
+        endpoint = Grape::Endpoint.generate({:befores => befores, :afters => afters}, &block)
         endpoint.send :include, helpers
         b.run endpoint
 

lib/grape/endpoint.rb

@@ -7,16 +7,17 @@ module Grape
   # on the instance level of this class may be called
   # from inside a `get`, `post`, etc. block.
   class Endpoint
-    def self.generate(&block)
+    def self.generate(options = {}, &block)
       c = Class.new(Grape::Endpoint)
       c.class_eval do
         @block = block
+        @options = options
       end
       c
     end
 
     class << self
-      attr_accessor :block
+      attr_accessor :block, :options
     end
 
     def self.call(env)
@@ -73,15 +74,43 @@ def header(key = nil, val = nil)
         @header
       end
     end
-    
+
+    # Allows you to define the response body as something other than the
+    # return value.
+    #
+    # @example
+    #   get '/body' do
+    #     body "Body"
+    #     "Not the Body"
+    #   end
+    #
+    #   GET /body # => "Body"
+    def body(value = nil)
+      if value
+        @body = value
+      else
+        @body
+      end
+    end
+
     def call(env)
       @env = env
       @header = {}
       @request = Rack::Request.new(@env)
-      
+
+      run_filters self.class.options[:befores]
       response_text = instance_eval &self.class.block
-      
-      [status, header, [response_text]]
+      run_filters self.class.options[:afters]
+
+      [status, header, [body || response_text]]
+    end
+
+    protected
+
+    def run_filters(filters)
+      (filters || []).each do |filter|
+        instance_eval &filter
+      end
     end
   end
 end

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

spec/grape/endpoint_spec.rb

@@ -111,4 +111,32 @@ def memoized
     get '/hello?howdy=yo'
     last_response.body.should == 'yo'
   end
+
+  context 'filters' do
+    describe 'before filters' do
+      it 'should run the before filter if set' do
+        subject.before{ env['before_test'] = "OK" }
+        subject.get('/before_test'){ env['before_test'] }
+
+        get '/before_test'
+        last_response.body.should == "OK"
+      end
+    end
+
+    describe 'after filters' do
+      it 'should override the response body if it sets it' do
+        subject.after{ body "after" }
+        subject.get('/after_test'){ "during" }
+        get '/after_test'
+        last_response.body.should == 'after'
+      end
+
+      it 'should not override the response body with its return' do
+        subject.after{ "after" }
+        subject.get('/after_test'){ "body" }
+        get '/after_test'
+        last_response.body.should == "body"
+      end
+    end
+  end
 end