grape-entity 0.4.5 → 0.4.6

data/lib/grape_entity/version.rb

@@ -1,3 +1,3 @@
 module GrapeEntity
-  VERSION = '0.4.5'
+  VERSION = '0.4.6'
 end

data/spec/grape_entity/entity_spec.rb

@@ -70,14 +70,14 @@ describe Grape::Entity do
 
         context 'with parameters passed to the block' do
           it 'sets the :proc option in the exposure options' do
-            block = lambda { |_| true }
+            block = ->(_) { true }
             subject.expose :name, using: 'Awesome', &block
             expect(subject.exposures[:name]).to eq(proc: block, using: 'Awesome')
           end
 
           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 @@ describe Grape::Entity do
             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,15 +105,15 @@ describe Grape::Entity do
             end
 
             expect(subject.represent({}).send(:value_for, :awesome)).to eq(
-                                                                             nested: 'value',
-                                                                             another_nested: 'value'
+              nested: 'value',
+              another_nested: 'value'
             )
           end
 
           it 'does not represent nested exposures whose conditions are not met' do
             subject.expose :awesome do
-              subject.expose(:condition_met, if: lambda { |_, _| true }) { |_| 'value' }
-              subject.expose(:condition_not_met, if: lambda { |_, _| false }) { |_| 'value' }
+              subject.expose(:condition_met, if: ->(_, _) { true }) { |_| 'value' }
+              subject.expose(:condition_not_met, if: ->(_, _) { false }) { |_| 'value' }
             end
 
             expect(subject.represent({}).send(:value_for, :awesome)).to eq(condition_met: 'value')
@@ -129,13 +129,13 @@ describe Grape::Entity do
             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 @@ describe Grape::Entity do
             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
 
@@ -190,11 +190,14 @@ describe Grape::Entity do
                 subject.expose :nested
               end
             end
-
-            valid_keys = subject.represent({}).valid_exposures.keys
-
-            expect(valid_keys.include?(:awesome)).to be true
-            expect(valid_keys.include?(:not_awesome)).to be false
+            expect(subject.represent({}, serializable: true)).to eq(
+              awesome: {
+                nested: 'value'
+              },
+              not_awesome: {
+                nested: nil
+              }
+            )
           end
         end
       end
@@ -228,7 +231,7 @@ describe Grape::Entity do
       end
 
       context 'register formatters' do
-        let(:date_formatter) { lambda { |date| date.strftime('%m/%d/%Y') } }
+        let(:date_formatter) { ->(date) { date.strftime('%m/%d/%Y') } }
 
         it 'registers a formatter' do
           subject.format_with :timestamp, &date_formatter
@@ -259,9 +262,9 @@ describe Grape::Entity do
         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 })
+          subject.expose(:size, format_with: ->(_value) { self.object.class.to_s })
           expect(subject.represent(object).send(:value_for, :size)).to eq object.class.to_s
         end
 
@@ -270,7 +273,7 @@ describe Grape::Entity do
             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
@@ -296,23 +299,12 @@ describe Grape::Entity do
           expect(subject.exposures).to eq(name: {}, email: {})
         end
 
-        # the following 2 behaviors are testing because it is not most intuitive and could be confusing
-        context 'when  called from the parent class' do
-          it 'remove from parent and all child classes that have not locked down their attributes with an .exposures call' do
+        context 'when called from the parent class' do
+          it 'remove from parent and do not remove from child classes' do
             subject.expose :name, :email
             child_class = Class.new(subject)
             subject.unexpose :email
 
-            expect(subject.exposures).to eq(name: {})
-            expect(child_class.exposures).to eq(name: {})
-          end
-
-          it 'remove from parent and do not remove from child classes that have locked down their attributes with an .exposures call' do
-            subject.expose :name, :email
-            child_class = Class.new(subject)
-            child_class.exposures
-            subject.unexpose :email
-
             expect(subject.exposures).to eq(name: {})
             expect(child_class.exposures).to eq(name: {}, email: {})
           end
@@ -364,7 +356,7 @@ describe Grape::Entity do
       end
 
       it 'merges nested :if option' do
-        match_proc = lambda { |_obj, _opts| true }
+        match_proc = ->(_obj, _opts) { true }
 
         subject.class_eval do
           # Symbol
@@ -383,13 +375,13 @@ describe Grape::Entity do
         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
 
       it 'merges nested :unless option' do
-        match_proc = lambda { |_, _| true }
+        match_proc = ->(_, _) { true }
 
         subject.class_eval do
           # Symbol
@@ -408,8 +400,8 @@ describe Grape::Entity do
         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
 
@@ -433,10 +425,10 @@ describe Grape::Entity do
       end
 
       it 'overrides nested :proc option' do
-        match_proc = lambda { |_obj, _opts| 'more awesomer' }
+        match_proc = ->(_obj, _opts) { 'more awesomer' }
 
         subject.class_eval do
-          with_options(proc: lambda { |_obj, _opts| 'awesome' }) do
+          with_options(proc: ->(_obj, _opts) { 'awesome' }) do
             expose :awesome_thing, proc: match_proc
           end
         end
@@ -461,7 +453,7 @@ describe Grape::Entity do
       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 +498,164 @@ describe Grape::Entity do
           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 'returns all fields except the ones specified in the except option' do
+          subject.expose(:id, :name, :phone)
+          representation = subject.represent(OpenStruct.new, except: [:phone], serializable: true)
+          expect(representation).to eq(id: nil, name: nil)
+        end
+
+        it 'returns only fields specified in the only option and not specified in the except option' do
+          subject.expose(:id, :name, :phone)
+          representation = subject.represent(OpenStruct.new,
+                                             only: [:name, :phone],
+                                             except: [:phone], serializable: true)
+          expect(representation).to eq(name: nil)
+        end
+
+        context 'with strings or symbols passed to only and except' do
+          let(:object) { OpenStruct.new(user: {}) }
+
+          before do
+            user_entity = Class.new(Grape::Entity)
+            user_entity.expose(:id, :name, :email)
+
+            subject.expose(:id, :name, :phone, :address)
+            subject.expose(:user, using: user_entity)
+          end
+
+          it 'can specify "only" option attributes as strings' do
+            representation = subject.represent(object, only: ['id', 'name', { 'user' => ['email'] }], serializable: true)
+            expect(representation).to eq(id: nil, name: nil, user: { email: nil })
+          end
+
+          it 'can specify "except" option attributes as strings' do
+            representation = subject.represent(object, except: ['id', 'name', { 'user' => ['email'] }], serializable: true)
+            expect(representation).to eq(phone: nil, address: nil, user: { id: nil, name: nil })
+          end
+
+          it 'can specify "only" option attributes as symbols' do
+            representation = subject.represent(object, only: [:name, :phone, { user: [:name] }], serializable: true)
+            expect(representation).to eq(name: nil, phone: nil, user: { name: nil })
+          end
+
+          it 'can specify "except" option attributes as symbols' do
+            representation = subject.represent(object, except: [:name, :phone, { user: [:name] }], serializable: true)
+            expect(representation).to eq(id: nil, address: nil, user: { id: nil, email: nil })
+          end
+
+          it 'can specify "only" attributes as strings and symbols' do
+            representation = subject.represent(object, only: [:id, 'address', { user: [:id, 'name'] }], serializable: true)
+            expect(representation).to eq(id: nil, address: nil, user: { id: nil, name: nil })
+          end
+
+          it 'can specify "except" attributes as strings and symbols' do
+            representation = subject.represent(object, except: [:id, 'address', { user: [:id, 'name'] }], serializable: true)
+            expect(representation).to eq(name: nil, phone: nil, user: { email: nil })
+          end
+        end
+
+        it 'can specify children attributes with only' 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
+
+        it 'can specify children attributes with except' 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: {}), except: [:phone, { user: [:id] }], serializable: true)
+          expect(representation).to eq(id: nil, name: nil, user: { name: nil, email: nil })
+        end
+
+        it 'can specify children attributes with mixed only and except' do
+          user_entity = Class.new(Grape::Entity)
+          user_entity.expose(:id, :name, :email, :address)
+
+          subject.expose(:id, :name, :phone, :mobile_phone)
+          subject.expose(:user, using: user_entity)
+
+          representation = subject.represent(OpenStruct.new(user: {}),
+                                             only: [:id, :name, :phone, user: [:id, :name, :email]],
+                                             except: [:phone, { user: [:id] }], 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)
+            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
+
+          it 'does not return fields specified in the except option' do
+            subject.expose(:id, :phone)
+            subject.with_options(if: { condition: true }) do
+              subject.expose(:name, :mobile_phone)
+            end
+
+            representation = subject.represent(OpenStruct.new, condition: true, except: [:phone, :mobile_phone], 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
+
+          it 'does not return fields specified in the except option' do
+            subject.expose(:id)
+            subject.expose(:name, as: :title)
+            subject.expose(:phone, as: :phone_number)
+
+            representation = subject.represent(OpenStruct.new, condition: true, except: [:phone_number], serializable: true)
+            expect(representation).to eq(id: nil, title: nil)
+          end
+        end
+
+        context 'attribute that is an entity itself' do
+          it 'returns correctly the children entity attributes' do
+            user_entity = Class.new(Grape::Entity)
+            user_entity.expose(:id, :name, :email)
+
+            nephew_entity = Class.new(Grape::Entity)
+            nephew_entity.expose(:id, :name, :email)
+
+            subject.expose(:id, :name, :phone)
+            subject.expose(:user, using: user_entity)
+            subject.expose(:nephew, using: nephew_entity)
+
+            representation = subject.represent(OpenStruct.new(user: {}),
+                                               only: [:id, :name, :user], except: [:nephew], serializable: true)
+            expect(representation).to eq(id: nil, name: nil, user: { id: nil, name: nil, email: nil })
+          end
+        end
+      end
     end
 
     describe '.present_collection' do
@@ -623,6 +773,30 @@ describe Grape::Entity do
           end
         end
       end
+
+      context 'inheriting from parent entity' do
+        before(:each) do
+          subject.root 'things', 'thing'
+        end
+
+        it 'inherits single root' do
+          child_class = Class.new(subject)
+          representation = child_class.represent(Object.new)
+          expect(representation).to be_kind_of Hash
+          expect(representation).to have_key 'thing'
+          expect(representation['thing']).to be_kind_of(child_class)
+        end
+
+        it 'inherits array root root' do
+          child_class = Class.new(subject)
+          representation = child_class.represent(4.times.map { Object.new })
+          expect(representation).to be_kind_of Hash
+          expect(representation).to have_key('things')
+          expect(representation['things']).to be_kind_of Array
+          expect(representation['things'].size).to eq 4
+          expect(representation['things'].reject { |r| r.is_a?(child_class) }).to be_empty
+        end
+      end
     end
 
     describe '#initialize' do
@@ -677,12 +851,23 @@ describe Grape::Entity do
           expect { fresh_class.new(model).serializable_hash }.not_to raise_error
         end
 
-        it "does not expose attributes that don't exist on the object" do
+        it 'exposes values of private method calls' do
+          some_class = Class.new do
+            define_method :name do
+              true
+            end
+            private :name
+          end
+          fresh_class.expose :name, safe: true
+          expect(fresh_class.new(some_class.new).serializable_hash).to eq(name: true)
+        end
+
+        it "does expose attributes that don't exist on the object as nil" do
           fresh_class.expose :email, :nonexistent_attribute, :name, safe: true
 
           res = fresh_class.new(model).serializable_hash
           expect(res).to have_key :email
-          expect(res).not_to have_key :nonexistent_attribute
+          expect(res).to have_key :nonexistent_attribute
           expect(res).to have_key :name
         end
 
@@ -693,15 +878,15 @@ describe Grape::Entity do
           expect(res).to have_key :name
         end
 
-        it "does not expose attributes that don't exist on the object, even with criteria" do
+        it "does expose attributes that don't exist on the object as nil if criteria is true" do
           fresh_class.expose :email
-          fresh_class.expose :nonexistent_attribute, safe: true, if: lambda { false }
-          fresh_class.expose :nonexistent_attribute2, safe: true, if: lambda { true }
+          fresh_class.expose :nonexistent_attribute, safe: true, if: ->(_obj, _opts) { false }
+          fresh_class.expose :nonexistent_attribute2, safe: true, if: ->(_obj, _opts) { true }
 
           res = fresh_class.new(model).serializable_hash
           expect(res).to have_key :email
           expect(res).not_to have_key :nonexistent_attribute
-          expect(res).not_to have_key :nonexistent_attribute2
+          expect(res).to have_key :nonexistent_attribute2
         end
       end
 
@@ -720,9 +905,9 @@ describe Grape::Entity do
         end
 
         it 'does not expose attributes that are generated by a block but have not passed criteria' do
-          fresh_class.expose :nonexistent_attribute, proc: lambda { |_model, _opts|
-            'I exist, but it is not yet my time to shine'
-          },                                         if: lambda { |_model, _opts| false }
+          fresh_class.expose :nonexistent_attribute,
+                             proc: ->(_model, _opts) { 'I exist, but it is not yet my time to shine' },
+                             if: ->(_model, _opts) { false }
           res = fresh_class.new(model).serializable_hash
           expect(res).not_to have_key :nonexistent_attribute
         end
@@ -742,9 +927,9 @@ describe Grape::Entity do
       end
 
       it 'does not expose attributes that are generated by a block but have not passed criteria' do
-        fresh_class.expose :nonexistent_attribute, proc: lambda { |_, _|
-          'I exist, but it is not yet my time to shine'
-        },                                         if: lambda { |_, _| false }
+        fresh_class.expose :nonexistent_attribute,
+                           proc: ->(_, _) { 'I exist, but it is not yet my time to shine' },
+                           if: ->(_, _) { false }
         res = fresh_class.new(model).serializable_hash
         expect(res).not_to have_key :nonexistent_attribute
       end
@@ -823,7 +1008,7 @@ describe Grape::Entity do
             date.strftime('%m/%d/%Y')
           end
 
-          expose :fantasies, format_with: lambda { |f| f.reverse }
+          expose :fantasies, format_with: ->(f) { f.reverse }
         end
       end
 
@@ -1071,6 +1256,46 @@ describe Grape::Entity do
 
         expect(subject.documentation).to eq(label: doc, email: doc)
       end
+
+      context 'inherited documentation' do
+        it 'returns documentation from ancestor' do
+          doc = { type: 'foo', desc: 'bar' }
+          fresh_class.expose :name, documentation: doc
+          child_class = Class.new(fresh_class)
+          child_class.expose :email, documentation: doc
+
+          expect(fresh_class.documentation).to eq(name: doc)
+          expect(child_class.documentation).to eq(name: doc, email: doc)
+        end
+
+        it 'obeys unexposed attributes in subclass' do
+          doc = { type: 'foo', desc: 'bar' }
+          fresh_class.expose :name, documentation: doc
+          fresh_class.expose :email, documentation: doc
+          child_class = Class.new(fresh_class)
+          child_class.unexpose :email
+
+          expect(fresh_class.documentation).to eq(name: doc, email: doc)
+          expect(child_class.documentation).to eq(name: doc)
+        end
+
+        it 'obeys re-exposed attributes in subclass' do
+          doc = { type: 'foo', desc: 'bar' }
+          fresh_class.expose :name, documentation: doc
+          fresh_class.expose :email, documentation: doc
+
+          child_class = Class.new(fresh_class)
+          child_class.unexpose :email
+
+          nephew_class = Class.new(child_class)
+          new_doc = { type: 'todler', descr: '???' }
+          nephew_class.expose :email, documentation: new_doc
+
+          expect(fresh_class.documentation).to eq(name: doc, email: doc)
+          expect(child_class.documentation).to eq(name: doc)
+          expect(nephew_class.documentation).to eq(name: doc, email: new_doc)
+        end
+      end
     end
 
     describe '#key_for' do
@@ -1120,7 +1345,7 @@ describe Grape::Entity do
       end
 
       it 'only passes through proc :if exposure if it returns truthy value' do
-        exposure_options = { if: lambda { |_, opts| opts[:true] } }
+        exposure_options = { if: ->(_, opts) { opts[:true] } }
 
         expect(subject.send(:conditions_met?, exposure_options, true: false)).to be false
         expect(subject.send(:conditions_met?, exposure_options, true: true)).to be true
@@ -1138,7 +1363,7 @@ describe Grape::Entity do
       end
 
       it 'only passes through proc :unless exposure if it returns falsy value' do
-        exposure_options = { unless: lambda { |_, options| options[:true] == true } }
+        exposure_options = { unless: ->(_, opts) { opts[:true] == true } }
 
         expect(subject.send(:conditions_met?, exposure_options, true: false)).to be true
         expect(subject.send(:conditions_met?, exposure_options, true: true)).to be false