Module: ActiveModel::Dirty

### Home Classes Methods

### In Files

- lib/active_model/dirty.rb

### Methods

- #changed
- #changed?
- #changed_attributes
- #changes
- #previous_changes

### Included Modules

- ActiveModel::AttributeMethods

### Class/Module Index

Quicksearch

- ActiveModel
- ActiveModel::AttributeMethods
- ActiveModel::AttributeMethods::ClassMethods
- ActiveModel::AttributeMethods::ClassMethods::AttributeMethodMatcher
- ActiveModel::BlockValidator
- ActiveModel::Callbacks
- ActiveModel::Conversion
- ActiveModel::Dirty
- ActiveModel::EachValidator
- ActiveModel::Errors
- ActiveModel::Lint
- ActiveModel::Lint::Tests
- ActiveModel::MassAssignmentSecurity
- ActiveModel::MassAssignmentSecurity::BlackList
- ActiveModel::MassAssignmentSecurity::ClassMethods
- ActiveModel::MassAssignmentSecurity::Error
- ActiveModel::MassAssignmentSecurity::LoggerSanitizer
- ActiveModel::MassAssignmentSecurity::PermissionSet
- ActiveModel::MassAssignmentSecurity::Sanitizer
- ActiveModel::MassAssignmentSecurity::StrictSanitizer
- ActiveModel::MassAssignmentSecurity::WhiteList
- ActiveModel::MissingAttributeError
- ActiveModel::Name
- ActiveModel::Naming
- ActiveModel::Observer
- ActiveModel::ObserverArray
- ActiveModel::Observing
- ActiveModel::Observing::ClassMethods
- ActiveModel::SecurePassword
- ActiveModel::SecurePassword::ClassMethods
- ActiveModel::SecurePassword::InstanceMethodsOnActivation
- ActiveModel::Serialization
- ActiveModel::Serializers
- ActiveModel::Serializers::JSON
- ActiveModel::Serializers::Xml
- ActiveModel::StrictValidationFailed
- ActiveModel::Translation
- ActiveModel::Validations
- ActiveModel::Validations::AcceptanceValidator
- ActiveModel::Validations::Callbacks
- ActiveModel::Validations::Callbacks::ClassMethods
- ActiveModel::Validations::ClassMethods
- ActiveModel::Validations::ConfirmationValidator
- ActiveModel::Validations::ExclusionValidator
- ActiveModel::Validations::FormatValidator
- ActiveModel::Validations::HelperMethods
- ActiveModel::Validations::InclusionValidator
- ActiveModel::Validations::LengthValidator
- ActiveModel::Validations::NumericalityValidator
- ActiveModel::Validations::PresenceValidator
- ActiveModel::Validations::WithValidator
- ActiveModel::Validator

No matching classes.

# ActiveModel::Dirty

## Active Model Dirty

Provides a way to track changes in your object in the same way as Active Record does.

The requirements for implementing ActiveModel::Dirty are:

- `include ActiveModel::Dirty` in your object

- Call `define_attribute_methods` passing each method you want to track

- Call `attr_name_will_change!` before each change to the tracked attribute

If you wish to also track previous changes on save or update, you need to add

    @previously_changed = changes

inside of your save or update method.

A minimal implementation could be:

    class Person

      include ActiveModel::Dirty

      define_attribute_methods [:name]

      def name
        @name
      end

      def name=(val)
        name_will_change! unless val == @name
        @name = val
      end

      def save
        @previously_changed = changes
        @changed_attributes.clear
      end

    end

## Examples:

A newly instantiated object is unchanged:

    person = Person.find_by_name('Uncle Bob')
    person.changed?       # => false

Change the name:

    person.name = 'Bob'
    person.changed?       # => true
    person.name_changed?  # => true
    person.name_was       # => 'Uncle Bob'
    person.name_change    # => ['Uncle Bob', 'Bob']
    person.name = 'Bill'
    person.name_change    # => ['Uncle Bob', 'Bill']

Save the changes:

    person.save
    person.changed?       # => false
    person.name_changed?  # => false

Assigning the same value leaves the attribute unchanged:

    person.name = 'Bill'
    person.name_changed?  # => false
    person.name_change    # => nil

Which attributes have changed?

    person.name = 'Bob'
    person.changed        # => ['name']
    person.changes        # => { 'name' => ['Bill', 'Bob'] }

If an attribute is modified in-place then make use of `[attribute_name]_will_change!` to mark that the attribute is changing. Otherwise ActiveModel can't track changes to in-place attributes.

    person.name_will_change!
    person.name << 'y'
    person.name_change    # => ['Bill', 'Billy']

### Public Instance Methods

changed() click to toggle source

List of attributes with unsaved changes.

    person.changed # => []
    person.name = 'bob'
    person.changed # => ['name']

    # File lib/active_model/dirty.rb, line 108
    def changed
      changed_attributes.keys
    end

changed?() click to toggle source

Returns true if any attribute have unsaved changes, false otherwise.

    person.changed? # => false
    person.name = 'bob'
    person.changed? # => true

    # File lib/active_model/dirty.rb, line 100
    def changed?
      changed_attributes.any?
    end

changed_attributes() click to toggle source

Map of change `attr => original value`.

    # File lib/active_model/dirty.rb, line 130
    def changed_attributes
      @changed_attributes ||= {}
    end

changes() click to toggle source

Map of changed attrs => [original value, new value].

    person.changes # => {}
    person.name = 'bob'
    person.changes # => { 'name' => ['bill', 'bob'] }

    # File lib/active_model/dirty.rb, line 116
    def changes
      HashWithIndifferentAccess[changed.map { |attr| [attr, attribute_change(attr)] }]
    end

previous_changes() click to toggle source

Map of attributes that were changed when the model was saved.

    person.name # => 'bob'
    person.name = 'robert'
    person.save
    person.previous_changes # => {'name' => ['bob, 'robert']}

    # File lib/active_model/dirty.rb, line 125
    def previous_changes
      @previously_changed
    end

[Validate]

Generated with the Darkfish Rdoc Generator 2.