dm-core 0.9.2 → 0.9.3

data/spec/integration/association_spec.rb

@@ -1,8 +1,76 @@
 require File.expand_path(File.join(File.dirname(__FILE__), '..', 'spec_helper'))
 
+if HAS_SQLITE3
+  describe DataMapper::Associations do
+    before :all do
+      db1 = File.expand_path(File.join(File.dirname(__FILE__), "custom_db1_sqlite3.db"))
+      db2 = File.expand_path(File.join(File.dirname(__FILE__), "custom_db2_sqlite3.db"))
+      FileUtils.touch(db1)
+      FileUtils.touch(db2)
+      DataMapper.setup(:custom_db1, "sqlite3://#{db1}")
+      DataMapper.setup(:custom_db2, "sqlite3://#{db2}")
+      class CustomParent
+        include DataMapper::Resource
+        def self.default_repository_name
+          :custom_db1
+        end
+        property :id, Serial
+        property :name, String
+        repository(:custom_db2) do
+          has n, :custom_childs
+        end
+      end
+      class CustomChild
+        include DataMapper::Resource
+        def self.default_repository_name
+          :custom_db2
+        end
+        property :id, Serial
+        property :name, String
+        repository(:custom_db1) do
+          belongs_to :custom_parent
+        end
+      end
+
+    end
+    before :each do
+      [ CustomChild, CustomParent ].each { |m| m.auto_migrate! }
+
+      parent = CustomParent.create(:name => "mother")
+      child1 = parent.custom_childs.create(:name => "son")
+      child2 = parent.custom_childs.create(:name => "daughter")
+
+      @parent = CustomParent.first(:name => "mother")
+      @child1 = CustomChild.first(:name => "son")
+      @child2 = CustomChild.first(:name => "daughter")
+    end
+    it "should be able to handle has_many relationships to other repositories" do
+      @parent.custom_childs.size.should == 2
+      @parent.custom_childs.include?(@child1).should == true
+      @parent.custom_childs.include?(@child2).should == true
+      @parent.custom_childs.delete(@child1)
+      @parent.custom_childs.save
+      @parent.reload
+      @parent.custom_childs.size.should == 1
+      @parent.custom_childs.include?(@child2).should == true
+    end
+    it "should be able to handle belongs_to relationships to other repositories" do
+      @child1.custom_parent.should == @parent
+      @child2.custom_parent.should == @parent
+      @child1.custom_parent = nil
+      @child1.save
+      @child1.reload
+      @child1.custom_parent.should == nil
+      @parent.reload
+      @parent.custom_childs.size.should == 1
+      @parent.custom_childs.include?(@child2).should == true
+    end
+  end
+end
+
 if ADAPTER
   repository(ADAPTER) do
-    class Engine
+    class Machine
       include DataMapper::Resource
 
       def self.default_repository_name
@@ -12,11 +80,11 @@ if ADAPTER
       property :id, Serial
       property :name, String
 
-      has n, :yards
-      has n, :fussy_yards, :class_name => 'Yard', :rating.gte => 3, :type => 'particular'
+      has n, :areas
+      has n, :fussy_areas, :class_name => 'Area', :rating.gte => 3, :type => 'particular'
     end
 
-    class Yard
+    class Area
       include DataMapper::Resource
 
       def self.default_repository_name
@@ -28,7 +96,7 @@ if ADAPTER
       property :rating, Integer
       property :type, String
 
-      belongs_to :engine
+      belongs_to :machine
     end
 
     class Pie
@@ -57,7 +125,7 @@ if ADAPTER
       has 1, :pie
     end
 
-    class Host
+    class Ultrahost
       include DataMapper::Resource
 
       def self.default_repository_name
@@ -67,10 +135,10 @@ if ADAPTER
       property :id, Serial
       property :name, String
 
-      has n, :slices, :order => [:id.desc]
+      has n, :ultraslices, :order => [:id.desc]
     end
 
-    class Slice
+    class Ultraslice
       include DataMapper::Resource
 
       def self.default_repository_name
@@ -80,7 +148,7 @@ if ADAPTER
       property :id, Serial
       property :name, String
 
-      belongs_to :host
+      belongs_to :ultrahost
     end
 
     class Node
@@ -108,8 +176,8 @@ if ADAPTER
         property :title, String, :length => 255, :key => true
         property :summary, DataMapper::Types::Text
 
-        has n, :tasks, :class_name => 'Models::Task'
-        has 1, :goal, :class_name => 'Models::Goal'
+        has n, :tasks
+        has 1, :goal
       end
 
       class Goal
@@ -122,7 +190,7 @@ if ADAPTER
         property :title, String, :length => 255, :key => true
         property :summary, DataMapper::Types::Text
 
-        belongs_to :project, :class_name => "Models::Project"
+        belongs_to :project
       end
 
       class Task
@@ -135,7 +203,7 @@ if ADAPTER
         property :title, String, :length => 255, :key => true
         property :description, DataMapper::Types::Text
 
-        belongs_to :project, :class_name => 'Models::Project'
+        belongs_to :project
       end
     end
 
@@ -187,8 +255,8 @@ if ADAPTER
       end
 
       it 'should allow namespaced classes in parent and child for one <=> one' do
-        g = Models::Goal.new(:title => "g2", :description => "desc 2")
-        p = Models::Project.create!(:title => "p2", :summary => "sum 2", :goal => g)
+        g = Models::Goal.new(:title => "g2", :summary => "desc 2")
+        p = Models::Project.create(:title => "p2", :summary => "sum 2", :goal => g)
 
         pp = Models::Project.first(:title => 'p2')
         pp.goal.title.should == "g2"
@@ -204,30 +272,38 @@ if ADAPTER
 
     describe 'many to one associations' do
       before do
-        Engine.auto_migrate!(ADAPTER)
-        Yard.auto_migrate!(ADAPTER)
+        Machine.auto_migrate!(ADAPTER)
+        Area.auto_migrate!(ADAPTER)
 
-        engine1 = Engine.create!(:name => 'engine1')
-        engine2 = Engine.create!(:name => 'engine2')
-        yard1   = Yard.create!(:name => 'yard1', :engine => engine1)
-        yard2   = Yard.create!(:name => 'yard2')
+        machine1 = Machine.create(:name => 'machine1')
+        machine2 = Machine.create(:name => 'machine2')
+        area1   = Area.create(:name => 'area1', :machine => machine1)
+        area2   = Area.create(:name => 'area2')
       end
 
       it '#belongs_to' do
-        yard = Yard.new
-        yard.should respond_to(:engine)
-        yard.should respond_to(:engine=)
+        area = Area.new
+        area.should respond_to(:machine)
+        area.should respond_to(:machine=)
       end
 
       it 'should load without the parent'
 
       it 'should allow substituting the parent' do
-        yard1   = Yard.first(:name => 'yard1')
-        engine2 = Engine.first(:name => 'engine2')
+        area1   = Area.first(:name => 'area1')
+        machine2 = Machine.first(:name => 'machine2')
 
-        yard1.engine = engine2
-        yard1.save
-        Yard.first(:name => 'yard1').engine.should == engine2
+        area1.machine = machine2
+        area1.save
+        Area.first(:name => 'area1').machine.should == machine2
+      end
+
+      it 'should save both the object and parent if both are new' do
+        pending "This is fixed"
+        area1 = Area.new(:name => 'area1')
+        area1.machine = Machine.new(:name => 'machine1')
+        area1.machine.save
+        area1.machine_id.should == area1.machine.id
       end
 
       it '#belongs_to with namespaced models' do
@@ -246,42 +322,42 @@ if ADAPTER
       end
 
       it 'should load the associated instance' do
-        engine1 = Engine.first(:name => 'engine1')
-        Yard.first(:name => 'yard1').engine.should == engine1
+        machine1 = Machine.first(:name => 'machine1')
+        Area.first(:name => 'area1').machine.should == machine1
       end
 
       it 'should save the association key in the child' do
-        engine2 = Engine.first(:name => 'engine2')
+        machine2 = Machine.first(:name => 'machine2')
 
-        Yard.create!(:name => 'yard3', :engine => engine2)
-        Yard.first(:name => 'yard3').engine.should == engine2
+        Area.create(:name => 'area3', :machine => machine2)
+        Area.first(:name => 'area3').machine.should == machine2
       end
 
       it 'should set the association key immediately' do
-        engine = Engine.first(:name => 'engine1')
-        Yard.new(:engine => engine).engine_id.should == engine.id
+        machine = Machine.first(:name => 'machine1')
+        Area.new(:machine => machine).machine_id.should == machine.id
       end
 
       it 'should save the parent upon saving of child' do
-        e = Engine.new(:name => 'engine10')
-        y = Yard.create!(:name => 'yard10', :engine => e)
+        e = Machine.new(:name => 'machine10')
+        y = Area.create(:name => 'area10', :machine => e)
 
-        y.engine.name.should == 'engine10'
-        Engine.first(:name => 'engine10').should_not be_nil
+        y.machine.name.should == 'machine10'
+        Machine.first(:name => 'machine10').should_not be_nil
       end
 
       it 'should convert NULL parent ids into nils' do
-        Yard.first(:name => 'yard2').engine.should be_nil
+        Area.first(:name => 'area2').machine.should be_nil
       end
 
       it 'should save nil parents as NULL ids' do
-        y1 = Yard.create!(:id => 20, :name => 'yard20')
-        y2 = Yard.create!(:id => 30, :name => 'yard30', :engine => nil)
+        y1 = Area.create(:id => 20, :name => 'area20')
+        y2 = Area.create(:id => 30, :name => 'area30', :machine => nil)
 
         y1.id.should == 20
-        y1.engine.should be_nil
+        y1.machine.should be_nil
         y2.id.should == 30
-        y2.engine.should be_nil
+        y2.machine.should be_nil
       end
 
       it 'should respect length on foreign keys' do
@@ -296,10 +372,10 @@ if ADAPTER
       end
 
       it 'should be reloaded when calling Resource#reload' do
-        e = Engine.new(:name => 'engine40')
-        y = Yard.create!(:name => 'yard40', :engine => e)
+        e = Machine.new(:name => 'machine40')
+        y = Area.create(:name => 'area40', :machine => e)
 
-        y.send(:engine_association).should_receive(:reload).once
+        y.send(:machine_association).should_receive(:reload).once
 
         lambda { y.reload }.should_not raise_error
       end
@@ -310,9 +386,9 @@ if ADAPTER
         Sky.auto_migrate!(ADAPTER)
         Pie.auto_migrate!(ADAPTER)
 
-        pie1 = Pie.create!(:name => 'pie1')
-        pie2 = Pie.create!(:name => 'pie2')
-        sky1 = Sky.create!(:name => 'sky1', :pie => pie1)
+        pie1 = Pie.create(:name => 'pie1')
+        pie2 = Pie.create(:name => 'pie2')
+        sky1 = Sky.create(:name => 'sky1', :pie => pie1)
       end
 
       it '#has 1' do
@@ -346,13 +422,13 @@ if ADAPTER
       it 'should save the association key in the child' do
         pie2 = Pie.first(:name => 'pie2')
 
-        sky2 = Sky.create!(:id => 2, :name => 'sky2', :pie => pie2)
+        sky2 = Sky.create(:id => 2, :name => 'sky2', :pie => pie2)
         pie2.sky.should == sky2
       end
 
       it 'should save the children upon saving of parent' do
         p = Pie.new(:id => 10, :name => 'pie10')
-        s = Sky.create!(:id => 10, :name => 'sky10', :pie => p)
+        s = Sky.create(:id => 10, :name => 'sky10', :pie => p)
 
         p.sky.should == s
 
@@ -360,8 +436,8 @@ if ADAPTER
       end
 
       it 'should save nil parents as NULL ids' do
-        p1 = Pie.create!(:id => 20, :name => 'pie20')
-        p2 = Pie.create!(:id => 30, :name => 'pie30', :sky => nil)
+        p1 = Pie.create(:id => 20, :name => 'pie20')
+        p2 = Pie.create(:id => 30, :name => 'pie30', :sky => nil)
 
         p1.id.should == 20
         p1.sky.should be_nil
@@ -378,154 +454,162 @@ if ADAPTER
 
     describe 'one to many associations' do
       before do
-        Host.auto_migrate!(ADAPTER)
-        Slice.auto_migrate!(ADAPTER)
-        Engine.auto_migrate!(ADAPTER)
-        Yard.auto_migrate!(ADAPTER)
+        Ultrahost.auto_migrate!(ADAPTER)
+        Ultraslice.auto_migrate!(ADAPTER)
+        Machine.auto_migrate!(ADAPTER)
+        Area.auto_migrate!(ADAPTER)
 
-        host1  = Host.create!(:name => 'host1')
-        host2  = Host.create!(:name => 'host2')
-        slice1 = Slice.create!(:name => 'slice1', :host => host1)
-        slice2 = Slice.create!(:name => 'slice2', :host => host1)
-        slice3 = Slice.create!(:name => 'slice3')
+        ultrahost1  = Ultrahost.create(:name => 'ultrahost1')
+        ultrahost2  = Ultrahost.create(:name => 'ultrahost2')
+        ultraslice1 = Ultraslice.create(:name => 'ultraslice1', :ultrahost => ultrahost1)
+        ultraslice2 = Ultraslice.create(:name => 'ultraslice2', :ultrahost => ultrahost1)
+        ultraslice3 = Ultraslice.create(:name => 'ultraslice3')
       end
 
       it '#has n' do
-        h = Host.new
-        h.should respond_to(:slices)
+        h = Ultrahost.new
+        h.should respond_to(:ultraslices)
       end
 
       it 'should allow removal of a child through a loaded association' do
-        host1  = Host.first(:name => 'host1')
-        slice2 = host1.slices.first
+        ultrahost1  = Ultrahost.first(:name => 'ultrahost1')
+        ultraslice2 = ultrahost1.ultraslices.first
 
-        host1.slices.size.should == 2
-        host1.slices.delete(slice2)
-        host1.slices.size.should == 1
+        ultrahost1.ultraslices.size.should == 2
+        ultrahost1.ultraslices.delete(ultraslice2)
+        ultrahost1.ultraslices.size.should == 1
 
-        slice2 = Slice.first(:name => 'slice2')
-        slice2.host.should_not be_nil
+        ultraslice2 = Ultraslice.first(:name => 'ultraslice2')
+        ultraslice2.ultrahost.should_not be_nil
 
-        host1.save
+        ultrahost1.save
 
-        slice2.reload.host.should be_nil
+        ultraslice2.reload.ultrahost.should be_nil
       end
 
       it 'should use the IdentityMap correctly' do
         repository(ADAPTER) do
-          host1 = Host.first(:name => 'host1')
+          ultrahost1 = Ultrahost.first(:name => 'ultrahost1')
 
-          slice =  host1.slices.first
-          slice2 = host1.slices(:order => [:id]).last # should be the same as 1
-          slice3 = Slice.get(2) # should be the same as 1
+          ultraslice =  ultrahost1.ultraslices.first
+          ultraslice2 = ultrahost1.ultraslices(:order => [:id]).last # should be the same as 1
+          ultraslice3 = Ultraslice.get(2) # should be the same as 1
 
-          slice.object_id.should == slice2.object_id
-          slice.object_id.should == slice3.object_id
+          ultraslice.object_id.should == ultraslice2.object_id
+          ultraslice.object_id.should == ultraslice3.object_id
         end
       end
 
       it '#<< should add exactly the parameters' do
-        engine = Engine.new(:name => 'my engine')
+        machine = Machine.new(:name => 'my machine')
         4.times do |i|
-          engine.yards << Yard.new(:name => "yard nr #{i}")
+          machine.areas << Area.new(:name => "area nr #{i}")
         end
-        engine.save
-        engine.yards.size.should == 4
+        machine.save
+        machine.areas.size.should == 4
         4.times do |i|
-          engine.yards.any? do |yard|
-            yard.name == "yard nr #{i}"
+          machine.areas.any? do |area|
+            area.name == "area nr #{i}"
           end.should == true
         end
-        engine = Engine.get!(engine.id)
-        engine.yards.size.should == 4
+        machine = Machine.get!(machine.id)
+        machine.areas.size.should == 4
         4.times do |i|
-          engine.yards.any? do |yard|
-            yard.name == "yard nr #{i}"
+          machine.areas.any? do |area|
+            area.name == "area nr #{i}"
           end.should == true
         end
       end
 
+      it "#<< should add the correct number of elements if they are created" do
+        machine = Machine.create(:name => 'my machine')
+        4.times do |i|
+          machine.areas << Area.create(:name => "area nr #{i}", :machine => machine)
+        end
+        machine.areas.size.should == 4
+      end
+
       it '#<< should add default values for relationships that have conditions' do
         # it should add default values
-        engine = Engine.new(:name => 'my engine')
-        engine.fussy_yards << Yard.new(:name => 'yard 1', :rating => 4 )
-        engine.save
-        Yard.first(:name => 'yard 1').type.should == 'particular'
+        machine = Machine.new(:name => 'my machine')
+        machine.fussy_areas << Area.new(:name => 'area 1', :rating => 4 )
+        machine.save
+        Area.first(:name => 'area 1').type.should == 'particular'
         # it should not add default values if the condition's property already has a value
-        engine.fussy_yards << Yard.new(:name => 'yard 2', :rating => 4, :type => 'not particular')
-        engine.save
-        Yard.first(:name => 'yard 2').type.should == 'not particular'
+        machine.fussy_areas << Area.new(:name => 'area 2', :rating => 4, :type => 'not particular')
+        machine.save
+        Area.first(:name => 'area 2').type.should == 'not particular'
         # it should ignore non :eql conditions
-        engine.fussy_yards << Yard.new(:name => 'yard 3')
-        engine.save
-        Yard.first(:name => 'yard 3').rating.should == nil
+        machine.fussy_areas << Area.new(:name => 'area 3')
+        machine.save
+        Area.first(:name => 'area 3').rating.should == nil
       end
 
       it 'should load the associated instances, in the correct order' do
-        host1 = Host.first(:name => 'host1')
+        ultrahost1 = Ultrahost.first(:name => 'ultrahost1')
 
-        host1.slices.should_not be_nil
-        host1.slices.size.should == 2
-        host1.slices.first.name.should == 'slice2' # ordered by [:id.desc]
-        host1.slices.last.name.should == 'slice1'
+        ultrahost1.ultraslices.should_not be_nil
+        ultrahost1.ultraslices.size.should == 2
+        ultrahost1.ultraslices.first.name.should == 'ultraslice2' # ordered by [:id.desc]
+        ultrahost1.ultraslices.last.name.should == 'ultraslice1'
 
-        slice3 = Slice.first(:name => 'slice3')
+        ultraslice3 = Ultraslice.first(:name => 'ultraslice3')
 
-        slice3.host.should be_nil
+        ultraslice3.ultrahost.should be_nil
       end
 
       it 'should add and save the associated instance' do
-        host1 = Host.first(:name => 'host1')
-        host1.slices << Slice.new(:id => 4, :name => 'slice4')
-        host1.save
+        ultrahost1 = Ultrahost.first(:name => 'ultrahost1')
+        ultrahost1.ultraslices << Ultraslice.new(:id => 4, :name => 'ultraslice4')
+        ultrahost1.save
 
-        Slice.first(:name => 'slice4').host.should == host1
+        Ultraslice.first(:name => 'ultraslice4').ultrahost.should == ultrahost1
       end
 
       it 'should not save the associated instance if the parent is not saved' do
-        h = Host.new(:id => 10, :name => 'host10')
-        h.slices << Slice.new(:id => 10, :name => 'slice10')
+        h = Ultrahost.new(:id => 10, :name => 'ultrahost10')
+        h.ultraslices << Ultraslice.new(:id => 10, :name => 'ultraslice10')
 
-        Slice.first(:name => 'slice10').should be_nil
+        Ultraslice.first(:name => 'ultraslice10').should be_nil
       end
 
       it 'should save the associated instance upon saving of parent' do
-        h = Host.new(:id => 10, :name => 'host10')
-        h.slices << Slice.new(:id => 10, :name => 'slice10')
+        h = Ultrahost.new(:id => 10, :name => 'ultrahost10')
+        h.ultraslices << Ultraslice.new(:id => 10, :name => 'ultraslice10')
         h.save
 
-        s = Slice.first(:name => 'slice10')
+        s = Ultraslice.first(:name => 'ultraslice10')
 
         s.should_not be_nil
-        s.host.should == h
+        s.ultrahost.should == h
       end
 
       it 'should save the associated instances upon saving of parent when mass-assigned' do
-        h = Host.create!(:id => 10, :name => 'host10', :slices => [ Slice.new(:id => 10, :name => 'slice10') ])
+        h = Ultrahost.create(:id => 10, :name => 'ultrahost10', :ultraslices => [ Ultraslice.new(:id => 10, :name => 'ultraslice10') ])
 
-        s = Slice.first(:name => 'slice10')
+        s = Ultraslice.first(:name => 'ultraslice10')
 
         s.should_not be_nil
-        s.host.should == h
+        s.ultrahost.should == h
       end
 
       it 'should have finder-functionality' do
-        h = Host.first(:name => 'host1')
+        h = Ultrahost.first(:name => 'ultrahost1')
 
-        h.slices.should have(2).entries
+        h.ultraslices.should have(2).entries
 
-        s = h.slices.all(:name => 'slice2')
+        s = h.ultraslices.all(:name => 'ultraslice2')
 
         s.should have(1).entries
         s.first.id.should == 2
 
-        h.slices.first(:name => 'slice2').should == s.first
+        h.ultraslices.first(:name => 'ultraslice2').should == s.first
       end
 
       it 'should be reloaded when calling Resource#reload' do
-        host = Host.first(:name => 'host1')
-        host.send(:slices_association).should_receive(:reload).once
-        lambda { host.reload }.should_not raise_error
+        ultrahost = Ultrahost.first(:name => 'ultrahost1')
+        ultrahost.send(:ultraslices_association).should_receive(:reload).once
+        lambda { ultrahost.reload }.should_not raise_error
       end
     end
 
@@ -533,12 +617,12 @@ if ADAPTER
       before do
         Node.auto_migrate!(ADAPTER)
 
-        Node.create!(:name => 'r1')
-        Node.create!(:name => 'r2')
-        Node.create!(:name => 'r1c1',   :parent_id => 1)
-        Node.create!(:name => 'r1c2',   :parent_id => 1)
-        Node.create!(:name => 'r1c3',   :parent_id => 1)
-        Node.create!(:name => 'r1c1c1', :parent_id => 3)
+        Node.create(:name => 'r1')
+        Node.create(:name => 'r2')
+        Node.create(:name => 'r1c1',   :parent_id => 1)
+        Node.create(:name => 'r1c2',   :parent_id => 1)
+        Node.create(:name => 'r1c3',   :parent_id => 1)
+        Node.create(:name => 'r1c1c1', :parent_id => 3)
       end
 
       it 'should properly set #parent' do
@@ -562,7 +646,7 @@ if ADAPTER
       end
 
       it 'should allow to create root nodes' do
-        r = Node.create!(:name => 'newroot')
+        r = Node.create(:name => 'newroot')
         r.parent.should be_nil
         r.children.size.should == 0
       end
@@ -589,21 +673,21 @@ if ADAPTER
               end
               property :id, Serial
               property :name, String
-              has n, :cakes,                                :class_name => 'Sweets::Cake'        # has n
-              has n, :recipes,     :through => :cakes,      :class_name => 'Sweets::Recipe'      # has n => has 1
-              has n, :ingredients, :through => :cakes,      :class_name => 'Sweets::Ingredient'  # has n => has 1 => has n
-              has n, :creators,    :through => :cakes,      :class_name => 'Sweets::Creator'     # has n => has 1 => has 1
-              has n, :slices,      :through => :cakes,      :class_name => 'Sweets::Slice'       # has n => has n
-              has n, :bites,       :through => :cakes,      :class_name => 'Sweets::Bite'        # has n => has n => has n
-              has n, :shapes,      :through => :cakes,      :class_name => 'Sweets::Shape'       # has n => has n => has 1
-              has n, :customers,   :through => :cakes,      :class_name => 'Sweets::Customer'    # has n => belongs_to (pending)
-              has 1, :shop_owner,                           :class_name => 'Sweets::ShopOwner'   # has 1
-              has 1, :wife,        :through => :shop_owner, :class_name => 'Sweets::Wife'        # has 1 => has 1
-              has 1, :ring,        :through => :shop_owner, :class_name => 'Sweets::Ring'        # has 1 => has 1 => has 1
-              has n, :coats,       :through => :shop_owner, :class_name => 'Sweets::Coat'        # has 1 => has 1 => has n
-              has n, :children,    :through => :shop_owner, :class_name => 'Sweets::Child'       # has 1 => has n
-              has n, :toys,        :through => :shop_owner, :class_name => 'Sweets::Toy'         # has 1 => has n => has n
-              has n, :boogers,     :through => :shop_owner, :class_name => 'Sweets::Booger'      # has 1 => has n => has 1
+              has n, :cakes                                 # has n
+              has n, :recipes,     :through => :cakes       # has n => has 1
+              has n, :ingredients, :through => :cakes       # has n => has 1 => has n
+              has n, :creators,    :through => :cakes       # has n => has 1 => has 1
+              has n, :ultraslices,      :through => :cakes       # has n => has n
+              has n, :bites,       :through => :cakes       # has n => has n => has n
+              has n, :shapes,      :through => :cakes       # has n => has n => has 1
+              has n, :customers,   :through => :cakes       # has n => belongs_to (pending)
+              has 1, :shop_owner                            # has 1
+              has 1, :wife,        :through => :shop_owner  # has 1 => has 1
+              has 1, :ring,        :through => :shop_owner  # has 1 => has 1 => has 1
+              has n, :coats,       :through => :shop_owner  # has 1 => has 1 => has n
+              has n, :children,    :through => :shop_owner  # has 1 => has n
+              has n, :toys,        :through => :shop_owner  # has 1 => has n => has n
+              has n, :boogers,     :through => :shop_owner  # has 1 => has n => has 1
             end
 
             class ShopOwner
@@ -614,13 +698,13 @@ if ADAPTER
               property :id, Serial
               property :name, String
               belongs_to :shop, :class_name => 'Sweets::Shop'
-              has 1, :wife,                            :class_name => 'Sweets::Wife'
-              has n, :children,                        :class_name => 'Sweets::Child'
-              has n, :toys,     :through => :children, :class_name => 'Sweets::Toy'
-              has n, :boogers,  :through => :children, :class_name => 'Sweets::Booger'
-              has n, :coats,    :through => :wife,     :class_name => 'Sweets::Coat'
-              has 1, :ring,     :through => :wife,     :class_name => 'Sweets::Ring'
-              has n, :schools,  :through => :children, :class_name => 'Sweets::School'
+              has 1, :wife
+              has n, :children
+              has n, :toys,     :through => :children
+              has n, :boogers,  :through => :children
+              has n, :coats,    :through => :wife
+              has 1, :ring,     :through => :wife
+              has n, :schools,  :through => :children
             end
 
             class Wife
@@ -630,9 +714,9 @@ if ADAPTER
               end
               property :id, Serial
               property :name, String
-              belongs_to :shop_owner, :class_name => 'Sweets::ShopOwner'
-              has 1, :ring,  :class_name => 'Sweets::Ring'
-              has n, :coats, :class_name => 'Sweets::Coat'
+              belongs_to :shop_owner
+              has 1, :ring
+              has n, :coats
             end
 
             class Coat
@@ -642,7 +726,7 @@ if ADAPTER
               end
               property :id, Serial
               property :name, String
-              belongs_to :wife, :class_name => 'Sweets::Wife'
+              belongs_to :wife
             end
 
             class Ring
@@ -652,7 +736,7 @@ if ADAPTER
               end
               property :id, Serial
               property :name, String
-              belongs_to :wife, :class_name => 'Sweets::Wife'
+              belongs_to :wife
             end
 
             class Child
@@ -662,9 +746,9 @@ if ADAPTER
               end
               property :id, Serial
               property :name, String
-              belongs_to :shop_owner, :class_name => 'Sweets::ShopOwner'
-              has n, :toys,   :class_name => 'Sweets::Toy'
-              has 1, :booger, :class_name => 'Sweets::Booger'
+              belongs_to :shop_owner
+              has n, :toys
+              has 1, :booger
             end
 
             class Booger
@@ -674,7 +758,7 @@ if ADAPTER
               end
               property :id, Serial
               property :name, String
-              belongs_to :child, :class_name => 'Sweets::Child'
+              belongs_to :child
             end
 
             class Toy
@@ -684,7 +768,7 @@ if ADAPTER
               end
               property :id, Serial
               property :name, String
-              belongs_to :child, :class_name => 'Sweets::Child'
+              belongs_to :child
             end
 
             class Cake
@@ -694,14 +778,14 @@ if ADAPTER
               end
               property :id, Serial
               property :name, String
-              belongs_to :shop, :class_name => 'Sweets::Shop'
-              belongs_to :customer, :class_name => 'Sweets::Customer'
-              has n, :slices,                           :class_name => 'Sweets::Slice'
-              has n, :bites,       :through => :slices, :class_name => 'Sweets::Bite'
-              has 1, :recipe,                           :class_name => 'Sweets::Recipe'
-              has n, :ingredients, :through => :recipe, :class_name => 'Sweets::Ingredient'
-              has 1, :creator,     :through => :recipe, :class_name => 'Sweets::Creator'
-              has n, :shapes,      :through => :slices, :class_name => 'Sweets::Shape'
+              belongs_to :shop
+              belongs_to :customer
+              has n, :ultraslices
+              has n, :bites,       :through => :ultraslices
+              has 1, :recipe
+              has n, :ingredients, :through => :recipe
+              has 1, :creator,     :through => :recipe
+              has n, :shapes,      :through => :ultraslices
             end
 
             class Recipe
@@ -711,9 +795,9 @@ if ADAPTER
               end
               property :id, Serial
               property :name, String
-              belongs_to :cake, :class_name => 'Sweets::Cake'
-              has n, :ingredients, :class_name => 'Sweets::Ingredient'
-              has 1, :creator,     :class_name => 'Sweets::Creator'
+              belongs_to :cake
+              has n, :ingredients
+              has 1, :creator
             end
 
             class Customer
@@ -723,7 +807,7 @@ if ADAPTER
               end
               property :id, Serial
               property :name, String
-              has n, :cakes, :class_name => 'Sweets::Cake'
+              has n, :cakes
             end
 
             class Creator
@@ -733,7 +817,7 @@ if ADAPTER
               end
               property :id, Serial
               property :name, String
-              belongs_to :recipe, :class_name => 'Sweets::Recipe'
+              belongs_to :recipe
             end
 
             class Ingredient
@@ -743,19 +827,19 @@ if ADAPTER
               end
               property :id, Serial
               property :name, String
-              belongs_to :recipe, :class_name => 'Sweets::Recipe'
+              belongs_to :recipe
             end
 
-            class Slice
+            class Ultraslice
               include DataMapper::Resource
               def self.default_repository_name
                 ADAPTER
               end
               property :id, Serial
               property :size, Integer
-              belongs_to :cake, :class_name => 'Sweets::Cake'
-              has n, :bites, :class_name => 'Sweets::Bite'
-              has 1, :shape, :class_name => 'Sweets::Shape'
+              belongs_to :cake
+              has n, :bites
+              has 1, :shape
             end
 
             class Shape
@@ -765,7 +849,7 @@ if ADAPTER
               end
               property :id, Serial
               property :name, String
-              belongs_to :slice, :class_name => 'Sweets::Slice'
+              belongs_to :ultraslice
             end
 
             class Bite
@@ -775,7 +859,7 @@ if ADAPTER
               end
               property :id, Serial
               property :name, String
-              belongs_to :slice, :class_name => 'Sweets::Slice'
+              belongs_to :ultraslice
             end
 
             DataMapper::Resource.descendants.each do |descendant|
@@ -832,31 +916,31 @@ if ADAPTER
 
             # has n => has n
 
-            10.times do |i| german_chocolate.slices << Slice.new(:size => i) end
-            5.times do |i| short_cake.slices << Slice.new(:size => i) end
-            german_chocolate.slices.size.should == 10
+            10.times do |i| german_chocolate.ultraslices << Ultraslice.new(:size => i) end
+            5.times do |i| short_cake.ultraslices << Ultraslice.new(:size => i) end
+            german_chocolate.ultraslices.size.should == 10
             # has n => has n => has 1
 
-            german_chocolate.slices.each do |slice|
+            german_chocolate.ultraslices.each do |ultraslice|
               shape = Shape.new(:name => 'square')
-              slice.shape = shape
+              ultraslice.shape = shape
               shape.save
             end
-            short_cake.slices.each do |slice|
+            short_cake.ultraslices.each do |ultraslice|
               shape = Shape.new(:name => 'round')
-              slice.shape = shape
+              ultraslice.shape = shape
               shape.save
             end
 
             # has n => has n => has n
-            german_chocolate.slices.each do |slice|
+            german_chocolate.ultraslices.each do |ultraslice|
               6.times do |i|
-                slice.bites << Bite.new(:name => "Big bite nr #{i}")
+                ultraslice.bites << Bite.new(:name => "Big bite nr #{i}")
               end
             end
-            short_cake.slices.each do |slice|
+            short_cake.ultraslices.each do |ultraslice|
               3.times do |i|
-                slice.bites << Bite.new(:name => "Small bite nr #{i}")
+                ultraslice.bites << Bite.new(:name => "Small bite nr #{i}")
               end
             end
 
@@ -919,10 +1003,10 @@ if ADAPTER
       #
 
       it 'should return the right children for has n => has n relationships' do
-        Sweets::Shop.first.slices.size.should == 15
+        Sweets::Shop.first.ultraslices.size.should == 15
         10.times do |i|
-          Sweets::Shop.first.slices.select do |slice|
-            slice.cake == Sweets::Cake.first(:name => 'German Chocolate') && slice.size == i
+          Sweets::Shop.first.ultraslices.select do |ultraslice|
+            ultraslice.cake == Sweets::Cake.first(:name => 'German Chocolate') && ultraslice.size == i
           end
         end
       end
@@ -940,10 +1024,10 @@ if ADAPTER
       it 'should return the right children for has n => has n => has n' do
         Sweets::Shop.first.bites.size.should == 75
         Sweets::Shop.first.bites.select do |bite|
-          bite.slice.cake == Sweets::Cake.first(:name => 'German Chocolate')
+          bite.ultraslice.cake == Sweets::Cake.first(:name => 'German Chocolate')
         end.size.should == 60
         Sweets::Shop.first.bites.select do |bite|
-          bite.slice.cake == Sweets::Cake.first(:name => 'Short Cake')
+          bite.ultraslice.cake == Sweets::Cake.first(:name => 'Short Cake')
         end.size.should == 15
       end