Module: Mongoid::Association::Accessors

# File 'lib/mongoid/association/accessors.rb', line 414

def self.define_creator!(association)
  name = association.name
  association.inverse_class.tap do |klass|
    klass.re_define_method("create_#{name}") do |*args|
      attributes, _options = parse_args(*args)
      document = Factory.build(association.klass, attributes)
      doc = _assigning do
        send("#{name}=", document)
      end
      doc.save
      save if new_record? && association.stores_foreign_key?
      doc
    end
  end
end

# File 'lib/mongoid/association/accessors.rb', line 275

def self.define_existence_check!(association)
  name = association.name
  association.inverse_class.tap do |klass|
    klass.module_eval <<-END, __FILE__, __LINE__ + 1
        def #{name}?
          without_autobuild { !__send__(:#{name}).blank? }
        end
        alias :has_#{name}? :#{name}?
    END
  end
end

# File 'lib/mongoid/association/accessors.rb', line 297

def self.define_getter!(association)
  name = association.name
  association.inverse_class.tap do |klass|
    klass.re_define_method(name) do |reload = false|
      value = get_relation(name, association, nil, reload)
      if value.nil? && association.autobuilding? && !without_autobuild?
        value = send("build_#{name}")
      end
      value
    end
  end
end

# File 'lib/mongoid/association/accessors.rb', line 319

def self.define_ids_getter!(association)
  ids_method = "#{association.name.to_s.singularize}_ids"
  association.inverse_class.tap do |klass|
    klass.re_define_method(ids_method) do
      send(association.name).pluck(:_id)
    end
  end
end

# File 'lib/mongoid/association/accessors.rb', line 370

def self.define_ids_setter!(association)
  ids_method = "#{association.name.to_s.singularize}_ids="
  association.inverse_class.aliased_associations[ids_method.chop] = association.name.to_s
  association.inverse_class.tap do |klass|
    klass.re_define_method(ids_method) do |ids|
      send(association.setter, association.relation_class.find(ids.reject(&:blank?)))
    end
  end
end

# File 'lib/mongoid/association/accessors.rb', line 339

def self.define_setter!(association)
  name = association.name
  association.inverse_class.tap do |klass|
    klass.re_define_method("#{name}=") do |object|
      without_autobuild do
        if value = get_relation(name, association, object)
          if !value.respond_to?(:substitute)
            value = __build__(name, value, association) 
          end

          set_relation(name, value.substitute(object.substitutable))
        else
          __build__(name, object.substitutable, association)
        end
      end
    end
  end
end

# File 'lib/mongoid/association/accessors.rb', line 153

def _mongoid_filter_selected_fields(assoc_key)
  return nil unless __selected_fields

  # If the list of fields was specified using #without instead of #only
  # and the provided list does not include the association, any of its
  # fields should be allowed.
  if __selected_fields.values.all? { |v| v == 0 } &&
    __selected_fields.keys.none? { |k| k.split('.', 2).first == assoc_key }
  then
    return nil
  end

  projecting_assoc = false

  filtered = {}
  __selected_fields.each do |k, v|
    bits = k.split('.')

    # If we are asked to project an association, we need all of that
    # association's fields. However, we may be asked to project
    # an association *and* its fields in the same query. In this case
    # behavior differs according to server version:
    #
    # 4.2 and lower take the most recent projection specification, meaning
    # projecting foo followed by foo.bar effectively projects foo.bar and
    # projecting foo.bar followed by foo effectively projects foo.
    # To match this behavior we need to track when we are being asked
    # to project the association and when we are asked to project a field,
    # and if we are asked to project the association last we need to
    # remove any field projections.
    #
    # 4.4 (and presumably higher) do not allow projection to be on an
    # association and its field, so it doesn't matter what we do. Hence
    # we just need to handle the 4.2 and lower case correctly.
    if bits.first == assoc_key
      # Projecting the entire association OR some of its fields
      if bits.length > 1
        # Projecting a field
        bits.shift
        filtered[bits.join('.')] = v
        projecting_assoc = false
      else
        # Projecting the entire association
        projecting_assoc = true
      end
    end
  end

  if projecting_assoc
    # The last projection was of the entire association; we may have
    # also been projecting fields, but discard the field projections
    # and return nil indicating we want the entire association.
    return nil
  end

  # Positional projection is specified as "foo.$". In this case the
  # document that the $ is referring to should be retrieved with all
  # fields. See https://www.mongodb.com/docs/manual/reference/operator/projection/positional/
  # and https://jira.mongodb.org/browse/MONGOID-4769.
  if filtered.keys == %w($)
    filtered = nil
  end

  filtered
end

# File 'lib/mongoid/association/accessors.rb', line 44

def create_relation(object, association, selected_fields = nil)
  type = @attributes[association.inverse_type]
  target = if t = association.build(self, object, type, selected_fields)
    association.create_relation(self, t)
  else
    nil
  end

  # Only need to do this on embedded associations. The pending callbacks
  # are only added when materializing the documents, which only happens
  # on embedded associations. There is no call to the database in the
  # construction of a referenced association.
  if association.embedded?
    Array(target).each do |doc|
      doc.try(:run_pending_callbacks)
    end
  end

  target
end

# File 'lib/mongoid/association/accessors.rb', line 108

def get_relation(name, association, object, reload = false)
  field_name = database_field_name(name)

  # As per the comments under MONGOID-5034, I've decided to only raise on
  # embedded associations for a missing attribute. Rails does not raise
  # for a missing attribute on referenced associations.
  # We also don't want to raise if we're retrieving an association within
  # the codebase. This is often done when retrieving the inverse association
  # during binding or when cascading callbacks. Whenever we retrieve
  # associations within the codebase, we use without_autobuild.
  if !without_autobuild? && association.embedded? && attribute_missing?(field_name)
    raise Mongoid::Errors::AttributeNotLoaded.new(self.class, field_name)
  end

  if !reload && (value = ivar(name)) != false
    value
  else
    _building do
      _loading do
        if object && needs_no_database_query?(object, association)
          __build__(name, object, association)
        else
          selected_fields = _mongoid_filter_selected_fields(association.key)
          __build__(name, attributes[association.key], association, selected_fields)
        end
      end
    end
  end
end

# File 'lib/mongoid/association/accessors.rb', line 219

def needs_no_database_query?(object, association)
  object.is_a?(Document) && !object.embedded? &&
      object._id == attributes[association.key]
end

# File 'lib/mongoid/association/accessors.rb', line 258

def parse_args(*args)
  [args.first || {}, args.size > 1 ? args[1] : {}]
end

# File 'lib/mongoid/association/accessors.rb', line 72

def reset_relation_criteria(name)
  if instance_variable_defined?("@_#{name}")
    send(name).reset_unloaded
  end
end

# File 'lib/mongoid/association/accessors.rb', line 88

def set_relation(name, relation)
  instance_variable_set("@_#{name}", relation)
end

# File 'lib/mongoid/association/accessors.rb', line 242

def without_autobuild
  Threaded.begin_execution("without_autobuild")
  yield
ensure
  Threaded.exit_execution("without_autobuild")
end