grape-entity 0.4.5 → 0.4.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 77619537334dd75647477a452a937b672ca248cb
-  data.tar.gz: f7c7659bd6f13e2f65efb8091b2ca00a37dfcd74
+  metadata.gz: 22fd603c80eeb68f64892de2f1ca6873c12b20ae
+  data.tar.gz: 63638985ec1e6d721d54885840ad66c54f14ac9c
 SHA512:
-  metadata.gz: c73b5b28f9cb7ebcc7ba71e264029e725720cfa79593bcb891aeb5628ca3b50a26699043d38e79f1842a0336f1a66e881d636befa6f20d74e469131f86b1ac04
-  data.tar.gz: 2d086dee3c598f34bedc613fe1da601e7eff2afb6f05d9cd8944c9ffac21e7f16f5e4cea2a686ecdbf1f60c0c6d9f08e918b0f247ed4b23a54df1ec13a6b9f45
+  metadata.gz: b1d88f629ac5188cd05ee77fa32641eb431a44b088c9ac17375c17100ccc6b314b04aad0ffae6f299af21d7fb4b6d33a6ff5c53ce9b64c50b7e5ca483761e0c4
+  data.tar.gz: e40e7c4e6fee4fef015cc554a38f8e6a44fb05e23142b0932263e059f97a9a9948d012e70f9e9a6f8084a83dd181894afb43d49c208a61712277ab09572f1809

data/.rubocop.yml

@@ -1,5 +1,6 @@
 AllCops:
   Exclude:
     - vendor/**/*
+    - Guardfile
 
 inherit_from: .rubocop_todo.yml

data/.rubocop_todo.yml

@@ -1,64 +1,42 @@
 # This configuration was generated by `rubocop --auto-gen-config`
-# on 2014-12-11 15:27:22 -0500 using RuboCop version 0.28.0.
+# on 2015-05-21 22:47:03 +0700 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: 5
+# Offense count: 8
 Metrics/AbcSize:
-  Max: 53
+  Max: 51
 
 # Offense count: 1
 # Configuration parameters: CountComments.
 Metrics/ClassLength:
-  Max: 301
+  Max: 328
 
-# Offense count: 4
+# Offense count: 5
 Metrics/CyclomaticComplexity:
   Max: 17
 
-# Offense count: 175
+# Offense count: 176
 # Configuration parameters: AllowURI, URISchemes.
 Metrics/LineLength:
-  Max: 147
+  Max: 146
 
-# Offense count: 6
+# Offense count: 7
 # Configuration parameters: CountComments.
 Metrics/MethodLength:
-  Max: 34
+  Max: 32
 
-# Offense count: 4
+# Offense count: 5
 Metrics/PerceivedComplexity:
   Max: 15
 
-# Offense count: 2
-# Cop supports --auto-correct.
-Style/Blocks:
-  Enabled: false
-
-# Offense count: 30
+# Offense count: 31
 Style/Documentation:
   Enabled: false
 
-# Offense count: 2
-Style/EachWithObject:
-  Enabled: false
-
 # Offense count: 1
 # Configuration parameters: Exclude.
 Style/FileName:
   Enabled: false
-
-# Offense count: 16
-Style/Lambda:
-  Enabled: false
-
-# Offense count: 1
-# Configuration parameters: EnforcedStyle, MinBodyLength, SupportedStyles.
-Style/Next:
-  Enabled: false
-
-# Offense count: 2
-Style/RegexpLiteral:
-  MaxSlashes: 0

data/CHANGELOG.md

@@ -1,3 +1,17 @@
+0.4.6 (2015-07-27)
+==================
+
+* [#114](https://github.com/intridea/grape-entity/pull/114): Added 'only' option that selects which attributes should be returned - [@estevaoam](https://github.com/estevaoam).
+* [#115](https://github.com/intridea/grape-entity/pull/115): Allowing 'root' to be inherited from parent to child entities - [@guidoprincess](https://github.com/guidoprincess).
+* [#121](https://github.com/intridea/grape-entity/pull/122): Sublcassed Entity#documentation properly handles unexposed params - [@dan-corneanu](https://github.com/dan-corneanu).
+* [#134](https://github.com/intridea/grape-entity/pull/134): Subclasses no longer affected in all cases by `unexpose` in parent - [@etehtsea](https://github.com/etehtsea).
+* [#135](https://github.com/intridea/grape-entity/pull/135): Added `except` option - [@dan-corneanu](https://github.com/dan-corneanu).
+* [#136](https://github.com/intridea/grape-entity/pull/136): Allow for strings in `only` and `except` options - [@bswinnerton](https://github.com/bswinnerton).
+* [#147](https://github.com/intridea/grape-entity/pull/147): Expose `safe` attributes as `nil` if they cannot be evaluated: [#140](https://github.com/intridea/grape-entity/issues/140) - [@marshall-lee](http://github.com/marshall-lee).
+* [#147](https://github.com/intridea/grape-entity/pull/147): Fix: private method values were not exposed with `safe` option: [#142](https://github.com/intridea/grape-entity/pull/142) - [@marshall-lee](http://github.com/marshall-lee).
+* [#147](https://github.com/intridea/grape-entity/pull/147): Remove catching of `NoMethodError` because it can occur deep inside in a method call so this exception does not mean that attribute not exist - [@marshall-lee](http://github.com/marshall-lee).
+* [#147](https://github.com/intridea/grape-entity/pull/147): `valid_exposures` is removed - [@marshall-lee](http://github.com/marshall-lee).
+
 0.4.5 (2015-03-10)
 ==================
 

data/Gemfile

@@ -12,5 +12,5 @@ group :development, :test do
   gem 'json'
   gem 'rspec'
   gem 'rack-test', '~> 0.6.2', require: 'rack/test'
-  gem 'rubocop', '0.28.0'
+  gem 'rubocop', '0.31.0'
 end

data/README.md

@@ -23,13 +23,13 @@ module API
       expose :user_type, :user_id, if: lambda { |status, options| status.user.public? }
       expose :contact_info do
         expose :phone
-        expose :address, using: API::Address
+        expose :address, using: API::Entities::Address
       end
       expose :digest do |status, options|
         Digest::MD5.hexdigest status.txt
       end
-      expose :replies, using: API::Status, as: :replies
-      expose :last_reply, using: API::Status do |status, options|
+      expose :replies, using: API::Entities::Status, as: :responses
+      expose :last_reply, using: API::Entities::Status do |status, options|
         status.replies.last
       end
 
@@ -78,13 +78,13 @@ The field lookup takes several steps
 Don't derive your model classes from `Grape::Entity`, expose them using a presenter.
 
 ```ruby
-expose :replies, using: API::Status, as: :replies
+expose :replies, using: API::Entities::Status, as: :responses
 ```
 
 Presenter classes can also be specified in string format, which helps with circular dependencies.
 
 ```ruby
-expose :replies, using: "API::Status", as: :replies
+expose :replies, using: "API::Entities::Status", as: :responses
 ```
 
 #### Conditional Exposure
@@ -116,7 +116,7 @@ Supply a block to define a hash using nested exposures.
 ```ruby
 expose :contact_info do
   expose :phone
-  expose :address, using: API::Address
+  expose :address, using: API::Entities::Address
 end
 ```
 
@@ -124,7 +124,7 @@ You can also conditionally expose attributes in nested exposures:
 ```ruby
 expose :contact_info do
   expose :phone
-  expose :address, using: API::Address
+  expose :address, using: API::Entities::Address
   expose :email, if: lambda { |instance, options| options[:type] == :full }
 end
 ```
@@ -148,7 +148,7 @@ As example:
 ```ruby
 
  present_collection true, :collection_name  # `collection_name` is optional and defaults to `items`
- expose :collection_name, using: API:Items
+ expose :collection_name, using: API::Entities::Items
 
 
 ```
@@ -220,16 +220,55 @@ class MailingAddress < UserData
 end
 ```
 
+#### Returning only the fields you want
 
+After exposing the desired attributes, you can choose which one you need when representing some object or collection by using the only: and except: options. See the example:
 
+```ruby
+class UserEntity
+  expose :id
+  expose :name
+  expose :email
+end
+
+class Entity
+  expose :id
+  expose :title
+  expose :user, using: UserEntity
+end
+
+data = Entity.represent(model, only: [:title, { user: [:name, :email] }])
+data.as_json
+```
 
+This will return something like this:
+
+```ruby
+{
+  title: 'grape-entity is awesome!',
+  user: {
+    name: 'John Applet',
+    email: 'john@example.com'
+  }
+}
+```
+
+Instead of returning all the exposed attributes.
+
+
+The same result can be achieved with the following exposure:
+
+```ruby
+data = Entity.represent(model, except: [:id, { user: [:id] }])
+data.as_json
+```
 
 #### Aliases
 
 Expose under a different name with `:as`.
 
 ```ruby
-expose :replies, using: API::Status, as: :replies
+expose :replies, using: API::Entities::Status, as: :responses
 ```
 
 #### Format Before Exposing
@@ -271,6 +310,30 @@ end
 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.
+
+```ruby
+# api/contact.rb
+expose :contact_info do
+  expose :phone
+  expose :address do |instance, options|
+    # use `#merge` to extend options and then pass the new version of options to the nested entity
+    API::Entities::Address.represent instance.address, options.merge(full_format: instance.need_full_format?)
+  end
+  expose :email, if: lambda { |instance, options| options[:type] == :full }
+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|
+  # 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.
+
 ### Using the Exposure DSL
 
 Grape ships with a DSL to easily define entities within the context of an existing class:
@@ -393,4 +456,3 @@ MIT License. See [LICENSE](LICENSE) for details.
 ## Copyright
 
 Copyright (c) 2010-2014 Michael Bleigh, Intridea, Inc., and contributors.
-

data/lib/grape_entity.rb

@@ -2,3 +2,4 @@ require 'active_support'
 require 'active_support/core_ext'
 require 'grape_entity/version'
 require 'grape_entity/entity'
+require 'grape_entity/delegator'

data/lib/grape_entity/delegator.rb

@@ -0,0 +1,23 @@
+require 'grape_entity/delegator/base'
+require 'grape_entity/delegator/hash_object'
+require 'grape_entity/delegator/openstruct_object'
+require 'grape_entity/delegator/fetchable_object'
+require 'grape_entity/delegator/plain_object'
+
+module Grape
+  class Entity
+    module Delegator
+      def self.new(object)
+        if object.is_a?(Hash)
+          HashObject.new object
+        elsif defined?(OpenStruct) && object.is_a?(OpenStruct)
+          OpenStructObject.new object
+        elsif object.respond_to? :fetch, true
+          FetchableObject.new object
+        else
+          PlainObject.new object
+        end
+      end
+    end
+  end
+end

data/lib/grape_entity/delegator/base.rb

@@ -0,0 +1,17 @@
+module Grape
+  class Entity
+    module Delegator
+      class Base
+        attr_reader :object
+
+        def initialize(object)
+          @object = object
+        end
+
+        def delegatable?(_attribute)
+          true
+        end
+      end
+    end
+  end
+end

data/lib/grape_entity/delegator/fetchable_object.rb

@@ -0,0 +1,11 @@
+module Grape
+  class Entity
+    module Delegator
+      class FetchableObject < Base
+        def delegate(attribute)
+          object.fetch attribute
+        end
+      end
+    end
+  end
+end

data/lib/grape_entity/delegator/hash_object.rb

@@ -0,0 +1,11 @@
+module Grape
+  class Entity
+    module Delegator
+      class HashObject < Base
+        def delegate(attribute)
+          object[attribute]
+        end
+      end
+    end
+  end
+end

data/lib/grape_entity/delegator/openstruct_object.rb

@@ -0,0 +1,11 @@
+module Grape
+  class Entity
+    module Delegator
+      class OpenStructObject < Base
+        def delegate(attribute)
+          object.send attribute
+        end
+      end
+    end
+  end
+end

data/lib/grape_entity/delegator/plain_object.rb

@@ -0,0 +1,15 @@
+module Grape
+  class Entity
+    module Delegator
+      class PlainObject < Base
+        def delegate(attribute)
+          object.send attribute
+        end
+
+        def delegatable?(attribute)
+          object.respond_to? attribute, true
+        end
+      end
+    end
+  end
+end

data/lib/grape_entity/entity.rb

@@ -42,7 +42,7 @@ module Grape
   #     end
   #   end
   class Entity
-    attr_reader :object, :options
+    attr_reader :object, :delegator, :options
 
     # The Entity DSL allows you to mix entity functionality into
     # your existing classes.
@@ -98,6 +98,28 @@ module Grape
       end
     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
+      # 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
+    end
+
+    def self.inherited(subclass)
+      subclass.exposures = exposures.try(:dup) || {}
+      subclass.root_exposures = root_exposures.try(:dup) || {}
+      subclass.nested_exposures = nested_exposures.try(:dup) || {}
+      subclass.nested_attribute_names = nested_attribute_names.try(:dup) || {}
+      subclass.formatters = formatters.try(:dup) || {}
+    end
+
     # This method is the primary means by which you will declare what attributes
     # should be exposed by the entity.
     #
@@ -137,17 +159,19 @@ module Grape
 
       @nested_attributes ||= []
 
+      # rubocop:disable Style/Next
       args.each do |attribute|
-        unless @nested_attributes.empty?
+        if @nested_attributes.empty?
+          root_exposures[attribute] = options
+        else
           orig_attribute = attribute.to_sym
-          attribute = "#{@nested_attributes.last}__#{attribute}"
-          nested_attribute_names_hash[attribute.to_sym] = orig_attribute
+          attribute = "#{@nested_attributes.last}__#{attribute}".to_sym
+          nested_attribute_names[attribute] = orig_attribute
           options[:nested] = true
-          nested_exposures_hash[@nested_attributes.last.to_sym] ||= {}
-          nested_exposures_hash[@nested_attributes.last.to_sym][attribute.to_sym] = options
+          nested_exposures.deep_merge!(@nested_attributes.last.to_sym  => { attribute => options })
         end
 
-        exposures[attribute.to_sym] = options
+        exposures[attribute] = options
 
         # Nested exposures are given in a block with no parameters.
         if block_given? && block.parameters.empty?
@@ -177,74 +201,15 @@ module Grape
       @block_options.pop
     end
 
-    # Returns a hash of 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.
-    def self.exposures
-      return @exposures unless @exposures.nil?
-
-      @exposures = {}
-
-      if superclass.respond_to? :exposures
-        @exposures = superclass.exposures.merge(@exposures)
-      end
-
-      @exposures
-    end
-
-    class << self
-      attr_accessor :_nested_attribute_names_hash
-      attr_accessor :_nested_exposures_hash
-
-      def nested_attribute_names_hash
-        self._nested_attribute_names_hash ||= {}
-      end
-
-      def nested_exposures_hash
-        self._nested_exposures_hash ||= {}
-      end
-
-      def nested_attribute_names
-        return @nested_attribute_names unless @nested_attribute_names.nil?
-
-        @nested_attribute_names = {}.merge(nested_attribute_names_hash)
-
-        if superclass.respond_to? :nested_attribute_names
-          @nested_attribute_names = superclass.nested_attribute_names.deep_merge(@nested_attribute_names)
-        end
-
-        @nested_attribute_names
-      end
-
-      def nested_exposures
-        return @nested_exposures unless @nested_exposures.nil?
-
-        @nested_exposures = {}.merge(nested_exposures_hash)
-
-        if superclass.respond_to? :nested_exposures
-          @nested_exposures = superclass.nested_exposures.deep_merge(@nested_exposures)
-        end
-
-        @nested_exposures
-      end
-    end
-
     # Returns a hash, the keys are symbolized references to fields in the entity,
     # 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.inject({}) do |memo, (attribute, exposure_options)|
-        unless exposure_options[:documentation].nil? || exposure_options[:documentation].empty?
+      @documentation ||= exposures.each_with_object({}) do |(attribute, exposure_options), memo|
+        if exposure_options[:documentation].present?
           memo[key_for(attribute)] = exposure_options[:documentation]
         end
-        memo
       end
-
-      if superclass.respond_to? :documentation
-        @documentation = superclass.documentation.merge(@documentation)
-      end
-
-      @documentation
     end
 
     # This allows you to declare a Proc in which exposures can be formatted with.
@@ -278,17 +243,6 @@ module Grape
       formatters[name.to_sym] = block
     end
 
-    # Returns a hash of all formatters that are registered for this and it's ancestors.
-    def self.formatters
-      @formatters ||= {}
-
-      if superclass.respond_to? :formatters
-        @formatters = superclass.formatters.merge(@formatters)
-      end
-
-      @formatters
-    end
-
     # This allows you to set a root element name for your representation.
     #
     # @param plural   [String] the root key to use when representing
@@ -404,13 +358,15 @@ module Grape
     #   even if one is defined for the entity.
     # @option options :serializable [true or false] when true a serializable Hash will be returned
     #
+    # @option options :only [Array] all the fields that should be returned
+    # @option options :except [Array] all the fields that should not be returned
     def self.represent(objects, options = {})
       if objects.respond_to?(:to_ary) && ! @present_collection
-        root_element =  @collection_root
+        root_element =  root_element(:collection_root)
         inner = objects.to_ary.map { |object| new(object, { collection: true }.merge(options)).presented }
       else
         objects = { @collection_name => objects } if @present_collection
-        root_element =  @root
+        root_element = root_element(:root)
         inner = new(objects, options).presented
       end
 
@@ -419,6 +375,16 @@ module Grape
       root_element ? { root_element => inner } : inner
     end
 
+    # This method returns the entity's root or collection root node, or its parent's
+    # @param root_type: either :collection_root or just :root
+    def self.root_element(root_type)
+      if instance_variable_get("@#{root_type}")
+        instance_variable_get("@#{root_type}")
+      elsif superclass.respond_to? :root_element
+        superclass.root_element(root_type)
+      end
+    end
+
     def presented
       if options[:serializable]
         serializable_hash
@@ -428,17 +394,17 @@ module Grape
     end
 
     def initialize(object, options = {})
-      @object, @options = object, options
+      @object = object
+      @delegator = Delegator.new object
+      @options = options
     end
 
     def exposures
       self.class.exposures
     end
 
-    def valid_exposures
-      exposures.reject { |_, options| options[:nested] }.select do |attribute, exposure_options|
-        valid_exposure?(attribute, exposure_options)
-      end
+    def root_exposures
+      self.class.root_exposures
     end
 
     def documentation
@@ -458,24 +424,77 @@ module Grape
     #   etc.
     def serializable_hash(runtime_options = {})
       return nil if object.nil?
+
       opts = options.merge(runtime_options || {})
-      valid_exposures.inject({}) do |output, (attribute, exposure_options)|
-        if 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.map { |o| o.respond_to? :serializable_hash }.include?(false)
-              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
+
+      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
+    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
+    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
-        output
+      end.symbolize_keys
+
+      if for_attribute && @only_fields[for_attribute].is_a?(Array)
+        @only_fields[for_attribute]
+      elsif for_attribute.nil?
+        @only_fields
+      end
+    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
+
+      if for_attribute && @except_fields[for_attribute].is_a?(Array)
+        @except_fields[for_attribute]
+      elsif for_attribute.nil?
+        @except_fields
       end
     end
 
@@ -502,21 +521,30 @@ module Grape
       exposures[attribute.to_sym][:as] || name_for(attribute)
     end
 
-    def self.nested_exposures_for(attribute)
-      nested_exposures[attribute] || {}
+    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]
-
-      nested_exposures = self.class.nested_exposures_for(attribute)
+      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.dup
-        using_options.delete(:collection)
-        using_options[:root] = nil
+        using_options = options_for_using(attribute, options)
 
         if exposure_options[:proc]
           exposure_options[:using].represent(instance_exec(object, options, &exposure_options[:proc]), using_options)
@@ -538,15 +566,8 @@ module Grape
           instance_exec(delegate_attribute(attribute), &format_with)
         end
 
-      elsif nested_exposures.any?
-        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]
+      elsif self.class.nested_exposures_for?(attribute)
+        nested_value_for(attribute, options)
       else
         delegate_attribute(attribute)
       end
@@ -556,28 +577,24 @@ module Grape
       name = self.class.name_for(attribute)
       if respond_to?(name, true)
         send(name)
-      elsif object.is_a?(Hash)
-        object[name]
-      elsif object.respond_to?(name, true)
-        object.send(name)
-      elsif object.respond_to?(:fetch, true)
-        object.fetch(name)
       else
-        begin
-          object.send(name)
-        rescue NoMethodError
-          raise NoMethodError, "#{self.class.name} missing attribute `#{name}' on #{object}"
-        end
+        delegator.delegate(name)
       end
     end
 
     def valid_exposure?(attribute, exposure_options)
-      nested_exposures = self.class.nested_exposures_for(attribute)
-      (nested_exposures.any? && nested_exposures.all? { |a, o| valid_exposure?(a, o) }) || \
-        exposure_options.key?(:proc) || \
-        !exposure_options[:safe] || \
-        object.respond_to?(self.class.name_for(attribute)) || \
-        object.is_a?(Hash) && object.key?(self.class.name_for(attribute))
+      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)
+        if exposure_options[:safe]
+          delegator.delegatable?(name)
+        else
+          delegator.delegatable?(name) || fail(NoMethodError, "#{self.class.name} missing attribute `#{name}' on #{object}")
+        end
+      end
     end
 
     def conditions_met?(exposure_options, options)
@@ -612,6 +629,16 @@ module Grape
       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