grape-entity 0.4.8 → 0.10.2

data/lib/grape_entity/exposure/base.rb

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+require 'active_support'
+require 'active_support/core_ext'
+
+module Grape
+  class Entity
+    module Exposure
+      class Base
+        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) }
+        end
+
+        def initialize(attribute, options, conditions)
+          @attribute = attribute.try(:to_sym)
+          @options = options
+          key = options[:as] || attribute
+          @key = key.respond_to?(:to_sym) ? key.to_sym : key
+          @is_safe = options[:safe]
+          @default_value = options[:default]
+          @for_merge = options[:merge]
+          @attr_path_proc = options[:attr_path]
+          @documentation = options[:documentation]
+          @override = options[:override]
+          @conditions = conditions
+        end
+
+        def dup(&block)
+          self.class.new(*dup_args, &block)
+        end
+
+        def dup_args
+          [@attribute, @options, @conditions.map(&:dup)]
+        end
+
+        def ==(other)
+          self.class == other.class &&
+            @attribute == other.attribute &&
+            @options == other.options &&
+            @conditions == other.conditions
+        end
+
+        def setup; end
+
+        def nesting?
+          false
+        end
+
+        # if we have any nesting exposures with the same name.
+        def deep_complex_nesting?(entity) # rubocop:disable Lint/UnusedMethodArgument
+          false
+        end
+
+        def valid?(entity)
+          is_delegatable = entity.delegator.delegatable?(@attribute) || entity.respond_to?(@attribute, true)
+          if @is_safe
+            is_delegatable
+          else
+            is_delegatable || raise(
+              NoMethodError,
+              "#{entity.class.name} missing attribute `#{@attribute}' on #{entity.object}"
+            )
+          end
+        end
+
+        def value(_entity, _options)
+          raise NotImplementedError
+        end
+
+        def serializable_value(entity, options)
+          partial_output = valid_value(entity, options)
+
+          if partial_output.respond_to?(:serializable_hash)
+            partial_output.serializable_hash
+          elsif partial_output.is_a?(Array) && partial_output.all? { |o| o.respond_to?(:serializable_hash) }
+            partial_output.map(&:serializable_hash)
+          elsif partial_output.is_a?(Hash)
+            partial_output.each do |key, value|
+              partial_output[key] = value.serializable_hash if value.respond_to?(:serializable_hash)
+            end
+          else
+            partial_output
+          end
+        end
+
+        def valid_value(entity, options)
+          return unless valid?(entity)
+
+          output = value(entity, options)
+          output.blank? && @default_value.present? ? @default_value : output
+        end
+
+        def should_return_key?(options)
+          options.should_return_key?(@key)
+        end
+
+        def conditional?
+          !@conditions.empty?
+        end
+
+        def conditions_met?(entity, options)
+          @conditions.all? { |condition| condition.met? entity, options }
+        end
+
+        def should_expose?(entity, options)
+          should_return_key?(options) && conditions_met?(entity, options)
+        end
+
+        def attr_path(entity, options)
+          if @attr_path_proc
+            entity.exec_with_object(options, &@attr_path_proc)
+          else
+            @key
+          end
+        end
+
+        def key(entity = nil)
+          @key.respond_to?(:call) ? entity.exec_with_object(@options, &@key) : @key
+        end
+
+        def with_attr_path(entity, options, &block)
+          path_part = attr_path(entity, options)
+          options.with_attr_path(path_part, &block)
+        end
+
+        def override?
+          @override
+        end
+
+        protected
+
+        attr_reader :options
+      end
+    end
+  end
+end

data/lib/grape_entity/exposure/block_exposure.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Grape
+  class Entity
+    module Exposure
+      class BlockExposure < Base
+        attr_reader :block
+
+        def value(entity, options)
+          entity.exec_with_object(options, &@block)
+        end
+
+        def dup
+          super(&@block)
+        end
+
+        def ==(other)
+          super && @block == other.block
+        end
+
+        def valid?(_entity)
+          true
+        end
+
+        def setup(&block)
+          @block = block
+        end
+      end
+    end
+  end
+end

data/lib/grape_entity/exposure/delegator_exposure.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Grape
+  class Entity
+    module Exposure
+      class DelegatorExposure < Base
+        def value(entity, _options)
+          entity.delegate_attribute(attribute)
+        end
+      end
+    end
+  end
+end

data/lib/grape_entity/exposure/formatter_block_exposure.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Grape
+  class Entity
+    module Exposure
+      class FormatterBlockExposure < Base
+        attr_reader :format_with
+
+        def setup(&format_with)
+          @format_with = format_with
+        end
+
+        def dup
+          super(&@format_with)
+        end
+
+        def ==(other)
+          super && @format_with == other.format_with
+        end
+
+        def value(entity, _options)
+          entity.exec_with_attribute(attribute, &@format_with)
+        end
+      end
+    end
+  end
+end

data/lib/grape_entity/exposure/formatter_exposure.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Grape
+  class Entity
+    module Exposure
+      class FormatterExposure < Base
+        attr_reader :format_with
+
+        def setup(format_with)
+          @format_with = format_with
+        end
+
+        def dup_args
+          [*super, format_with]
+        end
+
+        def ==(other)
+          super && @format_with == other.format_with
+        end
+
+        def value(entity, _options)
+          formatters = entity.class.formatters
+          if formatters[@format_with]
+            entity.exec_with_attribute(attribute, &formatters[@format_with])
+          else
+            entity.send(@format_with, entity.delegate_attribute(attribute))
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module Grape
+  class Entity
+    module Exposure
+      class NestingExposure
+        class NestedExposures
+          include Enumerable
+
+          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
+          end
+
+          def delete_by(*attributes)
+            reset_memoization!
+            @exposures.reject! { |e| attributes.include? e.attribute }
+            @exposures
+          end
+
+          def clear
+            reset_memoization!
+            @exposures.clear
+          end
+
+          # rubocop:disable Style/DocumentDynamicEvalDefinition
+          %i[
+            each
+            to_ary to_a
+            all?
+            select
+            each_with_object
+            \[\]
+            ==
+            size
+            count
+            length
+            empty?
+          ].each do |name|
+            class_eval <<-RUBY, __FILE__, __LINE__ + 1
+              def #{name}(*args, &block)
+                @exposures.#{name}(*args, &block)
+              end
+            RUBY
+          end
+          # rubocop:enable Style/DocumentDynamicEvalDefinition
+
+          # Determine if we have any nesting exposures with the same name.
+          def deep_complex_nesting?(entity)
+            if @deep_complex_nesting.nil?
+              all_nesting = select(&:nesting?)
+              @deep_complex_nesting =
+                all_nesting
+                .group_by { |exposure| exposure.key(entity) }
+                .any? { |_key, exposures| exposures.length > 1 }
+            else
+              @deep_complex_nesting
+            end
+          end
+
+          private
+
+          def reset_memoization!
+            @deep_complex_nesting = nil
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module Grape
+  class Entity
+    module Exposure
+      class NestingExposure
+        class OutputBuilder < SimpleDelegator
+          def initialize(entity)
+            @entity = entity
+            @output_hash = {}
+            @output_collection = []
+
+            super
+          end
+
+          def add(exposure, result)
+            # Save a result array in collections' array if it should be merged
+            if result.is_a?(Array) && exposure.for_merge
+              @output_collection << result
+            elsif exposure.for_merge
+              # 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(@entity)] = result
+            end
+          end
+
+          def kind_of?(klass)
+            klass == output.class || super
+          end
+          alias is_a? kind_of?
+
+          def __getobj__
+            output
+          end
+
+          private
+
+          # If output_collection contains at least one element we have to represent the output as a collection
+          def output
+            if @output_collection.empty?
+              output = @output_hash
+            else
+              output = @output_collection
+              output << @output_hash unless @output_hash.empty?
+              output.flatten!
+            end
+            output
+          end
+
+          # In case if we want to solve collisions providing lambda to :merge option
+          def merge_strategy(for_merge)
+            if for_merge.respond_to? :call
+              for_merge
+            else
+              -> {}
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/grape_entity/exposure/nesting_exposure.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+module Grape
+  class Entity
+    module Exposure
+      class NestingExposure < Base
+        attr_reader :nested_exposures
+
+        def setup(nested_exposures = [])
+          @nested_exposures = NestedExposures.new(nested_exposures)
+        end
+
+        def dup_args
+          [*super, @nested_exposures.map(&:dup)]
+        end
+
+        def ==(other)
+          super && @nested_exposures == other.nested_exposures
+        end
+
+        def nesting?
+          true
+        end
+
+        def find_nested_exposure(attribute)
+          nested_exposures.find_by(attribute)
+        end
+
+        def valid?(entity)
+          nested_exposures.all? { |e| e.valid?(entity) }
+        end
+
+        def value(entity, options)
+          map_entity_exposures(entity, options) do |exposure, nested_options|
+            exposure.value(entity, nested_options)
+          end
+        end
+
+        def serializable_value(entity, options)
+          map_entity_exposures(entity, options) do |exposure, nested_options|
+            exposure.serializable_value(entity, nested_options)
+          end
+        end
+
+        def valid_value_for(key, entity, options)
+          new_options = nesting_options_for(options)
+
+          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
+              exposure.valid_value(entity, new_options)
+            end
+          end.last
+        end
+
+        # if we have any nesting exposures with the same name.
+        # delegate :deep_complex_nesting?(entity), to: :nested_exposures
+        def deep_complex_nesting?(entity)
+          nested_exposures.deep_complex_nesting?(entity)
+        end
+
+        private
+
+        def nesting_options_for(options)
+          if @key
+            options.for_nesting(@key)
+          else
+            options
+          end
+        end
+
+        def easy_normalized_exposures(entity, options)
+          nested_exposures.select do |exposure|
+            exposure.with_attr_path(entity, options) do
+              exposure.should_expose?(entity, options)
+            end
+          end
+        end
+
+        # 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?(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(entity)] ||= []
+            output[exposure.key(entity)] << exposure
+          end
+
+          table.map do |key, exposures|
+            last_exposure = exposures.last
+
+            if last_exposure.nesting?
+              # For the given key if the last candidates for exposing are nesting then combine them.
+              nesting_tail = []
+              exposures.reverse_each do |exposure|
+                nesting_tail.unshift exposure if exposure.nesting?
+              end
+              new_nested_exposures = nesting_tail.flat_map(&:nested_exposures)
+              NestingExposure.new(key, {}, [], new_nested_exposures).tap do |new_exposure|
+                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
+end
+
+require 'grape_entity/exposure/nesting_exposure/nested_exposures'
+require 'grape_entity/exposure/nesting_exposure/output_builder'

data/lib/grape_entity/exposure/represent_exposure.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Grape
+  class Entity
+    module Exposure
+      class RepresentExposure < Base
+        attr_reader :using_class_name, :subexposure
+
+        def setup(using_class_name, subexposure)
+          @using_class = nil
+          @using_class_name = using_class_name
+          @subexposure = subexposure
+        end
+
+        def dup_args
+          [*super, using_class_name, subexposure]
+        end
+
+        def ==(other)
+          super &&
+            @using_class_name == other.using_class_name &&
+            @subexposure == other.subexposure
+        end
+
+        def value(entity, options)
+          new_options = options.for_nesting(key(entity))
+          using_class.represent(@subexposure.value(entity, options), new_options)
+        end
+
+        def valid?(entity)
+          @subexposure.valid? entity
+        end
+
+        def using_class
+          @using_class ||= if @using_class_name.respond_to? :constantize
+                             @using_class_name.constantize
+                           else
+                             @using_class_name
+                           end
+        end
+
+        private
+
+        def using_options_for(options)
+          options.for_nesting(key)
+        end
+      end
+    end
+  end
+end

data/lib/grape_entity/exposure.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+require 'grape_entity/exposure/base'
+require 'grape_entity/exposure/represent_exposure'
+require 'grape_entity/exposure/block_exposure'
+require 'grape_entity/exposure/delegator_exposure'
+require 'grape_entity/exposure/formatter_exposure'
+require 'grape_entity/exposure/formatter_block_exposure'
+require 'grape_entity/exposure/nesting_exposure'
+require 'grape_entity/condition'
+
+module Grape
+  class Entity
+    module Exposure
+      class << self
+        def new(attribute, options)
+          conditions = compile_conditions(attribute, options)
+          base_args = [attribute, options, conditions]
+
+          passed_proc = options[:proc]
+          using_class = options[:using]
+          format_with = options[:format_with]
+
+          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
+            build_delegator_exposure(base_args)
+          end
+        end
+
+        private
+
+        def compile_conditions(attribute, options)
+          if_conditions = [
+            options[:if_extras],
+            options[:if]
+          ].compact.flatten.map { |cond| Condition.new_if(cond) }
+
+          unless_conditions = [
+            options[:unless_extras],
+            options[:unless]
+          ].compact.flatten.map { |cond| Condition.new_unless(cond) }
+
+          unless_conditions << expose_nil_condition(attribute, options) if options[:expose_nil] == false
+
+          if_conditions + unless_conditions
+        end
+
+        def expose_nil_condition(attribute, options)
+          Condition.new_unless(
+            proc do |object, _options|
+              if options[:proc].nil?
+                delegator = Delegator.new(object)
+                if is_a?(Grape::Entity) && delegator.accepts_options?
+                  delegator.delegate(attribute, **self.class.delegation_opts).nil?
+                else
+                  delegator.delegate(attribute).nil?
+                end
+              else
+                exec_with_object(options, &options[:proc]).nil?
+              end
+            end
+          )
+        end
+
+        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
+
+        def build_nesting_exposure(base_args)
+          NestingExposure.new(*base_args)
+        end
+
+        def build_block_exposure(base_args, passed_proc)
+          BlockExposure.new(*base_args, &passed_proc)
+        end
+
+        def build_delegator_exposure(base_args)
+          DelegatorExposure.new(*base_args)
+        end
+      end
+    end
+  end
+end