deferred_associations 0.5.7 → 0.5.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 80ea93f4951198652fc52f31762e2bbfba01b748
-  data.tar.gz: 5ac0e402760f95e2cdca7eda2b2f7be32c20e295
+  metadata.gz: 868bf45a163b6381d3c286bf65251e0b3e6235f6
+  data.tar.gz: 1e12fb0d5b42f22ce07a12f01fe3fab812508779
 SHA512:
-  metadata.gz: ffb66400841e0f0b3ff3c94578c819d6f3048b9992399af672dba43aa46ee9aa80f645dfb543702f471c0de24cbeb677eb5b93e714e9e1f9e641270d276bc4b5
-  data.tar.gz: be23972de665dfbcbe5be755a439ad98816caaf787db53c794311e03da12d7966f198d1b7ca0e8c1f7de5ce3446cccf677b835b9aee42505c10b42eb8dda92f1
+  metadata.gz: 99860be2db82c21a509355252729c0f4b716d1b99e46d2c2203feba4053dc1cc93a758a46d0725fd639c72aaddbe76104f3825e275a5e815bf2e98bdfb46149f
+  data.tar.gz: 216aebba563c6374607036215dec3ee3bc55f1a7d9ccf3863f9cc9aa4c8327571696998567594d05b219df6455ed9888d186e94e334f7b4e18f0a9284fa6926e

data/CHANGELOG

@@ -1,3 +1,7 @@
+0.5.8
+=====
+* fix preloading of HABTM associations in ActiveRecord >= 4.0
+
 0.5.7
 =====
 * fix a problem, when model is loaded multiple times

data/Readme.markdown

@@ -39,7 +39,7 @@ Usage
 Compatibility
 =============
 
-Tested with Rails 2.3.14, 3.2.3, 3.2.14, 4.0 and 4.1 on Ruby 1.8.7, 1.9.3 and JRuby 1.7.12
+Tested with Rails 2.3.18, 3.2.22, 4.1.14, 4.2.5 on Ruby 1.9.3, 2.2.4, 2.3.0 and JRuby 1.7, JRuby 9.0.5.0
 
 Note, that Rails 3.2.14 associations are partly broken under JRuby cause of https://github.com/rails/rails/issues/11595
 You'll need to upgrade activerecord-jdbc-adapter to >= 1.3.0.beta1, if you want to use this combination.
@@ -74,7 +74,7 @@ History
 Most of the code for the habtm association was written by TylerRick for his gem [has_and_belongs_to_many_with_deferred_save](https://github.com/TylerRick/has_and_belongs_to_many_with_deferred_save)
 Mainly, I changed two things:
 
-* added ActiveRecord 3 compatibility
+* added compatibility for ActiveRecord 3 and 4
 * removed singleton methods, because they interfere with caching
 
 License
@@ -82,4 +82,4 @@ License
 
 This plugin is licensed under the BSD license.
 
-2013 (c) Martin Körner
+2016 (c) Martin Körner

data/VERSION

@@ -1 +1 @@
-0.5.5
+0.5.8

data/deferred_associations.gemspec

@@ -1,61 +1,58 @@
-# Generated by jeweler
-# DO NOT EDIT THIS FILE DIRECTLY
-# Instead, edit Jeweler::Tasks in rakefile, and run 'rake gemspec'
 # -*- encoding: utf-8 -*-
 
 Gem::Specification.new do |s|
-  s.name = "deferred_associations"
-  s.version = "0.5.7"
+  s.name = 'deferred_associations'
+  s.version = '0.5.8'
 
-  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
-  s.authors = ["Martin Koerner", "Tyler Rick", "Alessio Caiazza"]
-  s.date = "2013-10-25"
+  s.required_rubygems_version = Gem::Requirement.new('>= 0') if s.respond_to? :required_rubygems_version=
+  s.authors = ['Martin Koerner', 'Tyler Rick', 'Alessio Caiazza']
+  s.date = '2016-03-08'
   s.description = "Makes ActiveRecord defer/postpone saving the records you add to an habtm (has_and_belongs_to_many) or has_many\n                       association until you call model.save, allowing validation in the style of normal attributes. Additionally you\n                       can check inside before_save filters, if the association was altered."
-  s.email = "martin.koerner@objectfab.de"
+  s.email = 'martin.koerner@objectfab.de'
+  s.licenses = 'MIT'
   s.extra_rdoc_files = [
-    "CHANGELOG",
-    "Readme.markdown"
+    'CHANGELOG',
+    'Readme.markdown'
   ]
   s.files = [
-    "CHANGELOG",
-    "Rakefile",
-    "Readme.markdown",
-    "VERSION",
-    "deferred_associations.gemspec",
-    "init.rb",
-    "lib/array_to_association_wrapper.rb",
-    "lib/deferred_associations.rb",
-    "lib/has_and_belongs_to_many_with_deferred_save.rb",
-    "lib/has_many_with_deferred_save.rb",
-    "spec/db/database.yml",
-    "spec/db/schema.rb",
-    "spec/has_and_belongs_to_many_with_deferred_save_spec.rb",
-    "spec/has_many_with_deferred_save_spec.rb",
-    "spec/models/chair.rb",
-    "spec/models/door.rb",
-    "spec/models/person.rb",
-    "spec/models/room.rb",
-    "spec/models/table.rb",
-    "spec/spec_helper.rb"
+    'CHANGELOG',
+    'Readme.markdown',
+    'VERSION',
+    'deferred_associations.gemspec',
+    'init.rb',
+    'lib/array_to_association_wrapper.rb',
+    'lib/deferred_associations.rb',
+    'lib/has_and_belongs_to_many_with_deferred_save.rb',
+    'lib/has_many_with_deferred_save.rb',
+    'spec/db/database.yml',
+    'spec/db/schema.rb',
+    'spec/habtm_ar4_spec.rb',
+    'spec/has_and_belongs_to_many_with_deferred_save_spec.rb',
+    'spec/has_many_with_deferred_save_spec.rb',
+    'spec/models/chair.rb',
+    'spec/models/door.rb',
+    'spec/models/person.rb',
+    'spec/models/room.rb',
+    'spec/models/table.rb',
+    'spec/spec_helper.rb'
   ]
-  s.homepage = "http://github.com/MartinKoerner/deferred_associations"
-  s.require_paths = ["lib"]
-  s.rubygems_version = "1.8.24"
-  s.summary = "Makes ActiveRecord defer/postpone habtm or has_many associations"
+  s.homepage = 'http://github.com/MartinKoerner/deferred_associations'
+  s.require_paths = ['lib']
+  s.rubygems_version = '1.8.24'
+  s.summary = 'Makes ActiveRecord defer/postpone habtm or has_many associations'
 
-  if s.respond_to? :specification_version then
+  if s.respond_to? :specification_version
     s.specification_version = 3
 
-    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
-      s.add_runtime_dependency(%q<activerecord>, [">= 0"])
-      s.add_development_dependency(%q<rspec>, [">= 0"])
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0')
+      s.add_runtime_dependency('activerecord', ['>= 0'])
+      s.add_development_dependency('rspec', ['>= 0'])
     else
-      s.add_dependency(%q<activerecord>, [">= 0"])
-      s.add_dependency(%q<rspec>, [">= 0"])
+      s.add_dependency('activerecord', ['>= 0'])
+      s.add_dependency('rspec', ['>= 0'])
     end
   else
-    s.add_dependency(%q<activerecord>, [">= 0"])
-    s.add_dependency(%q<rspec>, [">= 0"])
+    s.add_dependency('activerecord', ['>= 0'])
+    s.add_dependency('rspec', ['>= 0'])
   end
 end
-

data/lib/array_to_association_wrapper.rb

@@ -1,67 +1,68 @@
-class ArrayToAssociationWrapper < Array
-
-  def defer_association_methods_to owner, association_name
-    @association_owner = owner
-    @association_name = association_name
-  end
-
-  # trick collection_name.include?(obj)
-  # If you use a collection of SingleTableInheritance and didn't :select 'type' the
-  # include? method will not find any subclassed object.
-  def include_with_deferred_save?(obj)
-    if @association_owner.present?
-      if self.detect { |itm| itm == obj || (itm[:id] == obj[:id] && obj.is_a?(itm.class)) }
-        return true
-      else
-        return false
-      end
-    else
-      include_without_deferred_save?(obj)
-    end
-  end
-
-  alias_method_chain :include?, 'deferred_save'
-
-  def find_with_deferred_save *args
-    if @association_owner.present?
-      collection_without_deferred_save.send(:find, *args)
-    else
-      find_without_deferred_save
-    end
-  end
-
-  alias_method_chain :find, :deferred_save
-
-  def first_with_deferred_save *args
-    if @association_owner.present?
-      collection_without_deferred_save.send(:first, *args)
-    else
-      first_without_deferred_save
-    end
-  end
-
-  alias_method_chain :first, :deferred_save
-
-  def last_with_deferred_save *args
-    if @association_owner.present?
-      collection_without_deferred_save.send(:last, *args)
-    else
-      last_without_deferred_save
-    end
-  end
-
-  alias_method_chain :last, :deferred_save
-
-  define_method :method_missing do |method, *args|
-    #puts "#{self.class}.method_missing(#{method}) (#{collection_without_deferred_save.inspect})"
-    if @association_owner.present?
-      collection_without_deferred_save.send(method, *args) unless method == :set_inverse_instance
-    else
-      super
-    end
-  end
-
-  def collection_without_deferred_save
-    @association_owner.send("#{@association_name}_without_deferred_save")
-  end
-end
+class ArrayToAssociationWrapper < Array
+
+  def defer_association_methods_to(owner, association_name)
+    @association_owner = owner
+    @association_name = association_name
+  end
+
+  # trick collection_name.include?(obj)
+  # If you use a collection of SingleTableInheritance and didn't :select 'type' the
+  # include? method will not find any subclassed object.
+  def include_with_deferred_save?(obj)
+    if @association_owner.present?
+      if detect { |itm| itm == obj || (itm[:id] == obj[:id] && obj.is_a?(itm.class)) }
+        return true
+      else
+        return false
+      end
+    else
+      include_without_deferred_save?(obj)
+    end
+  end
+
+  alias_method_chain :include?, 'deferred_save'
+
+  def find_with_deferred_save(*args)
+    if @association_owner.present?
+      collection_without_deferred_save.send(:find, *args)
+    else
+      find_without_deferred_save
+    end
+  end
+
+  alias_method_chain :find, :deferred_save
+
+  def first_with_deferred_save(*args)
+    if @association_owner.present?
+      collection_without_deferred_save.send(:first, *args)
+    else
+      first_without_deferred_save
+    end
+  end
+
+  alias_method_chain :first, :deferred_save
+
+  def last_with_deferred_save(*args)
+    if @association_owner.present?
+      collection_without_deferred_save.send(:last, *args)
+    else
+      last_without_deferred_save
+    end
+  end
+
+  alias_method_chain :last, :deferred_save
+
+  define_method :method_missing do |method, *args|
+    # puts "#{self.class}.method_missing(#{method}) (#{collection_without_deferred_save.inspect})"
+    if @association_owner.present?
+      collection_without_deferred_save.send(method, *args) unless method == :set_inverse_instance
+    else
+      super
+    end
+  end
+
+  def collection_without_deferred_save
+    @association_owner.send("#{@association_name}_without_deferred_save")
+  end
+
+end

data/lib/has_and_belongs_to_many_with_deferred_save.rb

@@ -1,7 +1,6 @@
 module ActiveRecord
   module Associations
     module ClassMethods
-
       # Instructions:
       #
       # Replace your existing call to has_and_belongs_to_many with has_and_belongs_to_many_with_deferred_save.
@@ -17,7 +16,7 @@ module ActiveRecord
       #  end
       def has_and_belongs_to_many_with_deferred_save(*args)
         collection_name = args[0].to_s
-        collection_singular_ids = collection_name.singularize + "_ids"
+        collection_singular_ids = collection_name.singularize + '_ids'
 
         return if method_defined?("#{collection_name}_with_deferred_save")
 
@@ -29,44 +28,40 @@ module ActiveRecord
         attr_accessor :"use_original_collection_reader_behavior_for_#{collection_name}"
 
         define_method "#{collection_name}_with_deferred_save=" do |collection|
-          #puts "has_and_belongs_to_many_with_deferred_save: #{collection_name} = #{collection.collect(&:id).join(',')}"
-          self.send "unsaved_#{collection_name}=", collection
+          # puts "has_and_belongs_to_many_with_deferred_save: #{collection_name} = #{collection.collect(&:id).join(',')}"
+          send "unsaved_#{collection_name}=", collection
         end
 
-        define_method "#{collection_name}_with_deferred_save" do |*args|
-          if self.send("use_original_collection_reader_behavior_for_#{collection_name}")
-            self.send("#{collection_name}_without_deferred_save")
+        define_method "#{collection_name}_with_deferred_save" do |*method_args|
+          if send("use_original_collection_reader_behavior_for_#{collection_name}")
+            send("#{collection_name}_without_deferred_save")
           else
-            if self.send("unsaved_#{collection_name}").nil?
-              send("initialize_unsaved_#{collection_name}", *args)
-            end
-            self.send("unsaved_#{collection_name}")
+            send("initialize_unsaved_#{collection_name}", *method_args) if send("unsaved_#{collection_name}").nil?
+            send("unsaved_#{collection_name}")
           end
         end
 
         alias_method_chain :"#{collection_name}=", 'deferred_save'
         alias_method_chain :"#{collection_name}", 'deferred_save'
 
-        define_method "#{collection_singular_ids}_with_deferred_save" do |*args|
-          if self.send("use_original_collection_reader_behavior_for_#{collection_name}")
-            self.send("#{collection_singular_ids}_without_deferred_save")
+        define_method "#{collection_singular_ids}_with_deferred_save" do |*method_args|
+          if send("use_original_collection_reader_behavior_for_#{collection_name}")
+            send("#{collection_singular_ids}_without_deferred_save")
           else
-            if self.send("unsaved_#{collection_name}").nil?
-              send("initialize_unsaved_#{collection_name}", *args)
-            end
-            self.send("unsaved_#{collection_name}").map { |e| e[:id] }
+            send("initialize_unsaved_#{collection_name}", *method_args) if send("unsaved_#{collection_name}").nil?
+            send("unsaved_#{collection_name}").map { |e| e[:id] }
           end
         end
 
         alias_method_chain :"#{collection_singular_ids}", 'deferred_save'
 
         # only needed for ActiveRecord >= 3.0
-        if ActiveRecord::VERSION::STRING >= "3"
+        if ActiveRecord::VERSION::STRING >= '3'
           define_method "#{collection_singular_ids}_with_deferred_save=" do |ids|
-            ids = Array.wrap(ids).reject { |id| id.blank? }
-            reflection_wrapper = self.send("#{collection_name}_without_deferred_save")
+            ids = Array.wrap(ids).reject(&:blank?)
+            reflection_wrapper = send("#{collection_name}_without_deferred_save")
             new_values = reflection_wrapper.klass.find(ids)
-            self.send("#{collection_name}=", new_values)
+            send("#{collection_name}=", new_values)
           end
           alias_method_chain :"#{collection_singular_ids}=", 'deferred_save'
         end
@@ -82,62 +77,48 @@ module ActiveRecord
           # But we only want the old behavior in this case -- most of the time we want the *new* behavior -- so we use
           # @use_original_collection_reader_behavior as a switch.
 
-          self.send "use_original_collection_reader_behavior_for_#{collection_name}=", true
-          if self.send("unsaved_#{collection_name}").nil?
-            send("initialize_unsaved_#{collection_name}")
-          end
-          self.send "#{collection_name}_without_deferred_save=", self.send("unsaved_#{collection_name}")
-            # /\ This is where the actual save occurs.
-          self.send "use_original_collection_reader_behavior_for_#{collection_name}=", false
+          send "use_original_collection_reader_behavior_for_#{collection_name}=", true
+          send("initialize_unsaved_#{collection_name}") if send("unsaved_#{collection_name}").nil?
+          send "#{collection_name}_without_deferred_save=", send("unsaved_#{collection_name}")
+          # /\ This is where the actual save occurs.
+          send "use_original_collection_reader_behavior_for_#{collection_name}=", false
 
           true
         end
         after_save "do_#{collection_name}_save!"
 
-
-        define_method "reload_with_deferred_save_for_#{collection_name}" do |*args|
+        define_method "reload_with_deferred_save_for_#{collection_name}" do |*method_args|
           # Reload from the *database*, discarding any unsaved changes.
-          self.send("reload_without_deferred_save_for_#{collection_name}", *args).tap do
-            self.send "unsaved_#{collection_name}=", nil
-              # /\ If we didn't do this, then when we called reload, it would still have the same (possibly invalid) value of
-              # unsaved_collection that it had before the reload.
+          send("reload_without_deferred_save_for_#{collection_name}", *method_args).tap do
+            send "unsaved_#{collection_name}=", nil
+            # /\ If we didn't do this, then when we called reload, it would still have the same (possibly invalid) value of
+            # unsaved_collection that it had before the reload.
           end
         end
         alias_method_chain :reload, "deferred_save_for_#{collection_name}"
 
+        define_method "initialize_unsaved_#{collection_name}" do |*method_args|
+          elements = send("#{collection_name}_without_deferred_save", *method_args)
 
-        define_method "initialize_unsaved_#{collection_name}" do |*args|
-          #puts "Initialized to #{self.send("#{collection_name}_without_deferred_save").clone.inspect}"
-          elements = self.send("#{collection_name}_without_deferred_save", *args).clone
+          # here the association will be duped, so changes to "unsaved_#{collection_name}" will not be saved immediately
           elements = ArrayToAssociationWrapper.new(elements)
           elements.defer_association_methods_to self, collection_name
-          self.send "unsaved_#{collection_name}=", elements
-            # /\ We initialize it to collection_without_deferred_save in case they just loaded the object from the
-            # database, in which case we want unsaved_collection to start out with the "saved collection".
-            # Actually, this doesn't clone the Association but the elements array instead (since the clone method is
-            # proxied like any other methods)
-            # Important: If we don't use clone, then it does an assignment by reference and any changes to unsaved_collection
-            # will also change *collection_without_deferred_save*! (Not what we want! Would result in us saving things
-            # immediately, which is exactly what we're trying to avoid.)
-
-
-
+          send "unsaved_#{collection_name}=", elements
         end
         private :"initialize_unsaved_#{collection_name}"
-
       end
 
       def add_deletion_callback
         # this will delete all the association into the join table after obj.destroy,
         # but is only useful/necessary, if the record is not paranoid?
-        unless (self.respond_to?(:paranoid?) && self.paranoid?)
-          after_destroy { |record|
+        unless respond_to?(:paranoid?) && paranoid?
+          after_destroy do |record|
             begin
               record.save
             rescue Exception => e
               logger.warn "Association cleanup after destroy failed with #{e}"
             end
-          }
+          end
         end
       end
     end

data/lib/has_many_with_deferred_save.rb

@@ -1,113 +1,107 @@
-module ActiveRecord
-  module Associations
-    module ClassMethods
-
-      def has_many_with_deferred_save *args
-        collection_name = args[0].to_s
-
-        return if method_defined?("#{collection_name}_with_deferred_save")
-
-        has_many *args
-
-        if args[1].is_a?(Hash) && args[1].keys.include?(:through)
-          logger.warn "You are using the option :through on #{self.name}##{collection_name}. This was not tested very much with has_many_with_deferred_save. Please write many tests for your functionality!"
-        end
-
-        after_save "hmwds_update_#{collection_name}"
-
-        define_obj_setter    collection_name
-        define_obj_getter    collection_name
-        define_id_setter     collection_name
-        define_id_getter     collection_name
-
-        define_update_method collection_name
-        define_reload_method collection_name
-      end
-
-
-      def define_obj_setter collection_name
-
-        define_method("#{collection_name}_with_deferred_save=") do |objs|
-          instance_variable_set "@hmwds_temp_#{collection_name}", objs || []
-        end
-
-        method_name = "#{collection_name}="
-        alias_method_chain method_name, :deferred_save
-      end
-
-      def define_obj_getter collection_name
-
-        define_method("#{collection_name}_with_deferred_save") do
-          save_in_progress = instance_variable_get "@hmwds_#{collection_name}_save_in_progress"
-
-          # while updating the association, rails loads the association object - this needs to be the original one
-          unless save_in_progress
-            elements  = instance_variable_get "@hmwds_temp_#{collection_name}"
-            if elements.nil?
-              elements = ArrayToAssociationWrapper.new(self.send("#{collection_name}_without_deferred_save"))
-              elements.defer_association_methods_to self, collection_name
-              instance_variable_set "@hmwds_temp_#{collection_name}", elements
-            end
-
-            result = elements
-          else
-            result = self.send("#{collection_name}_without_deferred_save")
-          end
-
-          result
-        end
-
-        alias_method_chain collection_name, :deferred_save
-      end
-
-      def define_id_setter collection_name
-        # only needed for ActiveRecord >= 3.0
-        if ActiveRecord::VERSION::STRING >= "3"
-          collection_singular_ids = "#{collection_name.singularize}_ids"
-          define_method "#{collection_singular_ids}_with_deferred_save=" do |ids|
-            ids = Array.wrap(ids).reject { |id| id.blank? }
-            new_values = self.send("#{collection_name}_without_deferred_save").klass.find(ids)
-            self.send("#{collection_name}=", new_values)
-          end
-          alias_method_chain :"#{collection_singular_ids}=", 'deferred_save'
-        end
-      end
-
-      def define_id_getter collection_name
-        collection_singular_ids = "#{collection_name.singularize}_ids"
-        define_method "#{collection_singular_ids}_with_deferred_save" do
-          self.send(collection_name).map { |e| e[:id] }
-        end
-        alias_method_chain :"#{collection_singular_ids}", 'deferred_save'
-      end
-
-      def define_update_method collection_name
-
-        define_method "hmwds_update_#{collection_name}" do
-
-          unless frozen?
-            elements = instance_variable_get "@hmwds_temp_#{collection_name}"
-            unless elements.nil? # nothing has been done with the association
-              # save is done automatically, if original behaviour is restored
-              instance_variable_set "@hmwds_#{collection_name}_save_in_progress", true
-              self.send("#{collection_name}_without_deferred_save=", elements)
-              instance_variable_set "@hmwds_#{collection_name}_save_in_progress", false
-
-              instance_variable_set "@hmwds_temp_#{collection_name}", nil
-            end
-          end
-        end
-      end
-
-      def define_reload_method collection_name
-        define_method "reload_with_deferred_save_for_#{collection_name}" do |*args|
-          # Reload from the *database*, discarding any unsaved changes.
-          self.send("reload_without_deferred_save_for_#{collection_name}", *args).tap do
-            instance_variable_set "@hmwds_temp_#{collection_name}", nil
-          end
-        end
-        alias_method_chain :reload, "deferred_save_for_#{collection_name}"
-      end
-    end
-  end
-end
+module ActiveRecord
+  module Associations
+    module ClassMethods
+      def has_many_with_deferred_save(*args)
+        collection_name = args[0].to_s
+
+        return if method_defined?("#{collection_name}_with_deferred_save")
+
+        has_many *args
+
+        if args[1].is_a?(Hash) && args[1].keys.include?(:through)
+          logger.warn "You are using the option :through on #{name}##{collection_name}. This was not tested very much with has_many_with_deferred_save. Please write many tests for your functionality!"
+        end
+
+        after_save "hmwds_update_#{collection_name}"
+
+        define_obj_setter    collection_name
+        define_obj_getter    collection_name
+        define_id_setter     collection_name
+        define_id_getter     collection_name
+
+        define_update_method collection_name
+        define_reload_method collection_name
+      end
+
+      def define_obj_setter(collection_name)
+        define_method("#{collection_name}_with_deferred_save=") do |objs|
+          instance_variable_set "@hmwds_temp_#{collection_name}", objs || []
+        end
+
+        method_name = "#{collection_name}="
+        alias_method_chain method_name, :deferred_save
+      end
+
+      def define_obj_getter(collection_name)
+        define_method("#{collection_name}_with_deferred_save") do
+          save_in_progress = instance_variable_get "@hmwds_#{collection_name}_save_in_progress"
+
+          # while updating the association, rails loads the association object - this needs to be the original one
+          unless save_in_progress
+            elements = instance_variable_get "@hmwds_temp_#{collection_name}"
+            if elements.nil?
+              elements = ArrayToAssociationWrapper.new(send("#{collection_name}_without_deferred_save"))
+              elements.defer_association_methods_to self, collection_name
+              instance_variable_set "@hmwds_temp_#{collection_name}", elements
+            end
+
+            result = elements
+          else
+            result = send("#{collection_name}_without_deferred_save")
+          end
+
+          result
+        end
+
+        alias_method_chain collection_name, :deferred_save
+      end
+
+      def define_id_setter(collection_name)
+        # only needed for ActiveRecord >= 3.0
+        if ActiveRecord::VERSION::STRING >= '3'
+          collection_singular_ids = "#{collection_name.singularize}_ids"
+          define_method "#{collection_singular_ids}_with_deferred_save=" do |ids|
+            ids = Array.wrap(ids).reject(&:blank?)
+            new_values = send("#{collection_name}_without_deferred_save").klass.find(ids)
+            send("#{collection_name}=", new_values)
+          end
+          alias_method_chain :"#{collection_singular_ids}=", 'deferred_save'
+        end
+      end
+
+      def define_id_getter(collection_name)
+        collection_singular_ids = "#{collection_name.singularize}_ids"
+        define_method "#{collection_singular_ids}_with_deferred_save" do
+          send(collection_name).map { |e| e[:id] }
+        end
+        alias_method_chain :"#{collection_singular_ids}", 'deferred_save'
+      end
+
+      def define_update_method(collection_name)
+        define_method "hmwds_update_#{collection_name}" do
+          unless frozen?
+            elements = instance_variable_get "@hmwds_temp_#{collection_name}"
+            unless elements.nil? # nothing has been done with the association
+              # save is done automatically, if original behaviour is restored
+              instance_variable_set "@hmwds_#{collection_name}_save_in_progress", true
+              send("#{collection_name}_without_deferred_save=", elements)
+              instance_variable_set "@hmwds_#{collection_name}_save_in_progress", false
+
+              instance_variable_set "@hmwds_temp_#{collection_name}", nil
+            end
+          end
+        end
+      end
+
+      def define_reload_method(collection_name)
+        define_method "reload_with_deferred_save_for_#{collection_name}" do |*args|
+          # Reload from the *database*, discarding any unsaved changes.
+          send("reload_without_deferred_save_for_#{collection_name}", *args).tap do
+            instance_variable_set "@hmwds_temp_#{collection_name}", nil
+          end
+        end
+        alias_method_chain :reload, "deferred_save_for_#{collection_name}"
+      end
+    end
+  end
+end