grape-entity 0.6.1 → 0.7.0

data/lib/grape_entity/exposure/nesting_exposure.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Grape
   class Entity
     module Exposure
@@ -29,45 +31,33 @@ module Grape
         end
 
         def value(entity, options)
-          new_options = nesting_options_for(options)
-          output = OutputBuilder.new
-
-          normalized_exposures(entity, new_options).each_with_object(output) do |exposure, out|
-            exposure.with_attr_path(entity, new_options) do
-              result = exposure.value(entity, new_options)
-              out.add(exposure, result)
-            end
+          map_entity_exposures(entity, options) do |exposure, nested_options|
+            exposure.value(entity, nested_options)
           end
         end
 
-        def valid_value_for(key, entity, options)
-          new_options = nesting_options_for(options)
-
-          result = nil
-          normalized_exposures(entity, new_options).select { |e| e.key == key }.each do |exposure|
-            exposure.with_attr_path(entity, new_options) do
-              result = exposure.valid_value(entity, new_options)
-            end
+        def serializable_value(entity, options)
+          map_entity_exposures(entity, options) do |exposure, nested_options|
+            exposure.serializable_value(entity, nested_options)
           end
-          result
         end
 
-        def serializable_value(entity, options)
+        def valid_value_for(key, entity, options)
           new_options = nesting_options_for(options)
-          output = OutputBuilder.new
 
-          normalized_exposures(entity, new_options).each_with_object(output) do |exposure, out|
+          key_exposures = normalized_exposures(entity, new_options).select { |e| e.key(entity) == key }
+
+          key_exposures.map do |exposure|
             exposure.with_attr_path(entity, new_options) do
-              result = exposure.serializable_value(entity, new_options)
-              out.add(exposure, result)
+              exposure.valid_value(entity, new_options)
             end
-          end
+          end.last
         end
 
         # if we have any nesting exposures with the same name.
-        # delegate :deep_complex_nesting?, to: :nested_exposures
-        def deep_complex_nesting?
-          nested_exposures.deep_complex_nesting?
+        # delegate :deep_complex_nesting?(entity), to: :nested_exposures
+        def deep_complex_nesting?(entity)
+          nested_exposures.deep_complex_nesting?(entity)
         end
 
         private
@@ -90,15 +80,15 @@ module Grape
 
         # This method 'merges' subsequent nesting exposures with the same name if it's needed
         def normalized_exposures(entity, options)
-          return easy_normalized_exposures(entity, options) unless deep_complex_nesting? # optimization
+          return easy_normalized_exposures(entity, options) unless deep_complex_nesting?(entity) # optimization
 
           table = nested_exposures.each_with_object({}) do |exposure, output|
             should_expose = exposure.with_attr_path(entity, options) do
               exposure.should_expose?(entity, options)
             end
             next unless should_expose
-            output[exposure.key] ||= []
-            output[exposure.key] << exposure
+            output[exposure.key(entity)] ||= []
+            output[exposure.key(entity)] << exposure
           end
           table.map do |key, exposures|
             last_exposure = exposures.last
@@ -111,13 +101,27 @@ module Grape
               end
               new_nested_exposures = nesting_tail.flat_map(&:nested_exposures)
               NestingExposure.new(key, {}, [], new_nested_exposures).tap do |new_exposure|
-                new_exposure.instance_variable_set(:@deep_complex_nesting, true) if nesting_tail.any?(&:deep_complex_nesting?)
+                if nesting_tail.any? { |exposure| exposure.deep_complex_nesting?(entity) }
+                  new_exposure.instance_variable_set(:@deep_complex_nesting, true)
+                end
               end
             else
               last_exposure
             end
           end
         end
+
+        def map_entity_exposures(entity, options)
+          new_options = nesting_options_for(options)
+          output = OutputBuilder.new(entity)
+
+          normalized_exposures(entity, new_options).each_with_object(output) do |exposure, out|
+            exposure.with_attr_path(entity, new_options) do
+              result = yield(exposure, new_options)
+              out.add(exposure, result)
+            end
+          end
+        end
       end
     end
   end

data/lib/grape_entity/exposure/nesting_exposure/nested_exposures.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Grape
   class Entity
     module Exposure
@@ -14,6 +16,10 @@ module Grape
             @exposures.find { |e| e.attribute == attribute }
           end
 
+          def select_by(attribute)
+            @exposures.select { |e| e.attribute == attribute }
+          end
+
           def <<(exposure)
             reset_memoization!
             @exposures << exposure
@@ -30,18 +36,18 @@ module Grape
             @exposures.clear
           end
 
-          [
-            :each,
-            :to_ary, :to_a,
-            :all?,
-            :select,
-            :each_with_object,
-            :[],
-            :==,
-            :size,
-            :count,
-            :length,
-            :empty?
+          %i[
+            each
+            to_ary to_a
+            all?
+            select
+            each_with_object
+            \[\]
+            ==
+            size
+            count
+            length
+            empty?
           ].each do |name|
             class_eval <<-RUBY, __FILE__, __LINE__
               def #{name}(*args, &block)
@@ -51,10 +57,13 @@ module Grape
           end
 
           # Determine if we have any nesting exposures with the same name.
-          def deep_complex_nesting?
+          def deep_complex_nesting?(entity)
             if @deep_complex_nesting.nil?
               all_nesting = select(&:nesting?)
-              @deep_complex_nesting = all_nesting.group_by(&:key).any? { |_key, exposures| exposures.length > 1 }
+              @deep_complex_nesting =
+                all_nesting
+                .group_by { |exposure| exposure.key(entity) }
+                .any? { |_key, exposures| exposures.length > 1 }
             else
               @deep_complex_nesting
             end

data/lib/grape_entity/exposure/nesting_exposure/output_builder.rb

@@ -1,9 +1,12 @@
+# frozen_string_literal: true
+
 module Grape
   class Entity
     module Exposure
       class NestingExposure
         class OutputBuilder < SimpleDelegator
-          def initialize
+          def initialize(entity)
+            @entity = entity
             @output_hash = {}
             @output_collection = []
           end
@@ -18,7 +21,7 @@ module Grape
               return unless result
               @output_hash.merge! result, &merge_strategy(exposure.for_merge)
             else
-              @output_hash[exposure.key] = result
+              @output_hash[exposure.key(@entity)] = result
             end
           end
 

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,28 +83,26 @@ 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)

data/lib/grape_entity/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module GrapeEntity
-  VERSION = '0.6.1'.freeze
+  VERSION = '0.7.0'
 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,130 @@ 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
+        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 +240,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 +283,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 +476,15 @@ 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 'overrides parent class exposure' 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(child_name: 'bar')
+        end
       end
 
       context 'register formatters' do
@@ -496,7 +657,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 +757,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 +842,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 +855,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 +925,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 +948,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 +960,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 +970,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 +1052,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 +1079,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
@@ -1341,8 +1530,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 +1954,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