grape-entity 0.6.0 → 0.8.1

data/lib/grape_entity/exposure/represent_exposure.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Grape
   class Entity
     module Exposure
@@ -21,7 +23,7 @@ module Grape
         end
 
         def value(entity, options)
-          new_options = options.for_nesting(key)
+          new_options = options.for_nesting(key(entity))
           using_class.represent(@subexposure.value(entity, options), new_options)
         end
 

data/lib/grape_entity/options.rb

@@ -1,8 +1,16 @@
+# frozen_string_literal: true
+
+require 'forwardable'
+
 module Grape
   class Entity
     class Options
+      extend Forwardable
+
       attr_reader :opts_hash
 
+      def_delegators :opts_hash, :dig, :key?, :fetch, :[], :empty
+
       def initialize(opts_hash = {})
         @opts_hash = opts_hash
         @has_only = !opts_hash[:only].nil?
@@ -11,54 +19,33 @@ module Grape
         @should_return_key_cache = {}
       end
 
-      def [](key)
-        @opts_hash[key]
-      end
+      def merge(new_opts)
+        return self if new_opts.empty?
 
-      def fetch(*args)
-        @opts_hash.fetch(*args)
-      end
+        merged = if new_opts.instance_of? Options
+                   @opts_hash.merge(new_opts.opts_hash)
+                 else
+                   @opts_hash.merge(new_opts)
+                 end
 
-      def key?(key)
-        @opts_hash.key? key
-      end
-
-      def merge(new_opts)
-        if new_opts.empty?
-          self
-        else
-          merged = if new_opts.instance_of? Options
-                     @opts_hash.merge(new_opts.opts_hash)
-                   else
-                     @opts_hash.merge(new_opts)
-                   end
-          Options.new(merged)
-        end
+        Options.new(merged)
       end
 
       def reverse_merge(new_opts)
-        if new_opts.empty?
-          self
-        else
-          merged = if new_opts.instance_of? Options
-                     new_opts.opts_hash.merge(@opts_hash)
-                   else
-                     new_opts.merge(@opts_hash)
-                   end
-          Options.new(merged)
-        end
-      end
+        return self if new_opts.empty?
 
-      def empty?
-        @opts_hash.empty?
+        merged = if new_opts.instance_of? Options
+                   new_opts.opts_hash.merge(@opts_hash)
+                 else
+                   new_opts.merge(@opts_hash)
+                 end
+
+        Options.new(merged)
       end
 
       def ==(other)
-        @opts_hash == if other.is_a? Options
-                        other.opts_hash
-                      else
-                        other
-                      end
+        other_hash = other.is_a?(Options) ? other.opts_hash : other
+        @opts_hash == other_hash
       end
 
       def should_return_key?(key)
@@ -66,7 +53,7 @@ module Grape
 
         only = only_fields.nil? ||
                only_fields.key?(key)
-        except = except_fields && except_fields.key?(key) &&
+        except = except_fields&.key?(key) &&
                  except_fields[key] == true
         only && !except
       end
@@ -96,36 +83,35 @@ module Grape
       end
 
       def with_attr_path(part)
+        return yield unless part
+
         stack = (opts_hash[:attr_path] ||= [])
-        if part
-          stack.push part
-          result = yield
-          stack.pop
-          result
-        else
-          yield
-        end
+        stack.push part
+        result = yield
+        stack.pop
+        result
       end
 
       private
 
       def build_for_nesting(key)
-        new_opts_hash = opts_hash.dup
-        new_opts_hash.delete(:collection)
-        new_opts_hash[:root] = nil
-        new_opts_hash[:only] = only_fields(key)
-        new_opts_hash[:except] = except_fields(key)
-        new_opts_hash[:attr_path] = opts_hash[:attr_path]
-
-        Options.new(new_opts_hash)
+        Options.new(
+          opts_hash.dup.reject { |current_key| current_key == :collection }.merge(
+            root: nil,
+            only: only_fields(key),
+            except: except_fields(key),
+            attr_path: opts_hash[:attr_path]
+          )
+        )
       end
 
       def build_symbolized_hash(attribute, hash)
-        if attribute.is_a?(Hash)
+        case attribute
+        when Hash
           attribute.each do |attr, nested_attrs|
             hash[attr.to_sym] = build_symbolized_hash(nested_attrs, {})
           end
-        elsif attribute.is_a?(Array)
+        when Array
           return attribute.each { |x| build_symbolized_hash(x, {}) }
         else
           hash[attribute.to_sym] = true

data/lib/grape_entity/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module GrapeEntity
-  VERSION = '0.6.0'.freeze
+  VERSION = '0.8.1'
 end

data/spec/grape_entity/entity_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 require 'ostruct'
 
@@ -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
@@ -64,6 +68,150 @@ describe Grape::Entity do
         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 a block' do
         it 'errors out if called with multiple attributes' do
           expect { subject.expose(:name, :email) { true } }.to raise_error ArgumentError
@@ -112,6 +260,30 @@ describe Grape::Entity do
           end
         end
 
+        context 'with block passed via &' do
+          it 'with does not pass options when block is passed via &' do
+            class SomeObject
+              def method_without_args
+                'result'
+              end
+            end
+
+            subject.expose :that_method_without_args do |object|
+              object.method_without_args
+            end
+
+            subject.expose :that_method_without_args_again, &:method_without_args
+
+            object = SomeObject.new
+
+            value = subject.represent(object).value_for(:that_method_without_args)
+            expect(value).to eq('result')
+
+            value2 = subject.represent(object).value_for(:that_method_without_args_again)
+            expect(value2).to eq('result')
+          end
+        end
+
         context 'with no parameters passed to the block' do
           it 'adds a nested exposure' do
             subject.expose :awesome do
@@ -131,7 +303,7 @@ describe Grape::Entity do
             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).to eq(:weee)
+            expect(moar_nested.key(subject)).to eq(:weee)
           end
 
           it 'represents the exposure as a hash of its nested.root_exposures' do
@@ -324,6 +496,24 @@ describe Grape::Entity do
           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
 
       context 'register formatters' do
@@ -496,7 +686,7 @@ describe Grape::Entity do
         end
 
         exposure = subject.find_exposure(:awesome_thing)
-        expect(exposure.key).to eq :extra_smooth
+        expect(exposure.key(subject)).to eq :extra_smooth
       end
 
       it 'merges nested :if option' do
@@ -596,6 +786,34 @@ describe Grape::Entity do
         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
 
     describe '.represent' do
@@ -653,7 +871,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
 
@@ -666,7 +884,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
@@ -736,7 +954,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
 
@@ -759,7 +977,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
@@ -771,7 +989,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
 
@@ -781,7 +999,7 @@ 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
 
@@ -863,7 +1081,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
 
@@ -890,7 +1108,7 @@ 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
@@ -1178,6 +1396,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' },
@@ -1341,8 +1571,8 @@ describe Grape::Entity 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: [:a, :b])).to eq(a: 1, b: 2)
-          expect(presenter.serializable_hash(only: [:b, :c])).to eq(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
@@ -1765,39 +1995,5 @@ describe Grape::Entity do
         end
       end
     end
-
-    describe Grape::Entity::Options do
-      module EntitySpec
-        class Crystalline
-          attr_accessor :prop1, :prop2
-
-          def initialize
-            @prop1 = 'value1'
-            @prop2 = 'value2'
-          end
-        end
-
-        class CrystallineEntity < Grape::Entity
-          expose :prop1, if: ->(_, options) { options.fetch(:signal) }
-          expose :prop2, if: ->(_, options) { options.fetch(:beam, 'destructive') == 'destructive' }
-        end
-      end
-
-      context '#fetch' do
-        it 'without passing in a required option raises KeyError' do
-          expect { EntitySpec::CrystallineEntity.represent(EntitySpec::Crystalline.new).as_json }.to raise_error KeyError
-        end
-
-        it 'passing in a required option will expose the values' do
-          crystalline_entity = EntitySpec::CrystallineEntity.represent(EntitySpec::Crystalline.new, signal: true)
-          expect(crystalline_entity.as_json).to eq(prop1: 'value1', prop2: 'value2')
-        end
-
-        it 'with an option that is not default will not expose that value' do
-          crystalline_entity = EntitySpec::CrystallineEntity.represent(EntitySpec::Crystalline.new, signal: true, beam: 'intermittent')
-          expect(crystalline_entity.as_json).to eq(prop1: 'value1')
-        end
-      end
-    end
   end
 end