Module: ActiveRecord::AttributeMethods

Extended by:
ActiveSupport::Autoload, ActiveSupport::Concern
Includes:
ActiveModel::AttributeMethods
Included in:
Base
Defined in:
lib/active_record/attribute_methods.rb,
lib/active_record.rb,
lib/active_record/attribute_methods/read.rb,
lib/active_record/attribute_methods/dirty.rb,
lib/active_record/attribute_methods/query.rb,
lib/active_record/attribute_methods/write.rb,
lib/active_record/attribute_methods/primary_key.rb,
lib/active_record/attribute_methods/serialization.rb,
lib/active_record/attribute_methods/before_type_cast.rb,
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

Instance Method Summary collapse

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.



155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
 
# File 'lib/active_record/attribute_methods.rb', line 155

def method_missing(method, *args, &block) # :nodoc:
  self.class.define_attribute_methods
  if respond_to_without_attributes?(method)
    # make sure to invoke the correct attribute method, as we might have gotten here via a `super`
    # call in a overwritten attribute method
    if attribute_method = self.class.find_generated_attribute_method(method)
      # this is probably horribly slow, but should only happen at most once for a given AR class
      attribute_method.bind(self).call(*args, &block)
    else
      send(method, *args, &block)
    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



343
344
345
 
# File 'lib/active_record/attribute_methods.rb', line 343

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



357
358
359
 
# File 'lib/active_record/attribute_methods.rb', line 357

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 D...\""

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



277
278
279
280
281
282
283
284
285
286
287
 
# File 'lib/active_record/attribute_methods.rb', line 277

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_missing(match, *args, &block) ⇒ Object

:nodoc:



171
172
173
174
175
176
177
178
179
180
181
182
183
 
# File 'lib/active_record/attribute_methods.rb', line 171

def attribute_missing(match, *args, &block) # :nodoc:
  if self.class.columns_hash[match.attr_name]
    ActiveSupport::Deprecation.warn(
      "The method `#{match.method_name}', matching the attribute `#{match.attr_name}' has " \
      "dispatched through method_missing. This shouldn't happen, because `#{match.attr_name}' " \
      "is a column of the table. If this error has happened through normal usage of Active " \
      "Record (rather than through your own code or external libraries), please report it as " \
      "a bug."
    )
  end

  super
end

#attribute_names ⇒ Object

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"]



241
242
243
 
# File 'lib/active_record/attribute_methods.rb', line 241

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

Returns:

  • (Boolean) 


304
305
306
307
 
# File 'lib/active_record/attribute_methods.rb', line 304

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

#attributes ⇒ Object

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}



253
254
255
256
257
 
# File 'lib/active_record/attribute_methods.rb', line 253

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

#attributes_for_coder ⇒ Object

Placeholder so it can be overriden when needed by serialization



260
261
262
 
# File 'lib/active_record/attribute_methods.rb', line 260

def attributes_for_coder # :nodoc:
  attributes
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



321
322
323
324
 
# File 'lib/active_record/attribute_methods.rb', line 321

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

Returns:

  • (Boolean) 


229
230
231
 
# File 'lib/active_record/attribute_methods.rb', line 229

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

Returns:

  • (Boolean) 


201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
 
# File 'lib/active_record/attribute_methods.rb', line 201

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.present? && self.class.column_names.include?(name)
    return has_attribute?(name)
  end

  return true
end