Ticket #1152: dirty.diff

activerecord/test/change_tracking_test.rb

@@ +1 @@
+require 'abstract_unit'
+require 'fixtures/company'
+
+Company.track_changes!
+
+class ChangeTrackingTest < Test::Unit::TestCase
+  self.use_instantiated_fixtures = false
+  fixtures :companies
+
+  def setup
+    @company = Company.find_first
+  end
+
+  def test_instance_variable_for_new_company
+    company = Company.new
+    assert_nil company.instance_variable_get('@attributes_snapshot')
+    assert_valid_instance_variable_lifecycle_for company
+  end
+
+  def test_instance_variable_for_company_after_find
+    assert_nil @company.instance_variable_get('@attributes_snapshot')
+    assert_valid_instance_variable_lifecycle_for @company
+  end
+
+  def test_instance_variable_for_company_after_save
+    clone = @company.clone
+    clone.save
+    assert_valid_instance_variable_lifecycle_for clone
+  end
+
+  def test_lifecycle
+    # Clean.
+    assert @company.changed_attribute_names.empty?
+    assert !@company.name_changed?    
+
+    # Dirty.
+    @company.name = 'Fu'
+    assert @company.name_changed?
+    assert_equal 1, @company.changed_attribute_names.size
+
+    # Clean.
+    @company.save
+    assert !@company.name_changed?
+    assert @company.changed_attribute_names.empty?
+  end
+
+  def test_tracking_in_place_changes
+    # Dirty an attribute without using a setter method.
+    assert !@company.name_changed?    
+    @company.name << ' Inc.'
+    assert @company.name_changed?
+  end
+
+  def test_dirty_collections
+    @company.name = 'Fu'
+    [:changed, :dirty, :modified].each do |prefix|
+      assert_respond_to @company, "#{prefix}_attribute_names"
+      assert_equal ['name'], @company.send("#{prefix}_attribute_names")
+    end
+  end
+
+  def test_dirty_queries
+    @company.name = 'Fu'
+    assert_respond_to @company, :name_changed?
+    assert @company.name_changed?
+    assert_respond_to @company, :name_dirty?
+    assert @company.name_dirty?
+    assert_respond_to @company, :name_modified?
+    assert @company.name_modified?
+  end
+
+  protected
+    def assert_valid_instance_variable_lifecycle_for(company)
+      # nil until requested.  Pull saved state from db.
+      # Mind your transaction isolation.
+      company.name = 'foo'
+      company.name_changed?
+      snapshot = company.instance_variable_get('@attributes_snapshot')
+      assert_not_nil snapshot
+      assert_kind_of Hash, snapshot
+
+      # Clear snapshot after save.
+      assert company.save
+      assert_equal company.attributes_before_type_cast, company.instance_variable_get('@attributes_snapshot')
+    end
+end

activerecord/test/callbacks_test.rb

@@ -286 +286 @@
-    ], david.history
-  end
-end
+
+
+module WithAfterSave
+  def self.append_features(base)
+    base.after_save do |model|
+      model.history << [:after_save, :declared]
+    end
+  end
+end
+
+class ActiveRecord::Base
+  def self.with_after_save
+    include WithAfterSave
+  end
+end
+
+class AfterSaveDev < CallbackDeveloper
+  with_after_save
+end
+
+class SubDev < CallbackDeveloper
+  private
+    def foobar
+      history << [:after_save, :declared]
+    end
+end
+SubDev.after_save :foobar
+
+class CallbacksTest < Test::Unit::TestCase
+  def setup
+    @developers = create_fixtures('developers')
+  end
+
+  def test_declared_after_save
+    [AfterSaveDev.find(1), SubDev.find(1)].each do |david|
+      david.save
+      assert_equal [
+        [ :after_find,            :string ],
+        [ :after_find,            :proc   ],
+        [ :after_find,            :object ],
+        [ :after_find,            :block  ],
+        [ :after_initialize,            :string ],
+        [ :after_initialize,            :proc   ],
+        [ :after_initialize,            :object ],
+        [ :after_initialize,            :block  ],
+        [ :before_validation,           :string ],
+        [ :before_validation,           :proc   ],
+        [ :before_validation,           :object ],
+        [ :before_validation,           :block  ],
+        [ :before_validation_on_update, :string ],
+        [ :before_validation_on_update, :proc   ],
+        [ :before_validation_on_update, :object ],
+        [ :before_validation_on_update, :block  ],
+        [ :after_validation,            :string ],
+        [ :after_validation,            :proc   ],
+        [ :after_validation,            :object ],
+        [ :after_validation,            :block  ],
+        [ :after_validation_on_update,  :string ],
+        [ :after_validation_on_update,  :proc   ],
+        [ :after_validation_on_update,  :object ],
+        [ :after_validation_on_update,  :block  ],
+        [ :before_save,                 :string ],
+        [ :before_save,                 :proc   ],
+        [ :before_save,                 :object ],
+        [ :before_save,                 :block  ],
+        [ :before_update,               :string ],
+        [ :before_update,               :proc   ],
+        [ :before_update,               :object ],
+        [ :before_update,               :block  ],
+        [ :after_update,                :string ],
+        [ :after_update,                :proc   ],
+        [ :after_update,                :object ],
+        [ :after_update,                :block  ],
+        [ :after_save,                  :string ],
+        [ :after_save,                  :proc   ],
+        [ :after_save,                  :object ],
+        [ :after_save,                  :block  ],
+        [ :after_save,                  :declared ]
+      ], david.history
+    end
+  end
+end

activerecord/test/associations_go_eager_test.rb

@@ -35 +35 @@
-
-  def test_eager_association_loading_with_belongs_to
-    comments = Comment.find(:all, :include => :post)
-
-
+
+
+
-  end
-
-  def test_eager_association_loading_with_habtm

activerecord/lib/active_record/change_tracking.rb

@@ +1 @@
+module ActiveRecord
+  class Base
+    # Enable change tracking for this class and its subclasses.
+    def self.track_changes!
+      include ChangeTracking
+    end
+  end
+
+  # Track unsaved attribute changes by comparing against "clean" attribute
+  # snapshots taken when records are initialized and saved.
+  #
+  # - changed_attribute_names returns the names of changed attributes.
+  # - #{attr}_changed? methods query whether attr has changed.
+  # - changed? queries whether any attribute has changed.
+  #
+  # This implementation is a non-invasive wrapper for existing Active Record
+  # behavior.  If it's generally useful, it should be merged into AR::Base
+  # for better performance.
+  module ChangeTracking
+    def self.append_features(base)
+      super
+      base.extend(ClassMethods)
+
+      base.class_eval do
+        # Wrap save to snapshot new attributes state.
+        alias_method :save_without_change_tracking, :save
+        alias_method :save, :save_with_change_tracking
+
+        # Wrap method_missing to respond to #{attr}_changed? queries.
+        alias_method :method_missing_without_change_tracking, :method_missing
+        alias_method :method_missing, :method_missing_with_change_tracking
+
+        # Some alternate names.
+        alias_method :dirty_attribute_names, :changed_attribute_names
+        alias_method :modified_attribute_names, :changed_attribute_names
+      end
+    end
+
+    module ClassMethods
+      def self.extend_object(base)
+        super
+        s = class << base; self; end
+        s.send :alias_method, :column_methods_hash_without_dirty_tracking, :column_methods_hash
+        s.send :alias_method, :column_methods_hash, :column_methods_hash_with_dirty_tracking
+      end
+
+      # Wrap column_methods_hash to include the #{attr}_changed? method family.
+      def column_methods_hash_with_dirty_tracking
+        @dynamic_methods_hash ||= columns_hash.keys.inject(column_methods_hash_without_dirty_tracking) do |methods, attr|
+          methods["#{attr}_changed?".to_sym] = true
+          methods["#{attr}_dirty?".to_sym] = true
+          methods["#{attr}_modified?".to_sym] = true
+          methods
+        end
+      end
+    end
+
+    # Names of attributes which have changed since the last clean snapshot.
+    def changed_attribute_names
+      attribute_names.select { |attr| attribute_changed? attr }
+    end
+
+    # Has an attribute changed since the last clean snapshot?
+    def attribute_changed?(attr = nil)
+      # Has any attribute changed?
+      if attr.nil?
+        attribute_names.any? { |attr| attribute_changed? attr }
+
+      # Has this attribute changed?
+      else
+        attributes_snapshot[attr.to_s] != @attributes[attr.to_s]
+      end
+    end
+
+    def save_with_change_tracking(*args)
+      result = save_without_change_tracking(*args)
+      @attributes_snapshot = attributes_before_type_cast.freeze
+      result
+    end
+
+    private
+      # Wrap method_missing to add #{attr}_changed? methods.
+      def method_missing_with_change_tracking(method, *args, &block)
+        if method.to_s =~ /^([a-zA-Z][-_\w]*)_(changed|dirty|modified)\?$/i
+          attribute_changed?($1)
+        else
+          method_missing_without_change_tracking(method, *args, &block)
+        end
+      end
+
+      # Lazy-load the record's saved state for comparisons.  The extra
+      # query for a few records is faster overall than dirty tracking
+      # all records (cloning is expensive.)
+      def attributes_snapshot
+        @attributes_snapshot ||=  if new_record?
+                                    EMPTY_ATTRIBUTES_SNAPSHOT
+                                  else
+                                    self.class.find(self.id).attributes_before_type_cast.freeze
+                                  end
+      end
+
+      EMPTY_ATTRIBUTES_SNAPSHOT = HashWithIndifferentAccess.new.freeze
+  end
+end

activerecord/lib/active_record/base.rb

@@ -1069 +1069 @@
-
-      # Returns a hash of all the attributes with their names as keys and clones of their objects as values.
-      def attributes
-
-
-
-
-
-
-
-
+
-      end
-
+      # A hash of cloned attributes before type-casting and unserialization.
+      def attributes_before_type_cast
+        clone_attributes :read_attribute_before_type_cast
+      end
+
-      # 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 responds to empty?, most notably Strings).
-      def attribute_present?(attribute)
@@ -1404 +1403 @@
-      def has_yaml_encoding_header?(string)
-        string[0..3] == "--- "
-      end
+
+      # A hash of cloned attributes pulled with reader_method.
+      def clone_attributes(reader_method, attributes = HashWithIndifferentAccess.new)
+        self.attribute_names.inject(attributes) do |attributes, name|
+          attributes[name] = clone_attribute_value(reader_method, name)
+          attributes
+        end
+      end
+
+      # Clone a single attribute value.
+      def clone_attribute_value(reader_method, attribute_name)
+        value = send(reader_method, attribute_name)
+        value.clone
+      rescue TypeError, NoMethodError
+        value
+      end
-  end
-end

activerecord/lib/active_record.rb

@@ -46 +46 @@
-require 'active_record/acts/nested_set'
-require 'active_record/locking'
-require 'active_record/migration'
+require 'active_record/change_tracking'
-
-ActiveRecord::Base.class_eval do
-  include ActiveRecord::Validations