snusnu-dm-is-awesome_set 0.7.1 → 0.10.0

data/README

@@ -6,9 +6,25 @@ I _think_ it does. Please test this out and let me know at jnicoll@gnexp.com
 if you run into any problems.  This readme will eventually have examples.  Until
 then, check the RDoc's and you should be fine.
 
+The latest versions of merb_datamapper by default use repository blocks which 
+also enable the Identity Map. This plugin relies on dm_adjust which does not 
+currently work with the Identity Map. Please add this line to your config/init.rb
+file in your Merb project:
+
+Merb::Plugins.config[:merb_datamapper][:use_repository_block] = false
+
+If you want to activate the IM, simply wrap code in a DataMapper repository block
+like so: 
+
+DataMapper.repository do
+ # Your code here
+end
+
 A quick note about discriminators:
 
 This version enables scoping that can either include or ignore discriminators.
 If you wish to scope by a discriminator, please include that column name in
 the scope option. Otherwise this plugin will work with all rows regardless of
-the discriminator column.
+the discriminator column.
+
+

data/Rakefile

@@ -4,9 +4,9 @@ require 'rake/gempackagetask'
 GEM_NAME = 'dm-is-awesome_set'
 
 spec = Gem::Specification.new do |s|
-  s.rubyforge_project = 'merb'
+  s.rubyforge_project = GEM_NAME
   s.name = GEM_NAME
-  s.version = "0.7.1"
+  s.version = "0.10.0"
   s.platform = Gem::Platform::RUBY
   s.has_rdoc = true
   s.extra_rdoc_files = ["README", "LICENSE", 'TODO']
@@ -15,10 +15,9 @@ spec = Gem::Specification.new do |s|
   s.author = "Jeremy Nicoll"
   s.email = "jnicoll@gnexp.com"
   s.homepage = "http://gnexp.com/"
-  s.add_dependency('dm-core', '>= 0.9.7')
-  s.add_dependency('dm-adjust', '>= 0.9.7')
-  s.add_dependency('dm-aggregates', '>= 0.9.7')
-  s.add_dependency('dm-validations', '>= 0.9.10')
+  s.add_dependency('dm-core',       '>= 0.10.0')
+  s.add_dependency('dm-adjust',     '>= 0.10.0')
+  s.add_dependency('dm-aggregates', '>= 0.10.0')
   s.require_path = 'lib'
   s.files = %w(LICENSE README Rakefile TODO) + Dir.glob("{lib,spec}/**/*")
 end

data/lib/dm-is-awesome_set.rb

@@ -1,6 +1,5 @@
 require 'pathname'
 ['dm-core', 'dm-adjust', 'dm-aggregates', 'dm-validations'].each do |dm_var|
-  gem dm_var, '>=0.9.7'
   require dm_var
 end
 require Pathname(__FILE__).dirname.expand_path / 'dm-is-awesome_set' / 'is' / 'awesome_set.rb'

data/lib/dm-is-awesome_set/is/awesome_set.rb

@@ -31,7 +31,7 @@ module DataMapper
         property :lft, Integer, :writer => :private, :index => true
         property :rgt, Integer, :writer => :private, :index => true
 
-        class_opts = {:class_name => self.name, :child_key => opts[:child_key], :order => [:lft.asc], :writer => :protected}
+        class_opts = {:model => self.name, :child_key => opts[:child_key], :order => [:lft.asc], :writer => :protected}
         belongs_to :parent,  class_opts
         has n,     :children, class_opts
 
@@ -153,7 +153,7 @@ module DataMapper
         def move(vector)
           transaction do
             move_without_saving(vector)
-            save!
+            respond_to?(:save!) ? save! : save
           end
           reload
         end
@@ -229,7 +229,7 @@ module DataMapper
 
         def update!(hash) #:nodoc#
           attributes_set(hash)
-          save!
+          respond_to?(:save!) ? save! : save
         end
 
         # Destroys the current node and all children nodes, running their before and after hooks

data/spec/dm-is-awesome_set_spec.rb

@@ -5,250 +5,578 @@ scope = {:scope => 1, :scope_2 => 2}
 scope2 = {:scope => 1, :scope_2 => 5}
 
 describe DataMapper::Is::AwesomeSet do
-  before :each do
-    Category.auto_migrate!
-    Discrim1.auto_migrate!
-    Discrim2.auto_migrate!
-  end
-
-  it "puts itself as the last root in the defined scope on initial save" do
-
-    c1 = Category.create(scope)
-    c2 = Category.create(scope)
-    c1.pos.should eql([1,2])
-    c2.pos.should eql([3,4])
-
-    c3 = Category.create(scope2)
-    c4 = Category.create(scope2)
-    c3.pos.should eql([1,2])
-    c4.pos.should eql([3,4])
-
-  end
-
-
-  it "moves itself into a parent" do
-
-    c1 = Category.create(scope)
-    c2 = Category.create(scope)
-    c3 = Category.create(scope)
-    c2.move(:into => c1)
-
-    [c1,c2,c3].each { |c| c.reload }
-    c1.pos.should eql([1,4])
-    c2.pos.should eql([2,3])
-    c3.pos.should eql([5,6])
-
-
-    c2.move(:into => c3)
-    [c1,c2,c3].each { |c| c.reload }
-    c1.pos.should eql([1,2])
-    c3.pos.should eql([3,6])
-    c2.pos.should eql([4,5])
-
-    # This is to ensure that
-    c4 = Category.new
-    c4.move(:into => c1)
-    [c1,c2,c3, c4].each { |c| c.reload }
-    c4.sco.should eql(c1.sco)
-    c1.pos.should eql([1,4])
-    c4.pos.should eql([2,3])
-    c3.pos.should eql([5,8])
-    c2.pos.should eql([6,7])
-  end
-
-  it "moves around properly" do
-    c1 = Category.create(scope)
-    c2 = Category.create(scope)
-    c3 = Category.create(scope)
-    c4 = Category.new(scope)
-
-    c2.move(:to => 1)
-    [c1,c2,c3].each { |c| c.reload }
-    c2.pos.should eql([1,2])
-    c1.pos.should eql([3,4])
-    c3.pos.should eql([5,6])
-
-    c3.move(:higher)
-    [c1,c2,c3].each { |c| c.reload }
-    c2.pos.should eql([1,2])
-    c3.pos.should eql([3,4])
-    c1.pos.should eql([5,6])
-
-    c3.move(:lower)
-    [c1,c2,c3].each { |c| c.reload }
-    c2.pos.should eql([1,2])
-    c1.pos.should eql([3,4])
-    c3.pos.should eql([5,6])
-
-    c1.move(:lowest)
-    [c1,c2,c3].each { |c| c.reload }
-    c2.pos.should eql([1,2])
-    c3.pos.should eql([3,4])
-    c1.pos.should eql([5,6])
-
-    c1.move(:highest)
-    [c1,c2,c3].each { |c| c.reload }
-    c1.pos.should eql([1,2])
-    c2.pos.should eql([3,4])
-    c3.pos.should eql([5,6])
-
-    c4.move(:highest)
-    [c1,c2,c3].each { |c| c.reload }
-
-    c4.pos.should eql([1,2])
-    c1.pos.should eql([3,4])
-    c2.pos.should eql([5,6])
-    c3.pos.should eql([7,8])
-
-  end
-
-  it "puts in proper places for above and below" do
-    c1 = Category.create(scope)
-    c2 = Category.create(scope)
-    c3 = Category.create(scope)
-
-    c2.move(:into => c1)
-    [c1,c2,c3].each { |c| c.reload }
-    c1.pos.should eql([1,4])
-    c2.pos.should eql([2,3])
-    c3.pos.should eql([5,6])
-
-
-    c3.move(:above => c2)
-    [c1,c2,c3].each { |c| c.reload }
-    c1.pos.should eql([1,6])
-    c2.pos.should eql([4,5])
-    c3.pos.should eql([2,3])
-
-    c3.move(:below => c1)
-    [c1,c2,c3].each { |c| c.reload }
-    c1.pos.should eql([1,4])
-    c2.pos.should eql([2,3])
-    c3.pos.should eql([5,6])
-
-    c2.move(:below => c1)
-    [c1,c2,c3].each { |c| c.reload }
-    c1.pos.should eql([1,2])
-    c2.pos.should eql([3,4])
-    c3.pos.should eql([5,6])
-  end
-
-  it "gets the parent" do
-    c1 = Category.create(scope)
-    c2 = Category.create(scope)
-    c2.move(:into => c1)
-    c2.parent.should_not be_nil
-    c2.parent.id.should eql(c1.id)
-  end
-
-  it "identifies the root" do
-
-    c1 = Category.create(scope)
-    c2 = Category.create(scope)
-    c3 = Category.create(scope)
-    c2.move :into => c1
-    c3.move :into => c2
-    c3.root.should_not be_nil
-    c3.root.id.should eql(c1.id)
-  end
-
-  it "gets all roots in the current scope" do
-    c1 = Category.create(scope)
-    c2 = Category.create(scope)
-    c2.roots.size.should eql(2)
-
-    c3 = Category.create(scope2)
-    c4 = Category.create(scope2)
-    c3.roots.size.should eql(2)
-  end
-
-  it "gets all ancestors" do
-    c1 = Category.create(scope)
-    c2 = Category.create(scope)
-    c3 = Category.create(scope)
-
-    c2.move(:into => c1)
-    c3.move(:into => c2)
-    c3.ancestors.size.should eql(2)
-  end
-
-  it "gets all siblings" do
-    c1 = Category.create(scope)
-    c2 = Category.create(scope)
-    c3 = Category.create(scope)
-
-    c2.move(:into => c1)
-    c3.move(:into => c1)
-    c3.siblings.size.should eql(1)
-  end
-
-  it "moves scope properly" do
-    c1 = Category.create(scope)
-    c2 = Category.create(scope)
-    c3 = Category.create(scope)
-
-    c4 = Category.create(scope2)
-    c5 = Category.create(scope2)
-    c6 = Category.create(scope2)
-
-    c1.move(:into => c4)
-    [c1,c2,c3,c4,c5,c6].each { |c| c.reload }
-
-    c1.sco.should eql(scope2)
-
-    c2.pos.should eql([1,2])
-    c3.pos.should eql([3,4])
-
-    c4.pos.should eql([1,4])
-    c1.pos.should eql([2,3])
-    c5.pos.should eql([5,6])
-    c6.pos.should eql([7,8])
-
-    c4.move(:into => c2)
-    [c1,c2,c3,c4,c5,c6].each { |c| c.reload }
-    c1.sco.should eql(scope)
-    c4.sco.should eql(scope)
-
-    c2.pos.should eql([1,6])
-    c4.pos.should eql([2,5])
-    c1.pos.should eql([3,4])
-    c3.pos.should eql([7,8])
-
-
-    c5.pos.should eql([1,2])
-    c6.pos.should eql([3,4])
-
-    # You can move into the root of a different scope by passing an object from that scope
-    # or a hash that represents that scope
-    c5.move(:root => scope)
-    [c1,c2,c3,c4,c5,c6].each { |c| c.reload }
-    c5.sco.should eql(scope)
-
-    c2.pos.should eql([1,6])
-    c4.pos.should eql([2,5])
-    c1.pos.should eql([3,4])
-    c3.pos.should eql([7,8])
-    c5.pos.should eql([9,10])
-
-    c6.pos.should eql([1,2])
-
-  end
   
-  it "should get all rows in the database if the discrimator is not part of scope" do
-    c1 = CatD11.create(scope)
-    c2 = CatD11.create(scope)
-    c3 = CatD12.create(scope)
-    c4 = CatD12.create(scope)
-    CatD12.roots(scope).size.should eql(4)
+  describe "without active DM Identity Map" do
+  
+    before :each do
+      Category.auto_migrate!
+      Discrim1.auto_migrate!
+      Discrim2.auto_migrate!
+    end
+
+    it "puts itself as the last root in the defined scope on initial save" do
+
+      c1 = Category.create(scope)
+      c2 = Category.create(scope)
+      c1.pos.should eql([1,2])
+      c2.pos.should eql([3,4])
+
+      c3 = Category.create(scope2)
+      c4 = Category.create(scope2)
+      c3.pos.should eql([1,2])
+      c4.pos.should eql([3,4])
+
+    end
+
+    it "moves itself into a parent" do
+
+      c1 = Category.create(scope)
+      c2 = Category.create(scope)
+      c3 = Category.create(scope)
+      c2.move(:into => c1)
+
+      [c1,c2,c3].each { |c| c.reload }
+      c1.pos.should eql([1,4])
+      c2.pos.should eql([2,3])
+      c3.pos.should eql([5,6])
+
+
+      c2.move(:into => c3)
+      [c1,c2,c3].each { |c| c.reload }
+      c1.pos.should eql([1,2])
+      c3.pos.should eql([3,6])
+      c2.pos.should eql([4,5])
+
+      # This is to ensure that
+      c4 = Category.new
+      c4.move(:into => c1)
+      [c1,c2,c3, c4].each { |c| c.reload }
+      c4.sco.should eql(c1.sco)
+      c1.pos.should eql([1,4])
+      c4.pos.should eql([2,3])
+      c3.pos.should eql([5,8])
+      c2.pos.should eql([6,7])
+    end
+
+    it "moves around properly" do
+      c1 = Category.create(scope)
+      c2 = Category.create(scope)
+      c3 = Category.create(scope)
+      c4 = Category.new(scope)
+
+      c2.move(:to => 1)
+      [c1,c2,c3].each { |c| c.reload }
+      c2.pos.should eql([1,2])
+      c1.pos.should eql([3,4])
+      c3.pos.should eql([5,6])
+
+      c3.move(:higher)
+      [c1,c2,c3].each { |c| c.reload }
+      c2.pos.should eql([1,2])
+      c3.pos.should eql([3,4])
+      c1.pos.should eql([5,6])
+
+      c3.move(:lower)
+      [c1,c2,c3].each { |c| c.reload }
+      c2.pos.should eql([1,2])
+      c1.pos.should eql([3,4])
+      c3.pos.should eql([5,6])
+
+      c1.move(:lowest)
+      [c1,c2,c3].each { |c| c.reload }
+      c2.pos.should eql([1,2])
+      c3.pos.should eql([3,4])
+      c1.pos.should eql([5,6])
+
+      c1.move(:highest)
+      [c1,c2,c3].each { |c| c.reload }
+      c1.pos.should eql([1,2])
+      c2.pos.should eql([3,4])
+      c3.pos.should eql([5,6])
+
+      c4.move(:highest)
+      [c1,c2,c3].each { |c| c.reload }
+
+      c4.pos.should eql([1,2])
+      c1.pos.should eql([3,4])
+      c2.pos.should eql([5,6])
+      c3.pos.should eql([7,8])
+
+    end
+
+    it "puts in proper places for above and below with scope" do
+      c1 = Category.create(scope)
+      c2 = Category.create(scope)
+      c3 = Category.create(scope)
+
+      c2.move(:into => c1)
+      [c1,c2,c3].each { |c| c.reload }
+      c1.pos.should eql([1,4])
+      c2.pos.should eql([2,3])
+      c3.pos.should eql([5,6])
+
+
+      c3.move(:above => c2)
+      [c1,c2,c3].each { |c| c.reload }
+      c1.pos.should eql([1,6])
+      c2.pos.should eql([4,5])
+      c3.pos.should eql([2,3])
+
+      c3.move(:below => c1)
+      [c1,c2,c3].each { |c| c.reload }
+      c1.pos.should eql([1,4])
+      c2.pos.should eql([2,3])
+      c3.pos.should eql([5,6])
+
+      c2.move(:below => c1)
+      [c1,c2,c3].each { |c| c.reload }
+      c1.pos.should eql([1,2])
+      c2.pos.should eql([3,4])
+      c3.pos.should eql([5,6])
+    end
+  
+    it "puts in proper places for above and below without scope" do
+      c1 = Category.create
+      c2 = Category.create
+      c3 = Category.create
+
+      c2.move(:into => c1)
+      [c1,c2,c3].each { |c| c.reload }
+      c1.pos.should eql([1,4])
+      c2.pos.should eql([2,3])
+      c3.pos.should eql([5,6])
+
+
+      c3.move(:above => c2)
+      [c1,c2,c3].each { |c| c.reload }
+      c1.pos.should eql([1,6])
+      c2.pos.should eql([4,5])
+      c3.pos.should eql([2,3])
+
+      c3.move(:below => c1)
+      [c1,c2,c3].each { |c| c.reload }
+      c1.pos.should eql([1,4])
+      c2.pos.should eql([2,3])
+      c3.pos.should eql([5,6])
+
+      c2.move(:below => c1)
+      [c1,c2,c3].each { |c| c.reload }
+      c1.pos.should eql([1,2])
+      c2.pos.should eql([3,4])
+      c3.pos.should eql([5,6])
+    end
+
+    it "gets the parent" do
+      c1 = Category.create(scope)
+      c2 = Category.create(scope)
+      c2.move(:into => c1)
+      c2.parent.should_not be_nil
+      c2.parent.id.should eql(c1.id)
+    end
+
+    it "identifies the root" do
+
+      c1 = Category.create(scope)
+      c2 = Category.create(scope)
+      c3 = Category.create(scope)
+      c2.move :into => c1
+      c3.move :into => c2
+      c3.root.should_not be_nil
+      c3.root.id.should eql(c1.id)
+    end
+
+    it "gets all roots in the current scope" do
+      c1 = Category.create(scope)
+      c2 = Category.create(scope)
+      c2.roots.size.should eql(2)
+
+      c3 = Category.create(scope2)
+      c4 = Category.create(scope2)
+      c3.roots.size.should eql(2)
+    end
+
+    it "gets all ancestors" do
+      c1 = Category.create(scope)
+      c2 = Category.create(scope)
+      c3 = Category.create(scope)
+
+      c2.move(:into => c1)
+      c3.move(:into => c2)
+      c3.ancestors.size.should eql(2)
+    end
+
+    it "gets all siblings" do
+      c1 = Category.create(scope)
+      c2 = Category.create(scope)
+      c3 = Category.create(scope)
+
+      c2.move(:into => c1)
+      c3.move(:into => c1)
+      c3.siblings.size.should eql(1)
+    end
+
+    it "moves scope properly" do
+      c1 = Category.create(scope)
+      c2 = Category.create(scope)
+      c3 = Category.create(scope)
+
+      c4 = Category.create(scope2)
+      c5 = Category.create(scope2)
+      c6 = Category.create(scope2)
+
+      c1.move(:into => c4)
+      [c1,c2,c3,c4,c5,c6].each { |c| c.reload }
+
+      c1.sco.should eql(scope2)
+
+      c2.pos.should eql([1,2])
+      c3.pos.should eql([3,4])
+
+      c4.pos.should eql([1,4])
+      c1.pos.should eql([2,3])
+      c5.pos.should eql([5,6])
+      c6.pos.should eql([7,8])
+
+      c4.move(:into => c2)
+      [c1,c2,c3,c4,c5,c6].each { |c| c.reload }
+      c1.sco.should eql(scope)
+      c4.sco.should eql(scope)
+
+      c2.pos.should eql([1,6])
+      c4.pos.should eql([2,5])
+      c1.pos.should eql([3,4])
+      c3.pos.should eql([7,8])
+
+
+      c5.pos.should eql([1,2])
+      c6.pos.should eql([3,4])
+
+      # You can move into the root of a different scope by passing an object from that scope
+      # or a hash that represents that scope
+      c5.move(:root => scope)
+      [c1,c2,c3,c4,c5,c6].each { |c| c.reload }
+      c5.sco.should eql(scope)
+
+      c2.pos.should eql([1,6])
+      c4.pos.should eql([2,5])
+      c1.pos.should eql([3,4])
+      c3.pos.should eql([7,8])
+      c5.pos.should eql([9,10])
+
+      c6.pos.should eql([1,2])
+
+    end
+  
+    it "should get all rows in the database if the discrimator is not part of scope" do
+      c1 = CatD11.create(scope)
+      c2 = CatD11.create(scope)
+      c3 = CatD12.create(scope)
+      c4 = CatD12.create(scope)
+      CatD12.roots(scope).size.should eql(4)
+    end
+  
+    it "should get only the same object types if discriminator is part of scope" do
+      c1 = CatD21.create(scope)
+      c2 = CatD21.create(scope)
+      c3 = CatD22.create(scope2)
+      c4 = CatD22.create(scope2)
+      Discrim2.roots(scope.merge(:type => 'CatD21')).size.should eql(2)
+      Discrim2.roots(scope2.merge(:type => 'CatD22')).size.should eql(2)
+    end
+    
   end
   
-  it "should get only the same object types if discriminator is part of scope" do
-    c1 = CatD21.create(scope)
-    c2 = CatD21.create(scope)
-    c3 = CatD22.create(scope2)
-    c4 = CatD22.create(scope2)
-    Discrim2.roots(scope.merge(:type => 'CatD21')).size.should eql(2)
-    Discrim2.roots(scope2.merge(:type => 'CatD22')).size.should eql(2)
+  describe "with active DM Identity Map" do
+    
+    it "puts itself as the last root in the defined scope on initial save when using the identity map" do
+      repository do
+        c1 = Category.create(scope)
+        c2 = Category.create(scope)
+        c1.pos.should eql([1,2])
+        c2.pos.should eql([3,4])
+
+        c3 = Category.create(scope2)
+        c4 = Category.create(scope2)
+        c3.pos.should eql([1,2])
+        c4.pos.should eql([3,4])
+      end
+    end
+    
+    it "moves itself into a parent when using the identity map" do
+      repository do
+        c1 = Category.create(scope)
+        c2 = Category.create(scope)
+        c3 = Category.create(scope)
+        c2.move(:into => c1)
+
+        [c1,c2,c3].each { |c| c.reload }
+        c1.pos.should eql([1,4])
+        c2.pos.should eql([2,3])
+        c3.pos.should eql([5,6])
+
+
+        c2.move(:into => c3)
+        [c1,c2,c3].each { |c| c.reload }
+        c1.pos.should eql([1,2])
+        c3.pos.should eql([3,6])
+        c2.pos.should eql([4,5])
+
+        # This is to ensure that
+        c4 = Category.new
+        c4.move(:into => c1)
+        [c1,c2,c3, c4].each { |c| c.reload }
+        c4.sco.should eql(c1.sco)
+        c1.pos.should eql([1,4])
+        c4.pos.should eql([2,3])
+        c3.pos.should eql([5,8])
+        c2.pos.should eql([6,7])
+      end
+    end
+    
+    it "moves around properly when using the identity map" do
+      repository do
+        c1 = Category.create(scope)
+        c2 = Category.create(scope)
+        c3 = Category.create(scope)
+        c4 = Category.new(scope)
+
+        c2.move(:to => 1)
+        [c1,c2,c3].each { |c| c.reload }
+        c2.pos.should eql([1,2])
+        c1.pos.should eql([3,4])
+        c3.pos.should eql([5,6])
+
+        c3.move(:higher)
+        [c1,c2,c3].each { |c| c.reload }
+        c2.pos.should eql([1,2])
+        c3.pos.should eql([3,4])
+        c1.pos.should eql([5,6])
+
+        c3.move(:lower)
+        [c1,c2,c3].each { |c| c.reload }
+        c2.pos.should eql([1,2])
+        c1.pos.should eql([3,4])
+        c3.pos.should eql([5,6])
+
+        c1.move(:lowest)
+        [c1,c2,c3].each { |c| c.reload }
+        c2.pos.should eql([1,2])
+        c3.pos.should eql([3,4])
+        c1.pos.should eql([5,6])
+
+        c1.move(:highest)
+        [c1,c2,c3].each { |c| c.reload }
+        c1.pos.should eql([1,2])
+        c2.pos.should eql([3,4])
+        c3.pos.should eql([5,6])
+
+        c4.move(:highest)
+        [c1,c2,c3].each { |c| c.reload }
+
+        c4.pos.should eql([1,2])
+        c1.pos.should eql([3,4])
+        c2.pos.should eql([5,6])
+        c3.pos.should eql([7,8])
+      end
+    end
+    
+    it "puts in proper places for above and below with scope when using the identity map" do
+      repository do
+        c1 = Category.create(scope)
+        c2 = Category.create(scope)
+        c3 = Category.create(scope)
+
+        c2.move(:into => c1)
+        [c1,c2,c3].each { |c| c.reload }
+        c1.pos.should eql([1,4])
+        c2.pos.should eql([2,3])
+        c3.pos.should eql([5,6])
+
+
+        c3.move(:above => c2)
+        [c1,c2,c3].each { |c| c.reload }
+        c1.pos.should eql([1,6])
+        c2.pos.should eql([4,5])
+        c3.pos.should eql([2,3])
+
+        c3.move(:below => c1)
+        [c1,c2,c3].each { |c| c.reload }
+        c1.pos.should eql([1,4])
+        c2.pos.should eql([2,3])
+        c3.pos.should eql([5,6])
+
+        c2.move(:below => c1)
+        [c1,c2,c3].each { |c| c.reload }
+        c1.pos.should eql([1,2])
+        c2.pos.should eql([3,4])
+        c3.pos.should eql([5,6])
+      end
+    end
+    
+    it "puts in proper places for above and below without scope when using the identity map" do
+      repository do
+        c1 = Category.create
+        c2 = Category.create
+        c3 = Category.create
+
+        c2.move(:into => c1)
+        [c1,c2,c3].each { |c| c.reload }
+        c1.pos.should eql([1,4])
+        c2.pos.should eql([2,3])
+        c3.pos.should eql([5,6])
+
+
+        c3.move(:above => c2)
+        [c1,c2,c3].each { |c| c.reload }
+        c1.pos.should eql([1,6])
+        c2.pos.should eql([4,5])
+        c3.pos.should eql([2,3])
+
+        c3.move(:below => c1)
+        [c1,c2,c3].each { |c| c.reload }
+        c1.pos.should eql([1,4])
+        c2.pos.should eql([2,3])
+        c3.pos.should eql([5,6])
+
+        c2.move(:below => c1)
+        [c1,c2,c3].each { |c| c.reload }
+        c1.pos.should eql([1,2])
+        c2.pos.should eql([3,4])
+        c3.pos.should eql([5,6])
+      end
+    end
+    
+    it "gets the parent when using the identity map" do
+      repository do
+        c1 = Category.create(scope)
+        c2 = Category.create(scope)
+        c2.move(:into => c1)
+        c2.parent.should_not be_nil
+        c2.parent.id.should eql(c1.id)
+      end
+    end
+    
+    it "identifies the root when using the identity map" do
+      repository do
+        c1 = Category.create(scope)
+        c2 = Category.create(scope)
+        c3 = Category.create(scope)
+        c2.move :into => c1
+        c3.move :into => c2
+        c3.root.should_not be_nil
+        c3.root.id.should eql(c1.id)
+      end
+    end
+    
+    it "gets all roots in the current scope when using the identity map" do
+      repository do
+        c1 = Category.create(scope)
+        c2 = Category.create(scope)
+        c2.roots.size.should eql(2)
+
+        c3 = Category.create(scope2)
+        c4 = Category.create(scope2)
+        c3.roots.size.should eql(2)
+      end
+    end
+    
+    it "gets all ancestors when using the identity map" do
+      repository do
+        c1 = Category.create(scope)
+        c2 = Category.create(scope)
+        c3 = Category.create(scope)
+
+        c2.move(:into => c1)
+        c3.move(:into => c2)
+        c3.ancestors.size.should eql(2)
+      end
+    end
+    
+    it "gets all siblings when using the identity map" do
+      repository do
+        c1 = Category.create(scope)
+        c2 = Category.create(scope)
+        c3 = Category.create(scope)
+
+        c2.move(:into => c1)
+        c3.move(:into => c1)
+        c3.siblings.size.should eql(1)
+      end
+    end
+    
+    it "moves scope properly when using the identity map" do
+      repository do
+        c1 = Category.create(scope)
+        c2 = Category.create(scope)
+        c3 = Category.create(scope)
+
+        c4 = Category.create(scope2)
+        c5 = Category.create(scope2)
+        c6 = Category.create(scope2)
+
+        c1.move(:into => c4)
+        [c1,c2,c3,c4,c5,c6].each { |c| c.reload }
+
+        c1.sco.should eql(scope2)
+
+        c2.pos.should eql([1,2])
+        c3.pos.should eql([3,4])
+
+        c4.pos.should eql([1,4])
+        c1.pos.should eql([2,3])
+        c5.pos.should eql([5,6])
+        c6.pos.should eql([7,8])
+
+        c4.move(:into => c2)
+        [c1,c2,c3,c4,c5,c6].each { |c| c.reload }
+        c1.sco.should eql(scope)
+        c4.sco.should eql(scope)
+
+        c2.pos.should eql([1,6])
+        c4.pos.should eql([2,5])
+        c1.pos.should eql([3,4])
+        c3.pos.should eql([7,8])
+
+
+        c5.pos.should eql([1,2])
+        c6.pos.should eql([3,4])
+
+        # You can move into the root of a different scope by passing an object from that scope
+        # or a hash that represents that scope
+        c5.move(:root => scope)
+        [c1,c2,c3,c4,c5,c6].each { |c| c.reload }
+        c5.sco.should eql(scope)
+
+        c2.pos.should eql([1,6])
+        c4.pos.should eql([2,5])
+        c1.pos.should eql([3,4])
+        c3.pos.should eql([7,8])
+        c5.pos.should eql([9,10])
+
+        c6.pos.should eql([1,2])
+      end
+    end
+    
+    it "should get all rows in the database if the discrimator is not part of scope when using the identity map" do
+      repository do
+        c1 = CatD11.create(scope)
+        c2 = CatD11.create(scope)
+        c3 = CatD12.create(scope)
+        c4 = CatD12.create(scope)
+        CatD12.roots(scope).size.should eql(4)
+      end
+    end
+    
+    it "should get only the same object types if discriminator is part of scope when using the identity map" do
+      repository do
+        c1 = CatD21.create(scope)
+        c2 = CatD21.create(scope)
+        c3 = CatD22.create(scope2)
+        c4 = CatD22.create(scope2)
+        Discrim2.roots(scope.merge(:type => 'CatD21')).size.should eql(2)
+        Discrim2.roots(scope2.merge(:type => 'CatD22')).size.should eql(2)
+      end
+    end
     
   end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: snusnu-dm-is-awesome_set
 version: !ruby/object:Gem::Version 
-  version: 0.7.1
+  version: 0.10.0
 platform: ruby
 authors: 
 - Jeremy Nicoll
@@ -9,44 +9,38 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-02-12 00:00:00 -08:00
+date: 2009-05-20 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: dm-core
+  type: :runtime
   version_requirement: 
   version_requirements: !ruby/object:Gem::Requirement 
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        version: 0.9.7
+        version: 0.10.0
     version: 
 - !ruby/object:Gem::Dependency 
   name: dm-adjust
+  type: :runtime
   version_requirement: 
   version_requirements: !ruby/object:Gem::Requirement 
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        version: 0.9.7
+        version: 0.10.0
     version: 
 - !ruby/object:Gem::Dependency 
   name: dm-aggregates
+  type: :runtime
   version_requirement: 
   version_requirements: !ruby/object:Gem::Requirement 
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        version: 0.9.7
-    version: 
-- !ruby/object:Gem::Dependency 
-  name: dm-validations
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Requirement 
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        version: 0.9.10
+        version: 0.10.0
     version: 
 description: DataMapper nested set plugin that works
 email: jnicoll@gnexp.com
@@ -69,7 +63,7 @@ files:
 - lib/dm-is-awesome_set.rb
 - spec/dm-is-awesome_set_spec.rb
 - spec/spec_helper.rb
-has_rdoc: true
+has_rdoc: false
 homepage: http://gnexp.com/
 post_install_message: 
 rdoc_options: []
@@ -90,10 +84,10 @@ required_rubygems_version: !ruby/object:Gem::Requirement
   version: 
 requirements: []
 
-rubyforge_project: merb
+rubyforge_project: dm-is-awesome_set
 rubygems_version: 1.2.0
 signing_key: 
-specification_version: 2
+specification_version: 3
 summary: DataMapper nested set plugin that works
 test_files: []