Module: Mongoid::Attributes

Extended by:
ActiveSupport::Concern
Includes:
Processing, Readonly
Included in:
Components
Defined in:
lib/mongoid/attributes.rb,
lib/mongoid/attributes/readonly.rb,
lib/mongoid/attributes/processing.rb

Overview

This module contains the logic for handling the internal attributes hash, and how to get and set values.

Defined Under Namespace

Modules: ClassMethods, Processing, Readonly

Instance Attribute Summary collapse

Instance Method Summary collapse

Methods included from Readonly

#attribute_writable?

Methods included from Processing

#process_attributes

Dynamic Method Handling

This class handles dynamic methods through the method_missing method

#method_missing(name, *args) ⇒ Object (private)

Used for allowing accessor methods for dynamic attributes.

Parameters:

  • name (String, Symbol) —

    The name of the method.

  • *args (Array) —

    The arguments to the method.



318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
 
# File 'lib/mongoid/attributes.rb', line 318

def method_missing(name, *args)
  attr = name.to_s
  return super unless attributes.has_key?(attr.reader)
  if attr.writer?
    getter = attr.reader
    define_dynamic_writer(getter)
    write_attribute(getter, args.first)
  elsif attr.before_type_cast?
    define_dynamic_before_type_cast_reader(attr.reader)
    attribute_will_change!(attr.reader)
    read_attribute_before_type_cast(attr.reader)
  else
    getter = attr.reader
    define_dynamic_reader(getter)
    attribute_will_change!(attr.reader)
    read_attribute(getter)
  end
end

Instance Attribute Details

#attributes ⇒ Object (readonly) Also known as: raw_attributes

Returns the value of attribute attributes.



14
15
16
 
# File 'lib/mongoid/attributes.rb', line 14

def attributes
  @attributes
end

Instance Method Details

#assign_attributes(attrs = nil, options = {}) ⇒ Object

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.

Examples:

Assign the attributes.

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

Assign the attributes (with a role).

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

Parameters:

  • attrs (Hash) (defaults to: nil) —

    The new attributes to set.

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

    Supported options: :without_protection, :as

Since:

  • 2.2.1



213
214
215
216
217
 
# File 'lib/mongoid/attributes.rb', line 213

def assign_attributes(attrs = nil, options = {})
  _assigning do
    process_attributes(attrs, options[:as] || :default, !options[:without_protection])
  end
end

#attribute_present?(name) ⇒ true, false

Determine if an attribute is present.

Examples:

Is the attribute present?

person.attribute_present?("title")

Parameters:

  • name (String, Symbol) —

    The name of the attribute.

Returns:

  • (true, false) —

    True if present, false if not.

Since:

  • 1.0.0



27
28
29
30
 
# File 'lib/mongoid/attributes.rb', line 27

def attribute_present?(name)
  attribute = read_attribute(name)
  !attribute.blank? || attribute == false
end

#attributes_before_type_cast ⇒ Hash

Get the attributes that have not been cast.

Examples:

Get the attributes before type cast.

document.attributes_before_type_cast

Returns:

  • (Hash) —

    The uncast attributes.

Since:

  • 3.1.0



40
41
42
 
# File 'lib/mongoid/attributes.rb', line 40

def attributes_before_type_cast
  @attributes_before_type_cast ||= {}
end

#has_attribute?(name) ⇒ true, false

Does the document have the provided attribute?

Examples:

Does the document have the attribute?

model.has_attribute?(:name)

Parameters:

  • name (String, Symbol) —

    The name of the attribute.

Returns:

  • (true, false) —

    If the key is present in the attributes.

Since:

  • 3.0.0



54
55
56
 
# File 'lib/mongoid/attributes.rb', line 54

def has_attribute?(name)
  attributes.has_key?(name.to_s)
end

#has_attribute_before_type_cast?(name) ⇒ true, false

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

Examples:

Does the document have the attribute before it was assigned?

model.has_attribute_before_type_cast?(:name)

Parameters:

  • name (String, Symbol) —

    The name of the attribute.

Returns:

  • (true, false) —

    If the key is present in the attributes_before_type_cast.

Since:

  • 3.1.0



70
71
72
 
# File 'lib/mongoid/attributes.rb', line 70

def has_attribute_before_type_cast?(name)
  attributes_before_type_cast.has_key?(name.to_s)
end

#read_attribute(name) ⇒ Object Also known as: []

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

Examples:

Read an attribute.

person.read_attribute(:title)

Read an attribute (alternate syntax.)

person[:title]

Parameters:

  • name (String, Symbol) —

    The name of the attribute to get.

Returns:

  • (Object) —

    The value of the attribute.

Since:

  • 1.0.0



88
89
90
91
92
93
94
95
 
# File 'lib/mongoid/attributes.rb', line 88

def read_attribute(name)
  normalized = name.to_s
  if hash_dot_syntax?(normalized)
    attributes.__nested__(normalized)
  else
    attributes[normalized]
  end
end

#read_attribute_before_type_cast(name) ⇒ Object

Read a value from the attributes before type cast. If the value has not yet been assigned then this will return the attribute’s existing value using read_attribute.

Examples:

Read an attribute before type cast.

person.read_attribute_before_type_cast(:price)

Parameters:

  • name (String, Symbol) —

    The name of the attribute to get.

Returns:

  • (Object) —

    The value of the attribute before type cast, if available. Otherwise, the value of the attribute.

Since:

  • 3.1.0



111
112
113
114
115
116
117
118
 
# File 'lib/mongoid/attributes.rb', line 111

def read_attribute_before_type_cast(name)
  attr = name.to_s
  if attributes_before_type_cast.has_key?(attr)
    attributes_before_type_cast[attr]
  else
    read_attribute(attr)
  end
end

#remove_attribute(name) ⇒ Object

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

Examples:

Remove the attribute.

person.remove_attribute(:title)

Parameters:

  • name (String, Symbol) —

    The name of the attribute to remove.

Raises:

Since:

  • 1.0.0



132
133
134
135
136
137
138
139
140
141
142
 
# File 'lib/mongoid/attributes.rb', line 132

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)] = [] unless new_record?
    attributes.delete(access)
  end
end

#respond_to?(name, include_private = false) ⇒ true, false

Override respond_to? so it responds properly for dynamic attributes.

Examples:

Does this object respond to the method?

person.respond_to?(:title)

Parameters:

  • *args (Array) —

    The name of the method.

Returns:

  • (true, false) —

    True if it does, false if not.

Since:

  • 1.0.0



154
155
156
157
158
159
160
161
 
# File 'lib/mongoid/attributes.rb', line 154

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) ⇒ Object Also known as: []=

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

Examples:

Write the attribute.

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

Write the attribute (alternate syntax.)

person[:title] = "Mr."

Parameters:

  • name (String, Symbol) —

    The name of the attribute to update.

  • value (Object) —

    The value to set for the attribute.

Since:

  • 1.0.0



177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
 
# File 'lib/mongoid/attributes.rb', line 177

def write_attribute(name, value)
  access = database_field_name(name.to_s)
  if attribute_writable?(access)
    _assigning do
      localized = fields[access].try(:localized?)
      attributes_before_type_cast[name.to_s] = value
      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

#write_attributes(attrs = nil, guard_protected_attributes = true) ⇒ Object Also known as: attributes=

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.

Examples:

Write the attributes.

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

Write the attributes (alternate syntax.)

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

Parameters:

  • attrs (Hash) (defaults to: nil) —

    The new attributes to set.

  • guard_protected_attributes (Boolean) (defaults to: true) —

    False to skip mass assignment protection.

Since:

  • 1.0.0



233
234
235
 
# File 'lib/mongoid/attributes.rb', line 233

def write_attributes(attrs = nil, guard_protected_attributes = true)
  assign_attributes(attrs, without_protection: !guard_protected_attributes)
end