massive_record 0.2.2.rc1 → 0.2.2.rc2

data/CHANGELOG.md

@@ -1,7 +1,10 @@
 # v0.2.2 (git develop)
 
 
-# v0.2.2.rc1 (git master)
+# v0.2.2.rc2 (git master)
+- Fixed some issues related to callbacks on embedded records.
+
+# v0.2.2.rc1
 
 - ProxyCollection destroy_all and delete_all returns removed records.
 - Changes are better detected on new records. user = User.new :email => "me@gmail.com"; user.email_changed?

data/lib/massive_record/orm/embedded.rb

@@ -1,9 +1,11 @@
 require 'massive_record/orm/schema/embedded_interface'
+require 'massive_record/orm/in_the_middle_of_saving_tracker'
 
 module MassiveRecord
   module ORM
     class Embedded < Base
       include Schema::EmbeddedInterface
+      include InTheMiddleOfSavingTracker
 
       DATABASE_ID_SEPARATOR = '|'
 

data/lib/massive_record/orm/in_the_middle_of_saving_tracker.rb

@@ -0,0 +1,75 @@
+module MassiveRecord
+  module ORM
+
+    #
+    # Tracks if we are in the middle of being saved or not, and if
+    # we are asked valid? in the middle of a save, we'll return the
+    # last answer we gave to that question, instead of running
+    # validations again.
+    #
+    #
+    # Main reason for doing so is when used in conjunction with
+    # Embedded records, in the following situations:
+    #
+    # 1. Calling save on an embedded record when the owner
+    #    is not persisted will call save on the same
+    #    record again when owner is saved and informs
+    #    embeds many proxy that it is being about to be
+    #    saved. Resulting in all callbacks fire again
+    #    on the record which issued the save in the first
+    #    place.
+    #
+    #    We can query each embedded record inside of
+    #    embeds_many#parent_will_be_saved! if we are to call save
+    #    on it (to make each embedded record update it's persisted state),
+    #    or if we should not do it, if the embedded record was the one
+    #    triggered the save in the first place.
+    #
+    # 2. Calling save on an embedded record when the owner
+    #    is not persisted will first validate the embedded
+    #    record, then the owner will validate all associated
+    #    records, including the one record which issued
+    #    the save and therefor is validated.
+    # 
+    #     We can controll if we are to run validations on a record
+    #     or not, based if we are in the middle of a save on current
+    #     record, thus callbacks (like before_validations etc) will
+    #     not run twice.
+    #
+    module InTheMiddleOfSavingTracker
+      attr_reader :in_the_middle_of_saving
+      alias in_the_middle_of_saving? in_the_middle_of_saving
+
+      def save(options = {})
+        with_in_the_middle_of_saving_tracker { super }
+      end
+
+      def save!(options = {})
+        with_in_the_middle_of_saving_tracker { super }
+      end
+
+      def valid?(*)
+        if in_the_middle_of_saving?
+          if @last_valid_value_inside_of_current_save.nil?
+            @last_valid_value_inside_of_current_save = super
+          else
+            @last_valid_value_inside_of_current_save
+          end
+        else
+          super
+        end
+      end
+
+      
+      private
+      
+      def with_in_the_middle_of_saving_tracker
+        @in_the_middle_of_saving = true
+        yield
+      ensure
+        @in_the_middle_of_saving = false
+        @last_valid_value_inside_of_current_save = nil
+      end
+    end
+  end
+end

data/lib/massive_record/orm/persistence/operations.rb

@@ -32,10 +32,17 @@ module MassiveRecord
       module Operations
         class << self
           def suppress
-            @suppressed = true
+            suppressed_was, @suppressed = @suppressed, true
             yield
           ensure
-            @suppressed = false
+            @suppressed = suppressed_was
+          end
+
+          def force
+            suppressed_was, @suppressed = @suppressed, false
+            yield
+          ensure
+            @suppressed = suppressed_was
           end
 
           def suppressed?

data/lib/massive_record/orm/relations/proxy/embeds_many.rb

@@ -93,7 +93,7 @@ module MassiveRecord
                 if record.destroyed?
                   proxy_targets_update_hash[record.database_id] = nil
                 elsif record.new_record? || record.changed?
-                  record.save 
+                  record.save(:validate => false) unless record.in_the_middle_of_saving?
                   proxy_targets_update_hash[record.database_id] = Base.coder.dump(record.attributes_db_raw_data_hash)
                 end
               end

data/lib/massive_record/version.rb

@@ -1,3 +1,3 @@
 module MassiveRecord
-  VERSION = "0.2.2.rc1"
+  VERSION = "0.2.2.rc2"
 end

data/spec/orm/cases/callbacks_spec.rb

@@ -1,309 +1,153 @@
 require 'spec_helper'
+require 'orm/models/callback_testable'
 require 'orm/models/person'
 require 'orm/models/address'
 
-#
-# Some basic tests
-#
-shared_examples_for "Massive Record with callbacks" do
-  it "should include ActiveModel::Callbacks" do
-    @model.class.should respond_to :define_model_callbacks
-  end
-
-  it "should include ActiveModell::Validations::Callback" do
-    @model.class.included_modules.should include(ActiveModel::Validations::Callbacks)
-  end
-end
-
-{
-  "MassiveRecord::Base::Table" => Person,
-  "MassiveRecord::Base::Column" => Address
-}.each do |orm_class, inherited_by_test_class|
-  describe orm_class do
-    before do
-      @model = inherited_by_test_class.new
-    end
-
-    it_should_behave_like "Massive Record with callbacks"
-  end
-end
-
-
-#
-# Some real life object tests
-#
-class CallbackDeveloper < MassiveRecord::ORM::Table
-  class << self
-    def callback_string(callback_method)
-      "history << [#{callback_method.to_sym.inspect}, :string]"
-    end
+describe "callbacks on" do
+  include SetUpHbaseConnectionBeforeAll
+  include SetTableNamesToTestTable
 
-    def callback_proc(callback_method)
-      Proc.new { |model| model.history << [callback_method, :proc] }
-    end
+  class CallbackDeveloperTable < MassiveRecord::ORM::Table
+    include CallbackTestable
 
-    def define_callback_method(callback_method)
-      define_method(callback_method) do
-        self.history << [callback_method, :method]
-      end
-      send(callback_method, :"#{callback_method}")
-    end
+    embeds_many :callback_developer_embeddeds, :store_in => :base
 
-    def callback_object(callback_method)
-      klass = Class.new
-      klass.send(:define_method, callback_method) do |model|
-        model.history << [callback_method, :object]
-      end
-      klass.new
+    column_family :base do
+      field :name, :default => "Thorbjorn"
     end
   end
 
-  MassiveRecord::ORM::Callbacks::CALLBACKS.each do |callback_method|
-    next if callback_method.to_s =~ /^around_/
-    define_callback_method(callback_method)
-    send(callback_method, callback_string(callback_method))
-    send(callback_method, callback_proc(callback_method))
-    send(callback_method, callback_object(callback_method))
-    send(callback_method) { |model| model.history << [callback_method, :block] }
-  end
+  describe CallbackDeveloperTable do
+    let(:new_record) { described_class.new "1" }
+    let(:created_record) { described_class.create "dummy" }
+    let(:persisted_record) do
+      described_class.create! "1"
+      described_class.find "1"
+    end
 
-  def history
-    @history ||= []
+    it_should_behave_like "a model with callbacks"
   end
-end
 
 
-describe "callbacks for" do
-  include MockMassiveRecordConnection
 
-  it "initialize should run in correct order" do
-    thorbjorn = CallbackDeveloper.new
-    thorbjorn.history.should == [
-      [:after_initialize, :method],
-      [:after_initialize, :string],
-      [:after_initialize, :proc],
-      [:after_initialize, :object],
-      [:after_initialize, :block]
-    ]
-  end
 
-  it "find should run in correct order" do
-    thorbjorn = CallbackDeveloper.find(1)
-    thorbjorn.history.should == [
-      [:after_find, :method],
-      [:after_find, :string],
-      [:after_find, :proc],
-      [:after_find, :object],
-      [:after_find, :block],
-      [:after_initialize, :method],
-      [:after_initialize, :string],
-      [:after_initialize, :proc],
-      [:after_initialize, :object],
-      [:after_initialize, :block]
-    ]
-  end
+  class CallbackDeveloperEmbedded < MassiveRecord::ORM::Embedded
+    include CallbackTestable
 
-  it "touch should run in correct order" do
-    thorbjorn = CallbackDeveloper.find(1)
-    thorbjorn.touch
-    thorbjorn.history.should == [
-      [:after_find, :method],
-      [:after_find, :string],
-      [:after_find, :proc],
-      [:after_find, :object],
-      [:after_find, :block],
-      [:after_initialize, :method],
-      [:after_initialize, :string],
-      [:after_initialize, :proc],
-      [:after_initialize, :object],
-      [:after_initialize, :block],
-      [:after_touch, :method],
-      [:after_touch, :string],
-      [:after_touch, :proc],
-      [:after_touch, :object],
-      [:after_touch, :block]
-    ]
-  end
-  
-  it "valid for new record should run in correct order" do
-    thorbjorn = CallbackDeveloper.new
-    thorbjorn.valid?
-    thorbjorn.history.should == [
-      [:after_initialize, :method],
-      [:after_initialize, :string],
-      [:after_initialize, :proc],
-      [:after_initialize, :object],
-      [:after_initialize, :block],
-      [:before_validation, :method],
-      [:before_validation, :string],
-      [:before_validation, :proc],
-      [:before_validation, :object],
-      [:before_validation, :block],
-      [:after_validation, :method],
-      [:after_validation, :string],
-      [:after_validation, :proc],
-      [:after_validation, :object],
-      [:after_validation, :block]
-    ]
-  end
+    embedded_in :callback_developer_table
 
-  it "valid for exiting record should run in correct order" do
-    thorbjorn = CallbackDeveloper.find(1)
-    thorbjorn.valid?
-    thorbjorn.history.should == [
-      [:after_find, :method],
-      [:after_find, :string],
-      [:after_find, :proc],
-      [:after_find, :object],
-      [:after_find, :block],
-      [:after_initialize, :method],
-      [:after_initialize, :string],
-      [:after_initialize, :proc],
-      [:after_initialize, :object],
-      [:after_initialize, :block],
-      [:before_validation, :method],
-      [:before_validation, :string],
-      [:before_validation, :proc],
-      [:before_validation, :object],
-      [:before_validation, :block],
-      [:after_validation, :method],
-      [:after_validation, :string],
-      [:after_validation, :proc],
-      [:after_validation, :object],
-      [:after_validation, :block]
-    ]
+    field :name, :default => "Trym"
   end
 
-  it "create should run in correct order" do
-    thorbjorn = CallbackDeveloper.create "dummy"
-    thorbjorn.history.should == [
-      [:after_initialize, :method],
-      [:after_initialize, :string],
-      [:after_initialize, :proc  ],
-      [:after_initialize, :object],
-      [:after_initialize, :block ],
-      [:before_validation, :method],
-      [:before_validation, :string],
-      [:before_validation, :proc  ],
-      [:before_validation, :object],
-      [:before_validation, :block ],
-      [:after_validation, :method],
-      [:after_validation, :string],
-      [:after_validation, :proc  ],
-      [:after_validation, :object],
-      [:after_validation, :block ],
-      [:before_save, :method],
-      [:before_save, :string],
-      [:before_save, :proc  ],
-      [:before_save, :object],
-      [:before_save, :block ],
-      [:before_create, :method],
-      [:before_create, :string],
-      [:before_create, :proc  ],
-      [:before_create, :object],
-      [:before_create, :block ],
-      [:after_create, :method],
-      [:after_create, :string],
-      [:after_create, :proc  ],
-      [:after_create, :object],
-      [:after_create, :block ],
-      [:after_save, :method],
-      [:after_save, :string],
-      [:after_save, :proc  ],
-      [:after_save, :object],
-      [:after_save, :block ]
-    ]
-  end
+  describe CallbackDeveloperEmbedded do
+    let(:owner_new_record) {  CallbackDeveloperTable.new "1" }
+    let(:owner) { owner_new_record.save! ; owner_new_record }
 
-  it "update should run in correct order" do
-    thorbjorn = CallbackDeveloper.find(1)
-    thorbjorn.save
-    thorbjorn.history.should == [
-      [:after_find, :method],
-      [:after_find, :string],
-      [:after_find, :proc],
-      [:after_find, :object],
-      [:after_find, :block],
-      [:after_initialize, :method],
-      [:after_initialize, :string],
-      [:after_initialize, :proc  ],
-      [:after_initialize, :object],
-      [:after_initialize, :block ],
-      [:before_validation, :method],
-      [:before_validation, :string],
-      [:before_validation, :proc  ],
-      [:before_validation, :object],
-      [:before_validation, :block ],
-      [:after_validation, :method],
-      [:after_validation, :string],
-      [:after_validation, :proc  ],
-      [:after_validation, :object],
-      [:after_validation, :block ],
-      [:before_save, :method],
-      [:before_save, :string],
-      [:before_save, :proc  ],
-      [:before_save, :object],
-      [:before_save, :block ],
-      [:before_update, :method],
-      [:before_update, :string],
-      [:before_update, :proc  ],
-      [:before_update, :object],
-      [:before_update, :block ],
-      [:after_update, :method],
-      [:after_update, :string],
-      [:after_update, :proc  ],
-      [:after_update, :object],
-      [:after_update, :block ],
-      [:after_save, :method],
-      [:after_save, :string],
-      [:after_save, :proc  ],
-      [:after_save, :object],
-      [:after_save, :block ]
-    ]
-  end
+    let(:new_record) { described_class.new "1", :callback_developer_table => owner_new_record }
+    let(:created_record) { described_class.create "dummy", :callback_developer_table => owner_new_record }
+    let(:persisted_record) do
+      owner.callback_developer_embeddeds << described_class.new("1-1")
+      owner.callback_developer_embeddeds.reset # Resets to drop all proxy cached records, force reload from DB
+      owner.callback_developer_embeddeds.find("1-1")
+    end
 
-  it "destroy should run in correct order" do
-    thorbjorn = CallbackDeveloper.find(1) 
-    thorbjorn.destroy
-    thorbjorn.history.should == [
-      [:after_find, :method],
-      [:after_find, :string],
-      [:after_find, :proc],
-      [:after_find, :object],
-      [:after_find, :block],
-      [:after_initialize, :method],
-      [:after_initialize, :string],
-      [:after_initialize, :proc  ],
-      [:after_initialize, :object],
-      [:after_initialize, :block ],
-      [:before_destroy, :method],
-      [:before_destroy, :string],
-      [:before_destroy, :proc  ],
-      [:before_destroy, :object],
-      [:before_destroy, :block ],
-      [:after_destroy, :method],
-      [:after_destroy, :string],
-      [:after_destroy, :proc  ],
-      [:after_destroy, :object],
-      [:after_destroy, :block ]
-    ]
-  end
+    it_should_behave_like "a model with callbacks"
+
+
+    describe "saved via owner" do
+      context "when owner is new record" do
+        subject { new_record }
+        before { subject } # Tap to initialize
+
+        describe "save callbacks" do
+          it "runs in correct order" do
+            owner_new_record.save
+            subject.history.should eq [
+              [:after_initialize, :method],
+              [:after_initialize, :string],
+              [:after_initialize, :proc  ],
+              [:after_initialize, :object],
+              [:after_initialize, :block ],
+              [:before_validation, :method],
+              [:before_validation, :string],
+              [:before_validation, :proc  ],
+              [:before_validation, :object],
+              [:before_validation, :block ],
+              [:after_validation, :method],
+              [:after_validation, :string],
+              [:after_validation, :proc  ],
+              [:after_validation, :object],
+              [:after_validation, :block ],
+              [:before_save, :method],
+              [:before_save, :string],
+              [:before_save, :proc  ],
+              [:before_save, :object],
+              [:before_save, :block ],
+              [:before_create, :method],
+              [:before_create, :string],
+              [:before_create, :proc  ],
+              [:before_create, :object],
+              [:before_create, :block ],
+              [:after_create, :method],
+              [:after_create, :string],
+              [:after_create, :proc  ],
+              [:after_create, :object],
+              [:after_create, :block ],
+              [:after_save, :method],
+              [:after_save, :string],
+              [:after_save, :proc  ],
+              [:after_save, :object],
+              [:after_save, :block ]
+            ]
+          end
+        end
+      end
 
-  it "should not run callbacks for destroy on delete" do
-    thorbjorn = CallbackDeveloper.find(1) 
-    thorbjorn.delete
-    thorbjorn.should be_destroyed
-    thorbjorn.history.should == [
-      [:after_find, :method],
-      [:after_find, :string],
-      [:after_find, :proc],
-      [:after_find, :object],
-      [:after_find, :block],
-      [:after_initialize, :method],
-      [:after_initialize, :string],
-      [:after_initialize, :proc  ],
-      [:after_initialize, :object],
-      [:after_initialize, :block ]
-    ]
+      context "when owner is persisted" do
+        subject { persisted_record; owner.callback_developer_embeddeds.first }
+        before { subject } # Tap to initialize
+
+        describe "update callbacks" do
+          it "is run in correct order" do
+            subject.name += "_NEW"
+            subject.history.clear
+            owner.save
+            subject.history.should eq [
+              [:before_validation, :method],
+              [:before_validation, :string],
+              [:before_validation, :proc  ],
+              [:before_validation, :object],
+              [:before_validation, :block ],
+              [:after_validation, :method],
+              [:after_validation, :string],
+              [:after_validation, :proc  ],
+              [:after_validation, :object],
+              [:after_validation, :block ],
+              [:before_save, :method],
+              [:before_save, :string],
+              [:before_save, :proc  ],
+              [:before_save, :object],
+              [:before_save, :block ],
+              [:before_update, :method],
+              [:before_update, :string],
+              [:before_update, :proc  ],
+              [:before_update, :object],
+              [:before_update, :block ],
+              [:after_update, :method],
+              [:after_update, :string],
+              [:after_update, :proc  ],
+              [:after_update, :object],
+              [:after_update, :block ],
+              [:after_save, :method],
+              [:after_save, :string],
+              [:after_save, :proc  ],
+              [:after_save, :object],
+              [:after_save, :block ]
+            ]
+          end
+        end
+      end
+    end
   end
 end
+

data/spec/orm/models/callback_testable.rb

@@ -0,0 +1,44 @@
+module CallbackTestable
+  extend ActiveSupport::Concern
+
+  included do
+    MassiveRecord::ORM::Callbacks::CALLBACKS.each do |callback_method|
+      next if callback_method.to_s =~ /^around_/
+      define_callback_method(callback_method)
+      send(callback_method, callback_string(callback_method))
+      send(callback_method, callback_proc(callback_method))
+      send(callback_method, callback_object(callback_method))
+      send(callback_method) { |model| model.history << [callback_method, :block] }
+    end
+  end
+
+  module ClassMethods
+    def callback_string(callback_method)
+      "history << [#{callback_method.to_sym.inspect}, :string]"
+    end
+
+    def callback_proc(callback_method)
+      Proc.new { |model| model.history << [callback_method, :proc] }
+    end
+
+    def define_callback_method(callback_method)
+      define_method(callback_method) do
+        self.history << [callback_method, :method]
+      end
+      send(callback_method, :"#{callback_method}")
+    end
+
+    def callback_object(callback_method)
+      klass = Class.new
+      klass.send(:define_method, callback_method) do |model|
+        model.history << [callback_method, :object]
+      end
+      klass.new
+    end
+  end
+
+
+  def history
+    @history ||= []
+  end
+end

data/spec/orm/persistence/operations_spec.rb

@@ -26,6 +26,15 @@ describe MassiveRecord::ORM::Persistence::Operations do
                subject.should be_instance_of MassiveRecord::ORM::Persistence::Operations::Suppress
              end
           end
+
+          it "is possible to force" do
+            MassiveRecord::ORM::Persistence::Operations.suppress do
+              MassiveRecord::ORM::Persistence::Operations.force do
+                klass = "MassiveRecord::ORM::Persistence::Operations::#{method.to_s.classify}".constantize
+                should be_instance_of klass
+              end
+            end
+          end
         end
       end
     end
@@ -51,6 +60,15 @@ describe MassiveRecord::ORM::Persistence::Operations do
                subject.should be_instance_of MassiveRecord::ORM::Persistence::Operations::Suppress
              end
           end
+
+          it "is possible to force" do
+            MassiveRecord::ORM::Persistence::Operations.suppress do
+              MassiveRecord::ORM::Persistence::Operations.force do
+                klass = "MassiveRecord::ORM::Persistence::Operations::Embedded::#{method.to_s.classify}".constantize
+                should be_instance_of klass
+              end
+            end
+          end
         end
       end
     end

data/spec/shared/orm/callbacks.rb

@@ -0,0 +1,316 @@
+require 'spec_helper'
+
+shared_examples_for "a model with callbacks" do
+  it "should include ActiveModel::Callbacks" do
+    described_class.should respond_to :define_model_callbacks
+  end
+
+  it "should include ActiveModell::Validations::Callback" do
+    described_class.included_modules.should include(ActiveModel::Validations::Callbacks)
+  end
+
+  
+
+  context "new record" do
+    describe "initialize callbacks" do
+      it "runs in correct order" do
+        subject.history.should eq [
+          [:after_initialize, :method],
+          [:after_initialize, :string],
+          [:after_initialize, :proc],
+          [:after_initialize, :object],
+          [:after_initialize, :block]
+        ]
+      end
+    end
+
+    describe "validations callback" do
+      it "runs in correct order for new records" do
+        subject.valid?
+        subject.history.should eq [
+          [:after_initialize, :method],
+          [:after_initialize, :string],
+          [:after_initialize, :proc],
+          [:after_initialize, :object],
+          [:after_initialize, :block],
+          [:before_validation, :method],
+          [:before_validation, :string],
+          [:before_validation, :proc],
+          [:before_validation, :object],
+          [:before_validation, :block],
+          [:after_validation, :method],
+          [:after_validation, :string],
+          [:after_validation, :proc],
+          [:after_validation, :object],
+          [:after_validation, :block]
+        ]
+      end
+    end
+
+    describe "create callbacks" do
+      subject { created_record }
+
+      it "runs in correct order" do
+        subject.history.should eq [
+          [:after_initialize, :method],
+          [:after_initialize, :string],
+          [:after_initialize, :proc  ],
+          [:after_initialize, :object],
+          [:after_initialize, :block ],
+          [:before_validation, :method],
+          [:before_validation, :string],
+          [:before_validation, :proc  ],
+          [:before_validation, :object],
+          [:before_validation, :block ],
+          [:after_validation, :method],
+          [:after_validation, :string],
+          [:after_validation, :proc  ],
+          [:after_validation, :object],
+          [:after_validation, :block ],
+          [:before_save, :method],
+          [:before_save, :string],
+          [:before_save, :proc  ],
+          [:before_save, :object],
+          [:before_save, :block ],
+          [:before_create, :method],
+          [:before_create, :string],
+          [:before_create, :proc  ],
+          [:before_create, :object],
+          [:before_create, :block ],
+          [:after_create, :method],
+          [:after_create, :string],
+          [:after_create, :proc  ],
+          [:after_create, :object],
+          [:after_create, :block ],
+          [:after_save, :method],
+          [:after_save, :string],
+          [:after_save, :proc  ],
+          [:after_save, :object],
+          [:after_save, :block ]
+        ]
+      end
+    end
+
+    describe "save callbacks" do
+      subject { new_record }
+
+      it "runs in correct order" do
+        subject.save
+        subject.history.should eq [
+          [:after_initialize, :method],
+          [:after_initialize, :string],
+          [:after_initialize, :proc  ],
+          [:after_initialize, :object],
+          [:after_initialize, :block ],
+          [:before_validation, :method],
+          [:before_validation, :string],
+          [:before_validation, :proc  ],
+          [:before_validation, :object],
+          [:before_validation, :block ],
+          [:after_validation, :method],
+          [:after_validation, :string],
+          [:after_validation, :proc  ],
+          [:after_validation, :object],
+          [:after_validation, :block ],
+          [:before_save, :method],
+          [:before_save, :string],
+          [:before_save, :proc  ],
+          [:before_save, :object],
+          [:before_save, :block ],
+          [:before_create, :method],
+          [:before_create, :string],
+          [:before_create, :proc  ],
+          [:before_create, :object],
+          [:before_create, :block ],
+          [:after_create, :method],
+          [:after_create, :string],
+          [:after_create, :proc  ],
+          [:after_create, :object],
+          [:after_create, :block ],
+          [:after_save, :method],
+          [:after_save, :string],
+          [:after_save, :proc  ],
+          [:after_save, :object],
+          [:after_save, :block ]
+        ]
+      end
+    end
+  end
+
+
+  context "persisted record" do
+    subject { persisted_record }
+
+    describe "find callbacks" do
+      it "runs in correct order" do
+        subject.history.should eq [
+          [:after_find, :method],
+          [:after_find, :string],
+          [:after_find, :proc],
+          [:after_find, :object],
+          [:after_find, :block],
+          [:after_initialize, :method],
+          [:after_initialize, :string],
+          [:after_initialize, :proc],
+          [:after_initialize, :object],
+          [:after_initialize, :block]
+        ]
+      end
+    end
+
+
+    describe "touch callbacks" do
+      it "runs in correct order" do
+        subject.touch
+        subject.history.should eq [
+          [:after_find, :method],
+          [:after_find, :string],
+          [:after_find, :proc],
+          [:after_find, :object],
+          [:after_find, :block],
+          [:after_initialize, :method],
+          [:after_initialize, :string],
+          [:after_initialize, :proc],
+          [:after_initialize, :object],
+          [:after_initialize, :block],
+          [:after_touch, :method],
+          [:after_touch, :string],
+          [:after_touch, :proc],
+          [:after_touch, :object],
+          [:after_touch, :block]
+        ]
+      end
+    end
+
+
+
+    describe "validations callback" do
+      it "runs in correct order for persisted records" do
+        subject.valid?
+        subject.history.should eq [
+          [:after_find, :method],
+          [:after_find, :string],
+          [:after_find, :proc],
+          [:after_find, :object],
+          [:after_find, :block],
+          [:after_initialize, :method],
+          [:after_initialize, :string],
+          [:after_initialize, :proc],
+          [:after_initialize, :object],
+          [:after_initialize, :block],
+          [:before_validation, :method],
+          [:before_validation, :string],
+          [:before_validation, :proc],
+          [:before_validation, :object],
+          [:before_validation, :block],
+          [:after_validation, :method],
+          [:after_validation, :string],
+          [:after_validation, :proc],
+          [:after_validation, :object],
+          [:after_validation, :block]
+        ]
+      end
+    end
+
+
+
+
+    describe "update callbacks" do
+      it "runs in the correct order" do
+        subject.save
+        subject.history.should eq [
+          [:after_find, :method],
+          [:after_find, :string],
+          [:after_find, :proc],
+          [:after_find, :object],
+          [:after_find, :block],
+          [:after_initialize, :method],
+          [:after_initialize, :string],
+          [:after_initialize, :proc  ],
+          [:after_initialize, :object],
+          [:after_initialize, :block ],
+          [:before_validation, :method],
+          [:before_validation, :string],
+          [:before_validation, :proc  ],
+          [:before_validation, :object],
+          [:before_validation, :block ],
+          [:after_validation, :method],
+          [:after_validation, :string],
+          [:after_validation, :proc  ],
+          [:after_validation, :object],
+          [:after_validation, :block ],
+          [:before_save, :method],
+          [:before_save, :string],
+          [:before_save, :proc  ],
+          [:before_save, :object],
+          [:before_save, :block ],
+          [:before_update, :method],
+          [:before_update, :string],
+          [:before_update, :proc  ],
+          [:before_update, :object],
+          [:before_update, :block ],
+          [:after_update, :method],
+          [:after_update, :string],
+          [:after_update, :proc  ],
+          [:after_update, :object],
+          [:after_update, :block ],
+          [:after_save, :method],
+          [:after_save, :string],
+          [:after_save, :proc  ],
+          [:after_save, :object],
+          [:after_save, :block ]
+        ]
+      end
+    end
+
+
+    describe "destroy callbacks" do
+      it "runs in correct order" do
+        subject.destroy
+        subject.history.should eq [
+          [:after_find, :method],
+          [:after_find, :string],
+          [:after_find, :proc],
+          [:after_find, :object],
+          [:after_find, :block],
+          [:after_initialize, :method],
+          [:after_initialize, :string],
+          [:after_initialize, :proc  ],
+          [:after_initialize, :object],
+          [:after_initialize, :block ],
+          [:before_destroy, :method],
+          [:before_destroy, :string],
+          [:before_destroy, :proc  ],
+          [:before_destroy, :object],
+          [:before_destroy, :block ],
+          [:after_destroy, :method],
+          [:after_destroy, :string],
+          [:after_destroy, :proc  ],
+          [:after_destroy, :object],
+          [:after_destroy, :block ]
+        ]
+      end
+    end
+
+
+
+    describe "delete callbacks" do
+      it "does not run callbacks for destroy" do
+        subject.delete
+        subject.should be_destroyed
+        subject.history.should eq [
+          [:after_find, :method],
+          [:after_find, :string],
+          [:after_find, :proc],
+          [:after_find, :object],
+          [:after_find, :block],
+          [:after_initialize, :method],
+          [:after_initialize, :string],
+          [:after_initialize, :proc  ],
+          [:after_initialize, :object],
+          [:after_initialize, :block ]
+        ]
+      end
+    end
+  end
+end

metadata

@@ -2,7 +2,7 @@
 name: massive_record
 version: !ruby/object:Gem::Version 
   prerelease: 6
-  version: 0.2.2.rc1
+  version: 0.2.2.rc2
 platform: ruby
 authors: 
 - Companybook
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-10-07 00:00:00 +02:00
+date: 2011-10-24 00:00:00 +02:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -122,6 +122,7 @@ files:
 - lib/massive_record/orm/id_factory/atomic_incrementation.rb
 - lib/massive_record/orm/id_factory/timestamp.rb
 - lib/massive_record/orm/identity_map.rb
+- lib/massive_record/orm/in_the_middle_of_saving_tracker.rb
 - lib/massive_record/orm/log_subscriber.rb
 - lib/massive_record/orm/observer.rb
 - lib/massive_record/orm/persistence.rb
@@ -217,6 +218,7 @@ files:
 - spec/orm/models/address.rb
 - spec/orm/models/address_with_timestamp.rb
 - spec/orm/models/best_friend.rb
+- spec/orm/models/callback_testable.rb
 - spec/orm/models/car.rb
 - spec/orm/models/friend.rb
 - spec/orm/models/model_without_default_id.rb
@@ -251,6 +253,7 @@ files:
 - spec/orm/schema/field_spec.rb
 - spec/orm/schema/fields_spec.rb
 - spec/orm/schema/table_interface_spec.rb
+- spec/shared/orm/callbacks.rb
 - spec/shared/orm/coders/an_orm_coder.rb
 - spec/shared/orm/id_factories.rb
 - spec/shared/orm/model_with_timestamps.rb
@@ -335,6 +338,7 @@ test_files:
 - spec/orm/models/address.rb
 - spec/orm/models/address_with_timestamp.rb
 - spec/orm/models/best_friend.rb
+- spec/orm/models/callback_testable.rb
 - spec/orm/models/car.rb
 - spec/orm/models/friend.rb
 - spec/orm/models/model_without_default_id.rb
@@ -369,6 +373,7 @@ test_files:
 - spec/orm/schema/field_spec.rb
 - spec/orm/schema/fields_spec.rb
 - spec/orm/schema/table_interface_spec.rb
+- spec/shared/orm/callbacks.rb
 - spec/shared/orm/coders/an_orm_coder.rb
 - spec/shared/orm/id_factories.rb
 - spec/shared/orm/model_with_timestamps.rb