grape-entity 0.6.0 → 0.8.1

data/lib/grape_entity/exposure.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'grape_entity/exposure/base'
 require 'grape_entity/exposure/represent_exposure'
 require 'grape_entity/exposure/block_exposure'
@@ -10,67 +12,88 @@ require 'grape_entity/condition'
 module Grape
   class Entity
     module Exposure
-      def self.new(attribute, options)
-        conditions = compile_conditions(options)
-        base_args = [attribute, options, conditions]
-
-        if options[:proc]
-          block_exposure = BlockExposure.new(*base_args, &options[:proc])
-        else
-          delegator_exposure = DelegatorExposure.new(*base_args)
-        end
+      class << self
+        def new(attribute, options)
+          conditions = compile_conditions(attribute, options)
+          base_args = [attribute, options, conditions]
 
-        if options[:using]
+          passed_proc = options[:proc]
           using_class = options[:using]
+          format_with = options[:format_with]
 
-          if options[:proc]
-            RepresentExposure.new(*base_args, using_class, block_exposure)
+          if using_class
+            build_class_exposure(base_args, using_class, passed_proc)
+          elsif passed_proc
+            build_block_exposure(base_args, passed_proc)
+          elsif format_with
+            build_formatter_exposure(base_args, format_with)
+          elsif options[:nesting]
+            build_nesting_exposure(base_args)
           else
-            RepresentExposure.new(*base_args, using_class, delegator_exposure)
+            build_delegator_exposure(base_args)
           end
+        end
 
-        elsif options[:proc]
-          block_exposure
+        private
 
-        elsif options[:format_with]
-          format_with = options[:format_with]
+        def compile_conditions(attribute, options)
+          if_conditions = [
+            options[:if_extras],
+            options[:if]
+          ].compact.flatten.map { |cond| Condition.new_if(cond) }
 
-          if format_with.is_a? Symbol
-            FormatterExposure.new(*base_args, format_with)
-          elsif format_with.respond_to? :call
-            FormatterBlockExposure.new(*base_args, &format_with)
-          end
+          unless_conditions = [
+            options[:unless_extras],
+            options[:unless]
+          ].compact.flatten.map { |cond| Condition.new_unless(cond) }
 
-        elsif options[:nesting]
-          NestingExposure.new(*base_args)
+          unless_conditions << expose_nil_condition(attribute, options) if options[:expose_nil] == false
 
-        else
-          delegator_exposure
+          if_conditions + unless_conditions
         end
-      end
 
-      def self.compile_conditions(options)
-        if_conditions = []
-        unless options[:if_extras].nil?
-          if_conditions.concat(options[:if_extras])
+        def expose_nil_condition(attribute, options)
+          Condition.new_unless(
+            proc do |object, _options|
+              if options[:proc].nil?
+                Delegator.new(object).delegate(attribute).nil?
+              else
+                exec_with_object(options, &options[:proc]).nil?
+              end
+            end
+          )
         end
-        if_conditions << options[:if] unless options[:if].nil?
 
-        if_conditions.map! do |cond|
-          Condition.new_if cond
+        def build_class_exposure(base_args, using_class, passed_proc)
+          exposure =
+            if passed_proc
+              build_block_exposure(base_args, passed_proc)
+            else
+              build_delegator_exposure(base_args)
+            end
+
+          RepresentExposure.new(*base_args, using_class, exposure)
+        end
+
+        def build_formatter_exposure(base_args, format_with)
+          if format_with.is_a? Symbol
+            FormatterExposure.new(*base_args, format_with)
+          elsif format_with.respond_to?(:call)
+            FormatterBlockExposure.new(*base_args, &format_with)
+          end
         end
 
-        unless_conditions = []
-        unless options[:unless_extras].nil?
-          unless_conditions.concat(options[:unless_extras])
+        def build_nesting_exposure(base_args)
+          NestingExposure.new(*base_args)
         end
-        unless_conditions << options[:unless] unless options[:unless].nil?
 
-        unless_conditions.map! do |cond|
-          Condition.new_unless cond
+        def build_block_exposure(base_args, passed_proc)
+          BlockExposure.new(*base_args, &passed_proc)
         end
 
-        if_conditions + unless_conditions
+        def build_delegator_exposure(base_args)
+          DelegatorExposure.new(*base_args)
+        end
       end
     end
   end

data/lib/grape_entity/exposure/base.rb

@@ -1,8 +1,10 @@
+# frozen_string_literal: true
+
 module Grape
   class Entity
     module Exposure
       class Base
-        attr_reader :attribute, :key, :is_safe, :documentation, :conditions, :for_merge
+        attr_reader :attribute, :is_safe, :documentation, :override, :conditions, :for_merge
 
         def self.new(attribute, options, conditions, *args, &block)
           super(attribute, options, conditions).tap { |e| e.setup(*args, &block) }
@@ -11,11 +13,13 @@ module Grape
         def initialize(attribute, options, conditions)
           @attribute = attribute.try(:to_sym)
           @options = options
-          @key = (options[:as] || attribute).try(:to_sym)
+          key = options[:as] || attribute
+          @key = key.respond_to?(:to_sym) ? key.to_sym : key
           @is_safe = options[:safe]
           @for_merge = options[:merge]
           @attr_path_proc = options[:attr_path]
           @documentation = options[:documentation]
+          @override = options[:override]
           @conditions = conditions
         end
 
@@ -34,15 +38,14 @@ module Grape
             @conditions == other.conditions
         end
 
-        def setup
-        end
+        def setup; end
 
         def nesting?
           false
         end
 
         # if we have any nesting exposures with the same name.
-        def deep_complex_nesting?
+        def deep_complex_nesting?(entity) # rubocop:disable Lint/UnusedMethodArgument
           false
         end
 
@@ -51,7 +54,10 @@ module Grape
           if @is_safe
             is_delegatable
           else
-            is_delegatable || raise(NoMethodError, "#{entity.class.name} missing attribute `#{@attribute}' on #{entity.object}")
+            is_delegatable || raise(
+              NoMethodError,
+              "#{entity.class.name} missing attribute `#{@attribute}' on #{entity.object}"
+            )
           end
         end
 
@@ -103,6 +109,10 @@ module Grape
           end
         end
 
+        def key(entity = nil)
+          @key.respond_to?(:call) ? entity.exec_with_object(@options, &@key) : @key
+        end
+
         def with_attr_path(entity, options)
           path_part = attr_path(entity, options)
           options.with_attr_path(path_part) do
@@ -110,6 +120,10 @@ module Grape
           end
         end
 
+        def override?
+          @override
+        end
+
         protected
 
         attr_reader :options

data/lib/grape_entity/exposure/block_exposure.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Grape
   class Entity
     module Exposure

data/lib/grape_entity/exposure/delegator_exposure.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Grape
   class Entity
     module Exposure

data/lib/grape_entity/exposure/formatter_block_exposure.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Grape
   class Entity
     module Exposure

data/lib/grape_entity/exposure/formatter_exposure.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Grape
   class Entity
     module Exposure

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,16 @@ 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 +102,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
@@ -7,12 +9,17 @@ module Grape
 
           def initialize(exposures)
             @exposures = exposures
+            @deep_complex_nesting = nil
           end
 
           def find_by(attribute)
             @exposures.find { |e| e.attribute == attribute }
           end
 
+          def select_by(attribute)
+            @exposures.select { |e| e.attribute == attribute }
+          end
+
           def <<(exposure)
             reset_memoization!
             @exposures << exposure
@@ -29,20 +36,20 @@ 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__
+            class_eval <<-RUBY, __FILE__, __LINE__ + 1
               def #{name}(*args, &block)
                 @exposures.#{name}(*args, &block)
               end
@@ -50,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
@@ -16,9 +19,10 @@ module Grape
               # If we have an array which should not be merged - save it with a key as a hash
               # If we have hash which should be merged - save it without a key (merge)
               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