module Mongoid::Serializable

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 |= ['_type'] unless Mongoid.include_type_for_serialization
  if !only.empty?
    names &= only
  elsif !except.empty?
    names -= except
  end
  names
end

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

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

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

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

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