class ActiveFedora::Associations::SingularAssociation

:nodoc:

def build(attributes = {}) 

def build(attributes = {})
  new_record(:build, attributes)
end

def create(attributes = {}) 

def create(attributes = {})
  new_record(:create, attributes)
end

def create!(attributes = {}) 

def create!(attributes = {})
  build(attributes).tap { |record| record.save! }
end

def find_target 

def find_target
  # TODO this forces a solr query, but I think it's likely we can just lookup from Fedora.
  rec = scope.take
  rec.tap { |record| set_inverse_instance(record) }
end

def new_record(method, attributes) 

def new_record(method, attributes)
  attributes = {} #scoped.scope_for_create.merge(attributes || {})
  record = @reflection.send("#{method}_association", attributes)
  set_new_record(record)
  record
end

def reader(force_reload = false)

Implements the reader method, e.g. foo.bar for Foo.has_one :bar 
def reader(force_reload = false)
  if force_reload
    raise NotImplementedError, "Need to define the uncached method" #TODO
    klass.uncached { reload }
  elsif !loaded? || stale_target?
    reload
  end
  target
end

def replace(record)

Implemented by subclasses 
def replace(record)
  raise NotImplementedError
end

def set_new_record(record) 

def set_new_record(record)
  replace(record)
end

def writer(record)

Implements the writer method, e.g. foo.items= for Foo.has_many :items 
def writer(record)
  replace(record)
end