Module: ActiveRecord::AttributeMethods

Extended by:
ActiveSupport::Autoload, ActiveSupport::Concern
Includes:
ActiveModel::AttributeMethods
Included in:
Base
Defined in:
activerecord/lib/active_record/attribute_methods.rb,
activerecord/lib/active_record.rb,
activerecord/lib/active_record/attribute_methods/read.rb,
activerecord/lib/active_record/attribute_methods/query.rb,
activerecord/lib/active_record/attribute_methods/dirty.rb,
activerecord/lib/active_record/attribute_methods/write.rb,
activerecord/lib/active_record/attribute_methods/primary_key.rb,
activerecord/lib/active_record/attribute_methods/serialization.rb,
activerecord/lib/active_record/attribute_methods/before_type_cast.rb,
activerecord/lib/active_record/attribute_methods/time_zone_conversion.rb

Overview

Active Record Attribute Methods

Defined Under Namespace

Modules: BeforeTypeCast, ClassMethods, Dirty, PrimaryKey, Query, Read, Serialization, TimeZoneConversion, Write Classes: AttributeMethodCache

Constant Summary collapse

AttrNames =
Module.new {
  def self.set_name_cache(name, value)
    const_name = "ATTR_#{name}"
    unless const_defined? const_name
      const_set const_name, value.dup.freeze
    end
  end
}

Constants included from ActiveModel::AttributeMethods

ActiveModel::AttributeMethods::CALL_COMPILABLE_REGEXP, ActiveModel::AttributeMethods::NAME_COMPILABLE_REGEXP

Instance Method Summary collapse

Methods included from ActiveSupport::Concern

append_features, extended, included

Methods included from ActiveSupport::Autoload

autoload, autoload_at, autoload_under, autoloads, eager_autoload, eager_load!, extended

Methods included from ActiveModel::AttributeMethods

#attribute_missing, #respond_to_without_attributes?

Dynamic Method Handling

This class handles dynamic methods through the method_missing method

#method_missing(method, *args, &block) ⇒ Object

If we haven't generated any methods yet, generate them, then see if we've created the method we're looking for.


167
168
169
170
171
172
173
174
175
176
177
# File 'activerecord/lib/active_record/attribute_methods.rb', line 167

def method_missing(method, *args, &block) # :nodoc:
  if self.class.define_attribute_methods
    if respond_to_without_attributes?(method)
      send(method, *args, &block)
    else
      super
    end
  else
    super
  end
end

Instance Method Details

#[](attr_name) ⇒ Object

Returns the value of the attribute identified by attr_name after it has been typecast (for example, “2004-12-12” in a data column is cast to a date object, like Date.new(2004, 12, 12)). It raises ActiveModel::MissingAttributeError if the identified attribute is missing.

Alias for the read_attribute method.

class Person < ActiveRecord::Base
  belongs_to :organization
end

person = Person.new(name: 'Francesco', age: '22')
person[:name] # => "Francesco"
person[:age]  # => 22

person = Person.select('id').first
person[:name]            # => ActiveModel::MissingAttributeError: missing attribute: name
person[:organization_id] # => ActiveModel::MissingAttributeError: missing attribute: organization_id

332
333
334
# File 'activerecord/lib/active_record/attribute_methods.rb', line 332

def [](attr_name)
  read_attribute(attr_name) { |n| missing_attribute(n, caller) }
end

#[]=(attr_name, value) ⇒ Object

Updates the attribute identified by attr_name with the specified value. (Alias for the protected write_attribute method).

class Person < ActiveRecord::Base
end

person = Person.new
person[:age] = '22'
person[:age] # => 22
person[:age] # => Fixnum

346
347
348
# File 'activerecord/lib/active_record/attribute_methods.rb', line 346

def []=(attr_name, value)
  write_attribute(attr_name, value)
end

#attribute_for_inspect(attr_name) ⇒ Object

Returns an #inspect-like string for the value of the attribute attr_name. String attributes are truncated upto 50 characters, and Date and Time attributes are returned in the :db format. Other attributes return the value of #inspect without modification.

person = Person.create!(name: 'David Heinemeier Hansson ' * 3)

person.attribute_for_inspect(:name)
# => "\"David Heinemeier Hansson David Heinemeier Hansson ...\""

person.attribute_for_inspect(:created_at)
# => "\"2012-10-22 00:15:07\""

266
267
268
269
270
271
272
273
274
275
276
# File 'activerecord/lib/active_record/attribute_methods.rb', line 266

def attribute_for_inspect(attr_name)
  value = read_attribute(attr_name)

  if value.is_a?(String) && value.length > 50
    "#{value[0, 50]}...".inspect
  elsif value.is_a?(Date) || value.is_a?(Time)
    %("#{value.to_s(:db)}")
  else
    value.inspect
  end
end

#attribute_namesObject

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

class Person < ActiveRecord::Base
end

person = Person.new
person.attribute_names
# => ["id", "created_at", "updated_at", "name", "age"]

235
236
237
# File 'activerecord/lib/active_record/attribute_methods.rb', line 235

def attribute_names
  @attributes.keys
end

#attribute_present?(attribute) ⇒ Boolean

Returns true if the specified attribute has been set by the user or by a database load and is neither nil nor empty? (the latter only applies to objects that respond to empty?, most notably Strings). Otherwise, false. Note that it always returns true with boolean attributes.

class Task < ActiveRecord::Base
end

person = Task.new(title: '', is_done: false)
person.attribute_present?(:title)   # => false
person.attribute_present?(:is_done) # => true
person.name = 'Francesco'
person.is_done = true
person.attribute_present?(:title)   # => true
person.attribute_present?(:is_done) # => true

293
294
295
296
# File 'activerecord/lib/active_record/attribute_methods.rb', line 293

def attribute_present?(attribute)
  value = read_attribute(attribute)
  !value.nil? && !(value.respond_to?(:empty?) && value.empty?)
end

#attributesObject

Returns a hash of all the attributes with their names as keys and the values of the attributes as values.

class Person < ActiveRecord::Base
end

person = Person.create(name: 'Francesco', age: 22)
person.attributes
# => {"id"=>3, "created_at"=>Sun, 21 Oct 2012 04:53:04, "updated_at"=>Sun, 21 Oct 2012 04:53:04, "name"=>"Francesco", "age"=>22}

247
248
249
250
251
# File 'activerecord/lib/active_record/attribute_methods.rb', line 247

def attributes
  attribute_names.each_with_object({}) { |name, attrs|
    attrs[name] = read_attribute(name)
  }
end

#column_for_attribute(name) ⇒ Object

Returns the column object for the named attribute. Returns nil if the named attribute not exists.

class Person < ActiveRecord::Base
end

person = Person.new
person.column_for_attribute(:name) # the result depends on the ConnectionAdapter
# => #<ActiveRecord::ConnectionAdapters::SQLite3Column:0x007ff4ab083980 @name="name", @sql_type="varchar(255)", @null=true, ...>

person.column_for_attribute(:nothing)
# => nil

310
311
312
313
# File 'activerecord/lib/active_record/attribute_methods.rb', line 310

def column_for_attribute(name)
  # FIXME: should this return a null object for columns that don't exist?
  self.class.columns_hash[name.to_s]
end

#has_attribute?(attr_name) ⇒ Boolean

Returns true if the given attribute is in the attributes hash, otherwise false.

class Person < ActiveRecord::Base
end

person = Person.new
person.has_attribute?(:name)    # => true
person.has_attribute?('age')    # => true
person.has_attribute?(:nothing) # => false

223
224
225
# File 'activerecord/lib/active_record/attribute_methods.rb', line 223

def has_attribute?(attr_name)
  @attributes.has_key?(attr_name.to_s)
end

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

A Person object with a name attribute can ask person.respond_to?(:name), person.respond_to?(:name=), and person.respond_to?(:name?) which will all return true. It also define the attribute methods if they have not been generated.

class Person < ActiveRecord::Base
end

person = Person.new
person.respond_to(:name)    # => true
person.respond_to(:name=)   # => true
person.respond_to(:name?)   # => true
person.respond_to('age')    # => true
person.respond_to('age=')   # => true
person.respond_to('age?')   # => true
person.respond_to(:nothing) # => false

195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
# File 'activerecord/lib/active_record/attribute_methods.rb', line 195

def respond_to?(name, include_private = false)
  name = name.to_s
  self.class.define_attribute_methods
  result = super

  # If the result is false the answer is false.
  return false unless result

  # If the result is true then check for the select case.
  # For queries selecting a subset of columns, return false for unselected columns.
  # We check defined?(@attributes) not to issue warnings if called on objects that
  # have been allocated but not yet initialized.
  if defined?(@attributes) && @attributes.any? && self.class.column_names.include?(name)
    return has_attribute?(name)
  end

  return true
end