Allow as: option to accept a proc.

Author: James McCarthy

lib/grape_entity/exposure/base.rb

@@ -11,7 +11,8 @@ def self.new(attribute, options, conditions, *args, &block)
         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]
@@ -41,7 +42,7 @@ def nesting?
         end
 
         # if we have any nesting exposures with the same name.
-        def deep_complex_nesting?
+        def deep_complex_nesting?(entity)
           false
         end
 
@@ -102,6 +103,10 @@ def attr_path(entity, options)
           end
         end
 
+        def key(entity=nil)
+          @key.respond_to?(:call) ? @key.call(entity).try(:to_sym) : @key
+        end
+
         def with_attr_path(entity, options)
           path_part = attr_path(entity, options)
           options.with_attr_path(path_part) do

lib/grape_entity/exposure/nesting_exposure.rb

@@ -30,7 +30,7 @@ def valid?(entity)
 
         def value(entity, options)
           new_options = nesting_options_for(options)
-          output = OutputBuilder.new
+          output = OutputBuilder.new(entity)
 
           normalized_exposures(entity, new_options).each_with_object(output) do |exposure, out|
             exposure.with_attr_path(entity, new_options) do
@@ -44,7 +44,7 @@ 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|
+          normalized_exposures(entity, new_options).select { |e| e.key(entity) == key }.each do |exposure|
             exposure.with_attr_path(entity, new_options) do
               result = exposure.valid_value(entity, new_options)
             end
@@ -54,7 +54,7 @@ def valid_value_for(key, entity, options)
 
         def serializable_value(entity, options)
           new_options = nesting_options_for(options)
-          output = OutputBuilder.new
+          output = OutputBuilder.new(entity)
 
           normalized_exposures(entity, new_options).each_with_object(output) do |exposure, out|
             exposure.with_attr_path(entity, new_options) do
@@ -65,9 +65,9 @@ def serializable_value(entity, options)
         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 +90,15 @@ def easy_normalized_exposures(entity, options)
 
         # 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,7 +111,7 @@ def normalized_exposures(entity, options)
               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?)
+                new_exposure.instance_variable_set(:@deep_complex_nesting, true) if nesting_tail.any? { |exposure| exposure.deep_complex_nesting?(entity) }
               end
             else
               last_exposure

lib/grape_entity/exposure/nesting_exposure/nested_exposures.rb

@@ -51,10 +51,13 @@ def #{name}(*args, &block)
           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

lib/grape_entity/exposure/nesting_exposure/output_builder.rb

@@ -3,7 +3,8 @@ class Entity
     module Exposure
       class NestingExposure
         class OutputBuilder < SimpleDelegator
-          def initialize
+          def initialize(entity)
+            @entity = entity
             @output_hash = {}
             @output_collection = []
           end
@@ -18,7 +19,7 @@ def add(exposure, result)
               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
 

lib/grape_entity/exposure/represent_exposure.rb

@@ -21,7 +21,7 @@ def ==(other)
         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
 

spec/grape_entity/entity_spec.rb

@@ -131,7 +131,7 @@ class BogusEntity < Grape::Entity
             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
@@ -496,7 +496,7 @@ class Parent < Person
         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

spec/grape_entity/exposure/nesting_exposure/nested_exposures_spec.rb

@@ -3,11 +3,11 @@
 describe Grape::Entity::Exposure::NestingExposure::NestedExposures do
   subject(:nested_exposures) { described_class.new([]) }
 
-  describe '#deep_complex_nesting?' do
+  describe '#deep_complex_nesting?(entity)' do
     it 'is reset when additional exposure is added' do
       subject << Grape::Entity::Exposure.new(:x, {})
       expect(subject.instance_variable_get(:@deep_complex_nesting)).to be_nil
-      subject.deep_complex_nesting?
+      subject.deep_complex_nesting?(subject)
       expect(subject.instance_variable_get(:@deep_complex_nesting)).to_not be_nil
       subject << Grape::Entity::Exposure.new(:y, {})
       expect(subject.instance_variable_get(:@deep_complex_nesting)).to be_nil
@@ -16,7 +16,7 @@
     it 'is reset when exposure is deleted' do
       subject << Grape::Entity::Exposure.new(:x, {})
       expect(subject.instance_variable_get(:@deep_complex_nesting)).to be_nil
-      subject.deep_complex_nesting?
+      subject.deep_complex_nesting?(subject)
       expect(subject.instance_variable_get(:@deep_complex_nesting)).to_not be_nil
       subject.delete_by(:x)
       expect(subject.instance_variable_get(:@deep_complex_nesting)).to be_nil
@@ -25,7 +25,7 @@
     it 'is reset when exposures are cleared' do
       subject << Grape::Entity::Exposure.new(:x, {})
       expect(subject.instance_variable_get(:@deep_complex_nesting)).to be_nil
-      subject.deep_complex_nesting?
+      subject.deep_complex_nesting?(subject)
       expect(subject.instance_variable_get(:@deep_complex_nesting)).to_not be_nil
       subject.clear
       expect(subject.instance_variable_get(:@deep_complex_nesting)).to be_nil