Adds exposures that are block-driven.

Author: Michael Bleigh

lib/grape/entity.rb

@@ -10,10 +10,11 @@ module Grape
   #   module API
   #     module Entities
   #       class User < Grape::Endpoint
-  #         expose :name, :screen_name, :location
+  #         expose :first_name, :last_name, :screen_name, :location
   #         expose :latest_status, :using => API::Status, :as => :status, :unless => {:collection => true}
   #         expose :email, :if => {:type => :full}
   #         expose :new_attribute, :if => {:version => 'v2'}
+  #         expose(:name){|model,options| [model.first_name, model.last_name].join(' ')}
   #       end
   #     end
   #   end
@@ -57,13 +58,21 @@ class Entity
     #   automatically be transformed into a representation that will receive the same
     #   options as the parent entity when called. Note that arrays are fine here and
     #   will automatically be detected and handled appropriately.
-    def self.expose(*args)
+    # @option options :proc If you pass a Proc into this option, it will
+    #   be used directly to determine the value for that attribute. It
+    #   will be called with the represented object as well as the
+    #   runtime options that were passed in. You can also just supply a
+    #   block to the expose call to achieve the same effect.
+    def self.expose(*args, &block)
       options = args.last.is_a?(Hash) ? args.pop : {}
 
-      if options[:as] && args.size > 1
-        raise ArgumentError, "You may not use the :as option on multi-attribute exposures."
+      if args.size > 1
+        raise ArgumentError, "You may not use the :as option on multi-attribute exposures." if options[:as]
+        raise ArgumentError, "You may not use block-setting on multi-attribute exposures." if block_given?
       end
 
+      options[:proc] = block if block_given?
+
       args.each do |attribute|
         exposures[attribute.to_sym] = options
       end
@@ -108,9 +117,10 @@ def exposures
     # @param options [Hash] Any options you pass in here will be known to the entity
     #   representation, this is where you can trigger things from conditional options
     #   etc.
-    def serializable_hash(options = {})
+    def serializable_hash(runtime_options = {})
+      opts = options.merge(runtime_options)
       exposures.inject({}) do |output, (attribute, exposure_options)|
-        output[key_for(attribute)] = value_for(attribute) if conditions_met?(exposure_options, options)
+        output[key_for(attribute)] = value_for(attribute, opts) if conditions_met?(exposure_options, opts)
         output
       end
     end
@@ -123,10 +133,12 @@ def key_for(attribute)
       exposures[attribute.to_sym][:as] || attribute.to_sym
     end
 
-    def value_for(attribute)
+    def value_for(attribute, options = {})
       exposure_options = exposures[attribute.to_sym]
 
-      if exposure_options[:using]
+      if exposure_options[:proc]
+        exposure_options[:proc].call(object, options)
+      elsif exposure_options[:using]
         exposure_options[:using].represent(object.send(attribute))
       else
         object.send(attribute)

spec/grape/entity_spec.rb

@@ -25,6 +25,20 @@
           expect{ subject.expose :name, :as => :foo }.not_to raise_error
         end
       end
+
+      context 'with a block' do
+        it 'should error out if called with multiple attributes' do
+          expect{ subject.expose(:name, :email) do
+            true
+          end }.to raise_error(ArgumentError)
+        end
+
+        it 'should set the :proc option in the exposure options' do
+          block = lambda{|obj,opts| true }
+          subject.expose :name, &block
+          subject.exposures[:name][:proc].should == block
+        end
+      end
     end
 
     describe '.represent' do
@@ -80,6 +94,9 @@
         fresh_class.class_eval do
           expose :name, :email
           expose :friends, :using => self
+          expose :computed do |object, options|
+            options[:awesome]
+          end
         end
       end
 
@@ -93,6 +110,10 @@
         rep.first.serializable_hash[:name].should == 'Friend 1'
         rep.last.serializable_hash[:name].should == 'Friend 2'
       end
+
+      it 'should call through to the proc if there is one' do
+        subject.send(:value_for, :computed, :awesome => 123).should == 123
+      end
     end
 
     describe '#key_for' do