grape-entity 0.4.8 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4da3e754b2801be8d8801bf8cc483e457261bee9
-  data.tar.gz: f5bda0779d4bb3bb76f43f4b6c1207d2b0e8f1d3
+  metadata.gz: ae09d2c2eb04cf66e6c186d175814bbd656d745c
+  data.tar.gz: cb06bd7e21f3b873631a59bcd736ff4c12f981af
 SHA512:
-  metadata.gz: 3c12c01509079508b09981d5f4196f489b38be1d23d33f1dd9db9b0e9f2f1f637b83e87e57ad6a2c98ba59cd0a570520960ad4926ba959e895f9a7cffce31f5e
-  data.tar.gz: 09f153d167e0e0f5e8007d3947660fa9b2723c46a9ca925b257709e6e5209b8d7fca8ef5ede080d8b50b294dfb04a3a5d1bfb7037b97996677dc048c50720440
+  metadata.gz: bd4ec8cf775bf7e9ea5db80cb14ef4eec682aafb29610cf0581530f372a1929926ba8abb6e4f8e8aa9b8a5b97a0bc224548346a9e05158f75ae250d24eaa08f8
+  data.tar.gz: f626ea6a74c2bf15945a3c0a3c29b8609939227bcb228361eedeb9dd247fc33ab7d2df2bb7c768b1a2073cc640ddfd39db51b908ff1d6a73f4a64602b66260fa

data/.rubocop_todo.yml

@@ -1,24 +1,24 @@
 # This configuration was generated by `rubocop --auto-gen-config`
-# on 2015-08-10 12:30:52 +0300 using RuboCop version 0.31.0.
+# on 2015-08-10 13:14:22 +0300 using RuboCop version 0.31.0.
 # The point is for the user to remove these configuration records
 # one by one as the offenses are removed from the code base.
 # Note that changes in the inspected code, or installation of new
 # versions of RuboCop, may require this file to be generated again.
 
-# Offense count: 7
+# Offense count: 6
 Metrics/AbcSize:
-  Max: 45
+  Max: 33
 
-# Offense count: 1
+# Offense count: 2
 # Configuration parameters: CountComments.
 Metrics/ClassLength:
-  Max: 333
+  Max: 202
 
-# Offense count: 4
+# Offense count: 3
 Metrics/CyclomaticComplexity:
-  Max: 17
+  Max: 11
 
-# Offense count: 193
+# Offense count: 210
 # Configuration parameters: AllowURI, URISchemes.
 Metrics/LineLength:
   Max: 146
@@ -26,13 +26,13 @@ Metrics/LineLength:
 # Offense count: 8
 # Configuration parameters: CountComments.
 Metrics/MethodLength:
-  Max: 26
+  Max: 28
 
-# Offense count: 7
+# Offense count: 5
 Metrics/PerceivedComplexity:
-  Max: 15
+  Max: 13
 
-# Offense count: 37
+# Offense count: 58
 Style/Documentation:
   Enabled: false
 

data/CHANGELOG.md

@@ -1,9 +1,27 @@
+0.5.0 (2015-12-07)
+==================
+
+* [#139](https://github.com/ruby-grape/grape-entity/pull/139): Keep a track of attribute nesting path during condition check or runtime exposure - [@calfzhou](https://github.com/calfzhou).
+* [#151](https://github.com/ruby-grape/grape-entity/pull/151): `.exposures` is removed and substituted with `.root_exposures` array - [@marshall-lee](https://github.com/marshall-lee).
+* [#151](https://github.com/ruby-grape/grape-entity/pull/151): `.nested_exposures` is removed too - [@marshall-lee](https://github.com/marshall-lee).
+* [#151](https://github.com/ruby-grape/grape-entity/pull/151): `#should_return_attribute?`, `#only_fields` and `#except_fields` are moved to other classes - [@marshall-lee](https://github.com/marshall-lee).
+* [#151](https://github.com/ruby-grape/grape-entity/pull/151): Fix: double exposures with conditions does not rewrite previously defined now: [#56](https://github.com/ruby-grape/grape-entity/issues/56) - [@marshall-lee](https://github.com/marshall-lee).
+* [#151](https://github.com/ruby-grape/grape-entity/pull/151): Fix: nested exposures were flattened in `.documentation`: [#112](https://github.com/ruby-grape/grape-entity/issues/112) - [@marshall-lee](https://github.com/marshall-lee).
+* [#151](https://github.com/ruby-grape/grape-entity/pull/151): Fix: `@only_fields` and `@except_fields` memoization: [#149](https://github.com/ruby-grape/grape-entity/issues/149) - [@marshall-lee](https://github.com/marshall-lee).
+* [#151](https://github.com/ruby-grape/grape-entity/pull/151): Fix: `:unless` condition with `Hash` argument logic: [#150](https://github.com/ruby-grape/grape-entity/issues/150) - [@marshall-lee](https://github.com/marshall-lee).
+* [#151](https://github.com/ruby-grape/grape-entity/pull/151): Nested `unexpose` now raises an exception: [#152](https://github.com/ruby-grape/grape-entity/issues/152) - [@marshall-lee](https://github.com/marshall-lee).
+* [#151](https://github.com/ruby-grape/grape-entity/pull/151): Fix: `@documentation` memoization: [#153](https://github.com/ruby-grape/grape-entity/issues/153) - [@marshall-lee](https://github.com/marshall-lee).
+* [#151](https://github.com/ruby-grape/grape-entity/pull/151): Fix: serializing of deeply nested presenter exposures: [#155](https://github.com/ruby-grape/grape-entity/issues/155) - [@marshall-lee](https://github.com/marshall-lee).
+* [#151](https://github.com/ruby-grape/grape-entity/pull/151): Fix: deep projections (`:only`, `:except`) were unaware of nesting: [#156](https://github.com/ruby-grape/grape-entity/issues/156) - [@marshall-lee](https://github.com/marshall-lee).
+
 0.4.8 (2015-08-10)
 ==================
+
 * [#167](https://github.com/ruby-grape/grape-entity/pull/167): Regression: global settings (exposures, formatters) on `Grape::Entity` should work: [#166](https://github.com/ruby-grape/grape-entity/issues/166) - [@marshall-lee](http://github.com/marshall-lee).
 
 0.4.7 (2015-08-03)
 ==================
+
 * [#164](https://github.com/ruby-grape/grape-entity/pull/164): Regression: entity instance methods were exposed with `NoMethodError`: [#163](https://github.com/ruby-grape/grape-entity/issues/163) - [@marshall-lee](http://github.com/marshall-lee).
 
 0.4.6 (2015-07-27)
@@ -87,4 +105,3 @@
 ==================
 
 * Initial public release - [@agileanimal](https://github.com/agileanimal).
-

data/README.md

@@ -311,7 +311,7 @@ present s, with: Status, user: current_user
 ```
 
 #### Passing Additional Option To Nested Exposure
-There are sometimes that you want to pass additional option or parameter to nested exposure. Assume that you need to expose an address for a contact info, but it has both two different format: **full** and **simple**. You can pass an additional `full_format` option to specify that if the nested entity should render address in `:full` format.
+Sometimes you want to pass additional options or parameters to nested a exposure. For example, let's say that you need to expose an address for a contact info and it has two different formats: **full** and **simple**. You can pass an additional `full_format` option to specify which format to render.
 
 ```ruby
 # api/contact.rb
@@ -327,12 +327,38 @@ end
 # api/address.rb
 expose :state, if: lambda {|instance, options| !!options[:full_format]}      # the new option could be retrieved in options hash for conditional exposure
 expose :city, if: lambda {|instance, options| !!options[:full_format]}
-expose :stree do |instance, options|
+expose :street do |instance, options|
   # the new option could be retrieved in options hash for runtime exposure
   !!options[:full_format] ? instance.full_street_name : instance.simple_street_name
 end
 ```
-**Notice**: In the above code, you should pay attention to [**Safe Exposure**](#safe-exposure) yourself, for example, `instance.address` might be `nil`, in this situation, it is better to expose it as nil directly.
+**Notice**: In the above code, you should pay attention to [**Safe Exposure**](#safe-exposure) yourself. For example, `instance.address` might be `nil`  and it is better to expose it as nil directly.
+
+#### Attribute Path Tracking
+
+Sometimes, especially when there are nested attributes, you might want to know which attribute
+is being exposed. For example, some APIs allow users to provide a parameter to control which fields
+will be included in (or excluded from) the response.
+
+GrapeEntity can track the path of each attribute, which you can access during conditions checking
+or runtime exposure via `options[:attr_path]`.
+
+The attribute path is an array. The last item of this array is the name (alias) of current attribute.
+If the attribute is nested, the former items are names (aliases) of its ancestor attributes.
+
+Example:
+
+```ruby
+class Status < Grape::Entity
+  expose :user  # path is [:user]
+  expose :foo, as: :bar  # path is [:bar]
+  expose :a do
+    expose :b, as: :xx do
+      expose :c  # path is [:a, :xx, :c]
+    end
+  end
+end
+```
 
 ### Using the Exposure DSL
 
@@ -388,7 +414,7 @@ class Status
 end
 ```
 
-If you organize your entities this way, Grape will automatically detect the `Entity` class and use it to present your models. In this example, if you added `present User.new` to your endpoint, Grape would automatically detect that there is a `Status::Entity` class and use that as the representative entity. This can still be overridden by using the `:with` option or an explicit `represents` call.
+If you organize your entities this way, Grape will automatically detect the `Entity` class and use it to present your models. In this example, if you added `present Status.new` to your endpoint, Grape would automatically detect that there is a `Status::Entity` class and use that as the representative entity. This can still be overridden by using the `:with` option or an explicit `represents` call.
 
 ### Caveats
 

data/Rakefile

@@ -19,4 +19,4 @@ require 'rainbow/ext/string' unless String.respond_to?(:color)
 require 'rubocop/rake_task'
 RuboCop::RakeTask.new(:rubocop)
 
-task default: [:rubocop, :spec]
+task default: [:spec, :rubocop]

data/lib/grape_entity.rb

@@ -1,5 +1,9 @@
-require 'active_support'
-require 'active_support/core_ext'
+require 'active_support/version'
+require 'active_support/core_ext/string/inflections'
+require 'active_support/core_ext/hash/reverse_merge'
+require 'active_support/core_ext/object/try'
 require 'grape_entity/version'
 require 'grape_entity/entity'
 require 'grape_entity/delegator'
+require 'grape_entity/exposure'
+require 'grape_entity/options'

data/lib/grape_entity/condition.rb

@@ -0,0 +1,26 @@
+require 'grape_entity/condition/base'
+require 'grape_entity/condition/block_condition'
+require 'grape_entity/condition/hash_condition'
+require 'grape_entity/condition/symbol_condition'
+
+module Grape
+  class Entity
+    module Condition
+      def self.new_if(arg)
+        case arg
+        when Hash then HashCondition.new false, arg
+        when Proc then BlockCondition.new false, &arg
+        when Symbol then SymbolCondition.new false, arg
+        end
+      end
+
+      def self.new_unless(arg)
+        case arg
+        when Hash then HashCondition.new true, arg
+        when Proc then BlockCondition.new true, &arg
+        when Symbol then SymbolCondition.new true, arg
+        end
+      end
+    end
+  end
+end

data/lib/grape_entity/condition/base.rb

@@ -0,0 +1,35 @@
+module Grape
+  class Entity
+    module Condition
+      class Base
+        def self.new(inverse, *args, &block)
+          super(inverse).tap { |e| e.setup(*args, &block) }
+        end
+
+        def initialize(inverse = false)
+          @inverse = inverse
+        end
+
+        def ==(other)
+          (self.class == other.class) && (self.inversed? == other.inversed?)
+        end
+
+        def inversed?
+          @inverse
+        end
+
+        def met?(entity, options)
+          !@inverse ? if_value(entity, options) : unless_value(entity, options)
+        end
+
+        def if_value(_entity, _options)
+          fail NotImplementedError
+        end
+
+        def unless_value(entity, options)
+          !if_value(entity, options)
+        end
+      end
+    end
+  end
+end

data/lib/grape_entity/condition/block_condition.rb

@@ -0,0 +1,21 @@
+module Grape
+  class Entity
+    module Condition
+      class BlockCondition < Base
+        attr_reader :block
+
+        def setup(&block)
+          @block = block
+        end
+
+        def ==(other)
+          super && @block == other.block
+        end
+
+        def if_value(entity, options)
+          entity.exec_with_object(options, &@block)
+        end
+      end
+    end
+  end
+end

data/lib/grape_entity/condition/hash_condition.rb

@@ -0,0 +1,25 @@
+module Grape
+  class Entity
+    module Condition
+      class HashCondition < Base
+        attr_reader :cond_hash
+
+        def setup(cond_hash)
+          @cond_hash = cond_hash
+        end
+
+        def ==(other)
+          super && @cond_hash == other.cond_hash
+        end
+
+        def if_value(_entity, options)
+          @cond_hash.all? { |k, v| options[k.to_sym] == v }
+        end
+
+        def unless_value(_entity, options)
+          @cond_hash.any? { |k, v| options[k.to_sym] != v }
+        end
+      end
+    end
+  end
+end

data/lib/grape_entity/condition/symbol_condition.rb

@@ -0,0 +1,21 @@
+module Grape
+  class Entity
+    module Condition
+      class SymbolCondition < Base
+        attr_reader :symbol
+
+        def setup(symbol)
+          @symbol = symbol
+        end
+
+        def ==(other)
+          super && @symbol == other.symbol
+        end
+
+        def if_value(_entity, options)
+          options[symbol]
+        end
+      end
+    end
+  end
+end

data/lib/grape_entity/entity.rb

@@ -99,30 +99,25 @@ module Grape
     end
 
     class << self
-      # Returns exposures that have been declared for this Entity or
-      # ancestors. The keys are symbolized references to methods on the
-      # containing object, the values are the options that were passed into expose.
-      # @return [Hash] of exposures
-      attr_accessor :exposures
-      attr_accessor :root_exposures
+      def root_exposure
+        @root_exposure ||= Exposure.new(nil, nesting: true)
+      end
+
+      attr_writer :root_exposure
+
       # Returns all formatters that are registered for this and it's ancestors
       # @return [Hash] of formatters
-      attr_accessor :formatters
-      attr_accessor :nested_attribute_names
-      attr_accessor :nested_exposures
+      def formatters
+        @formatters ||= {}
+      end
+
+      attr_writer :formatters
     end
 
-    @exposures = {}
-    @root_exposures = {}
-    @nested_exposures = {}
-    @nested_attribute_names = {}
     @formatters = {}
 
     def self.inherited(subclass)
-      subclass.exposures = exposures.dup
-      subclass.root_exposures = root_exposures.dup
-      subclass.nested_exposures = nested_exposures.dup
-      subclass.nested_attribute_names = nested_attribute_names.dup
+      subclass.root_exposure = root_exposure.dup
       subclass.formatters = formatters.dup
     end
 
@@ -161,38 +156,64 @@ module Grape
 
       fail ArgumentError, 'You may not use block-setting when also using format_with' if block_given? && options[:format_with].respond_to?(:call)
 
-      options[:proc] = block if block_given? && block.parameters.any?
+      if block_given?
+        if block.parameters.any?
+          options[:proc] = block
+        else
+          options[:nesting] = true
+        end
+      end
 
-      @nested_attributes ||= []
+      @documentation = nil
+      @nesting_stack ||= []
 
       # rubocop:disable Style/Next
       args.each do |attribute|
-        if @nested_attributes.empty?
-          root_exposures[attribute] = options
+        exposure = Exposure.new(attribute, options)
+
+        if @nesting_stack.empty?
+          root_exposures << exposure
         else
-          orig_attribute = attribute.to_sym
-          attribute = "#{@nested_attributes.last}__#{attribute}".to_sym
-          nested_attribute_names[attribute] = orig_attribute
-          options[:nested] = true
-          nested_exposures.deep_merge!(@nested_attributes.last.to_sym  => { attribute => options })
+          @nesting_stack.last.nested_exposures << exposure
         end
 
-        exposures[attribute] = options
-
         # Nested exposures are given in a block with no parameters.
-        if block_given? && block.parameters.empty?
-          @nested_attributes << attribute
+        if exposure.nesting?
+          @nesting_stack << exposure
           block.call
-          @nested_attributes.pop
+          @nesting_stack.pop
         end
       end
     end
 
-    def self.unexpose(attribute)
-      root_exposures.delete(attribute)
-      exposures.delete(attribute)
-      nested_exposures.delete(attribute)
-      nested_attribute_names.delete(attribute)
+    # Returns exposures that have been declared for this Entity on the top level.
+    # @return [Array] of exposures
+    def self.root_exposures
+      root_exposure.nested_exposures
+    end
+
+    def self.find_exposure(attribute)
+      root_exposures.find_by(attribute)
+    end
+
+    def self.unexpose(*attributes)
+      cannot_unexpose! unless can_unexpose?
+      @documentation = nil
+      root_exposures.delete_by(*attributes)
+    end
+
+    def self.unexpose_all
+      cannot_unexpose! unless can_unexpose?
+      @documentation = nil
+      root_exposures.clear
+    end
+
+    def self.can_unexpose?
+      (@nesting_stack ||= []).empty?
+    end
+
+    def self.cannot_unexpose!
+      fail "You cannot call 'unexpose` inside of nesting exposure!"
     end
 
     # Set options that will be applied to any exposures declared inside the block.
@@ -214,9 +235,9 @@ module Grape
     # the values are document keys in the entity's documentation key. When calling
     # #docmentation, any exposure without a documentation key will be ignored.
     def self.documentation
-      @documentation ||= exposures.each_with_object({}) do |(attribute, exposure_options), memo|
-        if exposure_options[:documentation].present?
-          memo[key_for(attribute)] = exposure_options[:documentation]
+      @documentation ||= root_exposures.each_with_object({}) do |exposure, memo|
+        if exposure.documentation && !exposure.documentation.empty?
+          memo[exposure.key] = exposure.documentation
         end
       end
     end
@@ -315,7 +336,7 @@ module Grape
     #
     #       class Users < Grape::Entity
     #         present_collection true
-    #         expose :items, as: 'users', using: API::Entities::Users
+    #         expose :items, as: 'users', using: API::Entities::User
     #         expose :version, documentation: { type: 'string',
     #                                           desc: 'actual api version',
     #                                           required: true }
@@ -372,7 +393,7 @@ module Grape
     def self.represent(objects, options = {})
       if objects.respond_to?(:to_ary) && ! @present_collection
         root_element =  root_element(:collection_root)
-        inner = objects.to_ary.map { |object| new(object, { collection: true }.merge(options)).presented }
+        inner = objects.to_ary.map { |object| new(object, options.reverse_merge(collection: true)).presented }
       else
         objects = { @collection_name => objects } if @present_collection
         root_element = root_element(:root)
@@ -405,17 +426,21 @@ module Grape
     def initialize(object, options = {})
       @object = object
       @delegator = Delegator.new object
-      @options = options
-    end
-
-    def exposures
-      self.class.exposures
+      @options = if options.is_a? Options
+                   options
+                 else
+                   Options.new options
+                 end
     end
 
     def root_exposures
       self.class.root_exposures
     end
 
+    def root_exposure
+      self.class.root_exposure
+    end
+
     def documentation
       self.class.documentation
     end
@@ -436,74 +461,26 @@ module Grape
 
       opts = options.merge(runtime_options || {})
 
-      root_exposures.each_with_object({}) do |(attribute, exposure_options), output|
-        next unless should_return_attribute?(attribute, opts) && conditions_met?(exposure_options, opts)
-
-        partial_output = value_for(attribute, opts)
-
-        output[self.class.key_for(attribute)] =
-          if partial_output.respond_to?(:serializable_hash)
-            partial_output.serializable_hash(runtime_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
+      root_exposure.serializable_value(self, opts)
     end
 
-    def should_return_attribute?(attribute, options)
-      key = self.class.key_for(attribute)
-      only = only_fields(options).nil? ||
-             only_fields(options).include?(key)
-      except = except_fields(options) && except_fields(options).include?(key) &&
-               except_fields(options)[key] == true
-      only && !except
+    def exec_with_object(options, &block)
+      instance_exec(object, options, &block)
     end
 
-    def only_fields(options, for_attribute = nil)
-      return nil unless options[:only]
-
-      @only_fields ||= options[:only].each_with_object({}) do |attribute, allowed_fields|
-        if attribute.is_a?(Hash)
-          attribute.each do |attr, nested_attrs|
-            allowed_fields[attr] ||= []
-            allowed_fields[attr] += nested_attrs
-          end
-        else
-          allowed_fields[attribute] = true
-        end
-      end.symbolize_keys
-
-      if for_attribute && @only_fields[for_attribute].is_a?(Array)
-        @only_fields[for_attribute]
-      elsif for_attribute.nil?
-        @only_fields
-      end
+    def exec_with_attribute(attribute, &block)
+      instance_exec(delegate_attribute(attribute), &block)
     end
 
-    def except_fields(options, for_attribute = nil)
-      return nil unless options[:except]
-
-      @except_fields ||= options[:except].each_with_object({}) do |attribute, allowed_fields|
-        if attribute.is_a?(Hash)
-          attribute.each do |attr, nested_attrs|
-            allowed_fields[attr] ||= []
-            allowed_fields[attr] += nested_attrs
-          end
-        else
-          allowed_fields[attribute] = true
-        end
-      end.symbolize_keys
+    def value_for(key, options = Options.new)
+      root_exposure.valid_value_for(key, self, options)
+    end
 
-      if for_attribute && @except_fields[for_attribute].is_a?(Array)
-        @except_fields[for_attribute]
-      elsif for_attribute.nil?
-        @except_fields
+    def delegate_attribute(attribute)
+      if respond_to?(attribute, true)
+        send(attribute)
+      else
+        delegator.delegate(attribute)
       end
     end
 
@@ -519,139 +496,9 @@ module Grape
       serializable_hash(options).to_xml(options)
     end
 
-    protected
-
-    def self.name_for(attribute)
-      attribute = attribute.to_sym
-      nested_attribute_names[attribute] || attribute
-    end
-
-    def self.key_for(attribute)
-      exposures[attribute.to_sym][:as] || name_for(attribute)
-    end
-
-    def self.nested_exposures_for?(attribute)
-      nested_exposures.key?(attribute)
-    end
-
-    def nested_value_for(attribute, options)
-      nested_exposures = self.class.nested_exposures[attribute]
-      nested_attributes =
-        nested_exposures.map do |nested_attribute, nested_exposure_options|
-          if conditions_met?(nested_exposure_options, options)
-            [self.class.key_for(nested_attribute), value_for(nested_attribute, options)]
-          end
-        end
-
-      Hash[nested_attributes.compact]
-    end
-
-    def value_for(attribute, options = {})
-      exposure_options = exposures[attribute.to_sym]
-      return unless valid_exposure?(attribute, exposure_options)
-
-      if exposure_options[:using]
-        exposure_options[:using] = exposure_options[:using].constantize if exposure_options[:using].respond_to? :constantize
-
-        using_options = options_for_using(attribute, options)
-
-        if exposure_options[:proc]
-          exposure_options[:using].represent(instance_exec(object, options, &exposure_options[:proc]), using_options)
-        else
-          exposure_options[:using].represent(delegate_attribute(attribute), using_options)
-        end
-
-      elsif exposure_options[:proc]
-        instance_exec(object, options, &exposure_options[:proc])
-
-      elsif exposure_options[:format_with]
-        format_with = exposure_options[:format_with]
-
-        if format_with.is_a?(Symbol) && formatters[format_with]
-          instance_exec(delegate_attribute(attribute), &formatters[format_with])
-        elsif format_with.is_a?(Symbol)
-          send(format_with, delegate_attribute(attribute))
-        elsif format_with.respond_to? :call
-          instance_exec(delegate_attribute(attribute), &format_with)
-        end
-
-      elsif self.class.nested_exposures_for?(attribute)
-        nested_value_for(attribute, options)
-      else
-        delegate_attribute(attribute)
-      end
-    end
-
-    def delegate_attribute(attribute)
-      name = self.class.name_for(attribute)
-      if respond_to?(name, true)
-        send(name)
-      else
-        delegator.delegate(name)
-      end
-    end
-
-    def valid_exposure?(attribute, exposure_options)
-      if self.class.nested_exposures_for?(attribute)
-        self.class.nested_exposures[attribute].all? { |a, o| valid_exposure?(a, o) }
-      elsif exposure_options.key?(:proc)
-        true
-      else
-        name = self.class.name_for(attribute)
-        is_delegatable = delegator.delegatable?(name) || respond_to?(name, true)
-        if exposure_options[:safe]
-          is_delegatable
-        else
-          is_delegatable || fail(NoMethodError, "#{self.class.name} missing attribute `#{name}' on #{object}")
-        end
-      end
-    end
-
-    def conditions_met?(exposure_options, options)
-      if_conditions = []
-      unless exposure_options[:if_extras].nil?
-        if_conditions.concat(exposure_options[:if_extras])
-      end
-      if_conditions << exposure_options[:if] unless exposure_options[:if].nil?
-
-      if_conditions.each do |if_condition|
-        case if_condition
-        when Hash then if_condition.each_pair { |k, v| return false if options[k.to_sym] != v }
-        when Proc then return false unless instance_exec(object, options, &if_condition)
-        when Symbol then return false unless options[if_condition]
-        end
-      end
-
-      unless_conditions = []
-      unless exposure_options[:unless_extras].nil?
-        unless_conditions.concat(exposure_options[:unless_extras])
-      end
-      unless_conditions << exposure_options[:unless] unless exposure_options[:unless].nil?
-
-      unless_conditions.each do |unless_condition|
-        case unless_condition
-        when Hash then unless_condition.each_pair { |k, v| return false if options[k.to_sym] == v }
-        when Proc then return false if instance_exec(object, options, &unless_condition)
-        when Symbol then return false if options[unless_condition]
-        end
-      end
-
-      true
-    end
-
-    def options_for_using(attribute, options)
-      using_options = options.dup
-      using_options.delete(:collection)
-      using_options[:root] = nil
-      using_options[:only] = only_fields(using_options, attribute)
-      using_options[:except] = except_fields(using_options, attribute)
-
-      using_options
-    end
-
     # All supported options.
     OPTIONS = [
-      :as, :if, :unless, :using, :with, :proc, :documentation, :format_with, :safe, :if_extras, :unless_extras
+      :rewrite, :as, :if, :unless, :using, :with, :proc, :documentation, :format_with, :safe, :attr_path, :if_extras, :unless_extras
     ].to_set.freeze
 
     # Merges the given options with current block options.