support nested expose declarations

Author: wyattisimo

CHANGELOG.md

@@ -10,6 +10,7 @@ Next Release
 * [#28](https://github.com/intridea/grape-entity/pull/28): Look for method on entity before calling it on the object - [@MichaelXavier](https://github.com/MichaelXavier).
 * [#33](https://github.com/intridea/grape-entity/pull/33): Support proper merging of nested conditionals - [@wyattisimo](https://github.com/wyattisimo).
 * [#43](https://github.com/intridea/grape-entity/pull/43): Call procs in context of entity instance - [@joelvh](https://github.com/joelvh).
+* [#47](https://github.com/intridea/grape-entity/pull/47): Support nested exposures - [@wyattisimo](https://github.com/wyattisimo).
 * Your contribution here.
 
 0.3.0 (2013-03-29)

README.md

@@ -18,6 +18,10 @@ module API
       expose :text, documentation: { type: "String", desc: "Status update text." }
       expose :ip, if: { type: :full }
       expose :user_type, :user_id, if: lambda { |status, options| status.user.public? }
+      expose :contact_info do
+        expose :phone
+        expose :address, using: API::Address
+      end
       expose :digest do |status, options|
         Digest::MD5.hexdigest status.txt
       end
@@ -89,9 +93,23 @@ Don't raise an exception and expose as nil, even if the :x cannot be evaluated.
 expose :ip, safe: true
 ```
 
+#### Nested Exposure
+
+Supply a block to define a hash using nested exposures.
+
+```ruby
+expose :contact_info do
+  expose :phone
+  expose :address, using: API::Address
+end
+```
+
 #### Runtime Exposure
 
-Use a block or a `Proc` to evaluate exposure at runtime.
+Use a block or a `Proc` to evaluate exposure at runtime. The supplied block or
+`Proc` will be called with two parameters: the represented object and runtime options.
+
+**NOTE:** A block supplied with no parameters will be evaluated as a nested exposure (see above).
 
 ```ruby
 expose :digest do |status, options|

lib/grape_entity/entity.rb

@@ -132,10 +132,22 @@ def self.expose(*args, &block)
 
       raise ArgumentError, "You may not use block-setting when also using format_with" if block_given? && options[:format_with].respond_to?(:call)
 
-      options[:proc] = block if block_given?
+      options[:proc] = block if block_given? && block.parameters.any?
 
+      @nested_attributes ||= []
       args.each do |attribute|
+        unless @nested_attributes.empty?
+          attribute = "#{@nested_attributes.last}__#{attribute}"
+        end
+
         exposures[attribute.to_sym] = options
+
+        # Nested exposures are given in a block with no parameters.
+        if block_given? && block.parameters.empty?
+          @nested_attributes << attribute
+          block.call
+          @nested_attributes.pop
+        end
       end
     end
 
@@ -368,27 +380,33 @@ def to_xml(options = {})
 
     protected
 
+    def self.name_for(attribute)
+      attribute.to_s.split('__').last.to_sym
+    end
+
     def self.key_for(attribute)
-      exposures[attribute.to_sym][:as] || attribute.to_sym
+      exposures[attribute.to_sym][:as] || name_for(attribute)
     end
 
     def value_for(attribute, options = {})
       exposure_options = exposures[attribute.to_sym]
 
-      if exposure_options[:proc]
-        if exposure_options[:using]
-          using_options = options.dup
-          using_options.delete(:collection)
-          using_options[:root] = nil
-          exposure_options[:using].represent(instance_exec(object, options, &exposure_options[:proc]), using_options)
-        else
-          instance_exec(object, options, &exposure_options[:proc])
-        end
-      elsif exposure_options[:using]
+      nested_exposures = exposures.select { |a, _| a.to_s =~ /^#{attribute}__/ }
+
+      if exposure_options[:using]
         using_options = options.dup
         using_options.delete(:collection)
         using_options[:root] = nil
-        exposure_options[:using].represent(delegate_attribute(attribute), using_options)
+
+        if exposure_options[:proc]
+          exposure_options[:using].represent(instance_exec(object, options, &exposure_options[:proc]), using_options)
+        else
+          exposure_options[:using].represent(delegate_attribute(attribute), using_options)
+        end
+
+      elsif exposure_options[:proc]
+        instance_exec(object, options, &exposure_options[:proc])
+
       elsif exposure_options[:format_with]
         format_with = exposure_options[:format_with]
 
@@ -399,23 +417,30 @@ def value_for(attribute, options = {})
         elsif format_with.respond_to? :call
           instance_exec(delegate_attribute(attribute), &format_with)
         end
+
+      elsif nested_exposures.any?
+        Hash[nested_exposures.map do |nested_attribute, _|
+          [self.class.key_for(nested_attribute), value_for(nested_attribute, options)]
+        end]
+
       else
         delegate_attribute(attribute)
       end
     end
 
     def delegate_attribute(attribute)
-      if respond_to?(attribute, true)
-        send(attribute)
+      name = self.class.name_for(attribute)
+      if respond_to?(name, true)
+        send(name)
       else
-        object.send(attribute)
+        object.send(name)
       end
     end
 
     def valid_exposure?(attribute, exposure_options)
       exposure_options.has_key?(:proc) || \
       !exposure_options[:safe] || \
-      object.respond_to?(attribute)
+      object.respond_to?(self.class.name_for(attribute))
     end
 
     def conditions_met?(exposure_options, options)

spec/grape_entity/entity_spec.rb

@@ -36,17 +36,6 @@
           expect { subject.expose(:name, :email) { true } }.to raise_error ArgumentError
         end
 
-        it 'sets the :proc option in the exposure options' do
-          block = lambda { |_| true }
-          subject.expose :name, using: 'Awesome', &block
-          subject.exposures[:name].should == { proc: block, using: 'Awesome' }
-        end
-
-        it 'references an instance of the entity without any options' do
-          subject.expose(:size) { self }
-          subject.represent(Hash.new).send(:value_for, :size).should be_an_instance_of fresh_class
-        end
-
         it 'references an instance of the entity with :using option' do
           module EntitySpec
             class SomeObject1
@@ -74,6 +63,49 @@ class BogusEntity < Grape::Entity
           prop1 = value.send(:value_for, :prop1)
           prop1.should == "MODIFIED 2"
         end
+
+        context 'with parameters passed to the block' do
+          it 'sets the :proc option in the exposure options' do
+            block = lambda { |_| true }
+            subject.expose :name, using: 'Awesome', &block
+            subject.exposures[:name].should == { proc: block, using: 'Awesome' }
+          end
+
+          it 'references an instance of the entity without any options' do
+            subject.expose(:size) { |_| self }
+            subject.represent(Hash.new).send(:value_for, :size).should be_an_instance_of fresh_class
+          end
+        end
+
+        context 'with no parameters passed to the block' do
+          it 'adds a nested exposure' do
+            subject.expose :awesome do
+              subject.expose :nested do
+                subject.expose :moar_nested, as: 'weee'
+              end
+              subject.expose :another_nested, using: 'Awesome'
+            end
+
+            subject.exposures.should == {
+              awesome: {},
+              awesome__nested: {},
+              awesome__nested__moar_nested: { as: 'weee' },
+              awesome__another_nested: { using: 'Awesome' }
+            }
+          end
+
+          it 'represents the exposure as a hash of its nested exposures' do
+            subject.expose :awesome do
+              subject.expose(:nested) { |_| "value" }
+              subject.expose(:another_nested) { |_| "value" }
+            end
+
+            subject.represent({}).send(:value_for, :awesome).should == {
+              nested: "value",
+              another_nested: "value"
+            }
+          end
+        end
       end
 
       context 'inherited exposures' do
@@ -293,13 +325,13 @@ class BogusEntity < Grape::Entity
       end
 
       it 'returns a serialized hash of a single object if serializable: true' do
-        subject.expose(:awesome) { true }
+        subject.expose(:awesome) { |_| true }
         representation = subject.represent(Object.new, serializable: true)
         representation.should == { awesome: true }
       end
 
       it 'returns a serialized array of hashes of multiple objects if serializable: true' do
-        subject.expose(:awesome) { true }
+        subject.expose(:awesome) { |_| true }
         representation = subject.represent(2.times.map { Object.new }, serializable: true)
         representation.should == [{ awesome: true }, { awesome: true }]
       end