Module: Mongoid::Composable

This method should be used to detect whether a persistence operation is executed inside transaction or not.

Convenience method for determining if we are using BSON::ObjectIds as our id.

Is the class able to have the default scope applied?

Determines if the document is a subclass of another document.

Are we currently performing a validation that has a query?

Whether the model is encrypted.

Creates the dirty change accessor.

Creates the dirty change check.

Creates the dirty change flag.

Creates the dirty default change check.

Generate all the dirty methods needed for the attribute.

Creates the dirty change accessor.

Creates the dirty change previous value accessors.

Creates the dirty change check.

Creates the dirty change reset.

Creates the dirty change reset to default.

Sets up a callback is called after a commit of a transaction.

Shortcut for after_commit :hook, on: :create.

Shortcut for after_commit :hook, on: :destroy.

This callback is called after a create, update, or destroy are rolled back.

Shortcut for after_commit :hook, on: [ :create, :update ].

Shortcut for after_commit :hook, on: :update.

Executes a block within the context of a transaction.

Execute a block within the context of a session.

Asserts that the given actions are valid for after_commit and after_rollback callbacks.

Runs after_rollback callbacks on modified documents.

Runs after_commit callbacks on modified documents.

Transforms custom options for after_commit and after_rollback callbacks into options for set_callback.

Driver version 2.20 introduced a new exception for reporting that transactions are not supported.

Get the database client name for the current persistence context of the document class.

Get the collection for the current persistence context of the document class.

Get the collection name for the current persistence context of the document class.

Get the database name for the current persistence context of the document class.

Get the client for the current persistence context of the document class.

Get the current persistence context of the document class.

Change the persistence context for this class during the block.

Reset the store_in options.

Get the default storage options.

Give this model specific custom default storage options.

Create the collection for the called upon ::Mongoid model.

Alias the provided name to the original field.

Removes a field alias.

Defines an attribute as readonly.

Used when needing to update related models from a parent association.

Add the autosave information for the nested association.

Returns an array of names for the attributes available on this object.

Removes the _translations from the given field name.

Get the name of the provided field as it is stored in the database.

Extracts the id field from the specified attributes hash based on aliases defined in this class.

Defines all the fields that are accessible on the Document For each field that is defined, a getter and setter will be added as an instance method to the Document.

Returns the list of id fields for this model class, as both strings and symbols.

Replace a field with a new type.

Traverse down the association tree and search for the field for the given key.

Add the default indexes to the root document if they do not already exist.

Send the actual index creation comments to the MongoDB driver.

Adds an index definition for the provided single or compound keys.

Get an index specification for the provided key.

Send the actual index removal comments to the MongoDB driver, but lets _id untouched.

Gets a list of index specification keys.

Get the names of all databases for this model that have index definitions.

Delete all documents given the supplied conditions.

Delete all documents given the supplied conditions.

Create a new document.

Create a new document.

Returns all association metadata for the supplied macros.

Returns the association metadata for the supplied name.

Adds a referenced association from the child Document to a Document in another database or collection.

Adds the association back to the parent document.

Adds the association from a parent document to its children.

Adds the association from a parent document to its child.

Adds a referenced many-to-many association between many of this Document and many of another Document.

Adds a referenced association from a parent Document to many Documents in another database or collection.

Adds a referenced association from the child Document to a Document in another database or collection.

::Set up the syncing of many to many foreign keys.

::Set up the sync of inverse keys that needs to happen on a destroy.

::Set up the sync of inverse keys that needs to happen on a save.

Decrement the counter name from the entries that match the id by one.

Increment the counter name from the entries that match the id by one.

Reset the given counter using the .count() query from the db.

Update the given counters by the value factor.

Create a cyclic embedded association that creates a tree hierarchy for the document and many embedded child documents.

Create a cyclic embedded association that creates a single self referencing relationship for a parent and a single child.

Determines the child name given the class.

Determines the parent name given the class.

Alias for Scopable::ClassMethods#with_default_scope.

Add a default scope to the model.

Get a queryable, either the last one on the scope stack or a fresh one.

Create a scope that can be accessed from the class level or chained to criteria by the provided name.

Get a criteria for the document with normal scoping.

Returns a hash of all the scopes defined for this class, including scopes defined on ancestor classes.

Get the criteria without any scoping applied.

Get a criteria with the default scope applied, if possible.

Pushes the provided criteria onto the scope stack, and removes it after the provided block is yielded.

Execute the block without applying the default scope.

Warns or raises exception if overriding another scope or method.

Checks if the intended scope is a valid object, either a criteria or proc with a criteria.

Defines the actual class method that will execute the scope when called.

Process the default scope value.

Request the creation of all registered search indices.

Removes the search index specified by the given name or id.

Request the removal of all registered search indexes.

Adds an index definition for the provided single or compound keys.

A convenience method for querying the search indexes available on the current model’s collection.

Waits for the named search indexes to be created.

Retrieves the index records for the indexes with the given names.

Specifies a shard key with the field(s) specified.

Execute a block in creating mode.

When inheriting, we want to copy the fields from the parent class and set the on the child to start, mimicking the behavior of the old class_inheritable_accessor that was deprecated in ::Rails edge.

Returns the root class of the STI tree that the current class participates in.

Adds an associated validator for the association if the validate option was not provided or set to true.

Add validation with the supplied validators for the provided fields with options.

Performs class equality checking.

::Set the encryption metadata for the model.

Override the key_id for the model.

Get the changed attributes for the document.

Has the document changed?

Have any children (embedded documents) of this document changed?

Get the document’s current persistence context.

Returns whether a persistence context is set for the document or the document’s class.

Remembers the storage options that were active when the current object was instantiated/created.

Alias for Attributes#attributes.

Is the document using object ids?

Are we executing an atomically block on the current document?

Determine if the document itself is embedded in another document via the proper channels.

Determine if the document is part of an embeds_many association.

Determine if the document is part of an embeds_one association.

Determine if the document is part of an references_many association.

Determine if the document is part of an references_one association.

Is the current code executing without autobuild functionality?

Used to prevent infinite loops in associated autosaves.

Alias for Stateful#flagged_for_destroy?.

Returns true if the Document has been successfully destroyed, and false if it hasn’t.

Returns whether or not the document has been flagged for deletion, but not destroyed yet.

Alias for Stateful#flagged_for_destroy?.

Sets whether the document has been persisted to the database.

Returns true if the document has not been persisted to the database, false if it has.

Checks if the document has been saved to the database.

Returns true if this document was just created – that is, prior to the last save, the object didn’t exist in the database and new_record? would have returned true.

Checks if the document was previously saved to the database but now it has been deleted.

Determine if the document can be pushed.

Is the document readonly?

Determine if the document can be set.

Is the document updateable?

Begin the assignment of attributes.

Is the current thread in assigning mode?

Execute a block in binding mode.

Is the current thread in binding mode?

Execute a block in building mode.

Is the current thread in building mode?

Is the current thread in creating mode?

Execute a block in loading mode.

Is the current thread in loading mode?

Retrieves the parent document of this document.

Sets the parent document of this document.

Return the root document in the object graph.

Is this document the root document of the hierarchy?

Determines if the document is a subclass of another document.

Used to prevent infinite loops in associated validations.

Are we currently performing a validation that has a query?

Returns the stored callbacks to be executed later.

Stores callbacks to be executed later.

We need to hook into this for autosave, since we don’t want it firing if the before callbacks were halted.

Alias for Atomic#atomic_updates.

Add the document as an atomic pull.

Add an atomic unset for the document.

For array fields these are the unique adds that need to happen.

For array fields these are the pulls that need to happen.

For array fields these are the pushes that need to happen.

Returns path of the attribute for modification.

Get the removal modifier for the document.

Get the insertion modifier for the document.

Return the path to this Document in JSON notation, used for atomic updates via $set in MongoDB.

Get the atomic paths utility for this document.

Returns the positional operator of this document for modification.

Get all the attributes that need to be pulled.

Get all the push attributes that need to occur.

Get all the attributes that need to be set.

Get all the attributes that need to be unset.

Get all the atomic updates that need to happen for the current Document.

Get a hash of atomic pulls that are pending.

Get all the atomic sets that have had their saves delayed.

Get the delayed atomic unsets.

Flag the document as destroyed and return the atomic path.

Get the flagged destroys.

Process all the pending flagged destroys from nested attributes.

Generates the atomic updates in the correct order.

Clears all pending atomic updates.

Returns the original value of an attribute before the last save.

Determine if a specific attribute has changed.

Get whether or not the field has a different value from the default.

Get the previous attribute value that was changed before the document was saved.

Get the previous value for the attribute.

Flag an attribute as going to change.

Get the attribute changes.

Get all the changes for the document.

Indicates that the children of this document may have changed, and ought to be checked when the document is validated.

Call this method after save, so the changes can be properly switched.

Things that need to execute after a document has been persisted.

Get the previous changes on the document.

Remove a change from the dirty attributes hash.

::Set the attribute back to its old value.

Returns the change to an attribute during the last save.

Returns whether this attribute changed during the last save.

Gets all the new values for each of the changed fields, to be passed to a MongoDB $set modifier.

Returns whether this attribute change the next time we save.

Get the old and new value for the provided attribute.

Get attributes of the document before the document was saved.

If at least one session is active, this ensures that the current model’s client is compatible with one of them.

Get the collection for the document’s current persistence context.

Get the collection name for the document’s current persistence context.

Get the database client for the document’s current persistence context.

Change the persistence context for this object during the block.

Saves the storage options from the current persistence context.

The storage options that apply to this record, consisting of both the class-level declared storage options (e.g.

Alias for Attributes#read_attribute.

Alias for Attributes#write_attribute.

Allows you to set all the attributes for a particular mass-assignment security role by passing in a hash of attributes with keys matching the attribute names (which again matches the column names) and the role name using the :as option.

Determine if the attribute is missing from the document, due to loading it from the database with missing fields.

Determine if an attribute is present.

Alias for Attributes#write_attributes.

Get the attributes that have not been cast.

Does the document have the provided attribute?

Does the document have the provided attribute before it was assigned and type cast?

Process the raw attribute values just read from the documents attributes.

Read a value from the document attributes.

Read a value from the attributes before type cast.

Remove a value from the Document attributes.

Return type-casted attributes.

Write a single attribute to the document attribute hash.

Writes the supplied attributes hash to the document.

Determine if the attribute will not change, by comparing the current value with the new value.

Does the string contain dot syntax for accessing hashes?

If value is a ::BSON::Decimal128, convert it to a BigDecimal for comparison purposes.

Return the typecasted value for a field.

Are we able to write the attribute with the provided name?

Process the provided attributes casting them to their proper values if a field exists for them on the document.

If the key provided is the name of an association or a nested attribute, we need to wait until all other attributes are set before processing these.

Get all the pending nested attributes that need to be set.

Get all the pending associations that need to be set.

If the attribute is dynamic, add a field for it with a type of object and then either way set the value.

Process all the pending nested attributes that needed to wait until ids were set to fire off.

Process all the pending items, then clear them out.

Process all the pending associations that needed to wait until ids were set to fire off.

::Set value of the pending nested attribute.

::Set value of the pending relation.

Evolve the document into an object id.

Applies a single default value for the given name.

Apply all the defaults at once.

Apply all default values to the document which are procs.

Apply all default values to the document which are not procs.

Returns an array of names for the attributes available on this object.

Get the name of the provided field as it is stored in the database.

Does this field start with a dollar sign ($) or contain a dot/period (.)?

Is the provided field a lazy evaluation?

Validate whether or not the field starts with a dollar sign ($) or contains a dot/period (.).

Returns the class name plus its attributes.

This pretty prints the same information as the inspect method.

Get an array of inspected dynamic fields for the document.

Get an array of inspected fields for the document.

Determines if this document has the attributes to match the supplied MongoDB selector.

Execute operations atomically (in a single database call) for everything that would happen inside the block.

Raise an error if a callback failed.

Raise an error if validation failed.

Return the current atomic context’s changed fields.

Pop an atomic context off the stack.

Push a new atomic context onto the stack.

Remove the dirty changes for all fields changed in the current atomic context.

Reset the attributes for all fields changed in the current atomic context.

Persist the atomic operations.

If we are in an atomically block, add the operations to the delayed group, otherwise persist immediately.

Post process the persistence operation.

Prepare an atomic persistence operation.

Process the atomic operations - this handles the common behavior of iterating through each op, getting the aliased field name, and removing appropriate dirty changes.

Perform an $unset operation on the provided fields and in the values in the document in memory.

Perform an upsert of the document.

Prepare the upsert for execution.

Update the document attributes in the database.

Update the document attributes in the database and raise an error if validation failed.

Update a single attribute and persist the entire document.

Alias for Persistable::Updatable#update.

Alias for Persistable::Updatable#update!.

Checks to see if the _id field has been modified.

Initialize the atomic updates.

Prepare the update for execution.

If there is a touch option and it is false, this method will call the timeless method so that the updated_at attribute is not updated.

Consolidates all the callback invocations into a single place, to avoid cluttering the logic in #prepare_update.

Update the document in the database.

Perform a $set operation on the provided field/value pairs and set the values in the document in memory.

Save the document - will perform an insert if the document is new, and update if not.

Save the document - will perform an insert if the document is new, and update if not.

Rename fields from one value to another via $rename.

Add the single values to the arrays only if the value does not already exist in the array.

Push a single value or multiple values onto arrays.

Pull single values from the provided arrays.

Pull multiple values from the provided array fields.

Takes the provided selector and atomic operations and replaces the indexes of the embedded documents with the positional operator when needed.

Pop or shift items from arrays using the $pop operator.

Multiply the provided fields by the corresponding values.

Alias for Persistable::Minable#set_min.

::Set the given field or fields to the smaller of either it’s current value, or a given value.

Alias for Persistable::Maxable#set_max.

::Set the given field or fields to the larger of either it’s current value, or a given value.

Performs an atomic $bit operation on the field with the provided hash of bitwise ops to execute in order.

Increment the provided fields by the corresponding values.

Remove the document from the database with callbacks.

Remove the document from the database with callbacks.

Remove the document from the database.

Alias for Persistable::Deletable#delete.

Get the atomic deletes for the operation.

Delete the embedded document.

Delete the root document.

Are we needing to notify the parent document of the deletion.

Prepare the delete operation.

Insert a new document into the database.

Get the atomic insert for embedded documents, either a push or set.

Insert the embedded document.

Insert the root document.

Post process an insert, which sets the new record attribute to false and flags all the children as persisted.

Prepare the insert for execution.

Get the association name for this document.

Convenience method for iterating through the loaded associations and reloading them.

Returns all association metadata for the supplied macros.

Returns the association metadata for the supplied name.

This is convenience for libraries still on the old API.

Parse out the attributes and the options from the args passed to a build_ or create_ methods.

Perform all cascading deletes, destroys, or nullifies.

Builds the related document and creates the association unless the document is nil, then sets the association on this document.

Create an association from an object and association metadata.

Resets the criteria inside the association proxy.

::Set the supplied association to an instance variable on the class with the provided name.

Returns a subset of __selected_fields attribute applicable to the (embedded) association with the given key, or nil if no projection is to be performed.

Get the association.

Parse out the attributes and the options from the args passed to a build_ or create_ methods.

Yield to the block with autobuild functionality turned off.

Is the document able to be synced on the inverse side? This is only if the key has changed and the association bindings have not been run.

Get the synced foreign keys.

Has the document been synced for the foreign key?

Update the inverse keys on destroy.

Update the inverse keys for the association.

Reset the given counter using the .count() query from the db.

Begin the associated autosave.

Check if there is changes for auto-saving.

Reloads the Document attributes from the database.

Reload the document, determining if it’s embedded or not and what behavior to use.

Checks to see if the given attributes argument indicates that the object has been deleted.

Reload the embedded document.

Reload the root document.

Resets the current object using the given attributes.

Apply the default scoping to the attributes of the document, as long as they are not complex queries.

Get the atomic selector for the document.

Get the atomic selector for an embedded document.

Get the atomic selector that would match the existing version of the root document.

Gets the document as a serializable hash, used by ActiveModel’s JSON serializer.

Get the names of all fields that will be serialized.

Since the inclusions can be a hash, symbol, or array of symbols, this is provided as a convenience to parse out the names.

Since the inclusions can be a hash, symbol, or array of symbols, this is provided as a convenience to parse out the options.

Serialize a single attribute.

For each of the provided include options, get the association needed and provide it in the hash.

Returns the value for the named shard key.

Get the shard key fields.

Returns the selector that would match the defined shard keys.

Returns the selector that would match the existing version of this document in the database.

Flags the document as readonly.

Print out the cache key.

Return the cache version for this model.

Get all child Documents to this Document

Get all descendant Documents of this Document recursively.

Resets the memoized descendants on the object.

Collect all the children of this document.

Collect all the descendants of this document.

Marks all descendants as being persisted.

Sets up a child/parent association.

Remove a child document from this parent.

After descendants are persisted we can call this to move all their changes and flag them as persisted in one call.

Validates whether or not an association is valid or not.

Validates the format of a field.

Validates the length of a field.

Validates whether or not a field contains a numeric value.

Validates whether or not a field is present - meaning nil or empty.

Validates whether or not a field is unique against the documents in the database.

Begin the associated validation.

Exit the associated validation.

Given the provided options, are we performing validations?

Overrides the default ActiveModel behavior since we need to handle validations of associations slightly different than just calling the getter.

Determine if the document is valid.

Perform a validation within the associated block.

Execute the after callbacks.

Execute the before callbacks of given kind for embedded documents.

Run the callbacks for embedded documents.

Execute the callbacks of given kind for embedded documents including around callbacks.

Execute the callbacks of given kind for embedded documents without around callbacks.

Is the provided type of callback executable by this document?

Is the document currently in a state that could potentially require callbacks to be executed?

Run only the after callbacks for the specific event.

Run only the before callbacks for the specific event.

Run the callbacks for the document.

Run the pending callbacks.

Determine if the child should fire the callback.

Get all the child embedded documents that are flagged as cascadable.

Get the name of the callback that the child should fire.

Compile the callback chain.

We need to hook into this for autosave, since we don’t want it firing if the before callbacks were halted.

Run only the callbacks for the target location (before, after, around) and kind (save, update, create).

Clone or dup the current Document.

Alias for Copyable#clone.

Clone the document attributes.

When cloning, if the document has localized fields we need to ensure they are properly processed in the clone.

Default comparison is via the string version of the id.

Performs equality checking on the document ids.

Delegates to ==.