Class: Mongoid::Relations::Referenced::Many

Inherits:
Many
  • Object
show all
Defined in:
lib/mongoid/relations/referenced/many.rb

Overview

This class defines the behaviour for all relations that are a one-to-many between documents in different collections.

Direct Known Subclasses

ManyToMany

Instance Attribute Summary

Attributes inherited from Proxy

#__metadata, #base, #target

Class Method Summary (collapse)

Instance Method Summary (collapse)

Methods inherited from Many

#blank?, #create, #create!, #find_or_create_by, #find_or_initialize_by, #nil?, #respond_to?, #scoped, #serializable_hash

Methods inherited from Proxy

apply_ordering, #extend_proxies, #init, #klass, #reset_unloaded, #substitutable, #with

Methods included from Marshalable

#marshal_dump, #marshal_load

Constructor Details

- (Many) initialize(base, target, metadata)

Instantiate a new references_many relation. Will set the foreign key and the base on the inverse object.

Examples:

Create the new relation.

Referenced::Many.new(base, target, )

Parameters:

  • base (Document)

    The document this relation hangs off of.

  • target (Array<Document>)

    The target of the relation.

  • metadata (Metadata)

    The relation's metadata.

Since:

  • 2.0.0.beta.1



215
216
217
218
219
# File 'lib/mongoid/relations/referenced/many.rb', line 215

def initialize(base, target, )
  init(base, Targets::Enumerable.new(target), ) do
    raise_mixed if klass.embedded? && !klass.cyclic?
  end
end

Dynamic Method Handling

This class handles dynamic methods through the method_missing method

- (Criteria, Object) method_missing(name, *args, &block) (private)

If the target array does not respond to the supplied method then try to find a named scope or criteria on the class and send the call there.

If the method exists on the array, use the default proxy behavior.

Parameters:

  • name (Symbol, String)

    The name of the method.

  • args (Array)

    The method args

  • block (Proc)

    Optional block to pass.

Returns:

  • (Criteria, Object)

    A Criteria or return value from the target.

Since:

  • 2.0.0.beta.1



408
409
410
411
412
413
414
415
416
# File 'lib/mongoid/relations/referenced/many.rb', line 408

def method_missing(name, *args, &block)
  if target.respond_to?(name)
    target.send(name, *args, &block)
  else
    klass.send(:with_scope, criteria) do
      criteria.public_send(name, *args, &block)
    end
  end
end

Class Method Details

+ (Builder) builder(base, meta, object)

Return the builder that is responsible for generating the documents that will be used by this relation.

Examples:

Get the builder.

Referenced::Many.builder(meta, object)

Parameters:

  • base (Document)

    The base document.

  • meta (Metadata)

    The metadata of the relation.

  • object (Document, Hash)

    A document or attributes to build with.

Returns:

  • (Builder)

    A new builder object.

Since:

  • 2.0.0.rc.1



543
544
545
# File 'lib/mongoid/relations/referenced/many.rb', line 543

def builder(base, meta, object)
  Builders::Referenced::Many.new(base, meta, object || [])
end

+ (Criteria) criteria(metadata, object, type = nil)

Get the standard criteria used for querying this relation.

Examples:

Get the criteria.

Proxy.criteria(meta, id, Model)

Parameters:

  • metadata (Metadata)

    The metadata.

  • object (Object)

    The value of the foreign key.

  • type (Class) (defaults to: nil)

    The optional type.

Returns:

Since:

  • 2.1.0



559
560
561
562
563
564
565
566
567
568
569
570
# File 'lib/mongoid/relations/referenced/many.rb', line 559

def criteria(, object, type = nil)
  apply_ordering(
    with_inverse_field_criterion(
      with_polymorphic_criterion(
        .klass.where(.foreign_key => object),
        ,
        type
      ),
      
    ), 
  )
end

+ (Object) eager_load_klass



572
573
574
# File 'lib/mongoid/relations/referenced/many.rb', line 572

def eager_load_klass
  Relations::Eager::HasMany
end

+ (false) embedded?

Returns true if the relation is an embedded one. In this case always false.

Examples:

Is this relation embedded?

Referenced::Many.embedded?

Returns:

  • (false)

    Always false.

Since:

  • 2.0.0.rc.1



585
586
587
# File 'lib/mongoid/relations/referenced/many.rb', line 585

def embedded?
  false
end

+ (String) foreign_key(name)

Get the foreign key for the provided name.

Examples:

Get the foreign key.

Referenced::Many.foreign_key(:person)

Parameters:

Returns:

  • (String)

    The foreign key.

Since:

  • 3.0.0



599
600
601
# File 'lib/mongoid/relations/referenced/many.rb', line 599

def foreign_key(name)
  "#{name}#{foreign_key_suffix}"
end

+ (nil) foreign_key_default

Get the default value for the foreign key.

Examples:

Get the default.

Referenced::Many.foreign_key_default

Returns:

  • (nil)

    Always nil.

Since:

  • 2.0.0.rc.1



611
612
613
# File 'lib/mongoid/relations/referenced/many.rb', line 611

def foreign_key_default
  nil
end

+ (String) foreign_key_suffix

Returns the suffix of the foreign key field, either “_id” or “_ids”.

Examples:

Get the suffix for the foreign key.

Referenced::Many.foreign_key_suffix

Returns:

  • (String)

    “_id”

Since:

  • 2.0.0.rc.1



623
624
625
# File 'lib/mongoid/relations/referenced/many.rb', line 623

def foreign_key_suffix
  "_id"
end

+ (Symbol) macro

Returns the macro for this relation. Used mostly as a helper in reflection.

Examples:

Get the macro.

Referenced::Many.macro

Returns:



634
635
636
# File 'lib/mongoid/relations/referenced/many.rb', line 634

def macro
  :has_many
end

+ (NestedBuilder) nested_builder(metadata, attributes, options)

Return the nested builder that is responsible for generating the documents that will be used by this relation.

Examples:

Get the nested builder.

Referenced::Many.builder(attributes, options)

Parameters:

  • metadata (Metadata)

    The relation metadata.

  • attributes (Hash)

    The attributes to build with.

  • options (Hash)

    The options for the builder.

Options Hash (options):

  • :allow_destroy (true, false)

    Can documents be deleted?

  • :limit (Integer)

    Max number of documents to create at once.

  • :reject_if (Proc, Symbol)

    If documents match this option then they are ignored.

  • :update_only (true, false)

    Only existing documents can be modified.

Returns:

  • (NestedBuilder)

    A newly instantiated nested builder object.

Since:

  • 2.0.0.rc.1



660
661
662
# File 'lib/mongoid/relations/referenced/many.rb', line 660

def nested_builder(, attributes, options)
  Builders::NestedAttributes::Many.new(, attributes, options)
end

+ (Root) path(document)

Get the path calculator for the supplied document.

Examples:

Get the path calculator.

Proxy.path(document)

Parameters:

  • document (Document)

    The document to calculate on.

Returns:

  • (Root)

    The root atomic path calculator.

Since:

  • 2.1.0



674
675
676
# File 'lib/mongoid/relations/referenced/many.rb', line 674

def path(document)
  Mongoid::Atomic::Paths::Root.new(document)
end

+ (false) stores_foreign_key?

Tells the caller if this relation is one that stores the foreign key on its own objects.

Examples:

Does this relation store a foreign key?

Referenced::Many.stores_foreign_key?

Returns:

  • (false)

    Always false.

Since:

  • 2.0.0.rc.1



687
688
689
# File 'lib/mongoid/relations/referenced/many.rb', line 687

def stores_foreign_key?
  false
end

+ (Array<Symbol>) valid_options

Get the valid options allowed with this relation.

Examples:

Get the valid options.

Relation.valid_options

Returns:

  • (Array<Symbol>)

    The valid options.

Since:

  • 2.1.0



699
700
701
702
703
704
705
706
707
708
709
710
711
712
# File 'lib/mongoid/relations/referenced/many.rb', line 699

def valid_options
  [
    :after_add,
    :after_remove,
    :as,
    :autosave,
    :before_add,
    :before_remove,
    :dependent,
    :foreign_key,
    :order,
    :primary_key
  ]
end

+ (true, false) validation_default

Get the default validation setting for the relation. Determines if by default a validates associated will occur.

Examples:

Get the validation default.

Proxy.validation_default

Returns:

  • (true, false)

    The validation default.

Since:

  • 2.1.9



723
724
725
# File 'lib/mongoid/relations/referenced/many.rb', line 723

def validation_default
  true
end

Instance Method Details

- (Array<Document>) <<(*args) Also known as: push

Appends a document or array of documents to the relation. Will set the parent and update the index in the process.

Examples:

Append a document.

person.posts << post

Push a document.

person.posts.push(post)

Concat with other documents.

person.posts.concat([ post_one, post_two ])

Parameters:

Returns:

  • (Array<Document>)

    The loaded docs.

Since:

  • 2.0.0.beta.1



30
31
32
33
34
35
36
37
38
# File 'lib/mongoid/relations/referenced/many.rb', line 30

def <<(*args)
  docs = args.flatten
  return concat(docs) if docs.size > 1
  if doc = docs.first
    append(doc)
    doc.save if persistable? && !_assigning? && !doc.validated?
  end
  self
end

- (Document) build(attributes = {}, options = {}, type = nil) - (Document) build(attributes = {}, type = nil) Also known as: new

Build a new document from the attributes and append it to this relation without saving.

Examples:

Build a new document on the relation.

person.posts.build(:title => "A new post")

Overloads:

  • - (Document) build(attributes = {}, options = {}, type = nil)

    Parameters:

    • attributes (Hash) (defaults to: {})

      The attributes of the new document.

    • options (Hash) (defaults to: {})

      The scoped assignment options.

    • type (Class) (defaults to: nil)

      The optional subclass to build.

  • - (Document) build(attributes = {}, type = nil)

    Parameters:

    • attributes (Hash) (defaults to: {})

      The attributes of the new document.

    • type (Class) (defaults to: nil)

      The optional subclass to build.

Yields:

  • (doc)

Returns:

Since:

  • 2.0.0.beta.1



81
82
83
84
85
86
87
88
# File 'lib/mongoid/relations/referenced/many.rb', line 81

def build(attributes = {}, type = nil)
  doc = Factory.build(type || klass, attributes)
  append(doc)
  doc.apply_post_processed_defaults
  yield(doc) if block_given?
  doc.run_callbacks(:build) { doc }
  doc
end

- (Array<Document>) concat(documents)

Appends an array of documents to the relation. Performs a batch insert of the documents instead of persisting one at a time.

Examples:

Concat with other documents.

person.posts.concat([ post_one, post_two ])

Parameters:

  • documents (Array<Document>)

    The docs to add.

Returns:

Since:

  • 2.4.0



52
53
54
55
56
57
58
59
60
61
# File 'lib/mongoid/relations/referenced/many.rb', line 52

def concat(documents)
  docs, inserts = [], []
  documents.each do |doc|
    next unless doc
    append(doc)
    save_or_delay(doc, docs, inserts) if persistable?
  end
  persist_delayed(docs, inserts)
  self
end

- (Document) delete(document)

Delete the document from the relation. This will set the foreign key on the document to nil. If the dependent options on the relation are :delete or :destroy the appropriate removal will occur.

Examples:

Delete the document.

person.posts.delete(post)

Parameters:

  • document (Document)

    The document to remove.

Returns:

Since:

  • 2.1.0



103
104
105
106
107
108
109
110
111
112
# File 'lib/mongoid/relations/referenced/many.rb', line 103

def delete(document)
  execute_callback :before_remove, document
  target.delete(document) do |doc|
    if doc
      unbind_one(doc)
      cascade!(doc) if !_assigning?
    end
    execute_callback :after_remove, doc
  end
end

- (Integer) delete_all(conditions = nil)

Deletes all related documents from the database given the supplied conditions.

Examples:

Delete all documents in the relation.

person.posts.delete_all

Conditonally delete all documents in the relation.

person.posts.delete_all({ :title => "Testing" })

Parameters:

  • conditions (Hash) (defaults to: nil)

    Optional conditions to delete with.

Returns:

  • (Integer)

    The number of documents deleted.

Since:

  • 2.0.0.beta.1



128
129
130
# File 'lib/mongoid/relations/referenced/many.rb', line 128

def delete_all(conditions = nil)
  remove_all(conditions, :delete_all)
end

- (Integer) destroy_all(conditions = nil)

Destroys all related documents from the database given the supplied conditions.

Examples:

Destroy all documents in the relation.

person.posts.destroy_all

Conditonally destroy all documents in the relation.

person.posts.destroy_all({ :title => "Testing" })

Parameters:

  • conditions (Hash) (defaults to: nil)

    Optional conditions to destroy with.

Returns:

  • (Integer)

    The number of documents destroyd.

Since:

  • 2.0.0.beta.1



146
147
148
# File 'lib/mongoid/relations/referenced/many.rb', line 146

def destroy_all(conditions = nil)
  remove_all(conditions, :destroy_all)
end

- (Array<Document>) each

Note:

This will load the entire relation into memory.

Iterate over each document in the relation and yield to the provided block.

Examples:

Iterate over the documents.

person.posts.each do |post|
  post.save
end

Returns:

  • (Array<Document>)

    The loaded docs.

Since:

  • 2.1.0



163
164
165
166
167
168
169
# File 'lib/mongoid/relations/referenced/many.rb', line 163

def each
  if block_given?
    target.each { |doc| yield(doc) }
  else
    to_enum
  end
end

- (true, false) exists?

Determine if any documents in this relation exist in the database.

Examples:

Are there persisted documents?

person.posts.exists?

Returns:

  • (true, false)

    True is persisted documents exist, false if not.



177
178
179
# File 'lib/mongoid/relations/referenced/many.rb', line 177

def exists?
  criteria.exists?
end

- (Document, Criteria) find(*args)

Note:

This will keep matching documents in memory for iteration later.

Find the matchind document on the association, either based on id or conditions.

Examples:

Find by an id.

person.posts.find(BSON::ObjectId.new)

Find by multiple ids.

person.posts.find([ BSON::ObjectId.new, BSON::ObjectId.new ])

Parameters:

Returns:

Since:

  • 2.0.0.beta.1



198
199
200
201
202
# File 'lib/mongoid/relations/referenced/many.rb', line 198

def find(*args)
  matching = criteria.find(*args)
  Array(matching).each { |doc| target.push(doc) }
  matching
end

- (Object) nullify Also known as: nullify_all

Removes all associations between the base document and the target documents by deleting the foreign keys and the references, orphaning the target documents in the process.

Examples:

Nullify the relation.

person.posts.nullify

Since:

  • 2.0.0.rc.1



229
230
231
232
233
234
235
# File 'lib/mongoid/relations/referenced/many.rb', line 229

def nullify
  criteria.update_all(foreign_key => nil)
  target.clear do |doc|
    unbind_one(doc)
    doc.changed_attributes.delete(foreign_key)
  end
end

- (Many) purge Also known as: clear

Clear the relation. Will delete the documents from the db if they are already persisted.

Examples:

Clear the relation.

person.posts.clear

Returns:

  • (Many)

    The relation emptied.

Since:

  • 2.0.0.beta.1



247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
# File 'lib/mongoid/relations/referenced/many.rb', line 247

def purge
  unless .destructive?
    nullify
  else
    after_remove_error = nil
    criteria.delete_all
    many = target.clear do |doc|
      execute_callback :before_remove, doc
      unbind_one(doc)
      doc.destroyed = true
      begin
        execute_callback :after_remove, doc
      rescue => e
        after_remove_error = e
      end
    end
    raise after_remove_error if after_remove_error
    many
  end
end

- (Many) substitute(replacement)

Substitutes the supplied target documents for the existing documents in the relation. If the new target is nil, perform the necessary deletion.

Examples:

Replace the relation.

person.posts.substitute([ new_post ])

Parameters:

  • replacement (Array<Document>)

    The replacement target.

Returns:

  • (Many)

    The relation.

Since:

  • 2.0.0.rc.1



281
282
283
284
285
286
287
288
289
290
291
292
293
294
# File 'lib/mongoid/relations/referenced/many.rb', line 281

def substitute(replacement)
  if replacement
    new_docs, docs = replacement.compact, []
    new_ids = new_docs.map { |doc| doc.id }
    remove_not_in(new_ids)
    new_docs.each do |doc|
      docs.push(doc) if doc.send(foreign_key) != base.id
    end
    concat(docs)
  else
    purge
  end
  self
end

- (Criteria) unscoped

Get a criteria for the documents without the default scoping applied.

Examples:

Get the unscoped criteria.

person.posts.unscoped

Returns:

Since:

  • 2.4.0



305
306
307
308
309
# File 'lib/mongoid/relations/referenced/many.rb', line 305

def unscoped
  klass.unscoped.where(
    foreign_key => Conversions.flag(base.id, )
  )
end