grape-entity 0.4.8 → 0.5.0

data/lib/grape_entity/exposure.rb

@@ -0,0 +1,77 @@
+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
+      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
+
+        if options[:using]
+          using_class = options[:using]
+
+          if options[:proc]
+            RepresentExposure.new(*base_args, using_class, block_exposure)
+          else
+            RepresentExposure.new(*base_args, using_class, delegator_exposure)
+          end
+
+        elsif options[:proc]
+          block_exposure
+
+        elsif options[:format_with]
+          format_with = options[: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
+
+        elsif options[:nesting]
+          NestingExposure.new(*base_args)
+
+        else
+          delegator_exposure
+        end
+      end
+
+      def self.compile_conditions(options)
+        if_conditions = []
+        unless options[:if_extras].nil?
+          if_conditions.concat(options[:if_extras])
+        end
+        if_conditions << options[:if] unless options[:if].nil?
+
+        if_conditions.map! do |cond|
+          Condition.new_if cond
+        end
+
+        unless_conditions = []
+        unless options[:unless_extras].nil?
+          unless_conditions.concat(options[:unless_extras])
+        end
+        unless_conditions << options[:unless] unless options[:unless].nil?
+
+        unless_conditions.map! do |cond|
+          Condition.new_unless cond
+        end
+
+        if_conditions + unless_conditions
+      end
+    end
+  end
+end

data/lib/grape_entity/exposure/base.rb

@@ -0,0 +1,118 @@
+module Grape
+  class Entity
+    module Exposure
+      class Base
+        attr_reader :attribute, :key, :is_safe, :documentation, :conditions
+
+        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).try(:to_sym)
+          @is_safe = options[:safe]
+          @attr_path_proc = options[:attr_path]
+          @documentation = options[:documentation]
+          @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?
+          false
+        end
+
+        def valid?(entity)
+          is_delegatable = entity.delegator.delegatable?(@attribute) || entity.respond_to?(@attribute, true)
+          if @is_safe
+            is_delegatable
+          else
+            is_delegatable || fail(NoMethodError, "#{entity.class.name} missing attribute `#{@attribute}' on #{entity.object}")
+          end
+        end
+
+        def value(_entity, _options)
+          fail NotImplementedError
+        end
+
+        def serializable_value(entity, options)
+          partial_output = valid_value(entity, options)
+
+          if partial_output.respond_to?(:serializable_hash)
+            partial_output.serializable_hash(options)
+          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)
+          value(entity, options) if valid?(entity)
+        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 with_attr_path(entity, options)
+          path_part = attr_path(entity, options)
+          options.with_attr_path(path_part) do
+            yield
+          end
+        end
+
+        protected
+
+        attr_reader :options
+      end
+    end
+  end
+end

data/lib/grape_entity/exposure/block_exposure.rb

@@ -0,0 +1,29 @@
+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,11 @@
+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,25 @@
+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,30 @@
+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.rb

@@ -0,0 +1,128 @@
+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)
+          new_options = nesting_options_for(options)
+
+          normalized_exposures(entity, new_options).each_with_object({}) do |exposure, output|
+            exposure.with_attr_path(entity, new_options) do
+              result = exposure.value(entity, new_options)
+              output[exposure.key] = result
+            end
+          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
+          end
+          result
+        end
+
+        def serializable_value(entity, options)
+          new_options = nesting_options_for(options)
+
+          normalized_exposures(entity, new_options).each_with_object({}) do |exposure, output|
+            exposure.with_attr_path(entity, new_options) do
+              result = exposure.serializable_value(entity, new_options)
+              output[exposure.key] = result
+            end
+          end
+        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?
+        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? # 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
+          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|
+                if exposure.nesting?
+                  nesting_tail.unshift exposure
+                else
+                  break
+                end
+              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?)
+              end
+            else
+              last_exposure
+            end
+          end
+        end
+      end
+    end
+  end
+end
+
+require 'grape_entity/exposure/nesting_exposure/nested_exposures'

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

@@ -0,0 +1,70 @@
+module Grape
+  class Entity
+    module Exposure
+      class NestingExposure
+        class NestedExposures
+          include Enumerable
+
+          def initialize(exposures)
+            @exposures = exposures
+          end
+
+          def find_by(attribute)
+            @exposures.find { |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 }
+          end
+
+          def clear
+            reset_memoization!
+            @exposures.clear
+          end
+
+          [
+            :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)
+                @exposures.#{name}(*args, &block)
+              end
+            RUBY
+          end
+
+          # Determine if we have any nesting exposures with the same name.
+          def deep_complex_nesting?
+            if @deep_complex_nesting.nil?
+              all_nesting = select(&:nesting?)
+              @deep_complex_nesting = all_nesting.group_by(&:key).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