123456789_123456789_123456789_123456789_123456789_

Module: Mongoid::Serializable

Relationships & Source Files
Extension / Inclusion / Inheritance Descendants
Included In:
Super Chains via Extension / Inclusion / Inheritance
Class Chain:
self, ActiveSupport::Concern
Defined in: lib/mongoid/serializable.rb

Overview

This module provides the extra behavior for including associations in JSON and XML serialization.

Instance Method Summary

DSL Calls

included

We need to redefine where the JSON configuration is getting defined, similar to ActiveRecord.

[ GitHub ]


13
14
15
16
17
18
19
20
21
22
23
24
# File 'lib/mongoid/serializable.rb', line 13

included do

  class << self
    # Note that this intentionally only delegates :include_root_in_json
    # and not :include_root_in_json? - delegating the latter produces
    # wrong behavior.
    # Also note that this intentionally uses the ActiveSupport delegation
    # functionality and not the Ruby standard library one.
    # See https://jira.mongodb.org/browse/MONGOID-4849.
    delegate :include_root_in_json, to: ::Mongoid
  end
end

Instance Method Details

#field_names(options) ⇒ Array<String> (private)

This method is for internal use only.

Get the names of all fields that will be serialized.

Examples:

Get all the field names.

document.send(:field_names)

Returns:

[ GitHub ]

  
# File 'lib/mongoid/serializable.rb', line 76

def field_names(options)
  names = (as_attributes.keys + attribute_names).uniq.sort

  only = Array.wrap(options[:only]).map(&:to_s)
  except = Array.wrap(options[:except]).map(&:to_s)
  except |= [self.class.discriminator_key] unless Mongoid.include_type_for_serialization

  if !only.empty?
    names &= only
  elsif !except.empty?
    names -= except
  end
  names
end

#relation_names(inclusions) ⇒ Array<Symbol> (private)

Since the inclusions can be a hash, symbol, or array of symbols, this is provided as a convenience to parse out the names.

Examples:

Get the association names.

document.relation_names(:include => [ :addresses ])

Parameters:

Returns:

  • (Array<Symbol>)

    The names of the included associations.

[ GitHub ]

  
# File 'lib/mongoid/serializable.rb', line 148

def relation_names(inclusions)
  inclusions.is_a?(Hash) ? inclusions.keys : Array.wrap(inclusions)
end

#relation_options(inclusions, options, name) ⇒ Hash (private)

Since the inclusions can be a hash, symbol, or array of symbols, this is provided as a convenience to parse out the options.

Examples:

Get the association options.

document.relation_names(:include => [ :addresses ])

Parameters:

Returns:

  • (Hash)

    The options for the association.

[ GitHub ]

  
# File 'lib/mongoid/serializable.rb', line 163

def relation_options(inclusions, options, name)
  if inclusions.is_a?(Hash)
    inclusions[name]
  else
    { except: options[:except], only: options[:only] }
  end
end

#serializable_hash(options = nil) ⇒ Hash

Gets the document as a serializable hash, used by ActiveModel’s JSON serializer.

Examples:

Get the serializable hash.

document.serializable_hash

Get the serializable hash with options.

document.serializable_hash(:include => :addresses)

Parameters:

  • options (Hash) (defaults to: nil)

    The options to pass.

Options Hash (options):

Returns:

  • (Hash)

    The document, ready to be serialized.

[ GitHub ]

  
# File 'lib/mongoid/serializable.rb', line 47

def serializable_hash(options = nil)
  options ||= {}
  attrs = {}

  names = field_names(options)

  method_names = Array.wrap(options[:methods]).map do |name|
    name.to_s if respond_to?(name)
  end.compact

  (names + method_names).each do |name|
    without_autobuild do
      serialize_attribute(attrs, name, names, options)
    end
  end
  serialize_relations(attrs, options) if options[:include]
  attrs
end

#serialize_attribute(attrs, name, names, options) ⇒ Object (private)

This method is for internal use only.

Serialize a single attribute. Handles associations, fields, and dynamic attributes.

Examples:

Serialize the attribute.

document.serialize_attribute({}, "id" , [ "id" ])

Parameters:

  • attrs (Hash)

    The attributes.

  • name (String)

    The attribute name.

  • names (Array<String>)

    The names of all attributes.

  • options (Hash)

    The options.

Returns:

  • (Object)

    The attribute.

[ GitHub ]

  
# File 'lib/mongoid/serializable.rb', line 105

def serialize_attribute(attrs, name, names, options)
  if relations.key?(name)
    value = send(name)
    attrs[name] = value ? value.serializable_hash(options) : nil
  elsif names.include?(name) && !fields.key?(name)
    attrs[name] = read_raw_attribute(name)
  elsif !attribute_missing?(name)
    attrs[name] = send(name)
  end
end

#serialize_relations(attributes = {}, options = {}) (private)

For each of the provided include options, get the association needed and provide it in the hash.

Examples:

Serialize the included associations.

document.serialize_relations({}, :include => :addresses)

Parameters:

  • attributes (Hash) (defaults to: {})

    The attributes to serialize.

  • options (Hash) (defaults to: {})

    The serialization options.

Options Hash (options):

  • :include (Symbol)

    What associations to include

  • :only (Symbol)

    Limit the fields to only these.

  • :except (Symbol)

    Dont include these fields.

[ GitHub ]

  
# File 'lib/mongoid/serializable.rb', line 128

def serialize_relations(attributes = {}, options = {})
  inclusions = options[:include]
  relation_names(inclusions).each do |name|
    association = relations[name.to_s]
    if association && relation = send(association.name)
      attributes[association.name.to_s] =
        relation.serializable_hash(relation_options(inclusions, options, name))
    end
  end
end