class ActiveModel::Serializer::Reflection

So you can inspect reflections in your Adapters.
# ]
# HasManyReflection.new(:secret_meta_data, { if: :is_admin? })
# HasManyReflection.new(:comments, { key: :last_comments }, #<Block>)
# HasManyReflection.new(:comments)
# HasOneReflection.new(:author, serializer: AuthorSerializer),
# [
PostSerializer._reflections #=>
2) as ‘object.comments.last(1)’ and named ‘last_comments’.
1) as ‘comments’ and named ‘comments’.
Specifically, the association ‘comments’ is evaluated two different ways:
end
end
current_user.admin?
def is_admin?
has_many :secret_meta_data, if: :is_admin?
end
object.comments.last(1)
has_many :comments, key: :last_comments do
has_many :comments
has_one :author, serializer: AuthorSerializer
class PostSerializer < ActiveModel::Serializer
@example
ActiveModel::Serializer class.
Holds all the meta-data about an association as it was specified in the

def build_association(parent_serializer, parent_serializer_options, include_slice = {})

Other tags:

Api

Parameters:

parent_serializer_options (Hash{Symbol => Object}) --
parent_serializer (Serializer) -- for given association

def build_association(parent_serializer, parent_serializer_options, include_slice = {})
  reflection_options = options.dup
  # Pass the parent's namespace onto the child serializer
  reflection_options[:namespace] ||= parent_serializer_options[:namespace]
  association_value = value(parent_serializer, include_slice)
  serializer_class = parent_serializer.class.serializer_for(association_value, reflection_options)
  reflection_options[:include_data] = include_data?(include_slice)
  reflection_options[:links] = @_links
  reflection_options[:meta] = @_meta
  if serializer_class
    serializer = catch(:no_serializer) do
      serializer_class.new(
        association_value,
        serializer_options(parent_serializer, parent_serializer_options, reflection_options)
      )
    end
    if serializer.nil?
      reflection_options[:virtual_value] = association_value.try(:as_json) || association_value
    else
      reflection_options[:serializer] = serializer
    end
  elsif !association_value.nil? && !association_value.instance_of?(Object)
    reflection_options[:virtual_value] = association_value
  end
  block = nil
  Association.new(name, reflection_options, block)
end

def include_data(value = true)

def include_data(value = true)
  @_include_data = value
  :nil
end

def include_data?(include_slice)

def include_data?(include_slice)
  if @_include_data == :if_sideloaded
    include_slice.key?(name)
  else
    @_include_data
  end
end

def initialize(*)

def initialize(*)
  super
  @_links = {}
  @_include_data = Serializer.config.include_data_default
  @_meta = nil
end

def link(name, value = nil, &block)

def link(name, value = nil, &block)
  @_links[name] = block || value
  :nil
end

def meta(value = nil, &block)

def meta(value = nil, &block)
  @_meta = block || value
  :nil
end

def serializer_options(parent_serializer, parent_serializer_options, reflection_options)

def serializer_options(parent_serializer, parent_serializer_options, reflection_options)
  serializer = reflection_options.fetch(:serializer, nil)
  serializer_options = parent_serializer_options.except(:serializer)
  serializer_options[:serializer] = serializer if serializer
  serializer_options[:serializer_context_class] = parent_serializer.class
  serializer_options
end

def value(serializer, include_slice)

Returns:

(:nil, associated resource or resource collection) -

Other tags:

Yield