module Mongoid::Document

def _destroy
  false
end

def as_document
  return attributes if frozen?
  embedded_relations.each_pair do |name, meta|
    without_autobuild do
      relation, stored = send(name), meta.store_as
      if attributes.key?(stored) || !relation.blank?
        if relation
          attributes[stored] = relation.as_document
        else
          attributes.delete(stored)
        end
      end
    end
  end
  attributes
end

def as_json(options = nil)
  if options && (options[:compact] == true)
    super(options).reject! { |k,v| v.nil? }
  else
    super(options)
  end
end

def becomes(klass)
  unless klass.include?(Mongoid::Document)
    raise ArgumentError, "A class which includes Mongoid::Document is expected"
  end
  became = klass.new(clone_document)
  became._id = _id
  became.instance_variable_set(:@changed_attributes, changed_attributes)
  became.instance_variable_set(:@errors, ActiveModel::Errors.new(became))
  became.errors.instance_variable_set(:@messages, errors.instance_variable_get(:@messages))
  became.instance_variable_set(:@new_record, new_record?)
  became.instance_variable_set(:@destroyed, destroyed?)
  became.changed_attributes["_type"] = self.class.to_s
  became._type = klass.to_s
  # mark embedded docs as persisted
  embedded_relations.each_pair do |name, meta|
    without_autobuild do
      relation = became.__send__(name)
      Array.wrap(relation).each do |r|
        r.instance_variable_set(:@new_record, new_record?)
      end
    end
  end
  became
end

def cache_key
  return "#{model_key}/new" if new_record?
  return "#{model_key}/#{id}-#{updated_at.utc.to_s(:nsec)}" if do_or_do_not(:updated_at)
  "#{model_key}/#{id}"
end

def freeze
  as_document.freeze and self
end

def frozen?
  attributes.frozen?
end

def hash
  identity.hash
end

def identity
  [ self.class, self._id ]
end

def initialize(attrs = nil)
  _building do
    @new_record = true
    @attributes ||= {}
    with(self.class.persistence_options)
    apply_pre_processed_defaults
    apply_default_scoping
    process_attributes(attrs) do
      yield(self) if block_given?
    end
    apply_post_processed_defaults
    # @todo: #2586: Need to have access to parent document in these
    #   callbacks.
    run_callbacks(:initialize) unless _initialize_callbacks.empty?
  end
end

def logger
  Mongoid.logger
end

def model_key
  @model_cache_key ||= self.class.model_name.cache_key
end

def model_name
  self.class.model_name
end

def to_a
  [ self ]
end

def to_ary
  nil
end

def to_key
  (persisted? || destroyed?) ? [ id.to_s ] : nil
end