Class: Mongoid::Relations::Embedded::Many

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

Overview

This class handles the behaviour for a document that embeds many other documents within in it as an array.

Instance Attribute Summary

Attributes inherited from Proxy

#__metadata, #base, #target

Class Method Summary (collapse)

Instance Method Summary (collapse)

Methods included from Batchable

#batch_clear, #batch_insert, #batch_remove, #batch_replace

Methods included from Positional

#positionally

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 embeds_many relation.

Examples:

Create the new relation.

Many.new(person, addresses, )


233
234
235
236
237
238
239
240
241
242
# File 'lib/mongoid/relations/embedded/many.rb', line 233

def initialize(base, target, )
  init(base, target, ) do
    target.each_with_index do |doc, index|
      integrate(doc)
      doc._index = index
    end
    @_unscoped = target.dup
    @target = scope(target)
  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.



403
404
405
406
407
408
# File 'lib/mongoid/relations/embedded/many.rb', line 403

def method_missing(name, *args, &block)
  return super if target.respond_to?(name)
  klass.send(:with_scope, criteria) do
    criteria.public_send(name, *args, &block)
  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.

Embedded::Many.builder(meta, object)

Since:

  • 2.0.0.rc.1



514
515
516
# File 'lib/mongoid/relations/embedded/many.rb', line 514

def builder(base, meta, object)
  Builders::Embedded::Many.new(base, meta, object)
end

+ (true) embedded?

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

Examples:

Is the relation embedded?

Embedded::Many.embedded?

Since:

  • 2.0.0.rc.1



527
528
529
# File 'lib/mongoid/relations/embedded/many.rb', line 527

def embedded?
  true
end

+ (nil) 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

Since:

  • 3.0.0



539
540
541
# File 'lib/mongoid/relations/embedded/many.rb', line 539

def foreign_key_suffix
  nil
end

+ (Symbol) macro

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

Examples:

Get the relation macro.

Mongoid::Relations::Embedded::Many.macro

Since:

  • 2.0.0.rc.1



552
553
554
# File 'lib/mongoid/relations/embedded/many.rb', line 552

def macro
  :embeds_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.

NestedAttributes::Many.builder(attributes, options)

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.

Since:

  • 2.0.0.rc.1



578
579
580
# File 'lib/mongoid/relations/embedded/many.rb', line 578

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

+ (Mongoid::Atomic::Paths::Embedded::Many) path(document)

Get the path calculator for the supplied document.

Examples:

Get the path calculator.

Proxy.path(document)

Since:

  • 2.1.0



593
594
595
# File 'lib/mongoid/relations/embedded/many.rb', line 593

def path(document)
  Mongoid::Atomic::Paths::Embedded::Many.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?

Embedded::Many.stores_foreign_key?

Since:

  • 2.0.0.rc.1



606
607
608
# File 'lib/mongoid/relations/embedded/many.rb', line 606

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

Since:

  • 2.1.0



618
619
620
621
622
623
# File 'lib/mongoid/relations/embedded/many.rb', line 618

def valid_options
  [
    :as, :cascade_callbacks, :cyclic, :order, :store_as,
    :before_add, :after_add, :before_remove, :after_remove
  ]
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

Since:

  • 2.1.9



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

def validation_default
  true
end

Instance Method Details

- (Object) <<(*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.addresses << address

Push a document.

person.addresses.push(address)


23
24
25
26
27
28
29
30
31
# File 'lib/mongoid/relations/embedded/many.rb', line 23

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

- (Array<Hash>) as_document

Get this relation as as its representation in the database.

Examples:

Convert the relation to an attributes hash.

person.addresses.as_document

Since:

  • 2.0.0.rc.1



42
43
44
45
46
47
48
# File 'lib/mongoid/relations/embedded/many.rb', line 42

def as_document
  attributes = []
  _unscoped.each do |doc|
    attributes.push(doc.as_document)
  end
  attributes
end

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

Builds a new document in the relation and appends it to the target. Takes an optional type if you want to specify a subclass.

Examples:

Build a new document on the relation.

person.people.build(:name => "Bozo")

Yields:

  • (doc)


81
82
83
84
85
86
87
88
# File 'lib/mongoid/relations/embedded/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

- (Many) clear

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

Examples:

Clear the relation.

person.addresses.clear


98
99
100
101
# File 'lib/mongoid/relations/embedded/many.rb', line 98

def clear
  batch_clear(target.dup)
  self
end

- (Array<Document>) concat(docs)

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.addresses.concat([ address_one, address_two ])

Since:

  • 2.4.0



61
62
63
64
# File 'lib/mongoid/relations/embedded/many.rb', line 61

def concat(docs)
  batch_insert(docs) unless docs.empty?
  self
end

- (Integer) count

Returns a count of the number of documents in the association that have actually been persisted to the database.

Use #size if you want the total number of documents.

Examples:

Get the count of persisted documents.

person.addresses.count


113
114
115
# File 'lib/mongoid/relations/embedded/many.rb', line 113

def count
  target.select { |doc| doc.persisted? }.size
end

- (Document?) delete(document)

Delete the supplied document from the target. This method is proxied in order to reindex the array after the operation occurs.

Examples:

Delete the document from the relation.

person.addresses.delete(address)

Since:

  • 2.0.0.rc.1



128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
# File 'lib/mongoid/relations/embedded/many.rb', line 128

def delete(document)
  execute_callback :before_remove, document
  doc = target.delete_one(document)
  if doc && !_binding?
    _unscoped.delete_one(doc)
    if _assigning?
      base.add_atomic_pull(doc)
    else
      doc.delete(suppress: true)
      unbind_one(doc)
    end
  end
  reindex
  execute_callback :after_remove, document
  doc
end

- (Integer) delete_all(conditions = {})

Delete all the documents in the association without running callbacks.

Examples:

Delete all documents from the relation.

person.addresses.delete_all

Conditionally delete documents from the relation.

person.addresses.delete_all({ :street => "Bond" })


156
157
158
# File 'lib/mongoid/relations/embedded/many.rb', line 156

def delete_all(conditions = {})
  remove_all(conditions, :delete)
end

- (Many, Enumerator) delete_if

Delete all the documents for which the provided block returns true.

Examples:

Delete the matching documents.

person.addresses.delete_if do |doc|
  doc.state = "GA"
end

Since:

  • 3.1.0



171
172
173
174
175
176
177
178
179
180
# File 'lib/mongoid/relations/embedded/many.rb', line 171

def delete_if
  if block_given?
    target.each do |doc|
      delete(doc) if yield(doc)
    end
    self
  else
    super
  end
end

- (Integer) destroy_all(conditions = {})

Destroy all the documents in the association whilst running callbacks.

Examples:

Destroy all documents from the relation.

person.addresses.destroy_all

Conditionally destroy documents from the relation.

person.addresses.destroy_all({ :street => "Bond" })


193
194
195
# File 'lib/mongoid/relations/embedded/many.rb', line 193

def destroy_all(conditions = {})
  remove_all(conditions, :destroy)
end

- (true, false) exists?

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

Examples:

Are there persisted documents?

person.posts.exists?


203
204
205
# File 'lib/mongoid/relations/embedded/many.rb', line 203

def exists?
  count > 0
end

- (Array<Document>, Document) find(*args)

Finds a document in this association through several different methods.

Examples:

Find a document by its id.

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

Find documents for multiple ids.

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


219
220
221
# File 'lib/mongoid/relations/embedded/many.rb', line 219

def find(*args)
  criteria.find(*args)
end

- (Array<Document>) in_memory

Get all the documents in the relation that are loaded into memory.

Examples:

Get the in memory documents.

relation.in_memory

Since:

  • 2.1.0



252
253
254
# File 'lib/mongoid/relations/embedded/many.rb', line 252

def in_memory
  target
end

- (Document+) pop(count = nil)

Pop documents off the relation. This can be a single document or multiples, and will automatically persist the changes.

Examples:

Pop a single document.

relation.pop

Pop multiple documents.

relation.pop(3)

Since:

  • 3.0.0



271
272
273
274
275
276
277
278
279
# File 'lib/mongoid/relations/embedded/many.rb', line 271

def pop(count = nil)
  if count
    if docs = target[target.size - count, target.size]
      docs.each { |doc| delete(doc) }
    end
  else
    delete(target[-1])
  end
end

- (Many) substitute(docs)

Substitutes the supplied target documents for the existing documents in the relation.

Examples:

Substitute the relation's target.

person.addresses.substitute([ address ])

Since:

  • 2.0.0.rc.1



292
293
294
295
# File 'lib/mongoid/relations/embedded/many.rb', line 292

def substitute(docs)
  batch_replace(docs)
  self
end

- (Criteria) unscoped

Return the relation with all previous scoping removed. This is the exact representation of the docs in the database.

Examples:

Get the unscoped documents.

person.addresses.unscoped

Since:

  • 2.4.0



306
307
308
309
310
311
# File 'lib/mongoid/relations/embedded/many.rb', line 306

def unscoped
  criterion = klass.unscoped
  criterion.embedded = true
  criterion.documents = _unscoped.delete_if(&:marked_for_destruction?)
  criterion
end