has_and_belongs_to_many_with_deferred_save 0.1.0 → 0.2.0

data/.gitignore

@@ -1 +1,2 @@
 pkg
+*.db

data/VERSION

@@ -1 +1 @@
-0.1.0
+0.2.0

data/has_and_belongs_to_many_with_deferred_save.gemspec

@@ -5,7 +5,7 @@
 
 Gem::Specification.new do |s|
   s.name = %q{has_and_belongs_to_many_with_deferred_save}
-  s.version = "0.1.0"
+  s.version = "0.2.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Tyler Rick", "Alessio Caiazza"]
@@ -24,6 +24,7 @@ Gem::Specification.new do |s|
      "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",
@@ -35,7 +36,8 @@ Gem::Specification.new do |s|
   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) association until you call model.save, allowing validation in the style of normal attributes.}
   s.test_files = [
-    "spec/models/room.rb",
+    "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",

data/lib/has_and_belongs_to_many_with_deferred_save.rb

@@ -21,7 +21,7 @@ module ActiveRecord
         has_and_belongs_to_many *args
         collection_name = args[0].to_s
         collection_singular_ids = collection_name.singularize + "_ids"
-        
+
         # this will delete all the assocation into the join table after obj.destroy
         after_destroy { |record| record.save }
 
@@ -63,18 +63,18 @@ module ActiveRecord
 
         define_method "before_save_with_deferred_save_for_#{collection_name}" 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 
+          # 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 
+          # 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 
+          # 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.
-          
+
           if self.respond_to? :"before_save_without_deferred_save_for_#{collection_name}"
-            self.send("before_save_without_deferred_save_for_#{collection_name}") 
-          end  
+            self.send("before_save_without_deferred_save_for_#{collection_name}")
+          end
 
           self.send "use_original_collection_reader_behavior_for_#{collection_name}=", true
           if self.send("unsaved_#{collection_name}").nil?
@@ -103,20 +103,20 @@ module ActiveRecord
         define_method "initialize_unsaved_#{collection_name}" do |*args|
           #puts "Initialized to #{self.send("#{collection_name}_without_deferred_save").clone.inspect}"
           self.send "unsaved_#{collection_name}=", self.send("#{collection_name}_without_deferred_save", *args).clone
-            # /\ We initialize it to collection_without_deferred_save in case they just loaded the object from the 
+            # /\ 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".
-            # If they just constructed a *new* object, this will still work, because self.collection_without_deferred_save.clone 
+            # If they just constructed a *new* object, this will still work, because self.collection_without_deferred_save.clone
             # will return a new HasAndBelongsToManyAssociation (which acts like an empty array, []).
             # 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.)
-          
+
           # trick collection_name.include?(obj)
           # If you use a collection of SignelTableInheritance and didn't :select 'type' the
           # include? method will not find any subclassed object.
           class << eval("@unsaved_#{collection_name}")
             def include_with_deferred_save?(obj)
-              if self.find { |itm| itm == obj || (itm[:id] == obj[:id] && obj.is_a?(itm.class) ) }
+              if self.detect { |itm| itm == obj || (itm[:id] == obj[:id] && obj.is_a?(itm.class) ) }
                 return true
               else
                 return false
@@ -124,9 +124,32 @@ module ActiveRecord
             end
             alias_method_chain :include?, 'deferred_save'
           end
+
+
+          collection_without_deferred_save =  self.send("#{collection_name}_without_deferred_save")
+          # (We don't have access to locals inside a normal class << object block, so we have to do it this way instead.)
+          (class << eval("@unsaved_#{collection_name}"); self end).class_eval do
+            define_method :find do |*args|
+              collection_without_deferred_save.send(:find, *args)
+            end
+            # We have to override these so that it doesn't call Array's version of these methods.
+            # Otherwise user will get a "can't convert Hash into Integer" error
+            define_method :first do |*args|
+              collection_without_deferred_save.send(:first, *args)
+            end
+            define_method :last do |*args|
+              collection_without_deferred_save.send(:first, *args)
+            end
+
+            define_method :method_missing do |method, *args|
+              #puts "#{self.class}.method_missing(#{method}) (#{collection_without_deferred_save.inspect})"
+              collection_without_deferred_save.send(method, *args)
+            end
+          end
+
         end
         private :"initialize_unsaved_#{collection_name}"
-        
+
       end
     end
   end

data/spec/db/schema.rb

@@ -18,4 +18,13 @@ ActiveRecord::Schema.define(:version => 1) do
     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
+
 end

data/spec/has_and_belongs_to_many_with_deferred_save_spec.rb

@@ -5,13 +5,17 @@ describe "has_and_belongs_to_many_with_deferred_save" do
   describe "room maximum_occupancy" do
     before :all do
       @people = []
-      @people << Person.create
-      @people << Person.create
-      @people << Person.create
+      @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 "initial checks" do
+    it "passes initial checks" do
       Room  .count.should == 0
       Person.count.should == 3
 
@@ -48,21 +52,23 @@ describe "has_and_belongs_to_many_with_deferred_save" do
 
       Room.count_by_sql("select count(*) from people_rooms").should == 2
       @room.valid?
-      @room.errors.on(:people).should == "There are too many people in this room"
+      @room.errors.on(: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 invaild" 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.errors.on(:people).should == "There are too many people in this room"
+      @room.errors.on(: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
@@ -70,5 +76,84 @@ describe "has_and_belongs_to_many_with_deferred_save" 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
+
+      class << @people[2]
+        def validate
+          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
+      end
+
+      @people[2].rooms << @room
+      @people[2].rooms.size.should == 1
+
+      @room.reload.people.size.should == 2
+      @people[2].valid?
+      @people[2].errors.on(: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.find_by_name('Filbert').                          should == @people[0]
+    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/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

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

data/spec/models/room.rb

@@ -1,9 +1,11 @@
 class Room < ActiveRecord::Base
   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
 
   def validate
     if people.size > maximum_occupancy
-      errors.add :people, "There are too many people in this room"
+      errors.add :people, "This room has reached its maximum occupancy"
     end
   end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: has_and_belongs_to_many_with_deferred_save
 version: !ruby/object:Gem::Version 
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors: 
 - Tyler Rick
@@ -54,6 +54,7 @@ files:
 - 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
@@ -87,6 +88,7 @@ signing_key:
 specification_version: 3
 summary: Make ActiveRecord defer/postpone saving the records you add to an habtm (has_and_belongs_to_many) association until you call model.save, allowing validation in the style of normal attributes.
 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