Module: Mongoid::Attributes

[](name) click to toggle source

Alias for: read_attribute

[]=(name, value) click to toggle source

Alias for: write_attribute

assign_attributes(attrs = nil, options = {}) click to toggle source

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. To bypass mass-assignment security you can use the :without_protection => true option.

@example Assign the attributes.

person.assign_attributes(:title => "Mr.")

@example Assign the attributes (with a role).

person.assign_attributes({ :title => "Mr." }, :as => :admin)

@param [ Hash ] attrs The new attributes to set. @param [ Hash ] options Supported options: :without_protection, :as

@since 2.2.1

# File lib/mongoid/attributes.rb, line 161
def assign_attributes(attrs = nil, options = {})
  _assigning do
    process_attributes(attrs, options[:as] || :default, !options[:without_protection])
  end
end

attribute_present?(name) click to toggle source

Determine if an attribute is present.

@example Is the attribute present?

person.attribute_present?("title")

@param [ String, Symbol ] name The name of the attribute.

@return [ true, false ] True if present, false if not.

@since 1.0.0

# File lib/mongoid/attributes.rb, line 26
def attribute_present?(name)
  attribute = read_attribute(name)
  !attribute.blank? || attribute == false
end

attributes=(attrs = nil, guard_protected_attributes = true) click to toggle source

Alias for: write_attributes

has_attribute?(name) click to toggle source

Does the document have the provided attribute?

@example Does the document have the attribute?

model.has_attribute?(:name)

@param [ String, Symbol ] name The name of the attribute.

@return [ true, false ] If the key is present in the attributes.

@since 3.0.0

# File lib/mongoid/attributes.rb, line 41
def has_attribute?(name)
  attributes.has_key?(name.to_s)
end

read_attribute(name) click to toggle source

Read a value from the document attributes. If the value does not exist it will return nil.

@example Read an attribute.

person.read_attribute(:title)

@example Read an attribute (alternate syntax.)

person[:title]

@param [ String, Symbol ] name The name of the attribute to get.

@return [ Object ] The value of the attribute.

@since 1.0.0

# File lib/mongoid/attributes.rb, line 59
def read_attribute(name)
  normalized = name.to_s
  if hash_dot_syntax?(normalized)
    attributes.__nested__(normalized)
  else
    attributes[normalized]
  end
end

Also aliased as: []

remove_attribute(name) click to toggle source

Remove a value from the Document attributes. If the value does not exist it will fail gracefully.

@example Remove the attribute.

person.remove_attribute(:title)

@param [ String, Symbol ] name The name of the attribute to remove.

@raise [ Errors::ReadonlyAttribute ] If the field cannot be removed due

to being flagged as reaodnly.

@since 1.0.0

# File lib/mongoid/attributes.rb, line 81
def remove_attribute(name)
  access = name.to_s
  unless attribute_writable?(name)
    raise Errors::ReadonlyAttribute.new(name, :nil)
  end
  _assigning do
    attribute_will_change!(access)
    delayed_atomic_unsets[atomic_attribute_name(access)] = []
    attributes.delete(access)
  end
end

respond_to?(name, include_private = false) click to toggle source

Override respond_to? so it responds properly for dynamic attributes.

@example Does this object respond to the method?

person.respond_to?(:title)

@param [ Array ] *args The name of the method.

@return [ true, false ] True if it does, false if not.

@since 1.0.0

# File lib/mongoid/attributes.rb, line 103
def respond_to?(name, include_private = false)
  super || (
    Mongoid.allow_dynamic_fields &&
    attributes &&
    attributes.has_key?(name.to_s.reader) &&
    name.to_s.valid_method_name?
  )
end

write_attribute(name, value) click to toggle source

Write a single attribute to the document attribute hash. This will also fire the before and after update callbacks, and perform any necessary typecasting.

@example Write the attribute.

person.write_attribute(:title, "Mr.")

@example Write the attribute (alternate syntax.)

person[:title] = "Mr."

@param [ String, Symbol ] name The name of the attribute to update. @param [ Object ] value The value to set for the attribute.

@since 1.0.0

# File lib/mongoid/attributes.rb, line 126
def write_attribute(name, value)
  access = database_field_name(name.to_s)
  if attribute_writable?(access)
    _assigning do
      localized = fields[access].try(:localized?)
      typed_value = typed_value_for(access, value)
      unless attributes[access] == typed_value || attribute_changed?(access)
        attribute_will_change!(access)
      end
      if localized
        (attributes[access] ||= {}).merge!(typed_value)
      else
        attributes[access] = typed_value
      end
      typed_value
    end
  end
end

Also aliased as: []=

write_attributes(attrs = nil, guard_protected_attributes = true) click to toggle source

Writes the supplied attributes hash to the document. This will only overwrite existing attributes if they are present in the new Hash, all others will be preserved.

@example Write the attributes.

person.write_attributes(:title => "Mr.")

@example Write the attributes (alternate syntax.)

person.attributes = { :title => "Mr." }

@param [ Hash ] attrs The new attributes to set. @param [ Boolean ] guard_protected_attributes False to skip mass assignment protection.

@since 1.0.0

# File lib/mongoid/attributes.rb, line 181
def write_attributes(attrs = nil, guard_protected_attributes = true)
  assign_attributes(attrs, without_protection: !guard_protected_attributes)
end

Also aliased as: attributes=

Home Classes Methods

In Files

Namespace

Methods

Included Modules

Class/Module Index

Mongoid::Attributes

Attributes

Public Instance Methods