deferring 0.0.2 → 0.0.3

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 533c02589a0e9c2ae8d48d47d3746ae7234633e7
+  data.tar.gz: cd023ba8e4b6f3cb9075a667503b26c1c8a60354
+SHA512:
+  metadata.gz: 90d31875102fdd4120714e484f7e30770f2324663fabc5dde2925787c63264fc41812458d4f0605c3b9b1e413654ab8613f52e5aaf01255024564c4c5e7083df
+  data.tar.gz: 2f4042d509e4b1f497e6b04db21bbf35fee8cddb28254e7ee24e7bf9425adf0be142c6dbeceed1c47a7eaf8a0a2ce8ad424635993d2e61f82c0d7040c34bf355

data/README.md

@@ -12,8 +12,6 @@ It is important to note that Deferring does not touch the original `has_many`
 and `has_and_belongs_to_many` associations. You can use them, without worrying
 about any changed behaviour or side-effects from using Deferring.
 
-**NOTE: This is currently work in progress.**
-
 ## Why use it?
 
 Let's take a look at the following example:
@@ -119,18 +117,156 @@ Or install it yourself as:
 
 ### How do I use it?
 
-Deferring adds a couple of methods to your ActiveRecord models. These are:
+Deferring adds a couple of methods to your ActiveRecord classes. These are:
 
 - `deferred_has_and_belongs_to_many`
 - `deferred_accepts_nested_attributes_for`
 - `deferred_has_many`
 
-These methods wrap the existing methods. For instance, `deferred_has_many` will
-call `has_many` in order to set up the association.
+These methods wrap the existing methods. For instance,
+`deferred_has_and_belongs_to_many` will call `has_and_belongs_to_many` in order
+to set up the association.
+
+In order to create a deferred association, you can just replace the regular
+method by one provided by Deferring.
+
+Simple!
+
+Next to that, Deferring adds the following functionality:
+* new callbacks that are triggered when adding/removing a record to the
+  deferred association before saving the parent, and
+* new methods on the deferred association to retrieve the records that are to be
+  linked to/unlinked from the parent.
+
+#### Callbacks
+
+##### Rails' callbacks
+
+You can use the regular Rails callbacks on deferred associations. However, these
+callbacks are triggered at a different point in time.
+
+An example to illustrate:
+
+``` ruby
+class Person < ActiveRecord::Base
+  has_and_belongs_to_many :teams, before_add: :before_adding
+  deferred_has_and_belongs_to_many :pets, before_add: :before_adding
+
+  def audit_log
+    @log = []
+  end
+
+  def before_adding(record)
+    audit_log << "Before adding #{record.class} with id #{record.id}"
+  end
+end
+```
+
+This sets up a Person model that has a regular HABTM association with teams and
+that has a deferred HABTM association with pets. Each time a team or pet is
+added to the database a log statement is written to the audit log (using the
+`before_adding` callback method).
+
+The regular HABTM association behaves likes this:
+
+``` ruby
+person = Person.first
+person.teams << Team.find(1)
+person.audit_log # => ['Before adding Team 1']
+```
+
+As records of deferred associations are saved to the database after saving the
+parent the behavior is a bit different:
+
+``` ruby
+person = Person.first
+person.pets << Pet.find(1)
+person.audit_log # => []
+
+person.save
+person.audit_log # => ['Before adding Pet 1']
+```
+
+##### New link and unlink callbacks
+
+As said, the regular `:before_add`, etc. callbacks still work, but they are only
+triggered after the parent object has been saved. You can use the following
+callbacks when you want a method to be executed when adding/deleting a record to
+the deferred association *before saving* the parent:
+* `:before_link`
+* `:after_link`
+* `:before_unlink`
+* `:after_unlink`
+
+Another example to illustrate:
+
+``` ruby
+class Person < ActiveRecord::Base
+  deferred_has_and_belongs_to_many :pets, before_link: :link_pet
+
+  def audit_log
+    @log = []
+  end
+
+  def link_pet(pet)
+    audit_log << "Before linking #{pet.class} with id #{pet.id}"
+  end
+end
+```
+
+This sets up a Person model that has a deferred HABTM association to pets. Each
+time a pet is linked to the Person a log statement is written to the audit log
+(using the `link_pet` callback function).
+
+``` ruby
+person = Person.first
+person.pets << Pet.find(1)
+person.audit_log # => ['Before linking Pet with id 1']
+
+person.save
+person.audit_log # => ['Before linking Pet with id 1']
+```
+
+As you can see, the callback method will not be called again when saving the
+parent object.
+
+Note that, instead of a `:before_link` callback, you can also use a
+`before_save` callback on the Person model that calls the `link_pet` method on
+each of the pets that are to be linked to the parent object.
+
+#### Links and unlinks
+
+In some cases, you want to know which records are going to be linked or unlinked
+from the parent object. Deferring provides this information with the following
+methods:
+* `association.links`
+* `association.unlinks`
+
+These are aliased as `:pending_creates` and `:pending_deletes`. I am not sure if
+this will be supported in the future, so do not depend on it.
 
-**TODO:** Describe pending_creates/pending_deletes/links/unlinks/callbacks/
-original_name/checked.
+An example:
 
+Writing to the audit log is very expensive. Writing to it every time a record is
+added would slow down the application. In this case, you want to write to the
+audit log in bulk. Here is how you could do that using Deferring:
+
+``` ruby
+class Person < ActiveRecord::Base
+  deferred_has_and_belongs_to_many :pets
+
+  before_save :log_linked_pets
+
+  def log_linked_pets
+    ids = pending_creates.map(&:id)
+    audit_log << "Linking pets: #{ids.join(',')}"
+  end
+
+  def audit_log
+    @log = []
+  end
+end
+```
 
 ### How does it work?
 
@@ -148,10 +284,10 @@ avoid ;-)
 
 ### Gotchas
 
-#### Using autosave (or not actually)
+#### Using autosave (or not, actually)
 
-TL;DR; Using `autosave: true` (or false) on a deferred association will work,
-but does not do anything.
+TL;DR; Using `autosave: true` (or false) on a deferred association does not do
+anything.
 
 This is what the Rails documentation says about the AutosaveAssociation:
 
@@ -172,53 +308,83 @@ the array of associated records to original association. This kind of assignment
 bypasses the autosave behaviour, see the _Why use it?_ part on top of this
 README.
 
-#### Using custom callback methods
+**TODO:** Is this correct? Or does autosave: true prevent new records from being
+saved? Test.
 
-**TODO**: This is incorrect and has to be rewritten to match code.
+#### Adding/removing records before saving parent
 
-You can use custom callback functions. However, the callbacks for defferred
-associations are triggered at a different point in time.
+Event if using Deferring, it is still possible to add/remove a record before
+saving the parent. There are two ways:
+* using methods that are not mapped to the deferred associations, or
+* using the original association.
 
-An example to illustrate:
+##### Unmapped methods
 
-``` ruby
-class Person < ActiveRecord::Base
-  has_and_belongs_to_many :teams, before_add: :before_adding
-  deferred_has_and_belongs_to_many :pets, before_add: :before_adding
+As a rule, you can expect that methods defined in `Enumerable` and `Array` are
+called on the deferred association. Exceptions are:
+* `find`, and
+* `select` (when not using a block).
 
-  def audit_log
-    @log = []
-  end
+Most other methods are called on the original association, most importantly:
+* `create` or `create!`, and
+* `destroy`, `destroy!` and `destroy_all`,
 
-  def before_adding(record)
-    audit_log << "Before adding #{record.class} with id #{record.id}"
-  end
+This can cause an record to be removed or added before saving the parent object.
+
+``` ruby
+class Person
+  deferred_has_and_belongs_to_many :teams
+  validates :name, presence: true
 end
-```
 
-This sets up a Person model that has a regular HABTM association with teams and
-that has a deferred HABTM association with pets. Each time a team or pet is
-added to the database a log statement is written to the audit log (using the
-`before_adding` callback function).
+class Team
+  has_and_belongs_to_many :people
+end
 
-The regular HABTM association behaves likes this:
+person = Person.create(name: 'Bob')
+person.teams.create(name: 'Support')
+person.name = nil
+person.save
+# => false, because the name attribute is empty
 
-``` ruby
-person = Person.first
-person.teams << Team.find(1)
-person.audit_log # => ['Before adding Team 1']
+Person.first.teams
+# => [#<Team id: 4, name: "Support", ... ]
 ```
 
-As records of deferred associations are saved to the database after saving the
-parent the behavior is a bit different:
+##### Original association
+
+The original association is renamed to "original_association_name". So, the
+original association of the deferred association named `teams` can be accessed
+by using `original_teams`.
 
 ``` ruby
-person = Person.first
-person.pets << Pet.find(1)
-person.audit_log # => []
+class Person
+  deferred_has_and_belongs_to_many :teams
+  validates :name, presence: true
+end
 
+class Team
+  has_and_belongs_to_many :people
+end
+
+support = Team.create(name: 'Support')
+person = Person.create(name: 'Bob')
+
+person.original_teams << support
+person.name = nil
 person.save
-person.audit_log # => ['Before adding Pet 1']
+# => false, because the name attribute is empty
+
+Person.first.teams
+# => [#<Team id: 4, name: "Support", ... ]
+```
+
+## Development
+
+Run specs on all different Rails version using Appraisal:
+
+```
+bundle exec appraisal rake
 ```
 
 ## TODO

data/deferring.gemspec

@@ -13,7 +13,7 @@ Gem::Specification.new do |spec|
     associations until the parent object is saved.
   }
   spec.summary       = %q{Defer saving ActiveRecord associations until parent is saved}
-  spec.homepage      = 'http://github.com/robinroestenburg/delay_many'
+  spec.homepage      = 'http://github.com/robinroestenburg/deferring'
   spec.license       = "MIT"
 
   spec.files         = `git ls-files`.split($/)

data/gemfiles/rails_30.gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: ../
   specs:
-    deferring (0.0.1)
+    deferring (0.0.2)
       activerecord (> 3.0)
 
 GEM

data/gemfiles/rails_32.gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: ../
   specs:
-    deferring (0.0.1)
+    deferring (0.0.2)
       activerecord (> 3.0)
 
 GEM

data/gemfiles/rails_40.gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: ../
   specs:
-    deferring (0.0.1)
+    deferring (0.0.2)
       activerecord (> 3.0)
 
 GEM

data/gemfiles/rails_41.gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: ../
   specs:
-    deferring (0.0.1)
+    deferring (0.0.2)
       activerecord (> 3.0)
 
 GEM

data/lib/deferring.rb

@@ -2,6 +2,7 @@
 
 require 'deferring/version'
 require 'deferring/deferred_association'
+require 'deferring/deferred_callback_listener'
 
 module Deferring
   # Creates a wrapper around `has_and_belongs_to_many`. A normal habtm
@@ -10,8 +11,11 @@ module Deferring
   # replaced with ones that will defer saving the association until the parent
   # object has been saved.
   def deferred_has_and_belongs_to_many(*args)
-    has_and_belongs_to_many(*args)
-    generate_deferred_association_methods(args.first.to_s)
+    options = args.extract_options!
+    listeners = create_callback_listeners!(options)
+
+    has_and_belongs_to_many(*args, options)
+    generate_deferred_association_methods(args.first.to_s, listeners)
   end
 
   # Creates a wrapper around `has_many`. A normal has many association is
@@ -19,8 +23,11 @@ module Deferring
   # accessor methods of the original association are replaced with ones that
   # will defer saving the association until the parent object has been saved.
   def deferred_has_many(*args)
-    has_many(*args)
-    generate_deferred_association_methods(args.first.to_s)
+    options = args.extract_options!
+    listeners = create_callback_listeners!(options)
+
+    has_many(*args, options)
+    generate_deferred_association_methods(args.first.to_s, listeners)
   end
 
   def deferred_accepts_nested_attributes_for(*args)
@@ -29,7 +36,7 @@ module Deferring
 
     # teams_attributes=
     define_method :"#{association_name}_attributes=" do |records|
-      find_or_create_deferred_association(association_name)
+      find_or_create_deferred_association(association_name, [])
 
       # Remove the records that are to be destroyed from the ids that are to be
       # assigned to the DeferredAssociation instance.
@@ -43,7 +50,9 @@ module Deferring
     generate_find_or_create_deferred_association_method
   end
 
-  def generate_deferred_association_methods(association_name)
+  private
+
+  def generate_deferred_association_methods(association_name, listeners)
     # Store the original accessor methods of the association.
     alias_method :"original_#{association_name}", :"#{association_name}"
     alias_method :"original_#{association_name}=", :"#{association_name}="
@@ -51,18 +60,13 @@ module Deferring
     # Accessor for our own association.
     attr_accessor :"deferred_#{association_name}"
 
-    # before/afer remove callbacks
-    define_callbacks :"deferred_#{association_name}_save", scope: [:kind, :name]
-    define_callbacks :"deferred_#{association_name.singularize}_remove", scope: [:kind, :name]
-    define_callbacks :"deferred_#{association_name.singularize}_add", scope: [:kind, :name]
-
     # collection
     #
     # Returns an array of all the associated objects. An empty array is returned
     # if none are found.
     # TODO: add force_reload argument?
     define_method :"#{association_name}" do
-      find_or_create_deferred_association(association_name)
+      find_or_create_deferred_association(association_name, listeners)
       send(:"deferred_#{association_name}")
     end
 
@@ -71,7 +75,7 @@ module Deferring
     # Replaces the collection's content by deleting and adding objects as
     # appropriate.
     define_method :"#{association_name}=" do |objects|
-      find_or_create_deferred_association(association_name)
+      find_or_create_deferred_association(association_name, listeners)
       send(:"deferred_#{association_name}").objects = objects
     end
 
@@ -80,7 +84,7 @@ module Deferring
     # Replace the collection by the objects identified by the primary keys in
     # ids.
     define_method :"#{association_name.singularize}_ids=" do |ids|
-      find_or_create_deferred_association(association_name)
+      find_or_create_deferred_association(association_name, listeners)
 
       klass = self.class.reflect_on_association(:"#{association_name}").klass
       objects = klass.find(ids.reject(&:blank?))
@@ -91,7 +95,7 @@ module Deferring
     #
     # Returns an array of the associated objects' ids.
     define_method :"#{association_name.singularize}_ids" do
-      find_or_create_deferred_association(association_name)
+      find_or_create_deferred_association(association_name, listeners)
       send(:"deferred_#{association_name}").ids
     end
 
@@ -105,27 +109,33 @@ module Deferring
     #  the save after the parent object has been saved
     after_save :"perform_deferred_#{association_name}_save!"
     define_method :"perform_deferred_#{association_name}_save!" do
-      run_callbacks :"deferred_#{association_name}_save" do
-        find_or_create_deferred_association(association_name)
-
-        # Send the objects of our delegated association to the original
-        # association and store the result.
-        send(:"original_#{association_name}=", send(:"deferred_#{association_name}").objects)
-
-        # Store the new value of the association into our delegated association.
-        send(
-          :"deferred_#{association_name}=",
-          DeferredAssociation.new(send(:"original_#{association_name}"), self, association_name))
+      find_or_create_deferred_association(association_name, listeners)
+
+      # Send the objects of our delegated association to the original
+      # association and store the result.
+      send(:"original_#{association_name}=", send(:"deferred_#{association_name}").objects)
+
+      # Store the new value of the association into our delegated association.
+      send(
+        :"deferred_#{association_name}=",
+        DeferredAssociation.new(send(:"original_#{association_name}"), association_name))
+      listeners.each do |event_name, callback_method|
+        l = DeferredCallbackListener.new(event_name, self, callback_method)
+        send(:"deferred_#{association_name}").add_callback_listener(l)
       end
     end
 
     define_method :"reload_with_deferred_#{association_name}" do |*args|
-      find_or_create_deferred_association(association_name)
+      find_or_create_deferred_association(association_name, listeners)
 
       send(:"reload_without_deferred_#{association_name}", *args).tap do
         send(
           :"deferred_#{association_name}=",
-          DeferredAssociation.new(send(:"original_#{association_name}"), self, association_name))
+          DeferredAssociation.new(send(:"original_#{association_name}"), association_name))
+        listeners.each do |event_name, callback_method|
+          l = DeferredCallbackListener.new(event_name, self, callback_method)
+          send(:"deferred_#{association_name}").add_callback_listener(l)
+        end
       end
     end
     alias_method_chain :reload, :"deferred_#{association_name}"
@@ -134,14 +144,26 @@ module Deferring
   end
 
   def generate_find_or_create_deferred_association_method
-    define_method :find_or_create_deferred_association do |name|
+    define_method :find_or_create_deferred_association do |name, listeners|
       if send(:"deferred_#{name}").nil?
         send(
           :"deferred_#{name}=",
-          DeferredAssociation.new(send(:"original_#{name}"), self, name))
+          DeferredAssociation.new(send(:"original_#{name}"), name))
+        listeners.each do |event_name, callback_method|
+          l = DeferredCallbackListener.new(event_name, self, callback_method)
+          send(:"deferred_#{name}").add_callback_listener(l)
+        end
       end
     end
   end
+
+  def create_callback_listeners!(options)
+    [:before_link, :before_unlink, :after_link, :after_unlink].map do |event_name|
+      callback_method = options.delete(event_name)
+      [event_name, callback_method] if callback_method
+    end.compact
+  end
+
 end
 
 ActiveRecord::Base.send(:extend, Deferring)

data/lib/deferring/deferred_association.rb

@@ -9,22 +9,15 @@ module Deferring
 
     attr_reader :load_state
 
-    def initialize(original_association, obj, name)
+    def initialize(original_association, name)
       super(original_association)
       @name = name
-      @obj = obj
       @load_state = :ghost
     end
-
     alias_method :original_association, :__getobj__
 
     delegate :to_s, :to_a, :inspect, :==, # methods undefined by SimpleDelegator
-             :is_a?, :as_json,
-
-             :[], :clear, :reject, :reject!, :flatten, :flatten!, :sort!,
-             :empty?, :size, :length, # methods on Array
-
-             to: :objects
+             :is_a?, :as_json, to: :objects
 
     def each(&block)
       objects.each(&block)
@@ -41,10 +34,26 @@ module Deferring
       end
     end
 
+    # Delegates methods from Ruby's Array module to the object in the deferred
+    # association.
+    delegate :[], :clear, :reject, :reject!, :flatten, :flatten!, :sort!,
+             :sort_by!, :empty?, :size, :length, to: :objects
+
+    # Delegates Ruby's Enumerable#find method to the original association.
+    #
+    # The delegation has to be explicit in this case, because the inclusion of
+    # Enumerable also defines the find-method on DeferredAssociation.
     def find(*args)
       original_association.find(*args)
     end
 
+    # Delegates Ruby's Enumerable#select method to the original association when
+    # no block has been given. Rails' select-method does not accept a block, so
+    # we know that in that case the select-method has to be called on our
+    # deferred association.
+    #
+    # The delegation has to be explicit in this case, because the inclusion of
+    # Enumerable also defines the select-method on DeferredAssociation.
     def select(value = Proc.new)
       if block_given?
         objects.select { |*block_args| value.call(*block_args) }
@@ -58,40 +67,18 @@ module Deferring
       original_association.__send__(:set_inverse_instance, associated_record, parent_record)
     end
 
-    def association
-      load_objects
-      original_association
-    end
-
     def objects
       load_objects
       @objects
     end
 
-    def original_objects
-      load_objects
-      @original_objects
-    end
-
     def objects=(records)
       @objects = records
       @original_objects = original_association.to_a.clone
       objects_loaded!
 
-      pending_deletes.each do |record|
-        # TODO: I don't like the fact that we know something about @obj in here.
-        #       Refactor to remove that (some kind of notification), it looks
-        #       terrible this way ;(
-        @obj.instance_variable_set(:"@deferred_#{@name.singularize}_remove", record)
-        @obj.run_callbacks :"deferred_#{@name.singularize}_remove"
-        @obj.send(:remove_instance_variable, :"@deferred_#{@name.singularize}_remove")
-      end
-
-      pending_creates.each do |record|
-        @obj.instance_variable_set(:"@deferred_#{@name.singularize}_add", record)
-        @obj.run_callbacks :"deferred_#{@name.singularize}_add"
-        @obj.send(:remove_instance_variable, :"@deferred_#{@name.singularize}_add")
-      end
+      pending_deletes.each { |record| run_deferring_callbacks(:unlink, record) }
+      pending_creates.each { |record| run_deferring_callbacks(:link, record) }
 
       @objects
     end
@@ -104,13 +91,11 @@ module Deferring
       # TODO: Do we want to prevent including the same object twice? Not sure,
       # but it will probably be filtered after saving and retrieving as well.
       Array(records).flatten.uniq.each do |record|
-        @obj.instance_variable_set(:"@deferred_#{@name.singularize}_add", record)
-        @obj.run_callbacks :"deferred_#{@name.singularize}_add" do
+        run_deferring_callbacks(:link, record) do
           objects << record
         end
-        @obj.send(:remove_instance_variable, :"@deferred_#{@name.singularize}_add")
       end
-      objects
+      self
     end
     alias_method :push, :<<
     alias_method :concat, :<<
@@ -118,11 +103,9 @@ module Deferring
 
     def delete(records)
       Array(records).flatten.uniq.each do |record|
-        @obj.instance_variable_set(:"@deferred_#{@name.singularize}_remove", record)
-        @obj.run_callbacks :"deferred_#{@name.singularize}_remove" do
+        run_deferring_callbacks(:unlink, record) do
           objects.delete(record)
         end
-        @obj.send(:remove_instance_variable, :"@deferred_#{@name.singularize}_remove")
       end
       self
     end
@@ -130,10 +113,21 @@ module Deferring
     def build(*args, &block)
       association.build(*args, &block).tap do |result|
         objects.push(result)
+
+        # Remove the newly build record from the original association. If we
+        # didn't do this, the new record would be saved to the database when
+        # saving the parent object (and not after, as we want).
         association.reload
       end
     end
 
+    def create(*args, &block)
+      association.create(*args, &block).tap do |result|
+        @load_state = :ghost
+        load_objects
+      end
+    end
+
     def create!(*args, &block)
       association.create!(*args, &block).tap do |result|
         @load_state = :ghost
@@ -150,23 +144,32 @@ module Deferring
 
     # Returns the associated records to which links will be created after saving
     # the parent of the association.
-    def pending_creates
+    def links
       return [] unless objects_loaded?
       objects - original_objects
     end
-    alias_method :links, :pending_creates
+    alias_method :pending_creates, :links
 
     # Returns the associated records to which the links will be deleted after
     # saving the parent of the assocation.
-    def pending_deletes
+    def unlinks
       # TODO: Write test for it.
       return [] unless objects_loaded?
       original_objects - objects
     end
-    alias_method :unlinks, :pending_deletes
+    alias_method :pending_deletes, :unlinks
+
+    def add_callback_listener(listener)
+      (@listeners ||= []) << listener
+    end
 
     private
 
+    def association
+      load_objects
+      original_association
+    end
+
     def load_objects
       return if objects_loaded?
 
@@ -183,5 +186,24 @@ module Deferring
       @load_state = :loaded
     end
 
+    def original_objects
+      load_objects
+      @original_objects
+    end
+
+    def run_deferring_callbacks(event_name, record)
+      notify_callback_listeners(:"before_#{event_name}", record)
+      yield if block_given?
+      notify_callback_listeners(:"after_#{event_name}", record)
+    end
+
+    def notify_callback_listeners(event_name, record)
+      @listeners && @listeners.each do |listener|
+        if listener.event_name == event_name
+          listener.public_send(event_name, record)
+        end
+      end
+    end
+
   end
 end

data/lib/deferring/deferred_callback_listener.rb

@@ -0,0 +1,11 @@
+module Deferring
+  class DeferredCallbackListener < Struct.new(:event_name, :callee, :callback)
+
+    [:before_link, :before_unlink, :after_link, :after_unlink].each do |event_name|
+      define_method(event_name) do |record|
+        callee.public_send(callback, record)
+      end
+    end
+
+  end
+end

data/lib/deferring/version.rb

@@ -1,5 +1,5 @@
 # encoding: UTF-8
 
 module Deferring
-  VERSION = '0.0.2'
+  VERSION = '0.0.3'
 end

data/spec/lib/deferring_spec.rb

@@ -274,6 +274,114 @@ RSpec.describe 'deferred has-and-belongs-to-many associations' do
 
   end
 
+  describe 'callbacks' do
+
+    before(:example) do
+      bob = Person.first
+      bob.teams = [Team.find(3)]
+      bob.save!
+    end
+
+    it 'calls the link callbacks when adding a record using <<' do
+      bob = Person.first
+      bob.teams << Team.find(1)
+
+      expect(bob.audit_log.length).to eq(2)
+      expect(bob.audit_log).to eq([
+        'Before linking team 1',
+        'After linking team 1'
+      ])
+    end
+
+    it 'calls the link callbacks when adding a record using push' do
+      bob = Person.first
+      bob.teams.push(Team.find(1))
+
+      expect(bob.audit_log.length).to eq(2)
+      expect(bob.audit_log).to eq([
+        'Before linking team 1',
+        'After linking team 1'
+      ])
+    end
+
+    it 'calls the link callbacks when adding a record using append' do
+      bob = Person.first
+      bob.teams.append(Team.find(1))
+
+      expect(bob.audit_log.length).to eq(2)
+      expect(bob.audit_log).to eq([
+        'Before linking team 1',
+        'After linking team 1'
+      ])
+    end
+
+    it 'only calls the Rails callbacks when creating a record on the association using create' do
+      bob = Person.first
+      bob.teams.create(name: 'HR')
+
+      expect(bob.audit_log.length).to eq(2)
+      expect(bob.audit_log).to eq([
+        'Before adding new team',
+        'After adding team 4'
+      ])
+    end
+
+    it 'only calls the Rails callbacks when creating a record on the association using create!' do
+      bob = Person.first
+      bob.teams.create!(name: 'HR')
+
+      expect(bob.audit_log.length).to eq(2)
+      expect(bob.audit_log).to eq([
+        'Before adding new team',
+        'After adding team 4'
+      ])
+    end
+
+    it 'calls the unlink callbacks when removing a record using delete' do
+      bob = Person.first
+      bob.teams.delete(Team.find(3))
+
+      expect(bob.audit_log.length).to eq(2)
+      expect(bob.audit_log).to eq([
+        'Before unlinking team 3',
+        'After unlinking team 3'
+      ])
+    end
+
+    it 'only calls the rails callbacks when removing a record using destroy' do
+      bob = Person.first
+      bob.teams.destroy(3)
+
+      expect(bob.audit_log.length).to eq(2)
+      expect(bob.audit_log).to eq([
+        'Before removing team 3',
+        'After removing team 3'
+      ])
+    end
+
+    it 'calls the regular Rails callbacks after saving' do
+      bob = Person.first
+      bob.teams = [Team.find(1), Team.find(3)]
+      bob.save!
+
+      bob = Person.first
+      bob.teams.delete(Team.find(1))
+      bob.teams << Team.find(2)
+      bob.save!
+
+      expect(bob.audit_log.length).to eq(8)
+      expect(bob.audit_log).to eq([
+        'Before unlinking team 1', 'After unlinking team 1',
+        'Before linking team 2', 'After linking team 2',
+        'Before removing team 1',
+        'After removing team 1',
+        'Before adding team 2',
+        'After adding team 2'
+      ])
+    end
+
+  end
+
   describe 'pending creates & deletes (aka links and unlinks)' do
 
     describe 'pending creates' do
@@ -417,25 +525,6 @@ RSpec.describe 'deferred has-and-belongs-to-many associations' do
 
   end
 
-  it 'should call before_add, after_add, before_remove, after_remove callbacks' do
-    bob = Person.first
-    bob.teams = [Team.first, Team.find(3)]
-    bob.save!
-
-    bob = Person.first
-    bob.teams.delete(bob.teams[0])
-    bob.teams << Team.find(2)
-    bob.save!
-
-    expect(bob.audit_log.length).to eq(4)
-    expect(bob.audit_log).to eq([
-      'Before removing team 1',
-      'After removing team 1',
-      'Before adding team 2',
-      'After adding team 2'
-    ])
-  end
-
   describe 'accepts_nested_attributes' do
     # TODO: Write more tests.
     it 'should mass assign' do

data/spec/support/models.rb

@@ -2,16 +2,19 @@
 
 class Person < ActiveRecord::Base
 
-  deferred_has_and_belongs_to_many :teams, before_add: :add_team,
-                                           after_add: :added_team
-  set_callback :deferred_team_remove, :before, :before_removing_team
-  set_callback :deferred_team_remove, :after, :after_removing_team
+  deferred_has_and_belongs_to_many :teams, before_link: :link_team,
+                                           after_link: :linked_team,
+                                           before_unlink: :unlink_team,
+                                           after_unlink: :unlinked_team,
+                                           before_add: :add_team,
+                                           after_add: :added_team,
+                                           before_remove: :remove_team,
+                                           after_remove: :removed_team
 
   deferred_accepts_nested_attributes_for :teams, allow_destroy: true
 
-  deferred_has_many :issues
-  set_callback :deferred_issue_remove, :before, :before_removing_issue
-  set_callback :deferred_issue_remove, :after, :after_removing_issue
+  deferred_has_many :issues, before_remove: :remove_issue,
+                             after_remove: :removed_issue
 
   validates_presence_of :name
 
@@ -24,28 +27,48 @@ class Person < ActiveRecord::Base
     audit_log
   end
 
+  def link_team(team)
+    log("Before linking team #{team.id}")
+  end
+
+  def linked_team(team)
+    log("After linking team #{team.id}")
+  end
+
+  def unlink_team(team)
+    log("Before unlinking team #{team.id}")
+  end
+
+  def unlinked_team(team)
+    log("After unlinking team #{team.id}")
+  end
+
   def add_team(team)
-    log("Before adding team #{team.id}")
+    if team.new_record?
+      log("Before adding new team")
+    else
+      log("Before adding team #{team.id}")
+    end
   end
 
   def added_team(team)
     log("After adding team #{team.id}")
   end
 
-  def before_removing_team
-    log("Before removing team #{@deferred_team_remove.id}")
+  def remove_team(team)
+    log("Before removing team #{team.id}")
   end
 
-  def after_removing_team
-    log("After removing team #{@deferred_team_remove.id}")
+  def removed_team(team)
+    log("After removing team #{team.id}")
   end
 
-  def before_adding_issue
-    log("Before removing issue #{@deferred_issue_add.id}")
+  def add_issue(issue)
+    log("Before removing issue #{issue.id}")
   end
 
-  def after_adding_issue
-    log("After removing issue #{@deferred_issue_add.id}")
+  def added_issue(issue)
+    log("After removing issue #{issue.id}")
   end
 end
 

metadata

@@ -1,113 +1,100 @@
 --- !ruby/object:Gem::Specification
 name: deferring
 version: !ruby/object:Gem::Version
-  version: 0.0.2
-  prerelease: 
+  version: 0.0.3
 platform: ruby
 authors:
 - Robin Roestenburg
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-06-12 00:00:00.000000000 Z
+date: 2014-07-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>'
+    - - ">"
       - !ruby/object:Gem::Version
         version: '3.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>'
+    - - ">"
       - !ruby/object:Gem::Version
         version: '3.0'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1.3'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1.3'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: sqlite3
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: appraisal
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-description: ! "\n    The Deferring gem makes it possible to defer saving ActiveRecord\n
+description: "\n    The Deferring gem makes it possible to defer saving ActiveRecord\n
   \   associations until the parent object is saved.\n  "
 email:
 - robin@roestenburg.io
@@ -115,9 +102,9 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- .gitignore
-- .rspec
-- .travis.yml
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
 - Appraisals
 - Gemfile
 - LICENSE.txt
@@ -136,6 +123,7 @@ files:
 - gemfiles/rails_41.gemfile.lock
 - lib/deferring.rb
 - lib/deferring/deferred_association.rb
+- lib/deferring/deferred_callback_listener.rb
 - lib/deferring/version.rb
 - spec/lib/deferring_has_many_spec.rb
 - spec/lib/deferring_spec.rb
@@ -143,30 +131,29 @@ files:
 - spec/support/active_record.rb
 - spec/support/models.rb
 - spec/support/rails_versions.rb
-homepage: http://github.com/robinroestenburg/delay_many
+homepage: http://github.com/robinroestenburg/deferring
 licenses:
 - MIT
+metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.23
+rubygems_version: 2.2.2
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: Defer saving ActiveRecord associations until parent is saved
 test_files:
 - spec/lib/deferring_has_many_spec.rb