module MongoMapper::Plugins::Serialization

Public Instance Methods

serializable_attributes() click to toggle source
# File lib/mongo_mapper/plugins/serialization.rb, line 16
def serializable_attributes
  attributes.keys.map { |k| k.to_s } + ['id'] - ['_id']
end
serializable_hash(options = nil) click to toggle source
# File lib/mongo_mapper/plugins/serialization.rb, line 20
def serializable_hash(options = nil)
  options ||= {}

  options[:only]   = Array.wrap(options[:only]).map { |k| k.to_s }
  options[:except] = Array.wrap(options[:except]).map { |k| k.to_s }

  attribute_names = serializable_attributes

  if options[:only].any?
    attribute_names &= options[:only]
  elsif options[:except].any?
    attribute_names -= options[:except]
  end

  attribute_names += Array.wrap(options[:methods]).map { |m| m.to_s }.select do |method|
    respond_to?(method)
  end

  hash = attribute_names.sort.inject({}) do |hash, name|
    value = send(name)
    hash[name] = if value.is_a?(Array)
      value.map {|v| v.respond_to?(:serializable_hash) ? v.serializable_hash : v }
    elsif value.respond_to?(:serializable_hash)
      value.serializable_hash
    else
      value
    end
    hash
  end

  serializable_add_includes(options) do |association, records, opts|
    hash[association.to_s] = records.is_a?(Array) ?
      records.map { |r| r.serializable_hash(opts) } :
      records.serializable_hash(opts)
  end

  hash
end
to_xml(options = {}, &block) click to toggle source
# File lib/mongo_mapper/plugins/serialization.rb, line 59
def to_xml(options = {}, &block)
  XmlSerializer.new(self, options).serialize(&block)
end

Private Instance Methods

serializable_add_includes(options = {}) { |association, records, opts| ... } click to toggle source
# File lib/mongo_mapper/plugins/serialization.rb, line 65
def serializable_add_includes(options = {})
  return unless include_associations = options.delete(:include)

  base_only_or_except = { :except => options[:except],
                          :only => options[:only] }

  include_has_options = include_associations.is_a?(Hash)
  associations = include_has_options ? include_associations.keys : Array.wrap(include_associations)

  associations.each do |association|
    records = get_proxy(self.class.associations[association])
    unless records.nil?
      association_options = include_has_options ? include_associations[association] : base_only_or_except
      opts = options.merge(association_options)
      yield(association, records, opts)
    end
  end

  options[:include] = include_associations
end