Class: Mongoid::GlobalDiscriminatorKeyAssignment::InvalidFieldHost Private

Checks if the document is frozen.

Sets the internal state of this document.

Constructs a hash representing the internal state of this object, suitable for passing to #internal_state=.

Indicates whether the parent exists and is touchable.

Queries whether touch callbacks are being suppressed for the class that includes this module.

When MongoDB finally fully implements the positional operator, we can get rid of all indexing related code in ::Mongoid.

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 ::Mongoid::Document has been succesfully 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.

Handles the setup and execution of callbacks, if callbacks are to be executed; otherwise, adds the appropriate callbacks to the pending callbacks list.

Return a hash of the entire document hierarchy from this document and below.

Returns an instance of the specified class with the attributes, errors, and embedded documents of the current document.

Freezes the internal attributes of the document.

Delegates to identity in order to allow two records of the same identity to work with something like:

A Document’s is identified absolutely by its class and database id:

Instantiate a new ::Mongoid::Document, setting the Document’s attributes if given.

Return the model name of the document.

Return the key value for the document.

Adds the attributes for the given relation to the document’s attributes.

Returns a hash of the attributes.

Does the construction of a document.

Returns the logger.

Marks all embedded documents with the given “new_record” state.

Get the name of the model used in caching.

Checks that the given argument is an instance of ::Mongoid::Document.

Initializes the object state prior to attribute processing; this is called only from #construct_document.

Either executes or enqueues the post-construction callbacks.

Updates the value of the discriminator_key for this object, setting its previous value to key_was.

Clears changes for the model caused by touch operation.

Recursively sets touchable fields on the current document and each of its parents, including the root node.

Recursively runs :touch callbacks for the document and its parents, beginning with the root document and cascading through each successive child document.

Suppresses the invocation of touch callbacks, for the class that includes this module, for the duration of the block.

Touch the document, in effect updating its updated_at timestamp and optionally the provided field to the current time.

Extract and remove the atomic updates for the touch operation(s) from the currently enqueued atomic $set operations.

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 ::Mongoid::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 ::Mongoid::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.

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 ::Mongoid::Document attributes.

Return type-casted attributes.

Write a single attribute to the document attribute hash.

Writes the supplied attributes hash to the document.

Does the string contain dot syntax for accessing hashes?

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 ::Mongoid::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 ::Mongoid::Document

Get all descendant Documents of this ::Mongoid::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 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 ::Mongoid::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 ==.