grape-entity 0.4.8 → 0.10.2

data/spec/grape_entity/entity_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 require 'ostruct'
 
@@ -11,12 +13,12 @@ describe Grape::Entity do
       context 'multiple attributes' do
         it 'is able to add multiple exposed attributes with a single call' do
           subject.expose :name, :email, :location
-          expect(subject.exposures.size).to eq 3
+          expect(subject.root_exposures.size).to eq 3
         end
 
-        it 'sets the same options for all exposures passed' do
+        it 'sets the same options for all.root_exposures passed' do
           subject.expose :name, :email, :location, documentation: true
-          subject.exposures.values.each { |v| expect(v).to eq(documentation: true) }
+          subject.root_exposures.each { |v| expect(v.documentation).to eq true }
         end
       end
 
@@ -27,7 +29,9 @@ describe Grape::Entity do
         end
 
         it 'makes sure that :format_with as a proc cannot be used with a block' do
-          expect { subject.expose :name, format_with: proc {} {} }.to raise_error ArgumentError
+          # rubocop:disable Style/BlockDelimiters
+          expect { subject.expose :name, format_with: proc {} do p 'hi' end }.to raise_error ArgumentError
+          # rubocop:enable Style/BlockDelimiters
         end
 
         it 'makes sure unknown options are not silently ignored' do
@@ -35,6 +39,303 @@ describe Grape::Entity do
         end
       end
 
+      context 'with a :merge option' do
+        let(:nested_hash) do
+          { something: { like_nested_hash: true }, special: { like_nested_hash: '12' } }
+        end
+
+        it 'merges an exposure to the root' do
+          subject.expose(:something, merge: true)
+          expect(subject.represent(nested_hash).serializable_hash).to eq(nested_hash[:something])
+        end
+
+        it 'allows to solve collisions providing a lambda to a :merge option' do
+          subject.expose(:something, merge: true)
+          subject.expose(:special, merge: ->(_, v1, v2) { v1 && v2 ? 'brand new val' : v2 })
+          expect(subject.represent(nested_hash).serializable_hash).to eq(like_nested_hash: 'brand new val')
+        end
+
+        context 'and nested object is nil' do
+          let(:nested_hash) do
+            { something: nil, special: { like_nested_hash: '12' } }
+          end
+
+          it 'adds nothing to output' do
+            subject.expose(:something, merge: true)
+            subject.expose(:special)
+            expect(subject.represent(nested_hash).serializable_hash).to eq(special: { like_nested_hash: '12' })
+          end
+        end
+      end
+
+      context 'with :expose_nil option' do
+        let(:a) { nil }
+        let(:b) { nil }
+        let(:c) { 'value' }
+
+        context 'when model is a PORO' do
+          let(:model) { Model.new(a, b, c) }
+
+          before do
+            stub_const 'Model', Class.new
+            Model.class_eval do
+              attr_accessor :a, :b, :c
+
+              def initialize(a, b, c)
+                @a = a
+                @b = b
+                @c = c
+              end
+            end
+          end
+
+          context 'when expose_nil option is not provided' do
+            it 'exposes nil attributes' do
+              subject.expose(:a)
+              subject.expose(:b)
+              subject.expose(:c)
+              expect(subject.represent(model).serializable_hash).to eq(a: nil, b: nil, c: 'value')
+            end
+          end
+
+          context 'when expose_nil option is true' do
+            it 'exposes nil attributes' do
+              subject.expose(:a, expose_nil: true)
+              subject.expose(:b, expose_nil: true)
+              subject.expose(:c)
+              expect(subject.represent(model).serializable_hash).to eq(a: nil, b: nil, c: 'value')
+            end
+          end
+
+          context 'when expose_nil option is false' do
+            it 'does not expose nil attributes' do
+              subject.expose(:a, expose_nil: false)
+              subject.expose(:b, expose_nil: false)
+              subject.expose(:c)
+              expect(subject.represent(model).serializable_hash).to eq(c: 'value')
+            end
+
+            it 'is only applied per attribute' do
+              subject.expose(:a, expose_nil: false)
+              subject.expose(:b)
+              subject.expose(:c)
+              expect(subject.represent(model).serializable_hash).to eq(b: nil, c: 'value')
+            end
+
+            it 'raises an error when applied to multiple attribute exposures' do
+              expect { subject.expose(:a, :b, :c, expose_nil: false) }.to raise_error ArgumentError
+            end
+          end
+
+          context 'when expose_nil option is false and block passed' do
+            it 'does not expose if block returns nil' do
+              subject.expose(:a, expose_nil: false) do |_obj, _options|
+                nil
+              end
+              subject.expose(:b)
+              subject.expose(:c)
+              expect(subject.represent(model).serializable_hash).to eq(b: nil, c: 'value')
+            end
+
+            it 'exposes is block returns a value' do
+              subject.expose(:a, expose_nil: false) do |_obj, _options|
+                100
+              end
+              subject.expose(:b)
+              subject.expose(:c)
+              expect(subject.represent(model).serializable_hash).to eq(a: 100, b: nil, c: 'value')
+            end
+          end
+        end
+
+        context 'when model is a hash' do
+          let(:model) { { a: a, b: b, c: c } }
+
+          context 'when expose_nil option is not provided' do
+            it 'exposes nil attributes' do
+              subject.expose(:a)
+              subject.expose(:b)
+              subject.expose(:c)
+              expect(subject.represent(model).serializable_hash).to eq(a: nil, b: nil, c: 'value')
+            end
+          end
+
+          context 'when expose_nil option is true' do
+            it 'exposes nil attributes' do
+              subject.expose(:a, expose_nil: true)
+              subject.expose(:b, expose_nil: true)
+              subject.expose(:c)
+              expect(subject.represent(model).serializable_hash).to eq(a: nil, b: nil, c: 'value')
+            end
+          end
+
+          context 'when expose_nil option is false' do
+            it 'does not expose nil attributes' do
+              subject.expose(:a, expose_nil: false)
+              subject.expose(:b, expose_nil: false)
+              subject.expose(:c)
+              expect(subject.represent(model).serializable_hash).to eq(c: 'value')
+            end
+
+            it 'is only applied per attribute' do
+              subject.expose(:a, expose_nil: false)
+              subject.expose(:b)
+              subject.expose(:c)
+              expect(subject.represent(model).serializable_hash).to eq(b: nil, c: 'value')
+            end
+
+            it 'raises an error when applied to multiple attribute exposures' do
+              expect { subject.expose(:a, :b, :c, expose_nil: false) }.to raise_error ArgumentError
+            end
+          end
+        end
+
+        context 'with nested structures' do
+          let(:model) { { a: a, b: b, c: { d: nil, e: nil, f: { g: nil, h: nil } } } }
+
+          context 'when expose_nil option is false' do
+            it 'does not expose nil attributes' do
+              subject.expose(:a, expose_nil: false)
+              subject.expose(:b)
+              subject.expose(:c) do
+                subject.expose(:d, expose_nil: false)
+                subject.expose(:e)
+                subject.expose(:f) do
+                  subject.expose(:g, expose_nil: false)
+                  subject.expose(:h)
+                end
+              end
+
+              expect(subject.represent(model).serializable_hash).to eq(b: nil, c: { e: nil, f: { h: nil } })
+            end
+          end
+        end
+      end
+
+      context 'with :default option' do
+        let(:a) { nil }
+        let(:b) { nil }
+        let(:c) { 'value' }
+
+        context 'when model is a PORO' do
+          let(:model) { Model.new(a, b, c) }
+
+          before do
+            stub_const 'Model', Class.new
+            Model.class_eval do
+              attr_accessor :a, :b, :c
+
+              def initialize(a, b, c)
+                @a = a
+                @b = b
+                @c = c
+              end
+            end
+          end
+
+          context 'when default option is not provided' do
+            it 'exposes attributes values' do
+              subject.expose(:a)
+              subject.expose(:b)
+              subject.expose(:c)
+              expect(subject.represent(model).serializable_hash).to eq(a: nil, b: nil, c: 'value')
+            end
+          end
+
+          context 'when default option is set' do
+            it 'exposes default values for attributes' do
+              subject.expose(:a, default: 'a')
+              subject.expose(:b, default: 'b')
+              subject.expose(:c, default: 'c')
+              expect(subject.represent(model).serializable_hash).to eq(a: 'a', b: 'b', c: 'value')
+            end
+          end
+
+          context 'when default option is set and block passed' do
+            it 'return default value if block returns nil' do
+              subject.expose(:a, default: 'a') do |_obj, _options|
+                nil
+              end
+              subject.expose(:b)
+              subject.expose(:c)
+              expect(subject.represent(model).serializable_hash).to eq(a: 'a', b: nil, c: 'value')
+            end
+
+            it 'return value from block if block returns a value' do
+              subject.expose(:a, default: 'a') do |_obj, _options|
+                100
+              end
+              subject.expose(:b)
+              subject.expose(:c)
+              expect(subject.represent(model).serializable_hash).to eq(a: 100, b: nil, c: 'value')
+            end
+          end
+        end
+
+        context 'when model is a hash' do
+          let(:model) { { a: a, b: b, c: c } }
+
+          context 'when expose_nil option is not provided' do
+            it 'exposes nil attributes' do
+              subject.expose(:a)
+              subject.expose(:b)
+              subject.expose(:c)
+              expect(subject.represent(model).serializable_hash).to eq(a: nil, b: nil, c: 'value')
+            end
+          end
+
+          context 'when expose_nil option is true' do
+            it 'exposes nil attributes' do
+              subject.expose(:a, expose_nil: true)
+              subject.expose(:b, expose_nil: true)
+              subject.expose(:c)
+              expect(subject.represent(model).serializable_hash).to eq(a: nil, b: nil, c: 'value')
+            end
+          end
+
+          context 'when expose_nil option is false' do
+            it 'does not expose nil attributes' do
+              subject.expose(:a, expose_nil: false)
+              subject.expose(:b, expose_nil: false)
+              subject.expose(:c)
+              expect(subject.represent(model).serializable_hash).to eq(c: 'value')
+            end
+
+            it 'is only applied per attribute' do
+              subject.expose(:a, expose_nil: false)
+              subject.expose(:b)
+              subject.expose(:c)
+              expect(subject.represent(model).serializable_hash).to eq(b: nil, c: 'value')
+            end
+
+            it 'raises an error when applied to multiple attribute exposures' do
+              expect { subject.expose(:a, :b, :c, expose_nil: false) }.to raise_error ArgumentError
+            end
+          end
+        end
+
+        context 'with nested structures' do
+          let(:model) { { a: a, b: b, c: { d: nil, e: nil, f: { g: nil, h: nil } } } }
+
+          context 'when expose_nil option is false' do
+            it 'does not expose nil attributes' do
+              subject.expose(:a, expose_nil: false)
+              subject.expose(:b)
+              subject.expose(:c) do
+                subject.expose(:d, expose_nil: false)
+                subject.expose(:e)
+                subject.expose(:f) do
+                  subject.expose(:g, expose_nil: false)
+                  subject.expose(:h)
+                end
+              end
+
+              expect(subject.represent(model).serializable_hash).to eq(b: nil, c: { e: nil, f: { h: nil } })
+            end
+          end
+        end
+      end
+
       context 'with a block' do
         it 'errors out if called with multiple attributes' do
           expect { subject.expose(:name, :email) { true } }.to raise_error ArgumentError
@@ -61,10 +362,10 @@ describe Grape::Entity do
           end
 
           object = EntitySpec::SomeObject1.new
-          value = subject.represent(object).send(:value_for, :bogus)
+          value = subject.represent(object).value_for(:bogus)
           expect(value).to be_instance_of EntitySpec::BogusEntity
 
-          prop1 = value.send(:value_for, :prop1)
+          prop1 = value.value_for(:prop1)
           expect(prop1).to eq 'MODIFIED 2'
         end
 
@@ -72,12 +373,76 @@ describe Grape::Entity do
           it 'sets the :proc option in the exposure options' do
             block = ->(_) { true }
             subject.expose :name, using: 'Awesome', &block
-            expect(subject.exposures[:name]).to eq(proc: block, using: 'Awesome')
+            exposure = subject.find_exposure(:name)
+            expect(exposure.subexposure.block).to eq(block)
+            expect(exposure.using_class_name).to eq('Awesome')
           end
 
           it 'references an instance of the entity without any options' do
             subject.expose(:size) { |_| self }
-            expect(subject.represent({}).send(:value_for, :size)).to be_an_instance_of fresh_class
+            expect(subject.represent({}).value_for(:size)).to be_an_instance_of fresh_class
+          end
+        end
+
+        describe 'blocks' do
+          class SomeObject
+            def method_without_args
+              'result'
+            end
+
+            def raises_argument_error
+              raise ArgumentError, 'something different'
+            end
+          end
+
+          describe 'with block passed in' do
+            specify do
+              subject.expose :that_method_without_args do |object|
+                object.method_without_args
+              end
+
+              object = SomeObject.new
+
+              value = subject.represent(object).value_for(:that_method_without_args)
+              expect(value).to eq('result')
+            end
+
+            it 'does not suppress ArgumentError' do
+              subject.expose :raises_argument_error do |object|
+                object.raises_argument_error
+              end
+
+              object = SomeObject.new
+              expect do
+                subject.represent(object).value_for(:raises_argument_error)
+              end.to raise_error(ArgumentError, 'something different')
+            end
+          end
+
+          context 'with block passed in via &' do
+            if RUBY_VERSION.start_with?('3')
+              specify do
+                subject.expose :that_method_without_args, &:method_without_args
+                subject.expose :method_without_args, as: :that_method_without_args_again
+
+                object = SomeObject.new
+                expect do
+                  subject.represent(object).value_for(:that_method_without_args)
+                end.to raise_error Grape::Entity::Deprecated
+
+                value2 = subject.represent(object).value_for(:that_method_without_args_again)
+                expect(value2).to eq('result')
+              end
+            else
+              specify do
+                subject.expose :that_method_without_args_again, &:method_without_args
+
+                object = SomeObject.new
+
+                value2 = subject.represent(object).value_for(:that_method_without_args_again)
+                expect(value2).to eq('result')
+              end
+            end
           end
         end
 
@@ -90,33 +455,38 @@ describe Grape::Entity do
               subject.expose :another_nested, using: 'Awesome'
             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 = subject.find_exposure(:awesome)
+            nested = awesome.find_nested_exposure(:nested)
+            another_nested = awesome.find_nested_exposure(:another_nested)
+            moar_nested = nested.find_nested_exposure(:moar_nested)
+
+            expect(awesome).to be_nesting
+            expect(nested).to_not be_nil
+            expect(another_nested).to_not be_nil
+            expect(another_nested.using_class_name).to eq('Awesome')
+            expect(moar_nested).to_not be_nil
+            expect(moar_nested.key(subject)).to eq(:weee)
           end
 
-          it 'represents the exposure as a hash of its nested exposures' do
+          it 'represents the exposure as a hash of its nested.root_exposures' do
             subject.expose :awesome do
               subject.expose(:nested) { |_| 'value' }
               subject.expose(:another_nested) { |_| 'value' }
             end
 
-            expect(subject.represent({}).send(:value_for, :awesome)).to eq(
+            expect(subject.represent({}).value_for(:awesome)).to eq(
               nested: 'value',
               another_nested: 'value'
             )
           end
 
-          it 'does not represent nested exposures whose conditions are not met' do
+          it 'does not represent nested.root_exposures whose conditions are not met' do
             subject.expose :awesome do
               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')
+            expect(subject.represent({}).value_for(:awesome)).to eq(condition_met: 'value')
           end
 
           it 'does not represent attributes, declared inside nested exposure, outside of it' do
@@ -139,7 +509,7 @@ describe Grape::Entity do
             )
           end
 
-          it 'complex nested attributes' do
+          it 'merges complex nested attributes' do
             class ClassRoom < Grape::Entity
               expose(:parents, using: 'Parent') { |_| [{}, {}] }
             end
@@ -181,7 +551,44 @@ describe Grape::Entity do
             )
           end
 
-          it 'is safe if its nested exposures are safe' do
+          it 'merges results of deeply nested double.root_exposures inside of nesting exposure' do
+            entity = Class.new(Grape::Entity) do
+              expose :data do
+                expose :something do
+                  expose(:x) { |_| 'x' }
+                end
+                expose :something do
+                  expose(:y) { |_| 'y' }
+                end
+              end
+            end
+            expect(entity.represent({}).serializable_hash).to eq(
+              data: {
+                something: {
+                  x: 'x',
+                  y: 'y'
+                }
+              }
+            )
+          end
+
+          it 'serializes deeply nested presenter exposures' do
+            e = Class.new(Grape::Entity) do
+              expose :f
+            end
+            subject.expose :a do
+              subject.expose :b do
+                subject.expose :c do
+                  subject.expose :lol, using: e
+                end
+              end
+            end
+            expect(subject.represent(lol: { f: 123 }).serializable_hash).to eq(
+              a: { b: { c: { lol: { f: 123 } } } }
+            )
+          end
+
+          it 'is safe if its nested.root_exposures are safe' do
             subject.with_options safe: true do
               subject.expose :awesome do
                 subject.expose(:nested) { |_| 'value' }
@@ -199,34 +606,75 @@ describe Grape::Entity do
               }
             )
           end
+          it 'merges attriutes if :merge option is passed' do
+            user_entity = Class.new(Grape::Entity)
+            admin_entity = Class.new(Grape::Entity)
+            user_entity.expose(:id, :name)
+            admin_entity.expose(:id, :name)
+
+            subject.expose(:profiles) do
+              subject.expose(:users, merge: true, using: user_entity)
+              subject.expose(:admins, merge: true, using: admin_entity)
+            end
+
+            subject.expose :awesome do
+              subject.expose(:nested, merge: true) { |_| { just_a_key: 'value' } }
+              subject.expose(:another_nested, merge: true) { |_| { just_another_key: 'value' } }
+            end
+
+            additional_hash = { users: [{ id: 1, name: 'John' }, { id: 2, name: 'Jay' }],
+                                admins: [{ id: 3, name: 'Jack' }, { id: 4, name: 'James' }] }
+            expect(subject.represent(additional_hash).serializable_hash).to eq(
+              profiles: additional_hash[:users] + additional_hash[:admins],
+              awesome: { just_a_key: 'value', just_another_key: 'value' }
+            )
+          end
         end
       end
 
-      context 'inherited exposures' do
-        it 'returns exposures from an ancestor' do
+      context 'inherited.root_exposures' do
+        it 'returns.root_exposures from an ancestor' do
           subject.expose :name, :email
           child_class = Class.new(subject)
 
-          expect(child_class.exposures).to eq(subject.exposures)
+          expect(child_class.root_exposures).to eq(subject.root_exposures)
         end
 
-        it 'returns exposures from multiple ancestor' do
+        it 'returns.root_exposures from multiple ancestor' do
           subject.expose :name, :email
           parent_class = Class.new(subject)
           child_class  = Class.new(parent_class)
 
-          expect(child_class.exposures).to eq(subject.exposures)
+          expect(child_class.root_exposures).to eq(subject.root_exposures)
         end
 
-        it 'returns descendant exposures as a priority' do
+        it 'returns descendant.root_exposures as a priority' do
           subject.expose :name, :email
           child_class = Class.new(subject)
           child_class.expose :name do |_|
             'foo'
           end
 
-          expect(subject.exposures[:name]).not_to have_key :proc
-          expect(child_class.exposures[:name]).to have_key :proc
+          expect(subject.represent({ name: 'bar' }, serializable: true)).to eq(email: nil, name: 'bar')
+          expect(child_class.represent({ name: 'bar' }, serializable: true)).to eq(email: nil, name: 'foo')
+        end
+
+        it 'not overrides exposure by default' do
+          subject.expose :name
+          child_class = Class.new(subject)
+          child_class.expose :name, as: :child_name
+
+          expect(subject.represent({ name: 'bar' }, serializable: true)).to eq(name: 'bar')
+          expect(child_class.represent({ name: 'bar' }, serializable: true)).to eq(name: 'bar', child_name: 'bar')
+        end
+
+        it 'overrides parent class exposure when option is specified' do
+          subject.expose :name
+          child_class = Class.new(subject)
+          child_class.expose :name, as: :child_name, override: true
+
+          expect(subject.represent({ name: 'bar' }, serializable: true)).to eq(name: 'bar')
+          expect(child_class.represent({ name: 'bar' }, serializable: true)).to eq(child_name: 'bar')
         end
       end
 
@@ -257,46 +705,46 @@ describe Grape::Entity do
 
           subject.expose :birthday, format_with: :timestamp
 
-          model  = { birthday: Time.gm(2012, 2, 27) }
+          model = { birthday: Time.gm(2012, 2, 27) }
           expect(subject.new(double(model)).as_json[:birthday]).to eq '02/27/2012'
         end
 
         it 'formats an exposure with a :format_with lambda that returns a value from the entity instance' do
           object = {}
 
-          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
+          subject.expose(:size, format_with: ->(_value) { object.class.to_s })
+          expect(subject.represent(object).value_for(:size)).to eq object.class.to_s
         end
 
         it 'formats an exposure with a :format_with symbol that returns a value from the entity instance' do
           subject.format_with :size_formatter do |_date|
-            self.object.class.to_s
+            object.class.to_s
           end
 
           object = {}
 
           subject.expose(:size, format_with: :size_formatter)
-          expect(subject.represent(object).send(:value_for, :size)).to eq object.class.to_s
+          expect(subject.represent(object).value_for(:size)).to eq object.class.to_s
         end
 
         it 'works global on Grape::Entity' do
           Grape::Entity.format_with :size_formatter do |_date|
-            self.object.class.to_s
+            object.class.to_s
           end
           object = {}
 
           subject.expose(:size, format_with: :size_formatter)
-          expect(subject.represent(object).send(:value_for, :size)).to eq object.class.to_s
+          expect(subject.represent(object).value_for(:size)).to eq object.class.to_s
         end
       end
 
       it 'works global on Grape::Entity' do
         Grape::Entity.expose :a
         object = { a: 11, b: 22 }
-        expect(Grape::Entity.represent(object).send(:value_for, :a)).to eq 11
+        expect(Grape::Entity.represent(object).value_for(:a)).to eq 11
         subject.expose :b
-        expect(subject.represent(object).send(:value_for, :a)).to eq 11
-        expect(subject.represent(object).send(:value_for, :b)).to eq 22
+        expect(subject.represent(object).value_for(:a)).to eq 11
+        expect(subject.represent(object).value_for(:b)).to eq 22
         Grape::Entity.unexpose :a
       end
     end
@@ -306,17 +754,20 @@ describe Grape::Entity do
         subject.expose :name, :email
         subject.unexpose :email
 
-        expect(subject.exposures).to eq(name: {})
+        expect(subject.root_exposures.length).to eq 1
+        expect(subject.root_exposures[0].attribute).to eq :name
       end
 
-      context 'inherited exposures' do
+      context 'inherited.root_exposures' do
         it 'when called from child class, only removes from the attribute from child' do
           subject.expose :name, :email
           child_class = Class.new(subject)
           child_class.unexpose :email
 
-          expect(child_class.exposures).to eq(name: {})
-          expect(subject.exposures).to eq(name: {}, email: {})
+          expect(child_class.root_exposures.length).to eq 1
+          expect(child_class.root_exposures[0].attribute).to eq :name
+          expect(subject.root_exposures[0].attribute).to eq :name
+          expect(subject.root_exposures[1].attribute).to eq :email
         end
 
         context 'when called from the parent class' do
@@ -325,17 +776,30 @@ describe Grape::Entity do
             child_class = Class.new(subject)
             subject.unexpose :email
 
-            expect(subject.exposures).to eq(name: {})
-            expect(child_class.exposures).to eq(name: {}, email: {})
+            expect(subject.root_exposures.length).to eq 1
+            expect(subject.root_exposures[0].attribute).to eq :name
+            expect(child_class.root_exposures[0].attribute).to eq :name
+            expect(child_class.root_exposures[1].attribute).to eq :email
           end
         end
       end
 
+      it 'does not allow unexposing inside of nesting exposures' do
+        expect do
+          Class.new(Grape::Entity) do
+            expose :something do
+              expose :x
+              unexpose :x
+            end
+          end
+        end.to raise_error(/You cannot call 'unexpose`/)
+      end
+
       it 'works global on Grape::Entity' do
-        Grape::Entity.expose :a
-        expect(Grape::Entity.exposures).to eq(a: {})
-        Grape::Entity.unexpose :a
-        expect(Grape::Entity.exposures).to eq({})
+        Grape::Entity.expose :x
+        expect(Grape::Entity.root_exposures[0].attribute).to eq(:x)
+        Grape::Entity.unexpose :x
+        expect(Grape::Entity.root_exposures).to eq([])
       end
     end
 
@@ -350,14 +814,16 @@ describe Grape::Entity do
         expect { subject.class_eval(&block) }.to raise_error ArgumentError
       end
 
-      it 'applies the options to all exposures inside' do
+      it 'applies the options to all.root_exposures inside' do
         subject.class_eval do
           with_options(if: { awesome: true }) do
             expose :awesome_thing, using: 'Awesome'
           end
         end
 
-        expect(subject.exposures[:awesome_thing]).to eq(if: { awesome: true }, using: 'Awesome')
+        exposure = subject.find_exposure(:awesome_thing)
+        expect(exposure.using_class_name).to eq('Awesome')
+        expect(exposure.conditions[0].cond_hash).to eq(awesome: true)
       end
 
       it 'allows for nested .with_options' do
@@ -369,7 +835,9 @@ describe Grape::Entity do
           end
         end
 
-        expect(subject.exposures[:awesome_thing]).to eq(if: { awesome: true }, using: 'Something')
+        exposure = subject.find_exposure(:awesome_thing)
+        expect(exposure.using_class_name).to eq('Something')
+        expect(exposure.conditions[0].cond_hash).to eq(awesome: true)
       end
 
       it 'overrides nested :as option' do
@@ -379,7 +847,8 @@ describe Grape::Entity do
           end
         end
 
-        expect(subject.exposures[:awesome_thing]).to eq(as: :extra_smooth)
+        exposure = subject.find_exposure(:awesome_thing)
+        expect(exposure.key(subject)).to eq :extra_smooth
       end
 
       it 'merges nested :if option' do
@@ -401,10 +870,11 @@ describe Grape::Entity do
           end
         end
 
-        expect(subject.exposures[:awesome_thing]).to eq(
-          if: { awesome: false, less_awesome: true },
-          if_extras: [:awesome, match_proc]
-        )
+        exposure = subject.find_exposure(:awesome_thing)
+        expect(exposure.conditions.any?(&:inversed?)).to be_falsey
+        expect(exposure.conditions[0].symbol).to eq(:awesome)
+        expect(exposure.conditions[1].block).to eq(match_proc)
+        expect(exposure.conditions[2].cond_hash).to eq(awesome: false, less_awesome: true)
       end
 
       it 'merges nested :unless option' do
@@ -426,10 +896,11 @@ describe Grape::Entity do
           end
         end
 
-        expect(subject.exposures[:awesome_thing]).to eq(
-          unless: { awesome: false, less_awesome: true },
-          unless_extras: [:awesome, match_proc]
-        )
+        exposure = subject.find_exposure(:awesome_thing)
+        expect(exposure.conditions.all?(&:inversed?)).to be_truthy
+        expect(exposure.conditions[0].symbol).to eq(:awesome)
+        expect(exposure.conditions[1].block).to eq(match_proc)
+        expect(exposure.conditions[2].cond_hash).to eq(awesome: false, less_awesome: true)
       end
 
       it 'overrides nested :using option' do
@@ -439,7 +910,8 @@ describe Grape::Entity do
           end
         end
 
-        expect(subject.exposures[:awesome_thing]).to eq(using: 'SomethingElse')
+        exposure = subject.find_exposure(:awesome_thing)
+        expect(exposure.using_class_name).to eq('SomethingElse')
       end
 
       it 'aliases :with option to :using option' do
@@ -448,7 +920,9 @@ describe Grape::Entity do
             expose :awesome_thing, with: 'SomethingElse'
           end
         end
-        expect(subject.exposures[:awesome_thing]).to eq(using: 'SomethingElse')
+
+        exposure = subject.find_exposure(:awesome_thing)
+        expect(exposure.using_class_name).to eq('SomethingElse')
       end
 
       it 'overrides nested :proc option' do
@@ -460,7 +934,8 @@ describe Grape::Entity do
           end
         end
 
-        expect(subject.exposures[:awesome_thing]).to eq(proc: match_proc)
+        exposure = subject.find_exposure(:awesome_thing)
+        expect(exposure.block).to eq(match_proc)
       end
 
       it 'overrides nested :documentation option' do
@@ -470,7 +945,36 @@ describe Grape::Entity do
           end
         end
 
-        expect(subject.exposures[:awesome_thing]).to eq(documentation: { desc: 'Other description.' })
+        exposure = subject.find_exposure(:awesome_thing)
+        expect(exposure.documentation).to eq(desc: 'Other description.')
+      end
+
+      it 'propagates expose_nil option' do
+        subject.class_eval do
+          with_options(expose_nil: false) do
+            expose :awesome_thing
+          end
+        end
+
+        exposure = subject.find_exposure(:awesome_thing)
+        expect(exposure.conditions[0].inversed?).to be true
+        expect(exposure.conditions[0].block.call(awesome_thing: nil)).to be true
+      end
+
+      it 'overrides nested :expose_nil option' do
+        subject.class_eval do
+          with_options(expose_nil: true) do
+            expose :awesome_thing, expose_nil: false
+            expose :other_awesome_thing
+          end
+        end
+
+        exposure = subject.find_exposure(:awesome_thing)
+        expect(exposure.conditions[0].inversed?).to be true
+        expect(exposure.conditions[0].block.call(awesome_thing: nil)).to be true
+        # Conditions are only added for exposures that do not expose nil
+        exposure = subject.find_exposure(:other_awesome_thing)
+        expect(exposure.conditions[0]).to be_nil
       end
     end
 
@@ -484,14 +988,14 @@ describe Grape::Entity do
       end
 
       it 'returns multiple entities if called with a collection' do
-        representation = subject.represent(4.times.map { Object.new })
+        representation = subject.represent(Array.new(4) { Object.new })
         expect(representation).to be_kind_of Array
         expect(representation.size).to eq(4)
         expect(representation.reject { |r| r.is_a?(subject) }).to be_empty
       end
 
       it 'adds the collection: true option if called with a collection' do
-        representation = subject.represent(4.times.map { Object.new })
+        representation = subject.represent(Array.new(4) { Object.new })
         representation.each { |r| expect(r.options[:collection]).to be true }
       end
 
@@ -503,7 +1007,7 @@ describe Grape::Entity do
 
       it 'returns a serialized array of hashes of multiple objects if serializable: true' do
         subject.expose(:awesome) { |_| true }
-        representation = subject.represent(2.times.map { Object.new }, serializable: true)
+        representation = subject.represent(Array.new(2) { Object.new }, serializable: true)
         expect(representation).to eq([{ awesome: true }, { awesome: true }])
       end
 
@@ -529,7 +1033,7 @@ describe Grape::Entity do
       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)
+          representation = subject.represent(OpenStruct.new, only: %i[id name], serializable: true)
           expect(representation).to eq(id: nil, name: nil)
         end
 
@@ -542,7 +1046,7 @@ describe Grape::Entity do
         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],
+                                             only: %i[name phone],
                                              except: [:phone], serializable: true)
           expect(representation).to eq(name: nil)
         end
@@ -587,6 +1091,22 @@ describe Grape::Entity 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
+
+          context 'with nested attributes' do
+            before do
+              subject.expose :additional do
+                subject.expose :something
+              end
+            end
+
+            it 'preserves nesting' do
+              expect(subject.represent({ something: 123 }, only: [{ additional: [:something] }], serializable: true)).to eq(
+                additional: {
+                  something: 123
+                }
+              )
+            end
+          end
         end
 
         it 'can specify children attributes with only' do
@@ -596,7 +1116,7 @@ describe Grape::Entity do
           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)
+          representation = subject.represent(OpenStruct.new(user: {}), only: [:id, :name, { user: %i[name email] }], serializable: true)
           expect(representation).to eq(id: nil, name: nil, user: { name: nil, email: nil })
         end
 
@@ -619,7 +1139,7 @@ describe Grape::Entity do
           subject.expose(:user, using: user_entity)
 
           representation = subject.represent(OpenStruct.new(user: {}),
-                                             only: [:id, :name, :phone, user: [:id, :name, :email]],
+                                             only: [:id, :name, :phone, { user: %i[id name email] }],
                                              except: [:phone, { user: [:id] }], serializable: true)
           expect(representation).to eq(id: nil, name: nil, user: { name: nil, email: nil })
         end
@@ -631,7 +1151,7 @@ describe Grape::Entity do
               subject.expose(:name)
             end
 
-            representation = subject.represent(OpenStruct.new, condition: true, only: [:id, :name], serializable: true)
+            representation = subject.represent(OpenStruct.new, condition: true, only: %i[id name], serializable: true)
             expect(representation).to eq(id: nil, name: nil)
           end
 
@@ -641,9 +1161,81 @@ describe Grape::Entity do
               subject.expose(:name, :mobile_phone)
             end
 
-            representation = subject.represent(OpenStruct.new, condition: true, except: [:phone, :mobile_phone], serializable: true)
+            representation = subject.represent(OpenStruct.new, condition: true, except: %i[phone mobile_phone], serializable: true)
             expect(representation).to eq(id: nil, name: nil)
           end
+
+          it 'choses proper exposure according to condition' do
+            strategy1 = ->(_obj, _opts) { 'foo' }
+            strategy2 = ->(_obj, _opts) { 'bar' }
+
+            subject.expose :id, proc: strategy1
+            subject.expose :id, proc: strategy2
+            expect(subject.represent({}, condition: false, serializable: true)).to eq(id: 'bar')
+            expect(subject.represent({}, condition: true, serializable: true)).to eq(id: 'bar')
+
+            subject.unexpose_all
+
+            subject.expose :id, proc: strategy1, if: :condition
+            subject.expose :id, proc: strategy2
+            expect(subject.represent({}, condition: false, serializable: true)).to eq(id: 'bar')
+            expect(subject.represent({}, condition: true, serializable: true)).to eq(id: 'bar')
+
+            subject.unexpose_all
+
+            subject.expose :id, proc: strategy1
+            subject.expose :id, proc: strategy2, if: :condition
+            expect(subject.represent({}, condition: false, serializable: true)).to eq(id: 'foo')
+            expect(subject.represent({}, condition: true, serializable: true)).to eq(id: 'bar')
+
+            subject.unexpose_all
+
+            subject.expose :id, proc: strategy1, if: :condition1
+            subject.expose :id, proc: strategy2, if: :condition2
+            expect(subject.represent({}, condition1: false, condition2: false, serializable: true)).to eq({})
+            expect(subject.represent({}, condition1: false, condition2: true, serializable: true)).to eq(id: 'bar')
+            expect(subject.represent({}, condition1: true, condition2: false, serializable: true)).to eq(id: 'foo')
+            expect(subject.represent({}, condition1: true, condition2: true, serializable: true)).to eq(id: 'bar')
+          end
+
+          it 'does not merge nested exposures with plain hashes' do
+            subject.expose(:id)
+            subject.expose(:info, if: :condition1) do
+              subject.expose :a, :b
+              subject.expose(:additional, if: :condition2) do |_obj, _opts|
+                {
+                  x: 11, y: 22, c: 123
+                }
+              end
+            end
+            subject.expose(:info, if: :condition2) do
+              subject.expose(:additional) do
+                subject.expose :c
+              end
+            end
+            subject.expose(:d, as: :info, if: :condition3)
+
+            obj = { id: 123, a: 1, b: 2, c: 3, d: 4 }
+
+            expect(subject.represent(obj, serializable: true)).to eq(id: 123)
+            expect(subject.represent(obj, condition1: true, serializable: true)).to eq(id: 123, info: { a: 1, b: 2 })
+            expect(subject.represent(obj, condition2: true, serializable: true)).to eq(
+              id: 123,
+              info: {
+                additional: {
+                  c: 3
+                }
+              }
+            )
+            expect(subject.represent(obj, condition1: true, condition2: true, serializable: true)).to eq(
+              id: 123,
+              info: {
+                a: 1, b: 2, additional: { c: 3 }
+              }
+            )
+            expect(subject.represent(obj, condition3: true, serializable: true)).to eq(id: 123, info: 4)
+            expect(subject.represent(obj, condition1: true, condition2: true, condition3: true, serializable: true)).to eq(id: 123, info: 4)
+          end
         end
 
         context 'attribute with alias' do
@@ -651,7 +1243,7 @@ describe Grape::Entity do
             subject.expose(:id)
             subject.expose(:name, as: :title)
 
-            representation = subject.represent(OpenStruct.new, condition: true, only: [:id, :title], serializable: true)
+            representation = subject.represent(OpenStruct.new, condition: true, only: %i[id title], serializable: true)
             expect(representation).to eq(id: nil, title: nil)
           end
 
@@ -678,10 +1270,22 @@ describe Grape::Entity do
             subject.expose(:nephew, using: nephew_entity)
 
             representation = subject.represent(OpenStruct.new(user: {}),
-                                               only: [:id, :name, :user], except: [:nephew], serializable: true)
+                                               only: %i[id name user], except: [:nephew], serializable: true)
             expect(representation).to eq(id: nil, name: nil, user: { id: nil, name: nil, email: nil })
           end
         end
+
+        context 'when NameError happens in a parameterized block_exposure' do
+          before do
+            subject.expose :raise_no_method_error do |_|
+              foo
+            end
+          end
+
+          it 'does not cause infinite loop' do
+            expect { subject.represent({}, serializable: true) }.to raise_error(NameError)
+          end
+        end
       end
     end
 
@@ -690,7 +1294,7 @@ describe Grape::Entity do
         subject.present_collection true
         subject.expose :items
 
-        representation = subject.represent(4.times.map { Object.new })
+        representation = subject.represent(Array.new(4) { Object.new })
         expect(representation).to be_kind_of(subject)
         expect(representation.object).to be_kind_of(Hash)
         expect(representation.object).to have_key :items
@@ -702,7 +1306,8 @@ describe Grape::Entity do
         subject.present_collection true, :my_items
         subject.expose :my_items
 
-        representation = subject.represent(4.times.map { Object.new }, serializable: true)
+        representation = subject.represent(Array.new(4) { Object.new }, serializable: true)
+        expect(representation).to be_kind_of(Grape::Entity::Exposure::NestingExposure::OutputBuilder)
         expect(representation).to be_kind_of(Hash)
         expect(representation).to have_key :my_items
         expect(representation[:my_items]).to be_kind_of Array
@@ -727,7 +1332,7 @@ describe Grape::Entity do
 
         context 'with an array of objects' do
           it 'allows a root element name to be specified' do
-            representation = subject.represent(4.times.map { Object.new })
+            representation = subject.represent(Array.new(4) { Object.new })
             expect(representation).to be_kind_of Hash
             expect(representation).to have_key 'things'
             expect(representation['things']).to be_kind_of Array
@@ -738,13 +1343,13 @@ describe Grape::Entity do
 
         context 'it can be overridden' do
           it 'can be disabled' do
-            representation = subject.represent(4.times.map { Object.new }, root: false)
+            representation = subject.represent(Array.new(4) { Object.new }, root: false)
             expect(representation).to be_kind_of Array
             expect(representation.size).to eq 4
             expect(representation.reject { |r| r.is_a?(subject) }).to be_empty
           end
           it 'can use a different name' do
-            representation = subject.represent(4.times.map { Object.new }, root: 'others')
+            representation = subject.represent(Array.new(4) { Object.new }, root: 'others')
             expect(representation).to be_kind_of Hash
             expect(representation).to have_key 'others'
             expect(representation['others']).to be_kind_of Array
@@ -770,7 +1375,7 @@ describe Grape::Entity do
 
         context 'with an array of objects' do
           it 'allows a root element name to be specified' do
-            representation = subject.represent(4.times.map { Object.new })
+            representation = subject.represent(Array.new(4) { Object.new })
             expect(representation).to be_kind_of Array
             expect(representation.size).to eq 4
             expect(representation.reject { |r| r.is_a?(subject) }).to be_empty
@@ -791,7 +1396,7 @@ describe Grape::Entity do
 
         context 'with an array of objects' do
           it 'allows a root element name to be specified' do
-            representation = subject.represent(4.times.map { Object.new })
+            representation = subject.represent(Array.new(4) { Object.new })
             expect(representation).to be_kind_of Hash
             expect(representation).to have_key('things')
             expect(representation['things']).to be_kind_of Array
@@ -816,7 +1421,7 @@ describe Grape::Entity do
 
         it 'inherits array root root' do
           child_class = Class.new(subject)
-          representation = child_class.represent(4.times.map { Object.new })
+          representation = child_class.represent(Array.new(4) { Object.new })
           expect(representation).to be_kind_of Hash
           expect(representation).to have_key('things')
           expect(representation['things']).to be_kind_of Array
@@ -856,6 +1461,11 @@ describe Grape::Entity do
         friends: [
           double(name: 'Friend 1', email: 'friend1@example.com', characteristics: [], fantasies: [], birthday: Time.gm(2012, 2, 27), friends: []),
           double(name: 'Friend 2', email: 'friend2@example.com', characteristics: [], fantasies: [], birthday: Time.gm(2012, 2, 27), friends: [])
+        ],
+        extra: { key: 'foo', value: 'bar' },
+        nested: [
+          { name: 'n1', data: { key: 'ex1', value: 'v1' } },
+          { name: 'n2', data: { key: 'ex2', value: 'v2' } }
         ]
       }
     end
@@ -889,7 +1499,7 @@ describe Grape::Entity do
           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
+        it "does expose attributes that don't exist on the object" do
           fresh_class.expose :email, :nonexistent_attribute, :name, safe: true
 
           res = fresh_class.new(model).serializable_hash
@@ -898,6 +1508,13 @@ describe Grape::Entity do
           expect(res).to have_key :name
         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[:nonexistent_attribute]).to eq(nil)
+        end
+
         it 'does expose attributes marked as safe if model is a hash object' do
           fresh_class.expose :name, safe: true
 
@@ -920,7 +1537,7 @@ describe Grape::Entity do
       context 'without safe option' do
         it 'throws an exception when an attribute is not found on the object' do
           fresh_class.expose :name, :nonexistent_attribute
-          expect { fresh_class.new(model).serializable_hash }.to raise_error
+          expect { fresh_class.new(model).serializable_hash }.to raise_error NoMethodError
         end
 
         it "exposes attributes that don't exist on the object only when they are generated by a block" do
@@ -953,6 +1570,18 @@ describe Grape::Entity do
         expect(res).to have_key :nonexistent_attribute
       end
 
+      it 'exposes attributes defined through module inclusion' do
+        module SharedAttributes
+          def a_value
+            3.14
+          end
+        end
+        fresh_class.include(SharedAttributes)
+        fresh_class.expose :a_value
+        res = fresh_class.new(model).serializable_hash
+        expect(res[:a_value]).to eq(3.14)
+      end
+
       it 'does not expose attributes that are generated by a block but have not passed criteria' do
         fresh_class.expose :nonexistent_attribute,
                            proc: ->(_, _) { 'I exist, but it is not yet my time to shine' },
@@ -1018,6 +1647,124 @@ describe Grape::Entity do
           expect(presenter.serializable_hash).to eq(name: 'abc', embedded: { a: nil, b: { abc: 'def' } })
         end
       end
+
+      context '#attr_path' do
+        it 'for all kinds of attributes' do
+          module EntitySpec
+            class EmailEntity < Grape::Entity
+              expose(:email, as: :addr) { |_, o| o[:attr_path].join('/') }
+            end
+
+            class UserEntity < Grape::Entity
+              expose(:name, as: :full_name) { |_, o| o[:attr_path].join('/') }
+              expose :email, using: 'EntitySpec::EmailEntity'
+            end
+
+            class ExtraEntity < Grape::Entity
+              expose(:key) { |_, o| o[:attr_path].join('/') }
+              expose(:value) { |_, o| o[:attr_path].join('/') }
+            end
+
+            class NestedEntity < Grape::Entity
+              expose(:name) { |_, o| o[:attr_path].join('/') }
+              expose :data, using: 'EntitySpec::ExtraEntity'
+            end
+          end
+
+          fresh_class.class_eval do
+            expose(:id) { |_, o| o[:attr_path].join('/') }
+            expose(:foo, as: :bar) { |_, o| o[:attr_path].join('/') }
+            expose :title do
+              expose :full do
+                expose(:prefix, as: :pref) { |_, o| o[:attr_path].join('/') }
+                expose(:main) { |_, o| o[:attr_path].join('/') }
+              end
+            end
+            expose :friends, as: :social, using: 'EntitySpec::UserEntity'
+            expose :extra, using: 'EntitySpec::ExtraEntity'
+            expose :nested, using: 'EntitySpec::NestedEntity'
+          end
+
+          expect(subject.serializable_hash).to eq(
+            id: 'id',
+            bar: 'bar',
+            title: { full: { pref: 'title/full/pref', main: 'title/full/main' } },
+            social: [
+              { full_name: 'social/full_name', email: { addr: 'social/email/addr' } },
+              { full_name: 'social/full_name', email: { addr: 'social/email/addr' } }
+            ],
+            extra: { key: 'extra/key', value: 'extra/value' },
+            nested: [
+              { name: 'nested/name', data: { key: 'nested/data/key', value: 'nested/data/value' } },
+              { name: 'nested/name', data: { key: 'nested/data/key', value: 'nested/data/value' } }
+            ]
+          )
+        end
+
+        it 'allows customize path of an attribute' do
+          module EntitySpec
+            class CharacterEntity < Grape::Entity
+              expose(:key) { |_, o| o[:attr_path].join('/') }
+              expose(:value) { |_, o| o[:attr_path].join('/') }
+            end
+          end
+
+          fresh_class.class_eval do
+            expose :characteristics, using: EntitySpec::CharacterEntity,
+                                     attr_path: ->(_obj, _opts) { :character }
+          end
+
+          expect(subject.serializable_hash).to eq(
+            characteristics: [
+              { key: 'character/key', value: 'character/value' }
+            ]
+          )
+        end
+
+        it 'can drop one nest level by set path_for to nil' do
+          module EntitySpec
+            class NoPathCharacterEntity < Grape::Entity
+              expose(:key) { |_, o| o[:attr_path].join('/') }
+              expose(:value) { |_, o| o[:attr_path].join('/') }
+            end
+          end
+
+          fresh_class.class_eval do
+            expose :characteristics, using: EntitySpec::NoPathCharacterEntity, attr_path: proc {}
+          end
+
+          expect(subject.serializable_hash).to eq(
+            characteristics: [
+              { key: 'key', value: 'value' }
+            ]
+          )
+        end
+      end
+
+      context 'with projections passed in options' do
+        it 'allows to pass different :only and :except params using the same instance' do
+          fresh_class.expose :a, :b, :c
+          presenter = fresh_class.new(a: 1, b: 2, c: 3)
+          expect(presenter.serializable_hash(only: %i[a b])).to eq(a: 1, b: 2)
+          expect(presenter.serializable_hash(only: %i[b c])).to eq(b: 2, c: 3)
+        end
+      end
+    end
+
+    describe '#inspect' do
+      before do
+        fresh_class.class_eval do
+          expose :name, :email
+        end
+      end
+
+      it 'does not serialize delegator or options' do
+        data = subject.inspect
+        expect(data).to include 'name='
+        expect(data).to include 'email='
+        expect(data).to_not include '@options'
+        expect(data).to_not include '@delegator'
+      end
     end
 
     describe '#value_for' do
@@ -1040,17 +1787,19 @@ describe Grape::Entity do
       end
 
       it 'passes through bare expose attributes' do
-        expect(subject.send(:value_for, :name)).to eq attributes[:name]
+        expect(subject.value_for(:name)).to eq attributes[:name]
       end
 
       it 'instantiates a representation if that is called for' do
-        rep = subject.send(:value_for, :friends)
+        rep = subject.value_for(:friends)
         expect(rep.reject { |r| r.is_a?(fresh_class) }).to be_empty
         expect(rep.first.serializable_hash[:name]).to eq 'Friend 1'
         expect(rep.last.serializable_hash[:name]).to eq 'Friend 2'
       end
 
       context 'child representations' do
+        after { EntitySpec::FriendEntity.unexpose_all }
+
         it 'disables root key name for child representations' do
           module EntitySpec
             class FriendEntity < Grape::Entity
@@ -1063,7 +1812,7 @@ describe Grape::Entity do
             expose :friends, using: EntitySpec::FriendEntity
           end
 
-          rep = subject.send(:value_for, :friends)
+          rep = subject.value_for(:friends)
           expect(rep).to be_kind_of Array
           expect(rep.reject { |r| r.is_a?(EntitySpec::FriendEntity) }).to be_empty
           expect(rep.first.serializable_hash[:name]).to eq 'Friend 1'
@@ -1084,7 +1833,7 @@ describe Grape::Entity do
             end
           end
 
-          rep = subject.send(:value_for, :custom_friends)
+          rep = subject.value_for(:custom_friends)
           expect(rep).to be_kind_of Array
           expect(rep.reject { |r| r.is_a?(EntitySpec::FriendEntity) }).to be_empty
           expect(rep.first.serializable_hash).to eq(name: 'Friend 1', email: 'friend1@example.com')
@@ -1105,7 +1854,7 @@ describe Grape::Entity do
             end
           end
 
-          rep = subject.send(:value_for, :first_friend)
+          rep = subject.value_for(:first_friend)
           expect(rep).to be_kind_of EntitySpec::FriendEntity
           expect(rep.serializable_hash).to eq(name: 'Friend 1', email: 'friend1@example.com')
         end
@@ -1118,12 +1867,14 @@ describe Grape::Entity do
             end
           end
 
+          # rubocop:disable Lint/EmptyBlock
           fresh_class.class_eval do
             expose :first_friend, using: EntitySpec::FriendEntity do |_user, _opts|
             end
           end
+          # rubocop:enable Lint/EmptyBlock
 
-          rep = subject.send(:value_for, :first_friend)
+          rep = subject.value_for(:first_friend)
           expect(rep).to be_kind_of EntitySpec::FriendEntity
           expect(rep.serializable_hash).to be_nil
         end
@@ -1140,7 +1891,7 @@ describe Grape::Entity do
             expose :characteristics, using: EntitySpec::CharacteristicsEntity
           end
 
-          rep = subject.send(:value_for, :characteristics)
+          rep = subject.value_for(:characteristics)
           expect(rep).to be_kind_of Array
           expect(rep.reject { |r| r.is_a?(EntitySpec::CharacteristicsEntity) }).to be_empty
           expect(rep.first.serializable_hash[:key]).to eq 'hair_color'
@@ -1160,13 +1911,13 @@ describe Grape::Entity do
             expose :friends, using: EntitySpec::FriendEntity
           end
 
-          rep = subject.send(:value_for, :friends)
+          rep = subject.value_for(:friends)
           expect(rep).to be_kind_of Array
           expect(rep.reject { |r| r.is_a?(EntitySpec::FriendEntity) }).to be_empty
           expect(rep.first.serializable_hash[:email]).to be_nil
           expect(rep.last.serializable_hash[:email]).to be_nil
 
-          rep = subject.send(:value_for, :friends,  user_type: :admin)
+          rep = subject.value_for(:friends, Grape::Entity::Options.new(user_type: :admin))
           expect(rep).to be_kind_of Array
           expect(rep.reject { |r| r.is_a?(EntitySpec::FriendEntity) }).to be_empty
           expect(rep.first.serializable_hash[:email]).to eq 'friend1@example.com'
@@ -1186,7 +1937,7 @@ describe Grape::Entity do
             expose :friends, using: EntitySpec::FriendEntity
           end
 
-          rep = subject.send(:value_for, :friends,  collection: false)
+          rep = subject.value_for(:friends, Grape::Entity::Options.new(collection: false))
           expect(rep).to be_kind_of Array
           expect(rep.reject { |r| r.is_a?(EntitySpec::FriendEntity) }).to be_empty
           expect(rep.first.serializable_hash[:email]).to eq 'friend1@example.com'
@@ -1195,23 +1946,24 @@ describe Grape::Entity do
       end
 
       it 'calls through to the proc if there is one' do
-        expect(subject.send(:value_for, :computed, awesome: 123)).to eq 123
+        expect(subject.value_for(:computed, Grape::Entity::Options.new(awesome: 123))).to eq 123
       end
 
       it 'returns a formatted value if format_with is passed' do
-        expect(subject.send(:value_for, :birthday)).to eq '02/27/2012'
+        expect(subject.value_for(:birthday)).to eq '02/27/2012'
       end
 
       it 'returns a formatted value if format_with is passed a lambda' do
-        expect(subject.send(:value_for, :fantasies)).to eq ['Nessy', 'Double Rainbows', 'Unicorns']
+        expect(subject.value_for(:fantasies)).to eq ['Nessy', 'Double Rainbows', 'Unicorns']
       end
 
-      it 'tries instance methods on the entity first' do
+      context 'delegate_attribute' do
         module EntitySpec
           class DelegatingEntity < Grape::Entity
             root 'friends', 'friend'
             expose :name
             expose :email
+            expose :system
 
             private
 
@@ -1221,14 +1973,33 @@ describe Grape::Entity do
           end
         end
 
-        friend = double('Friend', name: 'joe', email: 'joe@example.com')
-        rep = EntitySpec::DelegatingEntity.new(friend)
-        expect(rep.send(:value_for, :name)).to eq 'cooler name'
-        expect(rep.send(:value_for, :email)).to eq 'joe@example.com'
+        it 'tries instance methods on the entity first' do
+          friend = double('Friend', name: 'joe', email: 'joe@example.com')
+          rep = EntitySpec::DelegatingEntity.new(friend)
+          expect(rep.value_for(:name)).to eq 'cooler name'
+          expect(rep.value_for(:email)).to eq 'joe@example.com'
+
+          another_friend = double('Friend', email: 'joe@example.com')
+          rep = EntitySpec::DelegatingEntity.new(another_friend)
+          expect(rep.value_for(:name)).to eq 'cooler name'
+        end
+
+        it 'does not delegate Kernel methods' do
+          foo = double 'Foo', system: 'System'
+          rep = EntitySpec::DelegatingEntity.new foo
+          expect(rep.value_for(:system)).to eq 'System'
+        end
 
-        another_friend = double('Friend', email: 'joe@example.com')
-        rep = EntitySpec::DelegatingEntity.new(another_friend)
-        expect(rep.send(:value_for, :name)).to eq 'cooler name'
+        module EntitySpec
+          class DerivedEntity < DelegatingEntity
+          end
+        end
+
+        it 'derived entity get methods from base entity' do
+          foo = double 'Foo', name: 'joe'
+          rep = EntitySpec::DerivedEntity.new foo
+          expect(rep.value_for(:name)).to eq 'cooler name'
+        end
       end
 
       context 'using' do
@@ -1244,7 +2015,7 @@ describe Grape::Entity do
             expose :friends, using: 'EntitySpec::UserEntity'
           end
 
-          rep = subject.send(:value_for, :friends)
+          rep = subject.value_for(:friends)
           expect(rep).to be_kind_of Array
           expect(rep.size).to eq 2
           expect(rep.all? { |r| r.is_a?(EntitySpec::UserEntity) }).to be true
@@ -1255,7 +2026,7 @@ describe Grape::Entity do
             expose :friends, using: EntitySpec::UserEntity
           end
 
-          rep = subject.send(:value_for, :friends)
+          rep = subject.value_for(:friends)
           expect(rep).to be_kind_of Array
           expect(rep.size).to eq 2
           expect(rep.all? { |r| r.is_a?(EntitySpec::UserEntity) }).to be true
@@ -1263,7 +2034,7 @@ describe Grape::Entity do
       end
     end
 
-    describe '#documentation' do
+    describe '.documentation' do
       it 'returns an empty hash is no documentation is provided' do
         fresh_class.expose :name
 
@@ -1288,6 +2059,18 @@ describe Grape::Entity do
         expect(subject.documentation).to eq(label: doc, email: doc)
       end
 
+      it 'resets memoization when exposing additional attributes' do
+        fresh_class.expose :x, documentation: { desc: 'just x' }
+        expect(fresh_class.instance_variable_get(:@documentation)).to be_nil
+        doc1 = fresh_class.documentation
+        expect(fresh_class.instance_variable_get(:@documentation)).not_to be_nil
+        fresh_class.expose :y, documentation: { desc: 'just y' }
+        expect(fresh_class.instance_variable_get(:@documentation)).to be_nil
+        doc2 = fresh_class.documentation
+        expect(doc1).to eq(x: { desc: 'just x' })
+        expect(doc2).to eq(x: { desc: 'just x' }, y: { desc: 'just y' })
+      end
+
       context 'inherited documentation' do
         it 'returns documentation from ancestor' do
           doc = { type: 'foo', desc: 'bar' }
@@ -1326,78 +2109,14 @@ describe Grape::Entity do
           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
-      it 'returns the attribute if no :as is set' do
-        fresh_class.expose :name
-        expect(subject.class.send(:key_for, :name)).to eq :name
-      end
 
-      it 'returns a symbolized version of the attribute' do
-        fresh_class.expose :name
-        expect(subject.class.send(:key_for, 'name')).to eq :name
-      end
-
-      it 'returns the :as alias if one exists' do
-        fresh_class.expose :name, as: :nombre
-        expect(subject.class.send(:key_for, 'name')).to eq :nombre
-      end
-    end
-
-    describe '#conditions_met?' do
-      it 'only passes through hash :if exposure if all attributes match' do
-        exposure_options = { if: { condition1: true, condition2: true } }
-
-        expect(subject.send(:conditions_met?, exposure_options, {})).to be false
-        expect(subject.send(:conditions_met?, exposure_options, condition1: true)).to be false
-        expect(subject.send(:conditions_met?, exposure_options, condition1: true, condition2: true)).to be true
-        expect(subject.send(:conditions_met?, exposure_options, condition1: false, condition2: true)).to be false
-        expect(subject.send(:conditions_met?, exposure_options, condition1: true, condition2: true, other: true)).to be true
-      end
-
-      it 'looks for presence/truthiness if a symbol is passed' do
-        exposure_options = { if: :condition1 }
-
-        expect(subject.send(:conditions_met?, exposure_options, {})).to be false
-        expect(subject.send(:conditions_met?, exposure_options,  condition1: true)).to be true
-        expect(subject.send(:conditions_met?, exposure_options,  condition1: false)).to be false
-        expect(subject.send(:conditions_met?, exposure_options,  condition1: nil)).to be false
-      end
-
-      it 'looks for absence/falsiness if a symbol is passed' do
-        exposure_options = { unless: :condition1 }
-
-        expect(subject.send(:conditions_met?, exposure_options, {})).to be true
-        expect(subject.send(:conditions_met?, exposure_options,  condition1: true)).to be false
-        expect(subject.send(:conditions_met?, exposure_options,  condition1: false)).to be true
-        expect(subject.send(:conditions_met?, exposure_options,  condition1: nil)).to be true
-      end
-
-      it 'only passes through proc :if exposure if it returns truthy value' do
-        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
-      end
-
-      it 'only passes through hash :unless exposure if any attributes do not match' do
-        exposure_options = { unless: { condition1: true, condition2: true } }
-
-        expect(subject.send(:conditions_met?, exposure_options, {})).to be true
-        expect(subject.send(:conditions_met?, exposure_options, condition1: true)).to be false
-        expect(subject.send(:conditions_met?, exposure_options, condition1: true, condition2: true)).to be false
-        expect(subject.send(:conditions_met?, exposure_options, condition1: false, condition2: true)).to be false
-        expect(subject.send(:conditions_met?, exposure_options, condition1: true, condition2: true, other: true)).to be false
-        expect(subject.send(:conditions_met?, exposure_options, condition1: false, condition2: false)).to be true
-      end
-
-      it 'only passes through proc :unless exposure if it returns falsy value' do
-        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
+        it 'includes only root exposures' do
+          fresh_class.expose :name, documentation: { desc: 'foo' }
+          fresh_class.expose :nesting do
+            fresh_class.expose :smth, documentation: { desc: 'should not be seen' }
+          end
+          expect(fresh_class.documentation).to eq(name: { desc: 'foo' })
+        end
       end
     end
 
@@ -1418,19 +2137,19 @@ describe Grape::Entity do
             expose :name
           end
 
-          expect(subject.entity_class.exposures).not_to be_empty
+          expect(subject.entity_class.root_exposures).not_to be_empty
         end
 
         it 'is able to expose straight from the class' do
           subject.entity :name, :email
-          expect(subject.entity_class.exposures.size).to eq 2
+          expect(subject.entity_class.root_exposures.size).to eq 2
         end
 
-        it 'is able to mix field and advanced exposures' do
+        it 'is able to mix field and advanced.root_exposures' do
           subject.entity :name, :email do
             expose :third
           end
-          expect(subject.entity_class.exposures.size).to eq 3
+          expect(subject.entity_class.root_exposures.size).to eq 3
         end
 
         context 'instance' do