123456789_123456789_123456789_123456789_123456789_

Module: ActiveRecord::AttributeMethods::Dirty

Relationships & Source Files
Super Chains via Extension / Inclusion / Inheritance
Class Chain:
self, ::ActiveSupport::Concern
Instance Chain:
self, ::ActiveModel::Dirty, ::ActiveModel::AttributeMethods
Defined in: activerecord/lib/active_record/attribute_methods/dirty.rb

Overview

Provides a way to track changes in your Active Record models. It adds all methods from ::ActiveModel::Dirty and adds database-specific methods.

A newly created Person object is unchanged:

class Person < ActiveRecord::Base
end

person = Person.create(name: "Allison")
person.changed? # => false

Change the name:

person.name = 'Alice'
person.name_in_database          # => "Allison"
person.will_save_change_to_name? # => true
person.name_change_to_be_saved   # => ["Allison", "Alice"]
person.changes_to_save           # => {"name"=>["Allison", "Alice"]}

Save the changes:

person.save
person.name_in_database        # => "Alice"
person.saved_change_to_name?   # => true
person.saved_change_to_name    # => ["Allison", "Alice"]
person.name_before_last_save   # => "Allison"

Similar to ::ActiveModel::Dirty, methods can be invoked as saved_change_to_name? or by passing an argument to the generic method saved_change_to_attribute?("name").

Constant Summary

::ActiveModel::AttributeMethods - Included

CALL_COMPILABLE_REGEXP, NAME_COMPILABLE_REGEXP

Class Method Summary

::ActiveSupport::Concern - Extended

class_methods

Define class methods from given block.
included

Evaluate given block in context of base class, so that you can write class macros here.
prepended

Evaluate given block in context of base class, so that you can write class macros here.
append_features, prepend_features

Instance Attribute Summary

::ActiveModel::Dirty - Included

#attribute_aliases, #attribute_aliases?, #attribute_method_patterns, #attribute_method_patterns?,
#changed?

Returns true if any of the attributes has unsaved changes, false otherwise.

Instance Method Summary

::ActiveModel::Dirty - Included

#attribute_changed?

Dispatch target for *_changed? attribute methods.
#attribute_previously_changed?

Dispatch target for *_previously_changed? attribute methods.
#attribute_previously_was

Dispatch target for *_previously_was attribute methods.
#attribute_was

Dispatch target for *_was attribute methods.
#changed

Returns an array with the name of the attributes with unsaved changes.
#changed_attributes

Returns a hash of the attributes with unsaved changes indicating their original values like attr => original value.
#changes

Returns a hash of changed attributes indicating their original and new values like attr => [original value, new value].
#changes_applied

Clears dirty data and moves changes to previous_changes and mutations_from_database to mutations_before_last_save respectively.
#clear_attribute_changes,
#clear_changes_information

Clears all dirty data: current changes and previous changes.
#previous_changes

Returns a hash of attributes that were changed before the model was saved.
#restore_attributes

Restore all previous data of the provided attributes.
#attribute_change

Dispatch target for *_change attribute methods.
#attribute_previous_change

Dispatch target for *_previous_change attribute methods.
#attribute_will_change!

Dispatch target for *_will_change! attribute methods.
#clear_attribute_change, #forget_attribute_assignments, #init_internals, #mutations_before_last_save, #mutations_from_database,
#restore_attribute!

Dispatch target for restore_*! attribute methods.
#as_json, #attribute_changed_in_place?, #init_attributes, #initialize_dup

::ActiveModel::AttributeMethods - Included

#attribute_missing

attribute_missing is like #method_missing, but for attributes.
#method_missing

Allows access to the object attributes, which are held in the hash returned by #attributes, as though they were first-class methods.
#respond_to?,
#respond_to_without_attributes?

A Person instance with a name attribute can ask person.respond_to?(:name), person.respond_to?(:name=), and person.respond_to?(:name?) which will all return true.
#_read_attribute, #attribute_method?,
#matched_attribute_method

Returns a struct representing the matching attribute method.
#missing_attribute

Dynamic Method Handling

This class handles dynamic methods through the method_missing method in the class ActiveModel::AttributeMethods

DSL Calls

included

[ GitHub ] 

44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
# File 'activerecord/lib/active_record/attribute_methods/dirty.rb', line 44
included do
  if self < ::ActiveRecord::Timestamp
    raise "You cannot include Dirty after Timestamp"
  end

  class_attribute :partial_updates, instance_writer: false, default: true
  class_attribute :partial_inserts, instance_writer: false, default: true

  # Attribute methods for "changed in last call to save?"
  attribute_method_affix(prefix: "saved_change_to_", suffix: "?", parameters: "**options")
  attribute_method_prefix("saved_change_to_", parameters: false)
  attribute_method_suffix("_before_last_save", parameters: false)

  # Attribute methods for "will change if I call save?"
  attribute_method_affix(prefix: "will_save_change_to_", suffix: "?", parameters: "**options")
  attribute_method_suffix("_change_to_be_saved", "_in_database", parameters: false)
end

Instance Attribute Details

#has_changes_to_save? ⇒ Boolean (readonly)

Will the next call to save have any changes to persist?

[ GitHub ] 

  


# File 'activerecord/lib/active_record/attribute_methods/dirty.rb', line 169


def has_changes_to_save?
  mutations_from_database.any_changes?
end


  








  

    #saved_changes?  ⇒ Boolean  (readonly)
  



  

    

Did the last call to save have any changes to change?


  





  


  [ GitHub ]


  

  


# File 'activerecord/lib/active_record/attribute_methods/dirty.rb', line 113


def saved_changes?
  mutations_before_last_save.any_changes?
end


  







Instance Method Details



  

    #*_change  
  



  

    

This method is generated for each attribute.



Returns the old and the new value of the attribute.



person = Person.new
person.name = 'Nick'
person.name_change # => [nil, 'Nick']


  



  [ GitHub ]


  

  


# File 'activemodel/lib/active_model/dirty.rb', line 155


rdoc_method :method: *_change


  








  

    #*_changed?  
  



  

    

This method is generated for each attribute.



Returns true if the attribute has unsaved changes.



person = Person.new
person.name = 'Andrew'
person.name_changed? # => true


  



  [ GitHub ]


  

  


# File 'activemodel/lib/active_model/dirty.rb', line 144


rdoc_method :method: *_changed?


  








  

    #*_previous_change  
  



  

    

This method is generated for each attribute.



Returns the old and the new value of the attribute before the last save.



person = Person.new
person.name = 'Emmanuel'
person.save
person.name_previous_change # => [nil, 'Emmanuel']


  



  [ GitHub ]


  

  


# File 'activemodel/lib/active_model/dirty.rb', line 193


rdoc_method :method: *_previous_change


  








  

    #*    



  

    

This method is generated for each attribute.



Returns true if the attribute previously had unsaved changes.



person = Person.new
person.name = 'Britanny'
person.save
person.name_previously_changed? # => true
person.name_previously_changed?(from: nil, to: 'Britanny') # => true


  



  [ GitHub ]


  

  


# File 'activemodel/lib/active_model/dirty.rb', line 129


rdoc_method :method: *_previously_changed?


  








  

    #*_previously_was  
  



  

    

This method is generated for each attribute.



Returns the old value of the attribute before the last save.



person = Person.new
person.name = 'Sage'
person.save
person.name_previously_was  # => nil


  



  [ GitHub ]


  

  


# File 'activemodel/lib/active_model/dirty.rb', line 205


rdoc_method :method: *_previously_was


  








  

    #*_was  
  



  

    

This method is generated for each attribute.



Returns the old value of the attribute.



person = Person.new(name: 'Steph')
person.name = 'Stephanie'
person.name_was # => 'Steph'


  



  [ GitHub ]


  

  


# File 'activemodel/lib/active_model/dirty.rb', line 182


rdoc_method :method: *_was


  








  

    #*_will_change!  
  



  

    

This method is generated for each attribute.



If an attribute is modified in-place then make use of *_will_change! to mark that the attribute is changing. Otherwise Active Model can’t track changes to in-place attributes. Note that Active Record can detect in-place modifications automatically. You do not need to call *_will_change! on Active Record models.



person = Person.new('Sandy')
person.name_will_change!
person.name_change # => ['Sandy', 'Sandy']


  



  [ GitHub ]


  

  


# File 'activemodel/lib/active_model/dirty.rb', line 166


rdoc_method :method: *_will_change!


  








  

    #_create_record(attribute_names = attribute_names_for_partial_inserts)   (private)
  

  [ GitHub ]


  

  


# File 'activerecord/lib/active_record/attribute_methods/dirty.rb', line 239


def _create_record(attribute_names = attribute_names_for_partial_inserts)
  id = super
  changes_applied
  id
end


  








  

    #_touch_row(attribute_names, time)   (private)
  

  [ GitHub ]


  

  


# File 'activerecord/lib/active_record/attribute_methods/dirty.rb', line 204


def _touch_row(attribute_names, time)
  @_touch_attr_names = Set.new(attribute_names)

  affected_rows = super

  if @_skip_dirty_tracking ||= false
    clear_attribute_changes(@_touch_attr_names)
    return affected_rows
  end

  changes = {}
  @attributes.keys.each do |attr_name|
    next if @_touch_attr_names.include?(attr_name)

    if attribute_changed?(attr_name)
      changes[attr_name] = _read_attribute(attr_name)
      _write_attribute(attr_name, attribute_was(attr_name))
      clear_attribute_change(attr_name)
    end
  end

  changes_applied
  changes.each { |attr_name, value| _write_attribute(attr_name, value) }

  affected_rows
ensure
  @_touch_attr_names, @_skip_dirty_tracking = nil, nil
end


  








  

    #_update_record(attribute_names = attribute_names_for_partial_updates)   (private)
  

  [ GitHub ]


  

  


# File 'activerecord/lib/active_record/attribute_methods/dirty.rb', line 233


def _update_record(attribute_names = attribute_names_for_partial_updates)
  affected_rows = super
  changes_applied
  affected_rows
end


  








  

    #attribute_before_last_save(attr_name)  
  



  

    

Returns the original value of an attribute before the last save.



This method is useful in after callbacks to get the original value of an attribute before the save that triggered the callbacks to run. It can be invoked as name_before_last_save instead of attribute_before_last_save("name").


  



  [ GitHub ]


  

  


# File 'activerecord/lib/active_record/attribute_methods/dirty.rb', line 108


def attribute_before_last_save(attr_name)
  mutations_before_last_save.original_value(attr_name.to_s)
end


  








  

    #attribute_change_to_be_saved(attr_name)  
  



  

    

Returns the change to an attribute that will be persisted during the next save.



This method is useful in validations and before callbacks, to see the change to an attribute that will occur when the record is saved. It can be invoked as name_change_to_be_saved instead of attribute_change_to_be_saved("name").



If the attribute will change, the result will be an array containing the original value and the new value about to be saved.


  



  [ GitHub ]


  

  


# File 'activerecord/lib/active_record/attribute_methods/dirty.rb', line 152


def attribute_change_to_be_saved(attr_name)
  mutations_from_database.change_to_attribute(attr_name.to_s)
end


  








  

    #attribute_in_database(attr_name)  
  



  

    

Returns the value of an attribute in the database, as opposed to the in-memory value that will be persisted the next time the record is saved.



This method is useful in validations and before callbacks, to see the original value of an attribute prior to any changes about to be saved. It can be invoked as name_in_database instead of attribute_in_database("name").


  



  [ GitHub ]


  

  


# File 'activerecord/lib/active_record/attribute_methods/dirty.rb', line 164


def attribute_in_database(attr_name)
  mutations_from_database.original_value(attr_name.to_s)
end


  








  

    #attribute_names_for_partial_inserts   (private)
  

  [ GitHub ]


  

  


# File 'activerecord/lib/active_record/attribute_methods/dirty.rb', line 249


def attribute_names_for_partial_inserts
  if partial_inserts?
    changed_attribute_names_to_save
  else
    attribute_names.reject do |attr_name|
      if column_for_attribute(attr_name).auto_populated?
        !attribute_changed?(attr_name)
      end
    end
  end
end


  








  

    #attribute_names_for_partial_updates   (private)
  

  [ GitHub ]


  

  


# File 'activerecord/lib/active_record/attribute_methods/dirty.rb', line 245


def attribute_names_for_partial_updates
  partial_updates? ? changed_attribute_names_to_save : attribute_names
end


  








  

    #attributes_in_database  
  



  

    

Returns a hash of the attributes that will change when the record is next saved.



The hash keys are the attribute names, and the hash values are the original attribute values in the database (as opposed to the in-memory values about to be saved).


  



  [ GitHub ]


  

  


# File 'activerecord/lib/active_record/attribute_methods/dirty.rb', line 191


def attributes_in_database
  mutations_from_database.changed_values
end


  








  

    #changed_attribute_names_to_save  
  



  

    

Returns an array of the names of any attributes that will change when the record is next saved.


  



  [ GitHub ]


  

  


# File 'activerecord/lib/active_record/attribute_methods/dirty.rb', line 181


def changed_attribute_names_to_save
  mutations_from_database.changed_attribute_names
end


  








  

    #changes_to_save  
  



  

    

Returns a hash containing all the changes that will be persisted during the next save.


  



  [ GitHub ]


  

  


# File 'activerecord/lib/active_record/attribute_methods/dirty.rb', line 175


def changes_to_save
  mutations_from_database.changes
end


  








  

    #clear_*_change  
  



  

    

This method is generated for each attribute.



Clears all dirty data of the attribute: current changes and previous changes.



person = Person.new(name: 'Chris')
person.name = 'Jason'
person.name_change # => ['Chris', 'Jason']
person.clear_name_change
person.name_change # => nil


  



  [ GitHub ]


  

  


# File 'activemodel/lib/active_model/dirty.rb', line 242


rdoc_method :method: clear_*_change


  








  

    #init_internals   (private)
  

  [ GitHub ]


  

  


# File 'activerecord/lib/active_record/attribute_methods/dirty.rb', line 196


def init_internals
  super
  @mutations_before_last_save = nil
  @mutations_from_database = nil
  @_touch_attr_names = nil
  @_skip_dirty_tracking = nil
end


  








  

    #reload  
  



  

    

reload the record and clears changed attributes.


  



  [ GitHub ]


  

  


# File 'activerecord/lib/active_record/attribute_methods/dirty.rb', line 63


def reload(*)
  super.tap do
    @mutations_before_last_save = nil
    @mutations_from_database = nil
  end
end


  








  

    #restore_*!  
  



  

    

This method is generated for each attribute.



Restores the attribute to the old value.



person = Person.new
person.name = 'Amanda'
person.restore_name!
person.name # => nil


  



  [ GitHub ]


  

  


# File 'activemodel/lib/active_model/dirty.rb', line 217


rdoc_method :method: restore_*!


  








  

    #saved_change_to_attribute(attr_name)  
  



  

    

Returns the change to an attribute during the last save. If the attribute was changed, the result will be an array containing the original value and the saved value.



This method is useful in after callbacks, to see the change in an attribute during the save that triggered the callbacks to run. It can be invoked as saved_change_to_name instead of saved_change_to_attribute("name").


  



  [ GitHub ]


  

  


# File 'activerecord/lib/active_record/attribute_methods/dirty.rb', line 98


def saved_change_to_attribute(attr_name)
  mutations_before_last_save.change_to_attribute(attr_name.to_s)
end


  








  

    #saved_change_to_attribute?(attr_name, **options)  ⇒ Boolean 
  



  

    

Did this attribute change when we last saved?



This method is useful in after callbacks to determine if an attribute was changed during the save that triggered the callbacks to run. It can be invoked as saved_change_to_name? instead of saved_change_to_attribute?("name").



Options


from




When specified, this method will return false unless the original value is equal to the given value.


to




When specified, this method will return false unless the value will be changed to the given value.




  





  


  [ GitHub ]


  

  


# File 'activerecord/lib/active_record/attribute_methods/dirty.rb', line 86


def saved_change_to_attribute?(attr_name, **options)
  mutations_before_last_save.changed?(attr_name.to_s, **options)
end


  








  

    #saved_changes   (readonly)
  



  

    

Returns a hash containing all the changes that were just saved.


  



  [ GitHub ]


  

  


# File 'activerecord/lib/active_record/attribute_methods/dirty.rb', line 118


def saved_changes
  mutations_before_last_save.changes
end


  








  

    #will_save_change_to_attribute?(attr_name, **options)  ⇒ Boolean 
  



  

    

Will this attribute change the next time we save?



This method is useful in validations and before callbacks to determine if the next call to save will change a particular attribute. It can be invoked as will_save_change_to_name? instead of will_save_change_to_attribute?("name").



Options


from




When specified, this method will return false unless the original value is equal to the given value.


to




When specified, this method will return false unless the value will be changed to the given value.




  





  


  [ GitHub ]


  

  


# File 'activerecord/lib/active_record/attribute_methods/dirty.rb', line 138


def will_save_change_to_attribute?(attr_name, **options)
  mutations_from_database.changed?(attr_name.to_s, **options)
end