acts_as_list 0.1.4 → 0.1.5

data/.gitignore

@@ -2,3 +2,5 @@
 .bundle
 Gemfile.lock
 pkg/*
+.rvmrc
+*.tmproj

data/README.md

@@ -0,0 +1,37 @@
+# ActsAsList
+
+## Description
+
+This `acts_as extension` provides the capabilities for sorting and reordering a number of objects in a list. The class that has this specified needs to have a `position` column defined as an integer on the mapped database table.
+
+
+## Example
+
+    class TodoList < ActiveRecord::Base
+      has_many :todo_items, :order => "position"
+    end
+    
+    class TodoItem < ActiveRecord::Base
+      belongs_to :todo_list
+      acts_as_list :scope => :todo_list
+    end
+    
+    todo_list.first.move_to_bottom
+    todo_list.last.move_higher
+    
+## Notes
+If the `position` column has a default value, then there is a slight change in behavior, i.e if you have 4 items in the list, and you insert 1, with a default position 0, it would be pushed to the bottom of the list. Please look at the tests for this and some recent pull requests for discussions related to this.
+
+## Contributing to `acts_as_list`
+ 
+- Check out the latest master to make sure the feature hasn't been implemented or the bug hasn't been fixed yet
+- Check out the issue tracker to make sure someone already hasn't requested it and/or contributed it
+- Fork the project
+- Start a feature/bugfix branch
+- Commit and push until you are happy with your contribution
+- Make sure to add tests for it. This is important so I don't break it in a future version unintentionally.
+- Please try not to mess with the Rakefile, version, or history. If you want to have your own version, or is otherwise necessary, that is fine, but please isolate to its own commit so I can cherry-pick around it.
+
+## Copyright
+
+Copyright (c) 2007 David Heinemeier Hansson, released under the MIT license

data/lib/acts_as_list/active_record/acts/list.rb

@@ -31,7 +31,7 @@ module ActiveRecord
         #   to give it an entire string that is interpolated if you need a tighter scope than just a foreign key.
         #   Example: <tt>acts_as_list :scope => 'todo_list_id = #{todo_list_id} AND completed = 0'</tt>
         # * +top_of_list+ - defines the integer used for the top of the list. Defaults to 1. Use 0 to make the collection
-        #   act more line an array in it's indexing.
+        #   act more like an array in its indexing.
         def acts_as_list(options = {})
           configuration = { :column => "position", :scope => "1 = 1", :top_of_list => 1}
           configuration.update(options) if options.is_a?(Hash)
@@ -74,8 +74,8 @@ module ActiveRecord
 
             #{scope_condition_method}
 
-            before_destroy :decrement_positions_on_lower_items
-            before_create  :add_to_list_bottom
+            after_destroy :decrement_positions_on_lower_items
+            before_validation :add_to_list_bottom, :on => :create
           EOV
         end
       end
@@ -180,7 +180,19 @@ module ActiveRecord
 
         # Test if this record is in a list
         def in_list?
-          !send(position_column).nil?
+          !not_in_list?
+        end
+        
+        def not_in_list?
+          send(position_column).nil?
+        end
+        
+        def default_position
+          acts_as_list_class.columns_hash[position_column.to_s].default
+        end
+
+        def default_position?
+          default_position == send(position_column)
         end
 
         private
@@ -189,7 +201,7 @@ module ActiveRecord
           end
 
           def add_to_list_bottom
-            if self[position_column].nil?
+            if not_in_list? || default_position?
               self[position_column] = bottom_position_in_list.to_i + 1
             else
               increment_positions_on_lower_items(self[position_column])
@@ -210,7 +222,7 @@ module ActiveRecord
           def bottom_item(except = nil)
             conditions = scope_condition
             conditions = "#{conditions} AND #{self.class.primary_key} != #{except.id}" if except
-            acts_as_list_class.find(:first, :conditions => conditions, :order => "#{position_column} DESC")
+            acts_as_list_class.unscoped.find(:first, :conditions => conditions, :order => "#{position_column} DESC")
           end
 
           # Forces item to assume the bottom position in the list.
@@ -231,10 +243,11 @@ module ActiveRecord
           end
 
           # This has the effect of moving all the lower items up one.
-          def decrement_positions_on_lower_items
+          def decrement_positions_on_lower_items(position=nil)
             return unless in_list?
+            position ||= send(position_column).to_i
             acts_as_list_class.update_all(
-              "#{position_column} = (#{position_column} - 1)", "#{scope_condition} AND #{position_column} > #{send(position_column).to_i}"
+              "#{position_column} = (#{position_column} - 1)", "#{scope_condition} AND #{position_column} > #{position}"
             )
           end
 
@@ -260,11 +273,48 @@ module ActiveRecord
             )
           end
 
+          # Reorders intermediate items to support moving an item from old_position to new_position.
+          def shuffle_positions_on_intermediate_items(old_position, new_position)
+            return if old_position == new_position
+
+            if old_position < new_position
+              # Decrement position of intermediate items
+              #
+              # e.g., if moving an item from 2 to 5,
+              # move [3, 4, 5] to [2, 3, 4]
+              acts_as_list_class.update_all(
+                "#{position_column} = (#{position_column} - 1)", "#{scope_condition} AND #{position_column} > #{old_position} AND #{position_column} <= #{new_position}"
+              )
+            else
+              # Increment position of intermediate items
+              #
+              # e.g., if moving an item from 5 to 2,
+              # move [2, 3, 4] to [3, 4, 5]
+              acts_as_list_class.update_all(
+                "#{position_column} = (#{position_column} + 1)", "#{scope_condition} AND #{position_column} >= #{new_position} AND #{position_column} < #{old_position}"
+              )
+            end
+          end
+
           def insert_at_position(position)
-            remove_from_list
-            increment_positions_on_lower_items(position)
+            if in_list?
+              old_position = send(position_column).to_i
+              return if position == old_position
+              shuffle_positions_on_intermediate_items(old_position, position)
+            else
+              increment_positions_on_lower_items(position)
+            end
             self.update_attribute(position_column, position)
           end
+
+          # used by insert_at_position instead of remove_from_list, as postgresql raises error if position_column has non-null constraint
+          def store_at_0
+            if in_list?
+              old_position = send(position_column).to_i
+              update_attribute(position_column, 0)
+              decrement_positions_on_lower_items(old_position)
+            end
+          end
       end 
     end
   end

data/lib/acts_as_list/version.rb

@@ -1,7 +1,7 @@
 module ActiveRecord
   module Acts
     module List
-      VERSION = "0.1.4"
+      VERSION = "0.1.5"
     end
   end
 end

data/test/helper.rb

@@ -10,3 +10,5 @@ end
 require 'test/unit'
 require 'active_record'
 require "#{File.dirname(__FILE__)}/../init"
+
+require 'shared'

data/test/shared.rb

@@ -0,0 +1,7 @@
+# Common shared behaviour.
+module Shared
+  autoload :List,           'shared_list'
+  autoload :ListSub,        'shared_list_sub'
+  autoload :ZeroBased,      'shared_zero_based'
+  autoload :ArrayScopeList, 'shared_array_scope_list'
+end

data/test/shared_array_scope_list.rb

@@ -0,0 +1,156 @@
+module Shared
+  module ArrayScopeList
+    def setup
+      (1..4).each { |counter| ArrayScopeListMixin.create! :pos => counter, :parent_id => 5, :parent_type => 'ParentClass' }
+    end
+
+    def test_reordering
+      assert_equal [1, 2, 3, 4], ArrayScopeListMixin.find(:all, :conditions => "parent_id = 5 AND parent_type = 'ParentClass'", :order => 'pos').map(&:id)
+
+      ArrayScopeListMixin.find(2).move_lower
+      assert_equal [1, 3, 2, 4], ArrayScopeListMixin.find(:all, :conditions => "parent_id = 5 AND parent_type = 'ParentClass'", :order => 'pos').map(&:id)
+
+      ArrayScopeListMixin.find(2).move_higher
+      assert_equal [1, 2, 3, 4], ArrayScopeListMixin.find(:all, :conditions => "parent_id = 5 AND parent_type = 'ParentClass'", :order => 'pos').map(&:id)
+
+      ArrayScopeListMixin.find(1).move_to_bottom
+      assert_equal [2, 3, 4, 1], ArrayScopeListMixin.find(:all, :conditions => "parent_id = 5 AND parent_type = 'ParentClass'", :order => 'pos').map(&:id)
+
+      ArrayScopeListMixin.find(1).move_to_top
+      assert_equal [1, 2, 3, 4], ArrayScopeListMixin.find(:all, :conditions => "parent_id = 5 AND parent_type = 'ParentClass'", :order => 'pos').map(&:id)
+
+      ArrayScopeListMixin.find(2).move_to_bottom
+      assert_equal [1, 3, 4, 2], ArrayScopeListMixin.find(:all, :conditions => "parent_id = 5 AND parent_type = 'ParentClass'", :order => 'pos').map(&:id)
+
+      ArrayScopeListMixin.find(4).move_to_top
+      assert_equal [4, 1, 3, 2], ArrayScopeListMixin.find(:all, :conditions => "parent_id = 5 AND parent_type = 'ParentClass'", :order => 'pos').map(&:id)
+    end
+
+    def test_move_to_bottom_with_next_to_last_item
+      assert_equal [1, 2, 3, 4], ArrayScopeListMixin.find(:all, :conditions => "parent_id = 5 AND parent_type = 'ParentClass'", :order => 'pos').map(&:id)
+      ArrayScopeListMixin.find(3).move_to_bottom
+      assert_equal [1, 2, 4, 3], ArrayScopeListMixin.find(:all, :conditions => "parent_id = 5 AND parent_type = 'ParentClass'", :order => 'pos').map(&:id)
+    end
+
+    def test_next_prev
+      assert_equal ArrayScopeListMixin.find(2), ArrayScopeListMixin.find(1).lower_item
+      assert_nil ArrayScopeListMixin.find(1).higher_item
+      assert_equal ArrayScopeListMixin.find(3), ArrayScopeListMixin.find(4).higher_item
+      assert_nil ArrayScopeListMixin.find(4).lower_item
+    end
+
+    def test_injection
+      item = ArrayScopeListMixin.new(:parent_id => 1, :parent_type => 'ParentClass')
+      assert_equal '"mixins"."parent_id" = 1 AND "mixins"."parent_type" = \'ParentClass\'', item.scope_condition
+      assert_equal "pos", item.position_column
+    end
+
+    def test_insert
+      new = ArrayScopeListMixin.create(:parent_id => 20, :parent_type => 'ParentClass')
+      assert_equal 1, new.pos
+      assert new.first?
+      assert new.last?
+
+      new = ArrayScopeListMixin.create(:parent_id => 20, :parent_type => 'ParentClass')
+      assert_equal 2, new.pos
+      assert !new.first?
+      assert new.last?
+
+      new = ArrayScopeListMixin.create(:parent_id => 20, :parent_type => 'ParentClass')
+      assert_equal 3, new.pos
+      assert !new.first?
+      assert new.last?
+
+      new = ArrayScopeListMixin.create(:parent_id => 0, :parent_type => 'ParentClass')
+      assert_equal 1, new.pos
+      assert new.first?
+      assert new.last?
+    end
+
+    def test_insert_at
+      new = ArrayScopeListMixin.create(:parent_id => 20, :parent_type => 'ParentClass')
+      assert_equal 1, new.pos
+
+      new = ArrayScopeListMixin.create(:parent_id => 20, :parent_type => 'ParentClass')
+      assert_equal 2, new.pos
+
+      new = ArrayScopeListMixin.create(:parent_id => 20, :parent_type => 'ParentClass')
+      assert_equal 3, new.pos
+
+      new4 = ArrayScopeListMixin.create(:parent_id => 20, :parent_type => 'ParentClass')
+      assert_equal 4, new4.pos
+
+      new4.insert_at(3)
+      assert_equal 3, new4.pos
+
+      new.reload
+      assert_equal 4, new.pos
+
+      new.insert_at(2)
+      assert_equal 2, new.pos
+
+      new4.reload
+      assert_equal 4, new4.pos
+
+      new5 = ArrayScopeListMixin.create(:parent_id => 20, :parent_type => 'ParentClass')
+      assert_equal 5, new5.pos
+
+      new5.insert_at(1)
+      assert_equal 1, new5.pos
+
+      new4.reload
+      assert_equal 5, new4.pos
+    end
+
+    def test_delete_middle
+      assert_equal [1, 2, 3, 4], ArrayScopeListMixin.find(:all, :conditions => "parent_id = 5 AND parent_type = 'ParentClass'", :order => 'pos').map(&:id)
+
+      ArrayScopeListMixin.find(2).destroy
+
+      assert_equal [1, 3, 4], ArrayScopeListMixin.find(:all, :conditions => "parent_id = 5 AND parent_type = 'ParentClass'", :order => 'pos').map(&:id)
+
+      assert_equal 1, ArrayScopeListMixin.find(1).pos
+      assert_equal 2, ArrayScopeListMixin.find(3).pos
+      assert_equal 3, ArrayScopeListMixin.find(4).pos
+
+      ArrayScopeListMixin.find(1).destroy
+
+      assert_equal [3, 4], ArrayScopeListMixin.find(:all, :conditions => "parent_id = 5 AND parent_type = 'ParentClass'", :order => 'pos').map(&:id)
+
+      assert_equal 1, ArrayScopeListMixin.find(3).pos
+      assert_equal 2, ArrayScopeListMixin.find(4).pos
+    end
+
+    def test_remove_from_list_should_then_fail_in_list?
+      assert_equal true, ArrayScopeListMixin.find(1).in_list?
+      ArrayScopeListMixin.find(1).remove_from_list
+      assert_equal false, ArrayScopeListMixin.find(1).in_list?
+    end
+
+    def test_remove_from_list_should_set_position_to_nil
+      assert_equal [1, 2, 3, 4], ArrayScopeListMixin.find(:all, :conditions => "parent_id = 5 AND parent_type = 'ParentClass'", :order => 'pos').map(&:id)
+
+      ArrayScopeListMixin.find(2).remove_from_list
+
+      assert_equal [2, 1, 3, 4], ArrayScopeListMixin.find(:all, :conditions => "parent_id = 5 AND parent_type = 'ParentClass'", :order => 'pos').map(&:id)
+
+      assert_equal 1,   ArrayScopeListMixin.find(1).pos
+      assert_equal nil, ArrayScopeListMixin.find(2).pos
+      assert_equal 2,   ArrayScopeListMixin.find(3).pos
+      assert_equal 3,   ArrayScopeListMixin.find(4).pos
+    end
+
+    def test_remove_before_destroy_does_not_shift_lower_items_twice
+      assert_equal [1, 2, 3, 4], ArrayScopeListMixin.find(:all, :conditions => "parent_id = 5 AND parent_type = 'ParentClass'", :order => 'pos').map(&:id)
+
+      ArrayScopeListMixin.find(2).remove_from_list
+      ArrayScopeListMixin.find(2).destroy
+
+      assert_equal [1, 3, 4], ArrayScopeListMixin.find(:all, :conditions => "parent_id = 5 AND parent_type = 'ParentClass'", :order => 'pos').map(&:id)
+
+      assert_equal 1, ArrayScopeListMixin.find(1).pos
+      assert_equal 2, ArrayScopeListMixin.find(3).pos
+      assert_equal 3, ArrayScopeListMixin.find(4).pos
+    end
+  end
+end

data/test/shared_list.rb

@@ -0,0 +1,233 @@
+module Shared
+  module List
+    def setup
+      (1..4).each { |counter| ListMixin.create! :pos => counter, :parent_id => 5 }
+    end
+
+    def test_reordering
+      assert_equal [1, 2, 3, 4], ListMixin.find(:all, :conditions => 'parent_id = 5', :order => 'pos').map(&:id)
+
+      ListMixin.find(2).move_lower
+      assert_equal [1, 3, 2, 4], ListMixin.find(:all, :conditions => 'parent_id = 5', :order => 'pos').map(&:id)
+
+      ListMixin.find(2).move_higher
+      assert_equal [1, 2, 3, 4], ListMixin.find(:all, :conditions => 'parent_id = 5', :order => 'pos').map(&:id)
+
+      ListMixin.find(1).move_to_bottom
+      assert_equal [2, 3, 4, 1], ListMixin.find(:all, :conditions => 'parent_id = 5', :order => 'pos').map(&:id)
+
+      ListMixin.find(1).move_to_top
+      assert_equal [1, 2, 3, 4], ListMixin.find(:all, :conditions => 'parent_id = 5', :order => 'pos').map(&:id)
+
+      ListMixin.find(2).move_to_bottom
+      assert_equal [1, 3, 4, 2], ListMixin.find(:all, :conditions => 'parent_id = 5', :order => 'pos').map(&:id)
+
+      ListMixin.find(4).move_to_top
+      assert_equal [4, 1, 3, 2], ListMixin.find(:all, :conditions => 'parent_id = 5', :order => 'pos').map(&:id)
+    end
+
+    def test_move_to_bottom_with_next_to_last_item
+      assert_equal [1, 2, 3, 4], ListMixin.find(:all, :conditions => 'parent_id = 5', :order => 'pos').map(&:id)
+      ListMixin.find(3).move_to_bottom
+      assert_equal [1, 2, 4, 3], ListMixin.find(:all, :conditions => 'parent_id = 5', :order => 'pos').map(&:id)
+    end
+
+    def test_next_prev
+      assert_equal ListMixin.find(2), ListMixin.find(1).lower_item
+      assert_nil ListMixin.find(1).higher_item
+      assert_equal ListMixin.find(3), ListMixin.find(4).higher_item
+      assert_nil ListMixin.find(4).lower_item
+    end
+
+    def test_injection
+      item = ListMixin.new(:parent_id => 1)
+      assert_equal '"mixins"."parent_id" = 1', item.scope_condition
+      assert_equal "pos", item.position_column
+    end
+
+    def test_insert
+      new = ListMixin.create(:parent_id => 20)
+      assert_equal 1, new.pos
+      assert new.first?
+      assert new.last?
+
+      new = ListMixin.create(:parent_id => 20)
+      assert_equal 2, new.pos
+      assert !new.first?
+      assert new.last?
+
+      new = ListMixin.create(:parent_id => 20)
+      assert_equal 3, new.pos
+      assert !new.first?
+      assert new.last?
+
+      new = ListMixin.create(:parent_id => 0)
+      assert_equal 1, new.pos
+      assert new.first?
+      assert new.last?
+    end
+
+    def test_insert_at
+      new = ListMixin.create(:parent_id => 20)
+      assert_equal 1, new.pos
+
+      new = ListMixin.create(:parent_id => 20)
+      assert_equal 2, new.pos
+
+      new = ListMixin.create(:parent_id => 20)
+      assert_equal 3, new.pos
+
+      new4 = ListMixin.create(:parent_id => 20)
+      assert_equal 4, new4.pos
+
+      new4.insert_at(3)
+      assert_equal 3, new4.pos
+
+      new.reload
+      assert_equal 4, new.pos
+
+      new.insert_at(2)
+      assert_equal 2, new.pos
+
+      new4.reload
+      assert_equal 4, new4.pos
+
+      new5 = ListMixin.create(:parent_id => 20)
+      assert_equal 5, new5.pos
+
+      new5.insert_at(1)
+      assert_equal 1, new5.pos
+
+      new4.reload
+      assert_equal 5, new4.pos
+    end
+
+    def test_insert_middle_with_unsaved_item
+      assert_equal [1, 2, 3, 4], ListMixin.find(:all, :conditions => 'parent_id = 5', :order => 'pos').map(&:id)
+
+      # new item, not saved yet
+      insert_this = ListMixin.new(:parent_id => 5)
+      insert_this.insert_at(2)
+
+      assert_equal [1, 2, 3, 4, 5], ListMixin.find(:all, :conditions => 'parent_id = 5', :order => 'pos').map(&:pos)
+      assert_equal [1, 5, 2, 3, 4], ListMixin.find(:all, :conditions => 'parent_id = 5', :order => 'pos').map(&:id)
+    end
+
+    def test_delete_middle
+      assert_equal [1, 2, 3, 4], ListMixin.find(:all, :conditions => 'parent_id = 5', :order => 'pos').map(&:id)
+
+      ListMixin.find(2).destroy
+
+      assert_equal [1, 3, 4], ListMixin.find(:all, :conditions => 'parent_id = 5', :order => 'pos').map(&:id)
+
+      assert_equal 1, ListMixin.find(1).pos
+      assert_equal 2, ListMixin.find(3).pos
+      assert_equal 3, ListMixin.find(4).pos
+
+      ListMixin.find(1).destroy
+
+      assert_equal [3, 4], ListMixin.find(:all, :conditions => 'parent_id = 5', :order => 'pos').map(&:id)
+
+      assert_equal 1, ListMixin.find(3).pos
+      assert_equal 2, ListMixin.find(4).pos
+    end
+
+    def test_with_string_based_scope
+      new = ListWithStringScopeMixin.create(:parent_id => 500)
+      assert_equal 1, new.pos
+      assert new.first?
+      assert new.last?
+    end
+
+    def test_nil_scope
+      new1, new2, new3 = ListMixin.create, ListMixin.create, ListMixin.create
+      new2.move_higher
+      assert_equal [new2, new1, new3], ListMixin.find(:all, :conditions => 'parent_id IS NULL', :order => 'pos')
+    end
+
+    def test_remove_from_list_should_then_fail_in_list?
+      assert_equal true, ListMixin.find(1).in_list?
+      ListMixin.find(1).remove_from_list
+      assert_equal false, ListMixin.find(1).in_list?
+    end
+
+    def test_remove_from_list_should_set_position_to_nil
+      assert_equal [1, 2, 3, 4], ListMixin.find(:all, :conditions => 'parent_id = 5', :order => 'pos').map(&:id)
+
+      ListMixin.find(2).remove_from_list
+
+      assert_equal [2, 1, 3, 4], ListMixin.find(:all, :conditions => 'parent_id = 5', :order => 'pos').map(&:id)
+
+      assert_equal 1,   ListMixin.find(1).pos
+      assert_equal nil, ListMixin.find(2).pos
+      assert_equal 2,   ListMixin.find(3).pos
+      assert_equal 3,   ListMixin.find(4).pos
+    end
+
+    def test_remove_before_destroy_does_not_shift_lower_items_twice
+      assert_equal [1, 2, 3, 4], ListMixin.find(:all, :conditions => 'parent_id = 5', :order => 'pos').map(&:id)
+
+      ListMixin.find(2).remove_from_list
+      ListMixin.find(2).destroy
+
+      assert_equal [1, 3, 4], ListMixin.find(:all, :conditions => 'parent_id = 5', :order => 'pos').map(&:id)
+
+      assert_equal 1, ListMixin.find(1).pos
+      assert_equal 2, ListMixin.find(3).pos
+      assert_equal 3, ListMixin.find(4).pos
+    end
+
+    def test_before_destroy_callbacks_do_not_update_position_to_nil_before_deleting_the_record
+      assert_equal [1, 2, 3, 4], ListMixin.find(:all, :conditions => 'parent_id = 5', :order => 'pos').map(&:id)
+
+      # We need to trigger all the before_destroy callbacks without actually
+      # destroying the record so we can see the affect the callbacks have on
+      # the record.
+      # NOTE: Hotfix for rails3 ActiveRecord
+      list = ListMixin.find(2)
+      if list.respond_to?(:run_callbacks)
+        # Refactored to work according to Rails3 ActiveRSupport Callbacks <http://api.rubyonrails.org/classes/ActiveSupport/Callbacks.html>
+        list.run_callbacks :destroy, :before if rails_3
+        list.run_callbacks(:before_destroy) if !rails_3
+      else
+        list.send(:callback, :before_destroy)
+      end
+
+      assert_equal [1, 2, 3, 4], ListMixin.find(:all, :conditions => 'parent_id = 5', :order => 'pos').map(&:id)
+
+      assert_equal 1, ListMixin.find(1).pos
+      assert_equal 2, ListMixin.find(2).pos
+      assert_equal 2, ListMixin.find(3).pos
+      assert_equal 3, ListMixin.find(4).pos
+    end
+
+    def test_before_create_callback_adds_to_bottom
+      assert_equal [1, 2, 3, 4], ListMixin.find(:all, :conditions => 'parent_id = 5', :order => 'pos').map(&:id)
+
+      new = ListMixin.create(:parent_id => 5)
+      assert_equal 5, new.pos
+      assert !new.first?
+      assert new.last?
+
+      assert_equal [1, 2, 3, 4, 5], ListMixin.find(:all, :conditions => 'parent_id = 5', :order => 'pos').map(&:id)
+    end
+
+    def test_before_create_callback_adds_to_given_position
+      assert_equal [1, 2, 3, 4], ListMixin.find(:all, :conditions => 'parent_id = 5', :order => 'pos').map(&:id)
+
+      new = ListMixin.create(:pos => 1, :parent_id => 5)
+      assert_equal 1, new.pos
+      assert new.first?
+      assert !new.last?
+
+      assert_equal [5, 1, 2, 3, 4], ListMixin.find(:all, :conditions => 'parent_id = 5', :order => 'pos').map(&:id)
+
+      new = ListMixin.create(:pos => 3, :parent_id => 5)
+      assert_equal 3, new.pos
+      assert !new.first?
+      assert !new.last?
+
+      assert_equal [5, 1, 6, 2, 3, 4], ListMixin.find(:all, :conditions => 'parent_id = 5', :order => 'pos').map(&:id)
+    end
+  end
+end