Added 'only' option that selects which attributes should be returned.

estevaoam · dblock · commit 6375f15647ff · 2015-03-16T07:44:35.000-04:00
diff --git a/.rubocop_todo.yml b/.rubocop_todo.yml
@@ -1,32 +1,32 @@
 # This configuration was generated by `rubocop --auto-gen-config`
-# on 2014-12-11 15:27:22 -0500 using RuboCop version 0.28.0.
+# on 2015-03-16 03:40:21 -0300 using RuboCop version 0.28.0.
 # The point is for the user to remove these configuration records
 # one by one as the offenses are removed from the code base.
 # Note that changes in the inspected code, or installation of new
 # versions of RuboCop, may require this file to be generated again.
 
-# Offense count: 5
+# Offense count: 7
 Metrics/AbcSize:
-  Max: 53
+  Max: 51
 
 # Offense count: 1
 # Configuration parameters: CountComments.
 Metrics/ClassLength:
-  Max: 301
+  Max: 323
 
-# Offense count: 4
+# Offense count: 5
 Metrics/CyclomaticComplexity:
   Max: 17
 
-# Offense count: 175
+# Offense count: 187
 # Configuration parameters: AllowURI, URISchemes.
 Metrics/LineLength:
   Max: 147
 
-# Offense count: 6
+# Offense count: 7
 # Configuration parameters: CountComments.
 Metrics/MethodLength:
-  Max: 34
+  Max: 32
 
 # Offense count: 4
 Metrics/PerceivedComplexity:
@@ -37,11 +37,11 @@ Metrics/PerceivedComplexity:
 Style/Blocks:
   Enabled: false
 
-# Offense count: 30
+# Offense count: 31
 Style/Documentation:
   Enabled: false
 
-# Offense count: 2
+# Offense count: 3
 Style/EachWithObject:
   Enabled: false
 
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -1,6 +1,7 @@
 0.4.6 (Next)
 ============
 
+* [#114](https://github.com/intridea/grape-entity/pull/114): Added 'only' option that selects which attributes should be returned - [@estevaoam](https://github.com/estevaoam).
 * Your contribution here.
 
 0.4.5 (2015-03-10)
diff --git a/README.md b/README.md
@@ -220,6 +220,40 @@ class MailingAddress < UserData
 end
 ```
 
+#### Returning only the fields you want
+
+After exposing the desired attributes, you can choose which one you need when representing some object or collection, see the example:
+
+```ruby
+class UserEntity
+  expose :id
+  expose :name
+  expose :email
+end
+
+class Entity
+  expose :id
+  expose :title
+  expose :user, using: UserEntity
+end
+
+data = Entity.represent(model, only: [:name, { user: [:name, :email] }])
+data.as_json
+```
+
+This will return something like this:
+
+```ruby
+{
+  title: 'grape-entity is awesome!',
+  user: {
+    name: 'John Applet',
+    email: 'john@example.com'
+  }
+}
+```
+
+Instead of returning all the exposed attributes.
 
 
 
diff --git a/lib/grape_entity/entity.rb b/lib/grape_entity/entity.rb
@@ -404,6 +404,7 @@ def self.present_collection(present_collection = false, collection_name = :items
     #   even if one is defined for the entity.
     # @option options :serializable [true or false] when true a serializable Hash will be returned
     #
+    # @option options :only [Array] all the fields that should be returned
     def self.represent(objects, options = {})
       if objects.respond_to?(:to_ary) && ! @present_collection
         root_element =  @collection_root
@@ -458,27 +459,53 @@ def formatters
     #   etc.
     def serializable_hash(runtime_options = {})
       return nil if object.nil?
+
       opts = options.merge(runtime_options || {})
+
       valid_exposures.inject({}) do |output, (attribute, exposure_options)|
-        if conditions_met?(exposure_options, opts)
+        if should_return_attribute?(attribute, opts) && conditions_met?(exposure_options, opts)
           partial_output = value_for(attribute, opts)
+
           output[self.class.key_for(attribute)] =
-            if partial_output.respond_to? :serializable_hash
+            if partial_output.respond_to?(:serializable_hash)
               partial_output.serializable_hash(runtime_options)
-            elsif partial_output.is_a?(Array) && !partial_output.map { |o| o.respond_to? :serializable_hash }.include?(false)
+            elsif partial_output.is_a?(Array) && !partial_output.map { |o| o.respond_to?(:serializable_hash) }.include?(false)
               partial_output.map(&:serializable_hash)
             elsif partial_output.is_a?(Hash)
               partial_output.each do |key, value|
-                partial_output[key] = value.serializable_hash if value.respond_to? :serializable_hash
+                partial_output[key] = value.serializable_hash if value.respond_to?(:serializable_hash)
               end
             else
               partial_output
             end
         end
+
         output
       end
     end
 
+    def should_return_attribute?(attribute, options)
+      return true unless options[:only]
+      only_fields(options).include?(self.class.key_for(attribute))
+    end
+
+    def only_fields(options)
+      return {} unless options[:only]
+
+      @only_fields ||= options[:only].inject({}) do |allowed_fields, attribute|
+        if attribute.is_a?(Hash)
+          attribute.each do |attr, nested_attrs|
+            allowed_fields[attr] ||= []
+            allowed_fields[attr] += nested_attrs
+          end
+        else
+          allowed_fields[attribute] = true
+        end
+
+        allowed_fields
+      end
+    end
+
     alias_method :as_json, :serializable_hash
 
     def to_json(options = {})
@@ -508,15 +535,12 @@ def self.nested_exposures_for(attribute)
 
     def value_for(attribute, options = {})
       exposure_options = exposures[attribute.to_sym]
-
       nested_exposures = self.class.nested_exposures_for(attribute)
 
       if exposure_options[:using]
         exposure_options[:using] = exposure_options[:using].constantize if exposure_options[:using].respond_to? :constantize
 
-        using_options = options.dup
-        using_options.delete(:collection)
-        using_options[:root] = nil
+        using_options = options_for_using(attribute, options)
 
         if exposure_options[:proc]
           exposure_options[:using].represent(instance_exec(object, options, &exposure_options[:proc]), using_options)
@@ -612,6 +636,14 @@ def conditions_met?(exposure_options, options)
       true
     end
 
+    def options_for_using(attribute, options)
+      using_options = options.dup
+      using_options.delete(:collection)
+      using_options[:root] = nil
+      using_options[:only] = only_fields(using_options)[attribute]
+      using_options
+    end
+
     # All supported options.
     OPTIONS = [
       :as, :if, :unless, :using, :with, :proc, :documentation, :format_with, :safe, :if_extras, :unless_extras
diff --git a/spec/grape_entity/entity_spec.rb b/spec/grape_entity/entity_spec.rb
@@ -77,7 +77,7 @@ class BogusEntity < Grape::Entity
 
           it 'references an instance of the entity without any options' do
             subject.expose(:size) { |_| self }
-            expect(subject.represent(Hash.new).send(:value_for, :size)).to be_an_instance_of fresh_class
+            expect(subject.represent({}).send(:value_for, :size)).to be_an_instance_of fresh_class
           end
         end
 
@@ -91,10 +91,10 @@ class BogusEntity < Grape::Entity
             end
 
             expect(subject.exposures).to eq(
-                                              awesome: {},
-                                              awesome__nested: { nested: true },
-                                              awesome__nested__moar_nested: { as: 'weee', nested: true },
-                                              awesome__another_nested: { using: 'Awesome', nested: true }
+              awesome: {},
+              awesome__nested: { nested: true },
+              awesome__nested__moar_nested: { as: 'weee', nested: true },
+              awesome__another_nested: { using: 'Awesome', nested: true }
             )
           end
 
@@ -105,8 +105,8 @@ class BogusEntity < Grape::Entity
             end
 
             expect(subject.represent({}).send(:value_for, :awesome)).to eq(
-                                                                             nested: 'value',
-                                                                             another_nested: 'value'
+              nested: 'value',
+              another_nested: 'value'
             )
           end
 
@@ -129,13 +129,13 @@ class BogusEntity < Grape::Entity
             end
 
             expect(subject.represent({}).serializable_hash).to eq(
-                                                                    awesome: {
-                                                                      nested: 'value',
-                                                                      another_nested: 'value',
-                                                                      second_level_nested: {
-                                                                        deeply_exposed_attr: 'value'
-                                                                      }
-                                                                    }
+              awesome: {
+                nested: 'value',
+                another_nested: 'value',
+                second_level_nested: {
+                  deeply_exposed_attr: 'value'
+                }
+              }
             )
           end
 
@@ -162,22 +162,22 @@ class Parent < Person
             end
 
             expect(ClassRoom.represent({}).serializable_hash).to eq(
-                                                                      parents: [
-                                                                        {
-                                                                          user: { in_first: 'value' },
-                                                                          children: [
-                                                                            { user: { in_first: 'value', user_id: 'value', display_id: 'value' } },
-                                                                            { user: { in_first: 'value', user_id: 'value', display_id: 'value' } }
-                                                                          ]
-                                                                        },
-                                                                        {
-                                                                          user: { in_first: 'value' },
-                                                                          children: [
-                                                                            { user: { in_first: 'value', user_id: 'value', display_id: 'value' } },
-                                                                            { user: { in_first: 'value', user_id: 'value', display_id: 'value' } }
-                                                                          ]
-                                                                        }
-                                                                      ]
+              parents: [
+                {
+                  user: { in_first: 'value' },
+                  children: [
+                    { user: { in_first: 'value', user_id: 'value', display_id: 'value' } },
+                    { user: { in_first: 'value', user_id: 'value', display_id: 'value' } }
+                  ]
+                },
+                {
+                  user: { in_first: 'value' },
+                  children: [
+                    { user: { in_first: 'value', user_id: 'value', display_id: 'value' } },
+                    { user: { in_first: 'value', user_id: 'value', display_id: 'value' } }
+                  ]
+                }
+              ]
             )
           end
 
@@ -259,7 +259,7 @@ class Parent < Person
         end
 
         it 'formats an exposure with a :format_with lambda that returns a value from the entity instance' do
-          object = Hash.new
+          object = {}
 
           subject.expose(:size, format_with: lambda { |_value| self.object.class.to_s })
           expect(subject.represent(object).send(:value_for, :size)).to eq object.class.to_s
@@ -270,7 +270,7 @@ class Parent < Person
             self.object.class.to_s
           end
 
-          object = Hash.new
+          object = {}
 
           subject.expose(:size, format_with: :size_formatter)
           expect(subject.represent(object).send(:value_for, :size)).to eq object.class.to_s
@@ -383,8 +383,8 @@ class Parent < Person
         end
 
         expect(subject.exposures[:awesome_thing]).to eq(
-                                                          if: { awesome: false, less_awesome: true },
-                                                          if_extras: [:awesome, match_proc]
+          if: { awesome: false, less_awesome: true },
+          if_extras: [:awesome, match_proc]
         )
       end
 
@@ -408,8 +408,8 @@ class Parent < Person
         end
 
         expect(subject.exposures[:awesome_thing]).to eq(
-                                                          unless: { awesome: false, less_awesome: true },
-                                                          unless_extras: [:awesome, match_proc]
+          unless: { awesome: false, less_awesome: true },
+          unless_extras: [:awesome, match_proc]
         )
       end
 
@@ -461,7 +461,7 @@ class Parent < Person
       end
 
       it 'returns a single entity if called with a hash' do
-        expect(subject.represent(Hash.new)).to be_kind_of(subject)
+        expect(subject.represent({})).to be_kind_of(subject)
       end
 
       it 'returns multiple entities if called with a collection' do
@@ -506,6 +506,47 @@ class Parent < Person
           subject.represent(Object.new, serializable: true)
         end.to raise_error(NoMethodError, /missing attribute `awesome'/)
       end
+
+      context 'with specified fields' do
+        it 'returns only specified fields with only option' do
+          subject.expose(:id, :name, :phone)
+          representation = subject.represent(OpenStruct.new, only: [:id, :name], serializable: true)
+          expect(representation).to eq(id: nil, name: nil)
+        end
+
+        it 'can specify children attributes' do
+          user_entity = Class.new(Grape::Entity)
+          user_entity.expose(:id, :name, :email)
+
+          subject.expose(:id, :name, :phone)
+          subject.expose(:user, using: user_entity)
+
+          representation = subject.represent(OpenStruct.new(user: {}), only: [:id, :name, { user: [:name, :email] }], serializable: true)
+          expect(representation).to eq(id: nil, name: nil, user: { name: nil, email: nil })
+        end
+
+        context 'specify attribute with exposure condition' do
+          it 'returns only specified fields' do
+            subject.expose(:id, :name)
+            subject.with_options(if: { condition: true }) do
+              subject.expose(:name)
+            end
+
+            representation = subject.represent(OpenStruct.new, condition: true, only: [:id, :name], serializable: true)
+            expect(representation).to eq(id: nil, name: nil)
+          end
+        end
+
+        context 'attribute with alias' do
+          it 'returns only specified fields' do
+            subject.expose(:id)
+            subject.expose(:name, as: :title)
+
+            representation = subject.represent(OpenStruct.new, condition: true, only: [:id, :title], serializable: true)
+            expect(representation).to eq(id: nil, title: nil)
+          end
+        end
+      end
     end
 
     describe '.present_collection' do
