deferring 0.0.1

data/lib/deferring/version.rb

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

data/spec/lib/deferring_spec.rb

@@ -0,0 +1,536 @@
+require 'spec_helper'
+
+describe 'deferred has-and-belongs-to-many associations' do
+
+  before :each do
+    Person.create!(name: 'Alice')
+    Person.create!(name: 'Bob')
+
+    Team.create!(name: 'Database Administration')
+    Team.create!(name: 'End-User Support')
+    Team.create!(name: 'Operations')
+  end
+
+  let(:bob) { Person.where(name: 'Bob').first }
+
+  let(:dba) { Team.where(name: 'Database Administration').first }
+  let(:support) { Team.where(name: 'End-User Support').first }
+  let(:operations) { Team.where(name: 'Operations').first }
+
+  describe 'deferring' do
+
+    it 'does not create a link until parent is saved' do
+      bob.teams << dba << support
+      expect{ bob.save! }.to change{ Person.find(bob.id).teams.size }.from(0).to(2)
+    end
+
+    it 'does not unlink until parent is saved' do
+      bob.team_ids = [dba.id, support.id, operations.id]
+      bob.save!
+
+      bob.teams.delete([
+        Team.find(dba.id),
+        Team.find(operations.id)
+      ])
+
+      expect{ bob.save }.to change{ Person.find(bob.id).teams.size }.from(3).to(1)
+    end
+
+    it 'does not create a link when parent is not valid' do
+      bob.name = nil # Person.name should be present, Person should not be saved.
+      bob.teams << dba
+
+      expect{ bob.save }.not_to change{ Person.find(bob.id).teams.size }
+    end
+
+    it 'replaces existing records when assigning a new set of records' do
+      bob.teams = [dba]
+
+      # A mistake was made, Bob belongs to Support and Operations instead.
+      bob.teams = [support, operations]
+
+      # The initial assignment of Bob to the DBA team did not get saved, so
+      # at this moment Bob is not assigned to any team in the database.
+      expect{ bob.save }.to change{ Person.find(bob.id).teams.size }.from(0).to(2)
+    end
+
+    describe '#collection_singular_ids' do
+
+      it 'returns ids of saved & unsaved associated records' do
+        bob.teams = [dba, operations]
+        expect(bob.team_ids.size).to eq(2)
+        expect(bob.team_ids).to eq [dba.id, operations.id]
+
+        expect{ bob.save }.to change{ Person.find(bob.id).team_ids.size }.from(0).to(2)
+
+        expect(bob.team_ids.size).to eq(2)
+        expect(bob.team_ids).to eq [dba.id, operations.id]
+      end
+
+    end
+
+    describe '#collections_singular_ids=' do
+
+      it 'sets associated records' do
+        bob.team_ids = [dba.id, operations.id]
+        bob.save
+        expect(bob.teams).to eq [dba, operations]
+        expect(bob.team_ids).to eq [dba.id, operations.id]
+
+        bob.reload
+        expect(bob.teams).to eq [dba, operations]
+        expect(bob.team_ids).to eq [dba.id, operations.id]
+      end
+
+      it 'replace existing records when assigning a new set of ids of records' do
+        bob.teams = [dba]
+
+        # A mistake was made, Bob belongs to Support and Operations instead. The
+        # teams are assigned through the singular collection ids method. Note
+        # that, this also updates the teams association.
+        bob.team_ids = [support.id, operations.id]
+        expect(bob.teams.length).to eq(2)
+
+        expect{ bob.save }.to change{ Person.find(bob.id).teams.size }.from(0).to(2)
+      end
+
+      it 'clears empty values from the ids to be assigned' do
+        bob.team_ids = [dba.id, '']
+        expect(bob.teams.length).to eq(1)
+
+        expect{ bob.save }.to change{ Person.where(name: 'Bob').first.teams.size }.from(0).to(1)
+      end
+
+      describe '#collection_checked=' do
+
+        it 'set associated records' do
+          bob.teams_checked = [dba.id, operations.id]
+
+          expect{ bob.save }.to change{ Person.where(name: 'Bob').first.teams.size }.from(0).to(2)
+        end
+
+      end
+
+    end
+
+  end
+
+  describe 'validating' do
+
+    xit 'does not add duplicate values' do
+      pending 'uniq does not work correctly yet' do
+        dba = Team.first
+        dba.people = [Person.first, Person.find(2), Person.last]
+
+        dba.people.size.should eq 2
+        dba.person_ids.should eq [1,2]
+      end
+    end
+
+  end
+
+  describe 'preloading' do
+
+    before do
+      bob.teams << dba << support
+      bob.save!
+    end
+
+    if rails30 # old-style preload
+      it 'loads the association' do
+        person = Person.where(name: 'Bob').first
+        Person.send(:preload_associations, person, [:teams])
+        expect(person.teams.loaded?).to be_true
+        expect(person.team_ids).to eq [dba.id, support.id]
+      end
+    end
+
+    if rails32 || rails4
+      it 'loads the association when pre-loading' do
+        person = Person.preload(:teams).where(name: 'Bob').first
+        expect(person.teams.loaded?).to be_true
+        expect(person.team_ids).to eq [dba.id, support.id]
+      end
+
+      it 'loads the association when eager loading' do
+        person = Person.eager_load(:teams).where(name: 'Bob').first
+        expect(person.teams.loaded?).to be_true
+        expect(person.team_ids).to eq [dba.id, support.id]
+      end
+
+      it 'loads the association when joining' do
+        person = Person.includes(:teams).where(name: 'Bob').first
+        expect(person.teams.loaded?).to be_true
+        expect(person.team_ids).to eq [dba.id, support.id]
+      end
+    end
+
+    it 'does not load the association when using a regular query' do
+      person = Person.where(name: 'Bob').first
+      expect(person.teams.loaded?).to be_false
+    end
+
+  end
+
+  describe 'reloading' do
+
+    before do
+      bob.teams << operations
+      bob.save!
+    end
+
+    it 'throws away unsaved changes when reloading the parent' do
+      # Assign Bob to some teams, but reload Bob before saving. This should
+      # remove the unsaved teams from the list of teams Bob is assigned to.
+      bob.teams << dba << support
+      bob.reload
+
+      expect(bob.teams).to eq [operations]
+      expect(bob.teams.pending_creates).to be_empty
+    end
+
+    it 'throws away unsaved changes when reloading the association' do
+      # Assign Bob to some teams, but reload the association before saving Bob.
+      bob.teams << dba << support
+      bob.teams.reload
+
+      expect(bob.teams).to eq [operations]
+      expect(bob.teams.pending_creates).to be_empty
+    end
+
+    it 'loads changes saved on the other side of the association' do
+      # The DBA team will add Bob to their team, without him knowing it!
+      dba.people << bob
+
+      # Bob does not know about the fact that he has been added to the DBA team.
+      expect(bob.teams).to eq [operations]
+
+      # After resetting Bob, the teams are retrieved from the database and Bob
+      # finds out he is now also a team-member of team DBA!
+      bob.teams.reload
+      expect(bob.teams).to eq [operations, dba]
+    end
+  end
+
+  describe 'resetting' do
+
+    before do
+      bob.teams << operations
+      bob.save!
+    end
+
+    it 'throws away unsaved changes when resetting the association' do
+      # Assign Bob to some teams, but reset the association before saving Bob.
+      bob.teams << dba << support
+      bob.teams.reset
+
+      expect(bob.teams).to eq [operations]
+      expect(bob.teams.pending_creates).to be_empty
+    end
+
+    it 'loads changes saved on the other side of the association' do
+      # The DBA team will add Bob to their team, without him knowing it!
+      dba.people << bob
+
+      # Bob does not know about the fact that he has been added to the DBA team.
+      expect(bob.teams).to eq [operations]
+
+      # After resetting Bob, the teams are retrieved from the database and Bob
+      # finds out he is now also a team-member of team DBA!
+      bob.teams.reset
+      expect(bob.teams).to eq [operations, dba]
+    end
+
+  end
+
+  describe 'enumerable methods that conflict with ActiveRecord' do
+
+    describe '#select' do
+      before do
+        bob.teams << dba << support << operations
+        bob.save!
+      end
+
+      it 'selects specified columns directly from the database' do
+        teams = bob.teams.select('name')
+
+        expect(teams.map(&:name)).to eq ['Database Administration', 'End-User Support', 'Operations']
+        expect(teams.map(&:id)).to eq [nil, nil, nil]
+      end
+
+      it 'calls a block on the deferred associations' do
+        teams = bob.teams.select { |team| team.id == 1 }
+        expect(teams.map(&:id)).to eq [1]
+      end
+    end
+
+    describe 'find' do
+      # TODO: Write some tests.
+    end
+
+    describe 'first' do
+      # TODO: Write some tests.
+    end
+
+  end
+
+  describe 'pending creates & deletes (aka links and unlinks)' do
+
+    describe 'pending creates' do
+
+      it 'returns newly build records' do
+        bob.teams.build(name: 'Service Desk')
+        expect(bob.teams.pending_creates.size).to eq(1)
+      end
+
+      it 'does not return newly created records' do
+        bob.teams.create!(name: 'Service Desk')
+        expect(bob.teams.pending_creates).to be_empty
+      end
+
+      it 'returns associated records that need to be linked to parent' do
+        bob.teams = [dba]
+        expect(bob.teams.pending_creates).to eq [dba]
+      end
+
+      it 'does not return associated records that already have a link' do
+        bob.teams = [dba]
+        bob.save!
+
+        bob.teams << operations
+
+        expect(bob.teams.pending_creates).to_not include dba
+        expect(bob.teams.pending_creates).to include operations
+      end
+
+      it 'does not return associated records that are to be deleted' do
+        bob.teams = [dba, operations]
+        bob.save!
+        bob.teams.delete(dba)
+
+        expect(bob.teams.pending_creates).to be_empty
+      end
+
+      it 'does not return a record that has just been removed (and has not been saved)' do
+        bob.teams = [dba]
+        bob.save!
+
+        bob.teams.delete(dba)
+        bob.teams << dba
+
+        expect(bob.teams.pending_deletes).to be_empty
+        expect(bob.teams.pending_creates).to be_empty
+      end
+    end
+
+    describe 'pending deletes' do
+
+      it 'returns associated records that need to be unlinked from parent' do
+        bob.teams = [dba]
+        bob.save!
+        bob.teams.delete(dba)
+
+        expect(bob.teams.pending_deletes).to eq [dba]
+      end
+
+      it 'returns an empty array when no records are to be deleted' do
+        bob.teams = [dba]
+        bob.save!
+
+        expect(bob.teams.pending_deletes).to be_empty
+      end
+
+      it 'does not return a record that has just been added (and has not been saved)' do
+        bob.teams = [dba]
+        bob.teams.delete(dba)
+
+        expect(bob.teams.pending_deletes).to be_empty
+        expect(bob.teams.pending_creates).to be_empty
+      end
+
+    end
+
+  end
+
+  # TODO: Clean up tests.
+
+  describe 'active record api' do
+
+    # it 'should execute first on deferred association' do
+    #   p = Person.first
+    #   p.team_ids = [dba.id, support.id, operations.id]
+    #   expect(p.teams.first).to eq(dba)
+    #   p.save!
+    #   expect(Person.first.teams.first).to eq(dba)
+    # end
+
+    # it 'should execute last on deferred association' do
+    #   p = Person.first
+    #   p.team_ids = [dba.id, support.id, operations.id]
+    #   expect(p.teams.last).to eq(operations)
+    #   p.save!
+    #   expect(Person.first.teams.last).to eq(operations)
+    # end
+
+    it 'should build a new record' do
+      p = Person.first
+      p.teams.build(name: 'Service Desk')
+      expect(p.teams[0]).to be_new_record
+    end
+
+    it 'should build and save a new record' do
+      p = Person.first
+      p.teams.build(name: 'Service Desk')
+      expect(p.teams[0]).to be_new_record
+      expect(Person.first.teams.size).to eq(0)
+      p.save
+      expect(Person.first.teams.size).to eq(1)
+    end
+
+    it 'should add a new record' do
+      p = Person.first
+      p.teams.create!(:name => 'Service Desk')
+      expect(p.teams[0]).to_not be_new_record
+      expect(Person.first.teams.size).to eq(1)
+      p.save
+      expect(Person.first.teams.size).to eq(1)
+    end
+
+    it 'should allow ActiveRecord::QueryMethods' do
+      p = Person.first
+      p.teams << dba << operations
+      p.save
+      expect(Person.first.teams.where(name: 'Operations').first).to eq(operations)
+    end
+
+    it 'should find one without loading collection' do
+      p = Person.first
+      p.teams = [Team.first, Team.find(3)]
+      p.save
+      teams = Person.first.teams
+      teams.loaded?.should == false
+      teams.find(3).should ==  Team.find(3)
+      teams.first.should == Team.first
+      teams.last.should == Team.find(3)
+      teams.loaded?.should == false
+    end
+
+  end
+
+  it 'should call before_add, after_add, before_remove, after_remove callbacks' do
+    bob = Person.first
+    bob.teams = [Team.first, Team.find(3)]
+    bob.save!
+
+    bob = Person.first
+    bob.teams.delete(bob.teams[0])
+    bob.teams << Team.find(2)
+    bob.save!
+
+    bob.audit_log.length.should == 4
+    bob.audit_log.should == [
+      'Before removing team 1',
+      'After removing team 1',
+      'Before adding team 2',
+      'After adding team 2'
+    ]
+  end
+
+  describe 'accepts_nested_attributes' do
+    # TODO: Write more tests.
+    it 'should mass assign' do
+      p = Person.first
+      p.teams << Team.first << Team.last << Team.find(2)
+      p.save
+
+      # Destroy team 2 and 3. Keep team 1.
+      p = Person.first
+      p.attributes = {
+        teams_attributes: [
+          { id: 1 },
+          { id: 3, _destroy: true },
+          { id: 2, _destroy: true }
+        ]
+      }
+      p.teams.length.should == 1
+      p.team_ids.sort.should == [1]
+
+      Person.first
+      Person.first.teams.length.should == 3
+      Person.first.team_ids.sort.should == [1,2,3]
+
+      p.save!
+
+      p = Person.first
+      p.teams.length.should == 1
+      p.team_ids.sort.should == [1]
+    end
+
+    it 'should mass assign' do
+      p = Person.first
+      p.teams << Team.first << Team.last << Team.find(2)
+      p.save
+
+      # Destroy team 2 and 3. Keep team 1.
+      p = Person.first
+      p.teams_attributes = [
+        { id: 1 },
+        { id: 3, _destroy: true },
+        { id: 2, _destroy: true }
+      ]
+      p.teams.length.should == 1
+      p.team_ids.sort.should == [1]
+
+      Person.first
+      Person.first.teams.length.should == 3
+      Person.first.team_ids.sort.should == [1,2,3]
+
+      p.save!
+
+      p = Person.first
+      p.teams.length.should == 1
+      p.team_ids.sort.should == [1]
+    end
+  end
+
+  describe 'validations' do
+
+    xit 'deferred habtm <=> regular habtm' do
+      alice = Person.where(name: 'Alice').first
+      bob = Person.where(name: 'Bob').first
+
+      team = Team.first
+      team.people << alice << bob
+      team.save!
+
+      bob.reload
+      expect(bob.teams.size).to eq(1)
+
+      alice.reload
+      expect(alice.teams.size).to eq(1)
+
+      team.people.create!(name: 'Chuck')
+      expect(team).to_not be_valid
+
+      bob.reload
+      alice.reload
+
+      expect(bob).to_not be_valid
+      expect(alice).to_not be_valid
+
+      expect(bob.save).to be_false
+      expect(alice.save).to be_false
+    end
+
+    xit 'does not validate records when validate: false' do
+      pending 'validate: false does not work' do
+        alice = Person.where(name: 'Alice').first
+        alice.teams.build(name: nil)
+        alice.save!
+
+        expect(alice.teams.size).to eq 1
+      end
+    end
+  end
+
+end