graph_mediator 0.2.2 → 0.2.3

data/README.rdoc

@@ -106,7 +106,7 @@ lock_version.  So if another transaction updates a child, root.lock_version
 should increment, and the first transaction should raise a StaleObject error
 when it too tries to update the child.
 
-If you override super in the model hierarchy you are mediating, you must pass your 
+If you override save in the model hierarchy you are mediating, you must pass your 
 override as a block to super or it will occur outside of mediation:
 
   def save

data/graph_mediator.gemspec

@@ -24,8 +24,10 @@ Gem::Specification.new do |s|
   s.test_files = `git ls-files spec/*`.split("\n")
 
   s.add_development_dependency(%q<rspec>, [">= 1.2.9"])
-  s.add_runtime_dependency(%q<activerecord>, ["= 2.3.5"])
-  s.add_runtime_dependency(%q<activesupport>, ["= 2.3.5"])
+  s.add_development_dependency(%q<diff-lcs>)
+  s.add_development_dependency(%q<sqlite3>)
+  s.add_runtime_dependency(%q<activerecord>, [">= 2.3.6", "< 3.0.0"])
+  s.add_runtime_dependency(%q<activesupport>, [">= 2.3.6", "< 3.0.0"])
   s.add_runtime_dependency(%q<aasm>, [">= 2.2.0"])
 end
 

data/lib/graph_mediator.rb

@@ -80,6 +80,9 @@ module GraphMediator
       base.__send__(:class_inheritable_array, :graph_mediator_dependencies)
       base.graph_mediator_dependencies = []
       base.__send__(:_register_for_mediation, *(SAVE_METHODS.clone << { :track_changes => true }))
+      base.class_eval do 
+        _alias_method_chain_ensuring_inheritability(:destroy, :flag)
+      end
     end
 
     # Inserts a new #{base}::MediatorProxy module with Proxy included.
@@ -104,10 +107,12 @@ module GraphMediator
       key = base.to_s.underscore.gsub('/','_').upcase
       hash_key = "GRAPH_MEDIATOR_#{key}_HASH_KEY"
       new_array_key = "GRAPH_MEDIATOR_#{key}_NEW_ARRAY_KEY"
+      being_destroyed_array_key = "GRAPH_MEDIATOR_#{key}_BEING_DESTROYED_ARRAY_KEY"
       eigen = base.instance_eval { class << self; self; end }
       eigen.class_eval do
         define_method(:mediator_hash_key) { hash_key }
         define_method(:mediator_new_array_key) { new_array_key }
+        define_method(:mediator_being_destroyed_array_key) { being_destroyed_array_key }
       end
 
       # Relies on ActiveSupport::Callbacks (which is included
@@ -189,27 +194,38 @@ module GraphMediator
       # (This is overwritten by GraphMediator._include_new_proxy)
       def mediator_new_array_key; end
 
+      # Unique key to access a thread local array of ids of instances that
+      # are currently in the process of being deleted.
+      def mediator_being_destroyed_array_key; end
+
       # The hash of Mediator instances active in this Thread for the Proxy's 
       # base class.
       #
       # instance.id => Mediator of (instance)
       #
       def mediators
-        unless Thread.current[mediator_hash_key]
-          Thread.current[mediator_hash_key] = {}
-        end
-        Thread.current[mediator_hash_key]
+        _generate_thread_local(mediator_hash_key, Hash)
       end
 
       # An array of Mediator instances mediating new records in this Thread for
       # the Proxy's base class.
       def mediators_for_new_records
-        unless Thread.current[mediator_new_array_key]
-          Thread.current[mediator_new_array_key] = []
-        end
-        Thread.current[mediator_new_array_key]
+        _generate_thread_local(mediator_new_array_key, Array)
       end
 
+      # An array of instance ids currently being in the process of being destroyed.
+      def instances_being_destroyed
+        _generate_thread_local(mediator_being_destroyed_array_key, Array)
+      end
+
+      private
+
+      def _generate_thread_local(key, initial)
+        unless Thread.current[key]
+          Thread.current[key] = initial.kind_of?(Class) ? initial.new : initial
+        end
+        Thread.current[key]
+      end
     end
 
     # Wraps the given block in a transaction and begins mediation. 
@@ -257,6 +273,42 @@ module GraphMediator
       @graph_mediator_mediation_disabled = false
     end
 
+    # True if this instance is currently in the middle of being destroyed.  Set
+    # by code slipped around the core ActiveRecord::Base#destroy via
+    # destroy_with_flag.
+    #
+    # Used by dependents in the mediation process to check whether they should
+    # update their root (see notes under the +mediate+ method).
+    def being_destroyed?
+      instances_being_destroyed.include?(id)  
+    end
+
+    # Surrounding the base destroy ensures that instance is marked in Thread
+    # before any other callbacks occur (notably the collection destroy
+    # dependents pushed into the before_destroy callback).
+    #
+    # If we instead relied on on the before_destroy, after_destroy callbacks,
+    # we would be at the mercy of declaration order in the class for the
+    # GraphMediator include versus the association macro.
+    def destroy_with_flag
+      _mark_being_destroyed
+      destroy_without_flag
+    ensure
+      _unmark_being_destroyed
+    end
+
+    private
+
+    def _mark_being_destroyed
+      instances_being_destroyed << id
+    end
+
+    def _unmark_being_destroyed
+      instances_being_destroyed.delete(id) 
+    end
+
+    public
+
     # By default, every instance will be mediated and this will return true.
     # You can turn mediation on or off on an instance by instance basis with
     # calls to disable_mediation! or enable_mediation!.
@@ -295,6 +347,10 @@ module GraphMediator
       self.class.mediators_for_new_records
     end
 
+    def instances_being_destroyed
+      self.class.instances_being_destroyed
+    end
+
     # Accessor for the mediator associated with this instance's id, or nil if
     # we are not currently mediating.
     def current_mediator
@@ -335,7 +391,8 @@ module GraphMediator
     #
     # * options:
     #   * :through => root node accessor that will be the target of the
-    #     mediated_transaction.  By default self is assumed.
+    #     mediated_transaction.  By default self is assumed.  This is used for
+    #     tracking in the given root node the fact that dependents have changed.
     #   * :track_changes => if true, the mediator will track changes such
     #     that they can be reviewed after_mediation.  The after_mediation
     #     callbacks occur after dirty has completed and changes are normally
@@ -351,7 +408,7 @@ module GraphMediator
         _alias_method_chain_ensuring_inheritability(method, :mediation) do |aliased_target,punctuation|
           __send__(:define_method, "#{aliased_target}_with_mediation#{punctuation}") do |*args, &block|
             root_node = (root_node_accessor ? send(root_node_accessor) : self)
-            unless root_node.nil?
+            unless root_node.nil? || root_node.being_destroyed?
               root_node.mediated_transaction do |mediator|
                 mediator.debug("#{root_node} mediating #{aliased_target}#{punctuation} for #{self}")
                 mediator.track_changes_for(self) if track_changes && saveing
@@ -485,7 +542,26 @@ module GraphMediator
     # Dependent classes have their save methods mediated as well.  However, a
     # dependent class must provide an accessor for the root node, so that a
     # mediated_transaction can be begun in the root node when a dependent is
-    # changed.
+    # changed.  Dependent clases also have their destroy methods mediated so
+    # that destruction of a dependent also registers as a change to the 
+    # graph.
+    # 
+    # == Deletion and Dependents
+    # 
+    # When a class participating in mediation assigns a dependent to mediation,
+    # destruction of that dependent class will cause an update to the parent's
+    # lock_version.  This can cause a problem in Rails 2.3.6+ because
+    # ActiveRecord#destroy is wrapped with an optimistic locking check.  When
+    # the dependent association is set to :dependent => :destroy, the
+    # dependents are automatically destroyed before the parent, which causes
+    # graph_mediator to update the lock_version of the parent, which then fails
+    # the optimistic locking check when it is sent for destruction in
+    # ActiveRecord::Locking::Optimistic#destroy_with_lock.
+    # 
+    # To avoid this, GraphMediator causes an activerecord instance to flag when
+    # it is in the process of destroying itself.  This flag is then checked by
+    # dependents so they can bypass touching the parent when they are being
+    # destroyed.
     #
     # = Versioning and Optimistic Locking
     #

data/lib/graph_mediator/version.rb

@@ -1,3 +1,3 @@
 module GraphMediator
-  VERSION = "0.2.2"
+  VERSION = "0.2.3"
 end

data/spec/dependents/child.rb

@@ -0,0 +1,9 @@
+module Dependents
+  class Child < ActiveRecord::Base
+    belongs_to :parent
+  end
+
+  class ReverseChild < ActiveRecord::Base
+    belongs_to :reverse_parent
+  end
+end

data/spec/dependents/parent.rb

@@ -0,0 +1,20 @@
+module Dependents
+  class Parent < ActiveRecord::Base
+    include GraphMediator
+    mediate :dependencies => Child
+
+    has_many :children, :dependent => :destroy
+  end
+
+  # To test whether the order of declaration impacts function
+  # For example, if we used before_destroy callbacks to mark a parent
+  # as being destroyed, the order matters, because associations register
+  # themselves for deletion when first declared using before_destroy as
+  # well.
+  class ReverseParent < ActiveRecord::Base
+    has_many :reverse_children, :dependent => :destroy
+
+    include GraphMediator
+    mediate :dependencies => ReverseChild
+  end
+end

data/spec/dependents/schema.rb

@@ -0,0 +1,23 @@
+create_schema do |connection|
+  connection.create_table(:parents, :force => true) do |t|
+    t.string :name
+    t.integer :lock_version, :default => 0
+    t.timestamps
+  end
+
+  connection.create_table(:reverse_parents, :force => true) do |t|
+    t.string :name
+    t.integer :lock_version, :default => 0
+    t.timestamps
+  end
+
+  connection.create_table(:children, :force => true) do |t|
+    t.integer :parent_id
+    t.string :marker
+  end
+
+  connection.create_table(:reverse_children, :force => true) do |t|
+    t.integer :reverse_parent_id
+    t.string :marker
+  end
+end

data/spec/graph_mediator_spec.rb

@@ -485,7 +485,11 @@ describe "GraphMediator" do
     it "should generate a unique mediator_new_array_key for each MediatorProxy" do
       @f.class.mediator_new_array_key.should == 'GRAPH_MEDIATOR_GRAPH_MEDIATOR_SPEC_FOO_NEW_ARRAY_KEY'
     end
- 
+
+    it "should generate a unique mediator_being_destroyed_array_key for each MediatorProxy" do
+      @f.class.mediator_being_destroyed_array_key.should == 'GRAPH_MEDIATOR_GRAPH_MEDIATOR_SPEC_FOO_BEING_DESTROYED_ARRAY_KEY'
+    end
+
     it "should access an array of mediators for new records" do
       @f.__send__(:mediators_for_new_records).should == []
     end
@@ -494,6 +498,9 @@ describe "GraphMediator" do
       @f.__send__(:mediators).should == {}
     end
 
+    it "should access an array of ids for instances being destroyed" do
+      @f.__send__(:instances_being_destroyed).should == []
+    end
   end
 end
 

data/spec/integration/destroy_dependents_locking_tests_spec.rb

@@ -0,0 +1,84 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'spec_helper'))
+
+require 'dependents/child.rb'
+require 'dependents/parent.rb'
+
+module Dependents
+
+  describe "GraphMediator instances should flag that they are being destroyed" do
+    def load_track_destroy
+      create_schema do |conn|
+        conn.create_table(:track_destroys, :force => true) do |t|
+          t.string :name
+          t.integer :lock_version, :defaults => 0
+          t.tiimestamps
+        end
+      end
+
+      @destroy_callbacks = callbacks_ref = []
+      c = Class.new(ActiveRecord::Base)
+      Object.const_set(:TrackDestroy, c)
+      c.class_eval do 
+        include GraphMediator
+        
+        def destroy_without_callbacks
+          callbacks << being_destroyed?
+          super
+        end
+        define_method(:callbacks) { callbacks_ref }
+      end
+    end
+
+    before(:each) do
+      load_track_destroy
+      @t = TrackDestroy.create!
+    end
+
+    it "should note that it is being destroyed" do
+      @t.should_not be_being_destroyed
+      @t.destroy
+      @destroy_callbacks.should == [true]
+      @t.should_not be_being_destroyed
+      @t.should be_destroyed
+    end
+  end
+
+  describe "Tests ability to destroy objects with dependents despite optimistic locking" do
+  
+    before(:all) do
+      load 'dependents/schema.rb'
+    end
+
+    before(:each) do
+      @p = Parent.create!(:name => 'foo')
+      @c1 = @p.children.create(:marker => 'bar')
+      @c2 = @p.children.create(:marker => 'baz')
+    end  
+
+    it "should not raise a stale object error when deleting a parent with dependents that are automagically destroyed by activerecord" do
+      @p.should_not be_new_record
+      @c1.should_not be_new_record
+      @c2.should_not be_new_record
+      @p.reload
+      lambda { @p.destroy }.should_not raise_error(ActiveRecord::StaleObjectError)
+    end
+
+    it "does not matter whether the include or association is declared first" do
+      rp = ReverseParent.create(:name => 'foo')
+      c1 = rp.reverse_children.create(:marker => 'bar')
+      c2 = rp.reverse_children.create(:marker => 'baz')
+      rp.reload
+      lambda { rp.destroy }.should_not raise_error(ActiveRecord::StaleObjectError)
+    end
+
+    # This is a vague test that our changes to destroy workflow don't choke
+    # in the trivial case of an unstored instance.
+    it "should be okay if call destroy on new object" do
+      np = Parent.new(:name => 'foo')
+      cp = np.children.new(:marker => 'bar')
+      np.destroy.should == np # Nothing should be thrown
+      np.should be_destroyed
+      np.lock_version.should == 0
+    end
+  end
+end

metadata

@@ -1,12 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: graph_mediator
 version: !ruby/object:Gem::Version 
+  hash: 17
   prerelease: false
   segments: 
   - 0
   - 2
-  - 2
-  version: 0.2.2
+  - 3
+  version: 0.2.3
 platform: ruby
 authors: 
 - Josh Partlow
@@ -14,16 +15,18 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-12-08 00:00:00 -08:00
+date: 2013-01-24 00:00:00 -08:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: rspec
   prerelease: false
   requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
+        hash: 13
         segments: 
         - 1
         - 2
@@ -32,47 +35,97 @@ dependencies:
   type: :development
   version_requirements: *id001
 - !ruby/object:Gem::Dependency 
-  name: activerecord
+  name: diff-lcs
   prerelease: false
   requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
     requirements: 
-    - - "="
+    - - ">="
       - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: sqlite3
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: activerecord
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 15
         segments: 
         - 2
         - 3
-        - 5
-        version: 2.3.5
+        - 6
+        version: 2.3.6
+    - - <
+      - !ruby/object:Gem::Version 
+        hash: 7
+        segments: 
+        - 3
+        - 0
+        - 0
+        version: 3.0.0
   type: :runtime
-  version_requirements: *id002
+  version_requirements: *id004
 - !ruby/object:Gem::Dependency 
   name: activesupport
   prerelease: false
-  requirement: &id003 !ruby/object:Gem::Requirement 
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    none: false
     requirements: 
-    - - "="
+    - - ">="
       - !ruby/object:Gem::Version 
+        hash: 15
         segments: 
         - 2
         - 3
-        - 5
-        version: 2.3.5
+        - 6
+        version: 2.3.6
+    - - <
+      - !ruby/object:Gem::Version 
+        hash: 7
+        segments: 
+        - 3
+        - 0
+        - 0
+        version: 3.0.0
   type: :runtime
-  version_requirements: *id003
+  version_requirements: *id005
 - !ruby/object:Gem::Dependency 
   name: aasm
   prerelease: false
-  requirement: &id004 !ruby/object:Gem::Requirement 
+  requirement: &id006 !ruby/object:Gem::Requirement 
+    none: false
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
+        hash: 7
         segments: 
         - 2
         - 2
         - 0
         version: 2.2.0
   type: :runtime
-  version_requirements: *id004
+  version_requirements: *id006
 description: Mediates state changes between a set of interdependent ActiveRecord objects.
 email: jpartlow@glatisant.org
 executables: []
@@ -94,10 +147,14 @@ files:
 - lib/graph_mediator/mediator.rb
 - lib/graph_mediator/version.rb
 - spec/database.rb
+- spec/dependents/child.rb
+- spec/dependents/parent.rb
+- spec/dependents/schema.rb
 - spec/examples/course_example_spec.rb
 - spec/examples/dingo_pen_example_spec.rb
 - spec/graph_mediator_spec.rb
 - spec/integration/changes_spec.rb
+- spec/integration/destroy_dependents_locking_tests_spec.rb
 - spec/integration/locking_tests_spec.rb
 - spec/integration/nesting_spec.rb
 - spec/integration/threads_spec.rb
@@ -127,16 +184,20 @@ rdoc_options:
 require_paths: 
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      hash: 3
       segments: 
       - 0
       version: "0"
 required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      hash: 23
       segments: 
       - 1
       - 3
@@ -145,16 +206,20 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.3.6
+rubygems_version: 1.3.7
 signing_key: 
 specification_version: 3
 summary: Mediates ActiveRecord state changes
 test_files: 
 - spec/database.rb
+- spec/dependents/child.rb
+- spec/dependents/parent.rb
+- spec/dependents/schema.rb
 - spec/examples/course_example_spec.rb
 - spec/examples/dingo_pen_example_spec.rb
 - spec/graph_mediator_spec.rb
 - spec/integration/changes_spec.rb
+- spec/integration/destroy_dependents_locking_tests_spec.rb
 - spec/integration/locking_tests_spec.rb
 - spec/integration/nesting_spec.rb
 - spec/integration/threads_spec.rb