deferred_associations 0.5.0

data/CHANGELOG

@@ -0,0 +1,21 @@
+0.5.0
+=====
+* Added has_many with deferred save, which works like habtm with deferred save
+* Added id setters for AR >= 3.0 compatibility
+* HABTMs are changed in an after_save instead of before_save, dropping the need of
+  special before_save call sequences
+
+0.4.0
+=====
+* Added Rails 3.2.2 compatibility
+* used "before_save :callback" instead of redefining "before_save"
+
+0.3.0
+=====
+* method "last" proxies to collections "last" instead of "first"
+* removed singleton methods into a wrapper array
+* renamed to "deferred_associations"
+
+0.2.0
+=====
+* forked from TylerRick

data/Rakefile

@@ -0,0 +1,26 @@
+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 Körner", "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

data/Readme.markdown

@@ -0,0 +1,70 @@
+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.
+
+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_usage
+        # 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.2
+
+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.new
+    room.people << Person.create
+    room.people.first # => nil, since the DB doesn't have the association saved yet
+
+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](https://github.com/TylerRick/has_and_belongs_to_many_with_deferred)
+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

data/VERSION

@@ -0,0 +1 @@
+0.5.0

data/has_and_belongs_to_many_with_deferred_save.gemspec

@@ -0,0 +1,63 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{deferred_associations}
+  s.version = "0.4.0"
+
+  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 = %q{2012-03-18}
+  s.files = [
+    ".gitignore",
+     "Rakefile",
+     "Readme.markdown",
+     "VERSION",
+     "has_and_belongs_to_many_with_deferred_save.gemspec",
+     "init.rb",
+     "install.rb",
+     "lib/has_and_belongs_to_many_with_deferred_save.rb",
+     "lib/array_to_association_wrapper.rb",
+     "spec/.gitignore",
+     "spec/db/database.yml",
+     "spec/db/schema.rb",
+     "spec/has_and_belongs_to_many_with_deferred_save_spec.rb",
+     "spec/models/door.rb",
+     "spec/models/person.rb",
+     "spec/models/room.rb",
+     "spec/spec_helper.rb",
+     "uninstall.rb"
+  ]
+  s.homepage = %q{http://github.com/neogrande/deferred_associations}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.5}
+  s.summary = %q{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.}
+  s.test_files = [
+    "spec/models/door.rb",
+     "spec/models/room.rb",
+     "spec/models/person.rb",
+     "spec/has_and_belongs_to_many_with_deferred_save_spec.rb",
+     "spec/spec_helper.rb",
+     "spec/db/schema.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= 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

@@ -0,0 +1,3 @@
+require File.join(File.dirname(__FILE__), 'lib/array_to_association_wrapper')
+require File.join(File.dirname(__FILE__), 'lib/has_and_belongs_to_many_with_deferred_save')
+require File.join(File.dirname(__FILE__), 'lib/has_many_with_deferred_save')

data/install.rb

@@ -0,0 +1 @@
+# Install hook code here

data/lib/array_to_association_wrapper.rb

@@ -0,0 +1,67 @@
+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

data/lib/has_and_belongs_to_many_with_deferred_save.rb

@@ -0,0 +1,144 @@
+# To do: make it work to call this twice in a class. Currently that probably wouldn't work, because it would try to alias methods to existing names...
+# Note: before_save must be defined *before* including this module, not after.
+
+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? }
+            new_values = self.send("#{collection_name}").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

data/lib/has_many_with_deferred_save.rb

@@ -0,0 +1,102 @@
+module ActiveRecord
+  module Associations
+    module ClassMethods
+
+      def has_many_with_deferred_save *args
+        has_many *args
+
+        collection_name         = args[0].to_s
+
+        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_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}").klass.find(ids)
+            self.send("#{collection_name}=", new_values)
+          end
+          alias_method_chain :"#{collection_singular_ids}=", 'deferred_save'
+        end
+      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
+          # Reload from the *database*, discarding any unsaved changes.
+          self.send("reload_without_deferred_save_for_#{collection_name}").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

data/spec/.gitignore

@@ -0,0 +1,2 @@
+*.log
+*.db

data/spec/db/database.yml

@@ -0,0 +1,21 @@
+sqlite3:
+  adapter: sqlite3
+  database: test.sqlite3.db
+
+sqlite3mem:
+  adapter: sqlite3
+  database: ":memory:"
+
+postgresql:
+  adapter: postgresql
+  username: postgres
+  password: postgres
+  database: has_and_belongs_to_many_with_deferred_save_test
+  min_messages: ERROR
+
+mysql:
+  adapter: mysql
+  host: localhost
+  username: root
+  password:
+  database: has_and_belongs_to_many_with_deferred_save_test

data/spec/db/schema.rb

@@ -0,0 +1,40 @@
+# This file is autogenerated. Instead of editing this file, please use the
+# migrations feature of ActiveRecord to incrementally modify your database, and
+# then regenerate this schema definition.
+
+ActiveRecord::Schema.define(:version => 1) do
+
+  create_table "people", :force => true do |t|
+    t.column "name", :string
+  end
+
+  create_table "people_rooms", :id => false, :force => true do |t|
+    t.column "person_id", :integer
+    t.column "room_id",   :integer
+  end
+
+  create_table "rooms", :force => true do |t|
+    t.column "name",              :string
+    t.column "maximum_occupancy", :integer
+  end
+
+  create_table "doors_rooms", :id => false, :force => true do |t|
+    t.column "door_id",   :integer
+    t.column "room_id",   :integer
+  end
+
+  create_table "doors", :force => true do |t|
+    t.column "name",              :string
+  end
+
+  create_table "tables", :force => true do |t|
+    t.column "name", :string
+    t.column "room_id", :integer
+  end
+
+  create_table "chairs", :force => true do |t|
+    t.column "name", :string
+    t.column "table_id", :integer
+  end
+
+end

data/spec/has_and_belongs_to_many_with_deferred_save_spec.rb

@@ -0,0 +1,214 @@
+require "spec_helper"
+require 'has_and_belongs_to_many_with_deferred_save'
+
+describe "has_and_belongs_to_many_with_deferred_save" do
+  describe "room maximum_occupancy" do
+    before :all do
+      @people = []
+      @people << Person.create(:name => 'Filbert')
+      @people << Person.create(:name => 'Miguel')
+      @people << Person.create(:name => 'Rainer')
+      @room = Room.new(:maximum_occupancy => 2)
+    end
+    after :all do
+      Person.delete_all
+      Room.delete_all
+    end
+
+    it "passes initial checks" do
+      Room  .count.should == 0
+      Person.count.should == 3
+
+      @room.people.should == []
+      @room.people_without_deferred_save.should == []
+      @room.people_without_deferred_save.object_id.should_not ==
+        @room.unsaved_people.object_id
+    end
+
+    it "after adding people to room, it should not have saved anything to the database" do
+      @room.people << @people[0]
+      @room.people << @people[1]
+
+      # Still not saved to the association table!
+      Room.count_by_sql("select count(*) from people_rooms").should == 0
+      @room.people_without_deferred_save.size.               should == 0
+    end
+
+    it "but room.people.size should still report the current size of 2" do
+      @room.people.size.should == 2        # 2 because this looks at unsaved_people and not at the database
+    end
+
+    it "after saving the model, the association should be saved in the join table" do
+      @room.save    # Only here is it actually saved to the association table!
+      @room.errors.full_messages.should == []
+      Room.count_by_sql("select count(*) from people_rooms").should == 2
+      @room.people.size.                                     should == 2
+      @room.people_without_deferred_save.size.               should == 2
+    end
+
+    it "when we try to add a 3rd person, it should add a validation error to the errors object like any other validation error" do
+      lambda { @room.people << @people[2] }.should_not raise_error
+      @room.people.size.       should == 3
+
+      Room.count_by_sql("select count(*) from people_rooms").should == 2
+      @room.valid?
+      @room.get_error(:people).should == "This room has reached its maximum occupancy"
+      @room.people.size.       should == 3 # Just like with normal attributes that fail validation... the attribute still contains the invalid data but we refuse to save until it is changed to something that is *valid*.
+    end
+
+    it "when we try to save, it should fail, because room.people is still invalid" do
+      @room.save.should == false
+      Room.count_by_sql("select count(*) from people_rooms").should == 2 # It's still not there, because it didn't pass the validation.
+      @room.get_error(:people).should == "This room has reached its maximum occupancy"
+      @room.people.size.       should == 3
+      @people.map {|p| p.reload; p.rooms.size}.should == [1, 1, 0]
+    end
+
+    it "when we reload, it should go back to only having 2 people in the room" do
+      @room.reload
+      @room.people.size.                                     should == 2
+      @room.people_without_deferred_save.size.               should == 2
+      @people.map {|p| p.reload; p.rooms.size}.                        should == [1, 1, 0]
+    end
+
+    it "if they try to go around our accessors and use the original accessors, then (and only then) will the exception be raised in before_adding_person..." do
+      lambda do
+        @room.people_without_deferred_save << @people[2]
+      end.should raise_error(RuntimeError)
+    end
+
+    it "lets you bypass the validation on Room if we add the association from the other side (person.rooms <<)?" do
+      @people[2].rooms << @room
+      @people[2].rooms.size.should == 1
+
+      # Adding it from one direction does not add it to the other object's association (@room.people), so the validation passes.
+      @room.reload.people.size.should == 2
+      @people[2].valid?
+      @people[2].errors.full_messages.should == []
+      @people[2].save.should == true
+
+      # It is only after reloading that @room.people has this 3rd object, causing it to be invalid, and by then it's too late to do anything about it.
+      @room.reload.people.size.should == 3
+      @room.valid?.should == false
+    end
+
+    it "only if you add the validation to both sides, can you ensure that the size of the association does not exceed some limit" do
+      @room.reload.people.size.should == 3
+      @room.people.delete(@people[2])
+      @room.save.should == true
+      @room.reload.people.size.should == 2
+      @people[2].reload.rooms.size.should == 0
+
+      obj = @people[2]
+      def obj.extra_validation
+        rooms.each do |room|
+          this_room_unsaved = rooms_without_deferred_save.include?(room) ? 0 : 1
+          if room.people.size + this_room_unsaved > room.maximum_occupancy
+            errors.add :rooms, "This room has reached its maximum occupancy"
+          end
+        end
+      end
+      obj.class.send(:validate, :extra_validation)
+
+      @people[2].rooms << @room
+      @people[2].rooms.size.should == 1
+
+      @room.reload.people.size.should == 2
+      @people[2].valid?.should be_false
+      @people[2].get_error(:rooms).should == "This room has reached its maximum occupancy"
+      @room.reload.people.size.should == 2
+    end
+
+    it "still lets you do find" do
+      @room.people2.                     find(:first, :conditions => {:name => 'Filbert'}).should == @people[0]
+      @room.people_without_deferred_save.find(:first, :conditions => {:name => 'Filbert'}).should == @people[0]
+      @room.people2.first(:conditions                      => {:name => 'Filbert'}).should == @people[0]
+      @room.people_without_deferred_save.first(:conditions => {:name => 'Filbert'}).should == @people[0]
+      @room.people_without_deferred_save.find_by_name('Filbert').should == @people[0]
+
+      @room.people.find(:first, :conditions => {:name => 'Filbert'}).should == @people[0]
+      @room.people.first(:conditions => {:name => 'Filbert'}).       should == @people[0]
+      @room.people.last(:conditions => {:name => 'Filbert'}).        should == @people[0]
+      @room.people.first.                                            should == @people[0]
+      @room.people.last.                                             should == @people[1] # @people[2] was removed before
+      @room.people.find_by_name('Filbert').                          should == @people[0]
+    end
+
+    it "should be dumpable with Marshal" do
+      lambda { Marshal.dump(@room.people) }.should_not raise_exception
+      lambda { Marshal.dump(Room.new.people) }.should_not raise_exception
+    end
+
+    it "should detect difference in association" do
+      @room = Room.find(@room.id)
+      @room.bs_diff_before_module.should be_nil
+      @room.bs_diff_after_module.should  be_nil
+      @room.bs_diff_method.should        be_nil
+
+      @room.people.size.should == 2
+      @room.people = [@room.people[0]]
+      @room.save.should be_true
+
+      @room.bs_diff_before_module.should be_true
+      @room.bs_diff_after_module.should  be_true
+      if ActiveRecord::VERSION::STRING >= "3"
+        @room.bs_diff_method.should      be_nil # Rails 3.2: nil (before_save filter is not supported)
+      else
+        @room.bs_diff_method.should      be_true
+      end
+    end
+
+    it "should act like original habtm when using ID array with array manipulation" do
+      @room = Room.find(@room.id)
+      @room.people = [@people[0]]
+      @room.save
+      @room = Room.find(@room.id) # we don't want to let id and object setters interfere with each other
+      @room.people2_ids << @people[1].id
+      @room.people2_ids.should == [@people[0].id] # ID array manipulation is ignored
+
+      @room.person_ids.size.should == 1
+      @room.person_ids << @people[1].id
+      @room.person_ids.should == [@people[0].id]
+      Room.find(@room.id).person_ids.should == [@people[0].id]
+      @room.save.should be_true
+      Room.find(@room.id).person_ids.should == [@people[0].id] # ID array manipulation is ignored, too
+    end
+
+    it "should work with id setters" do
+      @room = Room.find(@room.id)
+      @room.people = [@people[0], @people[1]]
+      @room.save
+      @room = Room.find(@room.id)
+      @room.person_ids.should == [@people[0].id, @people[1].id]
+      @room.person_ids = [@people[1].id]
+      @room.person_ids.should == [@people[1].id]
+      Room.find(@room.id).person_ids.should == [@people[0].id,@people[1].id]
+      @room.save.should be_true
+      Room.find(@room.id).person_ids.should == [@people[1].id]
+    end
+  end
+
+  describe "doors" do
+    before :all do
+      @rooms = []
+      @rooms << Room.create(:name => 'Kitchen',     :maximum_occupancy => 1)
+      @rooms << Room.create(:name => 'Dining room', :maximum_occupancy => 10)
+      @door =   Door.new(:name => 'Kitchen-Dining-room door')
+    end
+
+    it "passes initial checks" do
+      Room.count.should == 2
+      Door.count.should == 0
+
+      @door.rooms.should == []
+      @door.rooms_without_deferred_save.should == []
+    end
+
+    it "the association has an include? method" do
+      @door.rooms << @rooms[0]
+      @door.rooms.include?(@rooms[0]).should be_true
+      @door.rooms.include?(@rooms[1]).should be_false
+    end
+  end
+
+end

data/spec/has_many_with_deferred_save_spec.rb

@@ -0,0 +1,77 @@
+require 'spec_helper'
+
+describe 'has_many_with_deferred_save' do
+
+  before :each do
+    @room    = Room.create(:maximum_occupancy => 2)
+    @table1  = Table.create(:room_id => @room.id)
+    @table2  = Table.create
+    @chair1  = Chair.create(:table_id => @table1.id, :name => "First")
+    @chair2  = Chair.create(:table_id => @table2.id, :name => "Second")
+  end
+
+  it 'should work with tables obj setter/getter' do
+    @room.tables.should == [@table1]
+    @room.tables = [@table1, @table2]
+    Room.find(@room.id).tables.should == [@table1] # not saved yet
+    @room.save.should be_true
+    Room.find(@room.id).tables.should == [@table1, @table2]
+  end
+
+  it 'should work with tables id setter/getter' do
+    @room.table_ids.should == [@table1.id]
+    @room.table_ids = [@table1.id, @table2.id]
+    Room.find(@room.id).table_ids.should == [@table1.id] # not saved yet
+    @room.save.should be_true
+    Room.find(@room.id).table_ids.should == [@table1.id, @table2.id]
+  end
+
+  it 'should work with array methods' do
+    @room.tables.should == [@table1]
+    @room.tables << @table2
+    Room.find(@room.id).tables.should == [@table1] # not saved yet
+    @room.save.should be_true
+    Room.find(@room.id).tables.should == [@table1, @table2]
+    @room.tables -= [@table1]
+    Room.find(@room.id).tables.should == [@table1, @table2]
+    @room.save.should be_true
+    Room.find(@room.id).tables.should == [@table2]
+  end
+
+  it 'should reload temporary objects' do
+    @room.tables << @table2
+    @room.tables.should == [@table1, @table2]
+    @room.reload
+    @room.tables.should == [@table1]
+  end
+
+  it "should be dumpable with Marshal" do
+    lambda { Marshal.dump(@room.tables) }.should_not raise_exception
+    lambda { Marshal.dump(Room.new.tables) }.should_not raise_exception
+  end
+
+  describe 'with through option' do
+    it 'should have a correct list' do
+      # TODO these testcases need to be improved
+      @room.chairs.should == [@chair1] # through table1
+      @room.tables << @table2
+      @room.save.should be_true
+      @room.chairs.should == [@chair1] # association doesn't reload itself
+      @room.reload
+      @room.chairs.should == [@chair1, @chair2]
+    end
+
+    it 'should defer association methods' do
+      @room.chairs.first.should == @chair1
+      @room.chairs.find(:all, :conditions => {:name => "First"}).should == [@chair1]
+      lambda {
+        @room.chairs.create(:name => "New one")
+      }.should raise_error(ActiveRecord::HasManyThroughCantAssociateThroughHasOneOrManyReflection)
+    end
+
+    it "should be dumpable with Marshal" do
+      lambda { Marshal.dump(@room.chairs) }.should_not raise_exception
+      lambda { Marshal.dump(Room.new.chairs) }.should_not raise_exception
+    end
+  end
+end

data/spec/models/chair.rb

@@ -0,0 +1,3 @@
+class Chair < ActiveRecord::Base
+  belongs_to :table
+end

data/spec/models/door.rb

@@ -0,0 +1,3 @@
+class Door < ActiveRecord::Base
+  has_and_belongs_to_many_with_deferred_save :rooms
+end

data/spec/models/person.rb

@@ -0,0 +1,3 @@
+class Person < ActiveRecord::Base
+  has_and_belongs_to_many_with_deferred_save :rooms, :validate => true
+end

data/spec/models/room.rb

@@ -0,0 +1,51 @@
+class Room < ActiveRecord::Base
+
+  attr :bs_diff_before_module, true
+  attr :bs_diff_after_module, true
+  attr :bs_diff_method, true
+
+  before_save :diff_before_module
+
+  has_and_belongs_to_many_with_deferred_save :people, :before_add => :before_adding_person
+  has_and_belongs_to_many :people2, :class_name => 'Person'
+  has_and_belongs_to_many_with_deferred_save :doors
+
+  has_many_with_deferred_save :tables
+  has_many_with_deferred_save :chairs, :through => :tables #TODO test compatibility with through associations
+
+  before_save :diff_after_module
+
+  validate :people_count
+
+  def people_count
+    if people.size > maximum_occupancy
+      errors.add :people, "This room has reached its maximum occupancy"
+    end
+  end
+
+  # Just in case they try to bypass our new accessor and call people_without_deferred_save directly...
+  # (This should never be necessary; it is for demonstration purposes only...)
+  def before_adding_person(person)
+    if self.people_without_deferred_save.size + [person].size > maximum_occupancy
+      raise "There are too many people in this room"
+    end
+  end
+
+  def diff_before_module
+    #should detect the changes
+    self.bs_diff_before_module = (people.size - people_without_deferred_save.size) != 0
+    true
+  end
+
+  def diff_after_module
+    # should not detect the changes
+    self.bs_diff_after_module = (people.size - people_without_deferred_save.size) != 0
+    true
+  end
+
+  def before_save
+    # old_style, should not detect the changes
+    self.bs_diff_method = (people.size - people_without_deferred_save.size) != 0
+    true
+  end
+end

data/spec/models/table.rb

@@ -0,0 +1,4 @@
+class Table < ActiveRecord::Base
+  belongs_to :room
+  has_many_with_deferred_save :chairs
+end

data/spec/spec_helper.rb

@@ -0,0 +1,44 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__) + '/../lib')
+plugin_test_dir = File.dirname(__FILE__)
+
+require 'rubygems'
+USE_AR_3 = true
+
+if defined?(USE_AR_3) && USE_AR_3
+  gem 'activerecord', '=3.2.2'
+  require 'logger'
+  require 'active_record'
+else
+ gem 'activerecord', '=2.3.14'
+ require 'active_record'
+ # Workaround for https://rails.lighthouseapp.com/projects/8994/tickets/2577-when-using-activerecordassociations-outside-of-rails-a-nameerror-is-thrown
+ ActiveRecord::ActiveRecordError
+end
+
+require plugin_test_dir + '/../init.rb'
+
+ActiveRecord::Base.logger = Logger.new(plugin_test_dir + "/test.log")
+
+ActiveRecord::Base.configurations = YAML::load(IO.read(plugin_test_dir + "/db/database.yml"))
+ActiveRecord::Base.establish_connection(ENV["DB"] || "sqlite3mem")
+ActiveRecord::Migration.verbose = false
+load(File.join(plugin_test_dir, "db", "schema.rb"))
+
+Dir["#{plugin_test_dir}/models/*.rb"].each {|file| require file }
+
+RSpec.configure do |config|
+  config.before do
+  end
+end
+
+class ActiveRecord::Base
+
+  # Compatibility method for AR 2.3.x and AR 3.2.x
+  def get_error attr
+    if errors.respond_to?(:on)
+      errors.on(attr)
+    else
+      errors[attr].try(:first)
+    end
+  end
+end

data/uninstall.rb

@@ -0,0 +1 @@
+# Uninstall hook code here

metadata

@@ -0,0 +1,101 @@
+--- !ruby/object:Gem::Specification 
+name: deferred_associations
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: 0.5.0
+platform: ruby
+authors: 
+  - "Martin K\xC3\xB6rner"
+  - Tyler Rick
+  - Alessio Caiazza
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2012-03-18 00:00:00 Z
+dependencies: 
+  - !ruby/object:Gem::Dependency 
+    name: activerecord
+    prerelease: false
+    requirement: &id001 !ruby/object:Gem::Requirement 
+      none: false
+      requirements: 
+        - - ">="
+          - !ruby/object:Gem::Version 
+            version: "0"
+    type: :runtime
+    version_requirements: *id001
+  - !ruby/object:Gem::Dependency 
+    name: rspec
+    prerelease: false
+    requirement: &id002 !ruby/object:Gem::Requirement 
+      none: false
+      requirements: 
+        - - ">="
+          - !ruby/object:Gem::Version 
+            version: "0"
+    type: :development
+    version_requirements: *id002
+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.
+email: martin.koerner@objectfab.de
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+  - CHANGELOG
+  - Rakefile
+  - Readme.markdown
+  - VERSION
+  - has_and_belongs_to_many_with_deferred_save.gemspec
+  - init.rb
+  - install.rb
+  - lib/array_to_association_wrapper.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
+  - uninstall.rb
+homepage: http://github.com/MartinKoerner/deferred_associations
+licenses: []
+
+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.15
+signing_key: 
+specification_version: 3
+summary: Makes ActiveRecord defer/postpone habtm or has_many associations
+test_files: []
+