deferred_associations 0.5.4 → 0.5.5

data/CHANGELOG

@@ -1,3 +1,8 @@
+0.5.5
+=====
+* id-setter for has_many associations couldn't be used twice on the same object
+* id-getter for has_many associations always returned the saved IDs, even if a new array was set
+
 0.5.0
 =====
 * Added has_many with deferred save, which works like habtm with deferred save

data/Rakefile

@@ -1,26 +1,27 @@
-task :default do |t|
-  options = "--colour"
-  files = FileList['spec/**/*_spec.rb'].map{|f| f.sub(%r{^spec/},'') }
-  exit system("cd spec && spec #{options} #{files}") ? 0 : 1
-end
-
-begin
-  require 'jeweler'
-  project_name = 'deferred_associations'
-  Jeweler::Tasks.new do |gem|
-    gem.name = project_name
-    gem.summary = "Makes ActiveRecord defer/postpone habtm or has_many associations"
-    gem.description = "Makes ActiveRecord defer/postpone saving the records you add to an habtm (has_and_belongs_to_many) or has_many
-                       association until you call model.save, allowing validation in the style of normal attributes. Additionally you
-                       can check inside before_save filters, if the association was altered."
-    gem.homepage = "http://github.com/MartinKoerner/deferred_associations"
-    gem.email   = "martin.koerner@objectfab.de"
-    gem.authors = ["Martin Koerner", "Tyler Rick", "Alessio Caiazza"]
-    gem.add_dependency('activerecord')
-    gem.add_development_dependency('rspec')
-  end
-
-  Jeweler::GemcutterTasks.new
-rescue LoadError
-  puts "Jeweler, or one of its dependencies, is not available. Install it with: sudo gem install technicalpickles-jeweler -s http://gems.github.com"
-end
+task :default do |t|
+  options = "--colour"
+  files = FileList['spec/**/*_spec.rb'].map{|f| f.sub(%r{^spec/},'') }
+  exit system("cd spec && spec #{options} #{files}") ? 0 : 1
+end
+
+begin
+  require 'jeweler'
+  project_name = 'deferred_associations'
+  Jeweler::Tasks.new do |gem|
+    gem.name = project_name
+    gem.summary = "Makes ActiveRecord defer/postpone habtm or has_many associations"
+    gem.description = "Makes ActiveRecord defer/postpone saving the records you add to an habtm (has_and_belongs_to_many) or has_many
+                       association until you call model.save, allowing validation in the style of normal attributes. Additionally you
+                       can check inside before_save filters, if the association was altered."
+    gem.homepage = "http://github.com/MartinKoerner/deferred_associations"
+    gem.email   = "martin.koerner@objectfab.de"
+    gem.authors = ["Martin Koerner", "Tyler Rick", "Alessio Caiazza"]
+    gem.add_dependency('activerecord')
+    gem.add_development_dependency('rspec')
+    gem.files.exclude 'gemfiles/*', '.travis.yml'
+  end
+
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler, or one of its dependencies, is not available. Install it with: sudo gem install technicalpickles-jeweler -s http://gems.github.com"
+end

data/Readme.markdown

@@ -1,82 +1,85 @@
-Make ActiveRecord defer/postpone saving the records you add to an habtm (has_and_belongs_to_many) or has_many association
-until you call model.save, allowing validation in the style of normal attributes.
-
-[![Build Status](https://secure.travis-ci.org/MartinKoerner/deferred_associations.png?branch=master)](http://travis-ci.org/MartinKoerner/deferred_associations) [![Dependency Status](https://gemnasium.com/MartinKoerner/deferred_associations.png?travis)](https://gemnasium.com/MartinKoerner/deferred_associations)
-
-How to install
-==============
-
-    gem install deferred_associations
-
-Usage
-=====
-
-    class Room < ActiveRecord::Base
-      has_and_belongs_to_many_with_deferred_save :people
-      has_many_with_deferred_save :tables
-
-      validate :usage
-      before_save :check_change
-
-      def usage
-        if people.size > 30
-          errors.add :people, "There are too many people in this room"
-        end
-        if tables.size > 15
-          errors.add :tables, "There are too many tables in this room"
-        end
-        # Neither people nor tables are saved to the database, if a validation error is added
-      end
-
-      def check_change
-        # you can check, if there were changes to the association
-        if people != people_without_deferred_save
-          self.updated_at = Time.now.utc
-        end
-      end
-    end
-
-Compatibility
-=============
-
-Tested with Rails 2.3.14, 3.2.3 on Ruby 1.8.7, 1.9.3 and JRuby 1.6.6
-
-Gotchas
-=======
-
-Be aware, that the habtm association objects sometimes asks the database instead of giving you the data directly from the array. So you can get something
-like
-
-    room = Room.create
-    room.people << Person.create
-    room.people.first # => nil, since the DB doesn't have the association saved yet
-
-
-Also it is good to know, that the array you set to an association is stored there directly, so after setting a list, the typical association
-methods are not working:
-
-    room = Room.create
-    room.people.klass   # => Person
-    room.people = [Person.first]
-    room.people.klass   # => undefined method klass for #Array:0x007fa3b9efc2c0`
-
-Bugs
-====
-
-http://github.com/MartinKoerner/deferred_associations/issues
-
-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
-* removed singleton methods, because they interfere with caching
-
-License
-=======
-
-This plugin is licensed under the BSD license.
-
-2012 (c) Martin Körner
+Make ActiveRecord defer/postpone saving the records you add to an habtm (has_and_belongs_to_many) or has_many association
+until you call model.save, allowing validation in the style of normal attributes.
+
+[![Build Status](https://secure.travis-ci.org/MartinKoerner/deferred_associations.png?branch=master)](http://travis-ci.org/MartinKoerner/deferred_associations) [![Dependency Status](https://gemnasium.com/MartinKoerner/deferred_associations.png?travis)](https://gemnasium.com/MartinKoerner/deferred_associations)
+
+How to install
+==============
+
+    gem install deferred_associations
+
+Usage
+=====
+
+    class Room < ActiveRecord::Base
+      has_and_belongs_to_many_with_deferred_save :people
+      has_many_with_deferred_save :tables
+
+      validate :usage
+      before_save :check_change
+
+      def usage
+        if people.size > 30
+          errors.add :people, "There are too many people in this room"
+        end
+        if tables.size > 15
+          errors.add :tables, "There are too many tables in this room"
+        end
+        # Neither people nor tables are saved to the database, if a validation error is added
+      end
+
+      def check_change
+        # you can check, if there were changes to the association
+        if people != people_without_deferred_save
+          self.updated_at = Time.now.utc
+        end
+      end
+    end
+
+Compatibility
+=============
+
+Tested with Rails 2.3.14, 3.2.3, 3.2.14 on Ruby 1.8.7, 1.9.3 and JRuby 1.7.4
+
+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.
+
+Gotchas
+=======
+
+Be aware, that the habtm association objects sometimes asks the database instead of giving you the data directly from the array. So you can get something
+like
+
+    room = Room.create
+    room.people << Person.create
+    room.people.first # => nil, since the DB doesn't have the association saved yet
+
+
+Also it is good to know, that the array you set to an association is stored there directly, so after setting a list, the typical association
+methods are not working:
+
+    room = Room.create
+    room.people.klass   # => Person
+    room.people = [Person.first]
+    room.people.klass   # => undefined method klass for #Array:0x007fa3b9efc2c0`
+
+Bugs
+====
+
+http://github.com/MartinKoerner/deferred_associations/issues
+
+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
+* removed singleton methods, because they interfere with caching
+
+License
+=======
+
+This plugin is licensed under the BSD license.
+
+2013 (c) Martin Körner

data/VERSION

@@ -1 +1 @@
-0.5.4
+0.5.5

data/deferred_associations.gemspec

@@ -1,75 +1,61 @@
-# Generated by jeweler
-# DO NOT EDIT THIS FILE
-# 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.4"
-
-  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 = "2012-04-23"
-  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.files = [
-    ".gitignore",
-     ".travis.yml",
-     "CHANGELOG",
-     "Rakefile",
-     "Readme.markdown",
-     "VERSION",
-     "deferred_associations.gemspec",
-     "gemfiles/ar2.3.14.gemfile",
-     "gemfiles/ar2.3.14.gemfile.lock",
-     "gemfiles/ar3.2.3.gemfile",
-     "gemfiles/ar3.2.3.gemfile.lock",
-     "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/.gitignore",
-     "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"
-  ]
-  s.homepage = "http://github.com/MartinKoerner/deferred_associations"
-  s.rdoc_options = ["--charset=UTF-8"]
-  s.require_paths = ["lib"]
-  s.rubygems_version = "1.8.15"
-  s.summary = "Makes ActiveRecord defer/postpone habtm or has_many associations"
-  s.test_files = [
-    "spec/has_and_belongs_to_many_with_deferred_save_spec.rb",
-     "spec/has_many_with_deferred_save_spec.rb",
-     "spec/spec_helper.rb",
-     "spec/db/schema.rb",
-     "spec/models/chair.rb",
-     "spec/models/door.rb",
-     "spec/models/person.rb",
-     "spec/models/room.rb",
-     "spec/models/table.rb"
-  ]
-
-  if s.respond_to? :specification_version then
-    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"])
-    else
-      s.add_dependency(%q<activerecord>, [">= 0"])
-      s.add_dependency(%q<rspec>, [">= 0"])
-    end
-  else
-    s.add_dependency(%q<activerecord>, [">= 0"])
-    s.add_dependency(%q<rspec>, [">= 0"])
-  end
-end
+# 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.5"
+
+  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.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.extra_rdoc_files = [
+    "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"
+  ]
+  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
+    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"])
+    else
+      s.add_dependency(%q<activerecord>, [">= 0"])
+      s.add_dependency(%q<rspec>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<activerecord>, [">= 0"])
+    s.add_dependency(%q<rspec>, [">= 0"])
+  end
+end
+

data/init.rb

@@ -1 +1 @@
-require 'deferred_associations'
+require 'deferred_associations'

data/lib/has_and_belongs_to_many_with_deferred_save.rb

@@ -1,142 +1,142 @@
-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.
-      #
-      # Then add a validation method that adds an error if there is something wrong with the (unsaved) collection. This will prevent it from being saved if there are any errors.
-      #
-      # Example:
-      #
-      #  def validate
-      #    if people.size > maximum_occupancy
-      #      errors.add :people, "There are too many people in this room"
-      #    end
-      #  end
-      def has_and_belongs_to_many_with_deferred_save(*args)
-        has_and_belongs_to_many *args
-        collection_name = args[0].to_s
-        collection_singular_ids = collection_name.singularize + "_ids"
-
-        add_deletion_callback
-
-        attr_accessor :"unsaved_#{collection_name}"
-        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
-        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")
-          else
-            if self.send("unsaved_#{collection_name}").nil?
-              send("initialize_unsaved_#{collection_name}", *args)
-            end
-            self.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")
-          else
-            if self.send("unsaved_#{collection_name}").nil?
-              send("initialize_unsaved_#{collection_name}", *args)
-            end
-            self.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"
-          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")
-            new_values = reflection_wrapper.klass.find(ids)
-            self.send("#{collection_name}=", new_values)
-          end
-          alias_method_chain :"#{collection_singular_ids}=", 'deferred_save'
-        end
-
-        define_method "do_#{collection_name}_save!" do
-          # Question: Why do we need this @use_original_collection_reader_behavior stuff?
-          # Answer: Because AssociationCollection#replace(other_array) performs a diff between current_array and other_array and deletes/adds only
-          # records that have changed.
-          # In order to perform that diff, it needs to figure out what "current_array" is, so it calls our collection_with_deferred_save, not
-          # knowing that we've changed its behavior. It expects that method to return the elements of that collection that are in the *database*
-          # (the original behavior), so we have to provide that behavior...  If we didn't provide it, it would end up trying to take the diff of
-          # two identical collections so nothing would ever get saved.
-          # 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
-
-          true
-        end
-        after_save "do_#{collection_name}_save!"
-
-
-        define_method "reload_with_deferred_save_for_#{collection_name}" do
-          # Reload from the *database*, discarding any unsaved changes.
-          self.send("reload_without_deferred_save_for_#{collection_name}").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.
-          end
-        end
-        alias_method_chain :"reload", "deferred_save_for_#{collection_name}"
-
-
-        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
-          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.)
-
-
-
-        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|
-            begin
-              record.save
-            rescue Exception => e
-              logger.warn "Association cleanup after destroy failed with #{e}"
-            end
-          }
-        end
-      end
-    end
-  end
-end
+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.
+      #
+      # Then add a validation method that adds an error if there is something wrong with the (unsaved) collection. This will prevent it from being saved if there are any errors.
+      #
+      # Example:
+      #
+      #  def validate
+      #    if people.size > maximum_occupancy
+      #      errors.add :people, "There are too many people in this room"
+      #    end
+      #  end
+      def has_and_belongs_to_many_with_deferred_save(*args)
+        has_and_belongs_to_many *args
+        collection_name = args[0].to_s
+        collection_singular_ids = collection_name.singularize + "_ids"
+
+        add_deletion_callback
+
+        attr_accessor :"unsaved_#{collection_name}"
+        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
+        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")
+          else
+            if self.send("unsaved_#{collection_name}").nil?
+              send("initialize_unsaved_#{collection_name}", *args)
+            end
+            self.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")
+          else
+            if self.send("unsaved_#{collection_name}").nil?
+              send("initialize_unsaved_#{collection_name}", *args)
+            end
+            self.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"
+          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")
+            new_values = reflection_wrapper.klass.find(ids)
+            self.send("#{collection_name}=", new_values)
+          end
+          alias_method_chain :"#{collection_singular_ids}=", 'deferred_save'
+        end
+
+        define_method "do_#{collection_name}_save!" do
+          # Question: Why do we need this @use_original_collection_reader_behavior stuff?
+          # Answer: Because AssociationCollection#replace(other_array) performs a diff between current_array and other_array and deletes/adds only
+          # records that have changed.
+          # In order to perform that diff, it needs to figure out what "current_array" is, so it calls our collection_with_deferred_save, not
+          # knowing that we've changed its behavior. It expects that method to return the elements of that collection that are in the *database*
+          # (the original behavior), so we have to provide that behavior...  If we didn't provide it, it would end up trying to take the diff of
+          # two identical collections so nothing would ever get saved.
+          # 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
+
+          true
+        end
+        after_save "do_#{collection_name}_save!"
+
+
+        define_method "reload_with_deferred_save_for_#{collection_name}" do
+          # Reload from the *database*, discarding any unsaved changes.
+          self.send("reload_without_deferred_save_for_#{collection_name}").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.
+          end
+        end
+        alias_method_chain :"reload", "deferred_save_for_#{collection_name}"
+
+
+        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
+          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.)
+
+
+
+        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|
+            begin
+              record.save
+            rescue Exception => e
+              logger.warn "Association cleanup after destroy failed with #{e}"
+            end
+          }
+        end
+      end
+    end
+  end
+end