class Mongoid::Relations::Proxy

def apply_ordering(criteria, metadata)
  metadata.order ? criteria.order_by(metadata.order) : criteria
end

def callback_method(callback_name)
  methods = []
  metadata = __metadata[callback_name]
  if metadata
    if metadata.is_a?(Array)
      methods.concat(metadata)
    else
      methods << metadata
    end
  end
  methods
end

def characterize_one(document)
  document.__metadata = __metadata unless document.__metadata
end

def collection
  root = base._root
  root.with(@persistence_options)
  root.collection unless root.embedded?
end

def execute_callback(callback, doc)
  callback_method = callback_method(callback)
  if callback_method
    callback_method.each do |c|
      if c.is_a? Proc
        c.call(base, doc)
      else
        base.send c, doc
      end
    end
  end
end

def extend_proxies(*extension)
  extension.flatten.each {|ext| extend_proxy(ext) }
end

def init(base, target, metadata)
  @base, @target, @__metadata = base, target, metadata
  yield(self) if block_given?
  extend_proxies(metadata.extension) if metadata.extension?
end

def klass
  __metadata ? __metadata.klass : nil
end

def method_missing(name, *args, &block)
  target.send(name, *args, &block)
end

def raise_mixed
  raise Errors::MixedRelations.new(base.class, __metadata.klass)
end

def raise_unsaved(doc)
  raise Errors::UnsavedDocument.new(base, doc)
end

def reset_unloaded
  target.reset_unloaded(criteria)
end

def substitutable
  target
end

def with(options)
  @persistence_options = options
  self
end