sortifiable 0.2.0 → 0.2.1

data/CHANGELOG

@@ -1,3 +1,8 @@
+*0.2.1 (April 20th, 2011)
+
+* Add checking for scope changes so items are moved between lists correctly [Manuel Meurer]
+
+
 *0.2.0 (April 7th, 2011)
 
 * Use pessimistic locking to reduce concurrency problems

data/README

@@ -24,4 +24,17 @@ the scope methods and query interface introduced with Ruby on Rails 3.0
   todo_list.last.move_higher
 
 
+=== Contributions
+
+Bug fixes and new feature patches are welcome. Please provide tests and
+documentation wherever possible - without them it is unlikely your patch
+will be accepted. If you're fixing a bug then a failing test for the bug
+is essential. Once you have completed your patch please open a GitHub
+pull request and I will review it and respond as quickly as possible.
+
+Thanks to the following people for their contributions:
+
+* Manuel Meurer
+
+
 Copyright (c) 2011 Andrew White, released under the MIT license

data/lib/sortifiable/version.rb

@@ -1,3 +1,3 @@
 module Sortifiable
-  VERSION = "0.2.0"
+  VERSION = "0.2.1"
 end

data/lib/sortifiable.rb

@@ -48,30 +48,35 @@ module Sortifiable
     def acts_as_list(options = {})
       options.reverse_merge!(:scope => [], :column => :position)
 
-      if options[:scope].is_a?(Symbol) && reflections.key?(options[:scope])
-        reflection = reflections[options.delete(:scope)]
-
-        if reflection.belongs_to?
-          if reflection.options[:polymorphic]
-            options[:scope] = [
-              reflection.association_foreign_key.to_sym,
-              reflection.options[:foreign_type].to_sym
-            ]
+      if options[:scope].is_a?(Symbol)
+        if reflections.key?(options[:scope])
+          reflection = reflections[options.delete(:scope)]
+
+          if reflection.belongs_to?
+            if reflection.options[:polymorphic]
+              options[:scope] = [
+                reflection.association_foreign_key.to_sym,
+                reflection.options[:foreign_type].to_sym
+              ]
+            else
+              options[:scope] = reflection.association_foreign_key.to_sym
+            end
           else
-            options[:scope] = reflection.association_foreign_key.to_sym
+            raise ArgumentError, "Only belongs_to associations can be used as a scope"
           end
-        else
-          raise ArgumentError, "Only belongs_to associations can be used as a scope"
+        elsif options[:scope].to_s !~ /_id$/
+          options[:scope] = "#{options[:scope]}_id".to_sym
         end
-      elsif options[:scope].is_a?(Symbol) && options[:scope].to_s !~ /_id$/
-        options[:scope] = "#{options[:scope]}_id".to_sym
       end
 
       options[:class] = self
 
       include InstanceMethods
-      before_create :add_to_list
-      before_destroy :decrement_position_on_lower_items, :if => :in_list?
+
+      before_create  :add_to_list
+      before_destroy :decrement_position_on_lower_items,             :if => :in_list?
+      before_save    :decrement_position_on_lower_items_in_old_list, :if => :will_leave_list?
+      before_save    :add_to_bottom_of_new_list,                     :if => :will_leave_list?
 
       self.acts_as_list_options = options
     end
@@ -92,9 +97,9 @@ module Sortifiable
           ids = lock_list!
           last_position = ids.size
           if persisted?
-            update_position(last_position + 1)
+            update_position last_position + 1
           else
-            send("#{position_column}=".to_sym, last_position + 1)
+            set_position last_position + 1
           end
         end
       end
@@ -138,6 +143,11 @@ module Sortifiable
       !new_record? && !send(position_column).nil?
     end
 
+    # Test if this record is in a scoped list but will leave the scoped list when saved
+    def will_leave_list?
+      in_list? && scope_parts.any? { |scope_part| send("#{scope_part}_changed?") }
+    end
+
     # Increase the position of this item without adjusting the rest of the list.
     def increment_position
       in_list? && update_position(current_position + 1)
@@ -200,8 +210,7 @@ module Sortifiable
 
     # Returns the bottom position in the list.
     def last_position
-      item = last_item
-      item ? item.current_position : 0
+      last_item.try(:current_position) || 0
     end
     alias_method :bottom_position, :last_position
 
@@ -232,7 +241,7 @@ module Sortifiable
               END
             SQL
 
-            send("#{position_column}=".to_sym, current_position - 1)
+            set_position current_position - 1
             list_scope.update_all(sql) > 0
           end
         end
@@ -258,7 +267,7 @@ module Sortifiable
               END
             SQL
 
-            send("#{position_column}=".to_sym, current_position + 1)
+            set_position current_position + 1
             list_scope.update_all(sql) > 0
           end
         end
@@ -285,7 +294,7 @@ module Sortifiable
               END
             SQL
 
-            send("#{position_column}=".to_sym, last_position)
+            set_position last_position
             list_scope.update_all(sql) > 0
           end
         end
@@ -311,7 +320,7 @@ module Sortifiable
               END
             SQL
 
-            send("#{position_column}=".to_sym, 1)
+            set_position 1
             list_scope.update_all(sql) > 0
           end
         end
@@ -335,7 +344,7 @@ module Sortifiable
             END
           SQL
 
-          send("#{position_column}=".to_sym, nil)
+          set_position nil
           list_scope.update_all(sql) > 0
         end
       else
@@ -354,6 +363,46 @@ module Sortifiable
         list_scope.update_all(update, conditions) > 0
       end
 
+      def decrement_position_on_lower_items_in_old_list #:nodoc:
+        with_old_scope do
+          decrement_position_on_lower_items
+        end
+      end
+
+      def with_old_scope #:nodoc:
+        # Save new scope in variable
+        new_scope = scope_parts.map { |scope_part| send(scope_part) }
+
+        # Set old scope
+        scope_parts.each { |scope_part| send "#{scope_part}=", send("#{scope_part}_was") }
+
+        yield
+
+        # Set new scope
+        scope_parts.each_with_index { |scope_part, i| send "#{scope_part}=", new_scope[i] }
+      end
+
+      def scope_parts_from_string(string) #:nodoc:
+        string.split('AND').map(&:strip).map { |condition| condition.split.first }
+      end
+
+      def scope_parts #:nodoc:
+        if acts_as_list_options[:scope].is_a?(String)
+          scope_parts_from_string(acts_as_list_options[:scope])
+        else
+          Array(acts_as_list_options[:scope])
+        end
+      end
+
+      def add_to_bottom_of_new_list #:nodoc:
+        set_position nil
+        add_to_list
+      end
+
+      def set_position(position) #:nodoc:
+        send "#{position_column}=", position
+      end
+
       def list_class #:nodoc:
         acts_as_list_options[:class]
       end
@@ -384,15 +433,15 @@ module Sortifiable
 
       def scope_condition #:nodoc:
         if acts_as_list_options[:scope].is_a?(String)
-          instance_eval("\"#{acts_as_list_options[:scope]}\"")
+          instance_eval %("#{acts_as_list_options[:scope]}")
         else
-          Array.wrap(acts_as_list_options[:scope]).inject({}){ |m,k| m[k] = send(k); m }
+          Array(acts_as_list_options[:scope]).each_with_object({}) { |k, m| m[k] = send(k) }
         end
       end
 
-      def update_position(new_position)
-        list_class.update_all(["#{quoted_position_column} = ?", new_position], list_class.primary_key => id)
-        send("#{position_column}=".to_sym, new_position)
+      def update_position(new_position) #:nodoc:
+        list_class.update_all({ position_column => new_position }, { list_class.primary_key => id })
+        set_position new_position
       end
   end
 end

data/test/sortifiable_test.rb

@@ -47,6 +47,7 @@ end
 class ListWithStringScopeMixin < ActiveRecord::Base
   acts_as_list :column => "pos", :scope => 'parent_id = #{parent_id}'
   set_table_name "mixins"
+  default_scope order(:pos)
 end
 
 class ArrayScopeListMixin < ActiveRecord::Base
@@ -100,7 +101,11 @@ class ListTest < Test::Unit::TestCase
 
   def setup
     setup_db
-    (1..4).each { |counter| ListMixin.create! :pos => counter, :parent_id => 5 }
+    [5, 6].each do |parent_id|
+      (1..4).each do |i|
+        ListMixin.create! :pos => i, :parent_id => parent_id
+      end
+    end
   end
 
   def teardown
@@ -108,41 +113,42 @@ class ListTest < Test::Unit::TestCase
   end
 
   def test_reordering
-    assert_equal [1, 2, 3, 4], ListMixin.where('parent_id = 5').map(&:id)
+    assert_equal [1, 2, 3, 4], ListMixin.where(:parent_id => 5).map(&:id)
 
     ListMixin.find(2).move_lower
-    assert_equal [1, 3, 2, 4], ListMixin.where('parent_id = 5').map(&:id)
+    assert_equal [1, 3, 2, 4], ListMixin.where(:parent_id => 5).map(&:id)
 
     ListMixin.find(2).move_higher
-    assert_equal [1, 2, 3, 4], ListMixin.where('parent_id = 5').map(&:id)
+    assert_equal [1, 2, 3, 4], ListMixin.where(:parent_id => 5).map(&:id)
 
     ListMixin.find(1).move_to_bottom
-    assert_equal [2, 3, 4, 1], ListMixin.where('parent_id = 5').map(&:id)
+    assert_equal [2, 3, 4, 1], ListMixin.where(:parent_id => 5).map(&:id)
 
     ListMixin.find(1).move_to_top
-    assert_equal [1, 2, 3, 4], ListMixin.where('parent_id = 5').map(&:id)
+    assert_equal [1, 2, 3, 4], ListMixin.where(:parent_id => 5).map(&:id)
 
     ListMixin.find(2).move_to_bottom
-    assert_equal [1, 3, 4, 2], ListMixin.where('parent_id = 5').map(&:id)
+    assert_equal [1, 3, 4, 2], ListMixin.where(:parent_id => 5).map(&:id)
 
     ListMixin.find(4).move_to_top
-    assert_equal [4, 1, 3, 2], ListMixin.where('parent_id = 5').map(&:id)
+    assert_equal [4, 1, 3, 2], ListMixin.where(:parent_id => 5).map(&:id)
   end
 
   def test_bounds_checking
-    assert_equal [1, 2, 3, 4], ListMixin.where('parent_id = 5').map(&:pos)
+    assert_equal [1, 2, 3, 4], ListMixin.where(:parent_id => 5).map(&:pos)
 
     ListMixin.find(1).move_higher
-    assert_equal [1, 2, 3, 4], ListMixin.where('parent_id = 5').map(&:pos)
+    assert_equal [1, 2, 3, 4], ListMixin.where(:parent_id => 5).map(&:pos)
 
     ListMixin.find(4).move_lower
-    assert_equal [1, 2, 3, 4], ListMixin.where('parent_id = 5').map(&:pos)
+    assert_equal [1, 2, 3, 4], ListMixin.where(:parent_id => 5).map(&:pos)
   end
 
   def test_move_to_bottom_with_next_to_last_item
-    assert_equal [1, 2, 3, 4], ListMixin.where('parent_id = 5').map(&:id)
+    assert_equal [1, 2, 3, 4], ListMixin.where(:parent_id => 5).map(&:id)
+
     ListMixin.find(3).move_to_bottom
-    assert_equal [1, 2, 4, 3], ListMixin.where('parent_id = 5').map(&:id)
+    assert_equal [1, 2, 4, 3], ListMixin.where(:parent_id => 5).map(&:id)
   end
 
   def test_next_prev
@@ -216,11 +222,11 @@ class ListTest < Test::Unit::TestCase
   end
 
   def test_delete_middle
-    assert_equal [1, 2, 3, 4], ListMixin.where('parent_id = 5').map(&:id)
+    assert_equal [1, 2, 3, 4], ListMixin.where(:parent_id => 5).map(&:id)
 
     ListMixin.find(2).destroy
 
-    assert_equal [1, 3, 4], ListMixin.where('parent_id = 5').map(&:id)
+    assert_equal [1, 3, 4], ListMixin.where(:parent_id => 5).map(&:id)
 
     assert_equal 1, ListMixin.find(1).pos
     assert_equal 2, ListMixin.find(3).pos
@@ -228,23 +234,16 @@ class ListTest < Test::Unit::TestCase
 
     ListMixin.find(1).destroy
 
-    assert_equal [3, 4], ListMixin.where('parent_id = 5').map(&:id)
+    assert_equal [3, 4], ListMixin.where(:parent_id => 5).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.where('parent_id IS NULL')
+    assert_equal [new2, new1, new3], ListMixin.where(:parent_id => nil)
   end
 
   def test_remove_from_list_should_then_fail_in_list?
@@ -254,11 +253,11 @@ class ListTest < Test::Unit::TestCase
   end
 
   def test_remove_from_list_should_set_position_to_nil
-    assert_equal [1, 2, 3, 4], ListMixin.where('parent_id = 5').map(&:id)
+    assert_equal [1, 2, 3, 4], ListMixin.where(:parent_id => 5).map(&:id)
 
     ListMixin.find(2).remove_from_list
 
-    assert_equal [2, 1, 3, 4], ListMixin.where('parent_id = 5').map(&:id)
+    assert_equal [2, 1, 3, 4], ListMixin.where(:parent_id => 5).map(&:id)
 
     assert_equal 1,   ListMixin.find(1).pos
     assert_equal nil, ListMixin.find(2).pos
@@ -267,20 +266,47 @@ class ListTest < Test::Unit::TestCase
   end
 
   def test_remove_before_destroy_does_not_shift_lower_items_twice
-    assert_equal [1, 2, 3, 4], ListMixin.where('parent_id = 5').map(&:id)
+    assert_equal [1, 2, 3, 4], ListMixin.where(:parent_id => 5).map(&:id)
 
     ListMixin.find(2).remove_from_list
     ListMixin.find(2).destroy
 
-    assert_equal [1, 3, 4], ListMixin.where('parent_id = 5').map(&:id)
+    assert_equal [1, 3, 4], ListMixin.where(:parent_id => 5).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_remove_from_list_by_updating_should_shift_lower_items
+    assert_equal [1, 2, 3, 4], ListMixin.where(:parent_id => 5).map(&:id)
+
+    ListMixin.find(2).update_attributes! :parent_id => 6
+
+    assert_equal [1, 3, 4], ListMixin.where(:parent_id => 5).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_move_to_new_list_by_updating_should_append
+    assert_equal [1, 2, 3, 4], ListMixin.where(:parent_id => 5).map(&:id)
+    assert_equal [5, 6, 7, 8], ListMixin.where(:parent_id => 6).map(&:id)
+
+    ListMixin.find(2).update_attributes! :parent_id => 6
+
+    assert_equal [5, 6, 7, 8, 2], ListMixin.where(:parent_id => 6).map(&:id)
+
+    assert_equal 1, ListMixin.find(5).pos
+    assert_equal 2, ListMixin.find(6).pos
+    assert_equal 3, ListMixin.find(7).pos
+    assert_equal 4, ListMixin.find(8).pos
+    assert_equal 5, ListMixin.find(2).pos
+  end
+
   def test_before_destroy_callbacks_do_not_update_position_to_nil_before_deleting_the_record
-    assert_equal [1, 2, 3, 4], ListMixin.where('parent_id = 5').map(&:id)
+    assert_equal [1, 2, 3, 4], ListMixin.where(:parent_id => 5).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
@@ -292,7 +318,7 @@ class ListTest < Test::Unit::TestCase
       list.send(:callback, :before_destroy)
     end
 
-    assert_equal [1, 2, 3, 4], ListMixin.where('parent_id = 5').map(&:id)
+    assert_equal [1, 2, 3, 4], ListMixin.where(:parent_id => 5).map(&:id)
 
     assert_equal 1, ListMixin.find(1).pos
     assert_equal 2, ListMixin.find(2).pos
@@ -302,12 +328,78 @@ class ListTest < Test::Unit::TestCase
 
   def test_higher_items
     assert_equal [1, 2], ListMixin.find(3).higher_items.map(&:id)
-    assert_equal [], ListMixin.find(1).higher_items.map(&:id)
+    assert_equal     [], ListMixin.find(1).higher_items.map(&:id)
   end
 
   def test_lower_items
     assert_equal [3, 4], ListMixin.find(2).lower_items.map(&:id)
-    assert_equal [], ListMixin.find(4).lower_items.map(&:id)
+    assert_equal     [], ListMixin.find(4).lower_items.map(&:id)
+  end
+
+end
+
+class ListWithStringScopeTest < Test::Unit::TestCase
+
+  def setup
+    setup_db
+    [5, 6].each do |parent_id|
+      (1..4).each do |i|
+        ListWithStringScopeMixin.create! :parent_id => parent_id
+      end
+    end
+  end
+
+  def teardown
+    teardown_db
+  end
+
+  def test_insert
+    new = ListWithStringScopeMixin.create(:parent_id => 500)
+    assert_equal 1, new.pos
+    assert new.first?
+    assert new.last?
+
+    new = ListWithStringScopeMixin.create(:parent_id => 500)
+    assert_equal 2, new.pos
+    assert !new.first?
+    assert new.last?
+
+    new = ListWithStringScopeMixin.create(:parent_id => 500)
+    assert_equal 3, new.pos
+    assert !new.first?
+    assert new.last?
+
+    new = ListWithStringScopeMixin.create(:parent_id => 0)
+    assert_equal 1, new.pos
+    assert new.first?
+    assert new.last?
+  end
+
+  def test_remove_from_list_by_updating_should_shift_lower_items
+    assert_equal [1, 2, 3, 4], ListWithStringScopeMixin.where(:parent_id => 5).map(&:id)
+
+    ListWithStringScopeMixin.find(2).update_attributes! :parent_id => 6
+
+    assert_equal [1, 3, 4], ListWithStringScopeMixin.where(:parent_id => 5).map(&:id)
+
+    assert_equal 1, ListWithStringScopeMixin.find(1).pos
+    assert_equal 2, ListWithStringScopeMixin.find(3).pos
+    assert_equal 3, ListWithStringScopeMixin.find(4).pos
+  end
+
+  def test_move_to_new_list_by_updating_should_append
+    assert_equal [1, 2, 3, 4], ListWithStringScopeMixin.where(:parent_id => 5).map(&:id)
+    assert_equal [5, 6, 7, 8], ListWithStringScopeMixin.where(:parent_id => 6).map(&:id)
+
+    ListWithStringScopeMixin.find(2).update_attributes! :parent_id => 6
+
+    assert_equal [5, 6, 7, 8, 2], ListWithStringScopeMixin.where(:parent_id => 6).map(&:id)
+
+    assert_equal 1, ListWithStringScopeMixin.find(5).pos
+    assert_equal 2, ListWithStringScopeMixin.find(6).pos
+    assert_equal 3, ListWithStringScopeMixin.find(7).pos
+    assert_equal 4, ListWithStringScopeMixin.find(8).pos
+    assert_equal 5, ListWithStringScopeMixin.find(2).pos
   end
 
 end
@@ -334,41 +426,41 @@ class ListSubTest < Test::Unit::TestCase
   end
 
   def test_reordering
-    assert_equal [1, 2, 3, 4], ListMixin.where('parent_id = 5000').map(&:id)
+    assert_equal [1, 2, 3, 4], ListMixin.where(:parent_id => 5000).map(&:id)
 
     ListMixin.find(2).move_lower
-    assert_equal [1, 3, 2, 4], ListMixin.where('parent_id = 5000').map(&:id)
+    assert_equal [1, 3, 2, 4], ListMixin.where(:parent_id => 5000).map(&:id)
 
     ListMixin.find(2).move_higher
-    assert_equal [1, 2, 3, 4], ListMixin.where('parent_id = 5000').map(&:id)
+    assert_equal [1, 2, 3, 4], ListMixin.where(:parent_id => 5000).map(&:id)
 
     ListMixin.find(1).move_to_bottom
-    assert_equal [2, 3, 4, 1], ListMixin.where('parent_id = 5000').map(&:id)
+    assert_equal [2, 3, 4, 1], ListMixin.where(:parent_id => 5000).map(&:id)
 
     ListMixin.find(1).move_to_top
-    assert_equal [1, 2, 3, 4], ListMixin.where('parent_id = 5000').map(&:id)
+    assert_equal [1, 2, 3, 4], ListMixin.where(:parent_id => 5000).map(&:id)
 
     ListMixin.find(2).move_to_bottom
-    assert_equal [1, 3, 4, 2], ListMixin.where('parent_id = 5000').map(&:id)
+    assert_equal [1, 3, 4, 2], ListMixin.where(:parent_id => 5000).map(&:id)
 
     ListMixin.find(4).move_to_top
-    assert_equal [4, 1, 3, 2], ListMixin.where('parent_id = 5000').map(&:id)
+    assert_equal [4, 1, 3, 2], ListMixin.where(:parent_id => 5000).map(&:id)
   end
 
   def test_bounds_checking
-    assert_equal [1, 2, 3, 4], ListMixin.where('parent_id = 5000').map(&:pos)
+    assert_equal [1, 2, 3, 4], ListMixin.where(:parent_id => 5000).map(&:pos)
 
     ListMixin.find(1).move_higher
-    assert_equal [1, 2, 3, 4], ListMixin.where('parent_id = 5000').map(&:pos)
+    assert_equal [1, 2, 3, 4], ListMixin.where(:parent_id => 5000).map(&:pos)
 
     ListMixin.find(4).move_lower
-    assert_equal [1, 2, 3, 4], ListMixin.where('parent_id = 5000').map(&:pos)
+    assert_equal [1, 2, 3, 4], ListMixin.where(:parent_id => 5000).map(&:pos)
   end
 
   def test_move_to_bottom_with_next_to_last_item
-    assert_equal [1, 2, 3, 4], ListMixin.where('parent_id = 5000').map(&:id)
+    assert_equal [1, 2, 3, 4], ListMixin.where(:parent_id => 5000).map(&:id)
     ListMixin.find(3).move_to_bottom
-    assert_equal [1, 2, 4, 3], ListMixin.where('parent_id = 5000').map(&:id)
+    assert_equal [1, 2, 4, 3], ListMixin.where(:parent_id => 5000).map(&:id)
   end
 
   def test_next_prev
@@ -379,22 +471,22 @@ class ListSubTest < Test::Unit::TestCase
   end
 
   def test_injection
-    item = ListMixin.new("parent_id"=>1)
+    item = ListMixin.new(:parent_id => 1)
     assert_equal({ :parent_id => 1 }, item.send(:scope_condition))
     assert_equal("pos", item.send(:position_column))
   end
 
   def test_insert_at
-    new = ListMixin.create("parent_id" => 20)
+    new = ListMixin.create(:parent_id => 20)
     assert_equal 1, new.pos
 
-    new = ListMixinSub1.create("parent_id" => 20)
+    new = ListMixinSub1.create(:parent_id => 20)
     assert_equal 2, new.pos
 
-    new = ListMixinSub2.create("parent_id" => 20)
+    new = ListMixinSub2.create(:parent_id => 20)
     assert_equal 3, new.pos
 
-    new4 = ListMixin.create("parent_id" => 20)
+    new4 = ListMixin.create(:parent_id => 20)
     assert_equal 4, new4.pos
 
     new4.insert_at(3)
@@ -409,7 +501,7 @@ class ListSubTest < Test::Unit::TestCase
     new4.reload
     assert_equal 4, new4.pos
 
-    new5 = ListMixinSub1.create("parent_id" => 20)
+    new5 = ListMixinSub1.create(:parent_id => 20)
     assert_equal 5, new5.pos
 
     new5.insert_at(1)
@@ -420,11 +512,11 @@ class ListSubTest < Test::Unit::TestCase
   end
 
   def test_delete_middle
-    assert_equal [1, 2, 3, 4], ListMixin.where('parent_id = 5000').map(&:id)
+    assert_equal [1, 2, 3, 4], ListMixin.where(:parent_id => 5000).map(&:id)
 
     ListMixin.find(2).destroy
 
-    assert_equal [1, 3, 4], ListMixin.where('parent_id = 5000').map(&:id)
+    assert_equal [1, 3, 4], ListMixin.where(:parent_id => 5000).map(&:id)
 
     assert_equal 1, ListMixin.find(1).pos
     assert_equal 2, ListMixin.find(3).pos
@@ -432,7 +524,7 @@ class ListSubTest < Test::Unit::TestCase
 
     ListMixin.find(1).destroy
 
-    assert_equal [3, 4], ListMixin.where('parent_id = 5000').map(&:id)
+    assert_equal [3, 4], ListMixin.where(:parent_id => 5000).map(&:id)
 
     assert_equal 1, ListMixin.find(3).pos
     assert_equal 2, ListMixin.find(4).pos
@@ -441,13 +533,13 @@ class ListSubTest < Test::Unit::TestCase
   def test_higher_items
     ListMixin.find(2).remove_from_list
     assert_equal [1], ListMixin.find(3).higher_items.map(&:id)
-    assert_equal [], ListMixin.find(1).higher_items.map(&:id)
+    assert_equal  [], ListMixin.find(1).higher_items.map(&:id)
   end
 
   def test_lower_items
     ListMixin.find(3).remove_from_list
     assert_equal [4], ListMixin.find(2).lower_items.map(&:id)
-    assert_equal [], ListMixin.find(4).lower_items.map(&:id)
+    assert_equal  [], ListMixin.find(4).lower_items.map(&:id)
   end
 
   def test_list_class
@@ -460,12 +552,16 @@ class ArrayScopeListTest < Test::Unit::TestCase
 
   def setup
     setup_db
-    (1..4).each do |counter|
-      ArrayScopeListMixin.create!(
-        :pos => counter,
-        :parent_id => 5,
-        :parent_type => 'ParentClass'
-      )
+    ['ParentClass', 'bananas'].each do |parent_type|
+      [5, 6].each do |parent_id|
+        (1..4).each do |i|
+          ArrayScopeListMixin.create!(
+            :pos => i,
+            :parent_id => parent_id,
+            :parent_type => parent_type
+          )
+        end
+      end
     end
   end
 
@@ -524,8 +620,8 @@ class ArrayScopeListTest < Test::Unit::TestCase
 
   def test_injection
     item = ArrayScopeListMixin.new(conditions)
-    assert_equal(conditions, item.send(:scope_condition))
-    assert_equal("pos", item.send(:position_column))
+    assert_equal conditions, item.send(:scope_condition)
+    assert_equal "pos", item.send(:position_column)
   end
 
   def test_insert
@@ -604,9 +700,92 @@ class ArrayScopeListTest < Test::Unit::TestCase
     assert_equal 2, ArrayScopeListMixin.find(4).pos
   end
 
+  def test_remove_from_list_by_updating_scope_part_1_should_shift_lower_items
+    assert_equal [1, 2, 3, 4], ArrayScopeListMixin.where(conditions).map(&:id)
+
+    ArrayScopeListMixin.find(2).update_attributes! :parent_id => 6
+
+    assert_equal [1, 3, 4], ArrayScopeListMixin.where(conditions).map(&:id)
+
+    assert_equal 1, ArrayScopeListMixin.find(1).pos
+    assert_equal 2, ArrayScopeListMixin.find(3).pos
+    assert_equal 3, ArrayScopeListMixin.find(4).pos
+  end
+
+  def test_remove_from_list_by_updating_scope_part_2_should_shift_lower_items
+    assert_equal [1, 2, 3, 4], ArrayScopeListMixin.where(conditions).map(&:id)
+
+    ArrayScopeListMixin.find(2).update_attributes! :parent_type => 'bananas'
+
+    assert_equal [1, 3, 4], ArrayScopeListMixin.where(conditions).map(&:id)
+
+    assert_equal 1, ArrayScopeListMixin.find(1).pos
+    assert_equal 2, ArrayScopeListMixin.find(3).pos
+    assert_equal 3, ArrayScopeListMixin.find(4).pos
+  end
+
+  def test_remove_from_list_by_updating_complete_scope_should_shift_lower_items
+    assert_equal [1, 2, 3, 4], ArrayScopeListMixin.where(conditions).map(&:id)
+
+    ArrayScopeListMixin.find(2).update_attributes! :parent_id => 6, :parent_type => 'bananas'
+
+    assert_equal [1, 3, 4], ArrayScopeListMixin.where(conditions).map(&:id)
+
+    assert_equal 1, ArrayScopeListMixin.find(1).pos
+    assert_equal 2, ArrayScopeListMixin.find(3).pos
+    assert_equal 3, ArrayScopeListMixin.find(4).pos
+  end
+
+  def test_move_to_new_list_by_updating_scope_part_1_should_append
+    assert_equal [1, 2, 3, 4], ArrayScopeListMixin.where(conditions).map(&:id)
+    assert_equal [5, 6, 7, 8], ArrayScopeListMixin.where(conditions(:parent_id => 6)).map(&:id)
+
+    ArrayScopeListMixin.find(2).update_attributes! :parent_id => 6
+
+    assert_equal [5, 6, 7, 8, 2], ArrayScopeListMixin.where(conditions(:parent_id => 6)).map(&:id)
+
+    assert_equal 1, ArrayScopeListMixin.find(5).pos
+    assert_equal 2, ArrayScopeListMixin.find(6).pos
+    assert_equal 3, ArrayScopeListMixin.find(7).pos
+    assert_equal 4, ArrayScopeListMixin.find(8).pos
+    assert_equal 5, ArrayScopeListMixin.find(2).pos
+  end
+
+  def test_move_to_new_list_by_updating_scope_part_2_should_append
+    assert_equal [1,  2,  3,  4], ArrayScopeListMixin.where(conditions).map(&:id)
+    assert_equal [9, 10, 11, 12], ArrayScopeListMixin.where(conditions(:parent_type => 'bananas')).map(&:id)
+
+    ArrayScopeListMixin.find(2).update_attributes! :parent_type => 'bananas'
+
+    assert_equal [9, 10, 11, 12, 2], ArrayScopeListMixin.where(conditions(:parent_type => 'bananas')).map(&:id)
+
+    assert_equal 1, ArrayScopeListMixin.find(9).pos
+    assert_equal 2, ArrayScopeListMixin.find(10).pos
+    assert_equal 3, ArrayScopeListMixin.find(11).pos
+    assert_equal 4, ArrayScopeListMixin.find(12).pos
+    assert_equal 5, ArrayScopeListMixin.find(2).pos
+  end
+
+  def test_move_to_new_list_by_updating_complete_scope_should_append
+    assert_equal [ 1,  2,  3,  4], ArrayScopeListMixin.where(conditions).map(&:id)
+    assert_equal [13, 14, 15, 16], ArrayScopeListMixin.where(:parent_id => 6, :parent_type => 'bananas').map(&:id)
+
+    ArrayScopeListMixin.find(2).update_attributes! :parent_id => 6, :parent_type => 'bananas'
+
+    assert_equal [13, 14, 15, 16, 2], ArrayScopeListMixin.where(:parent_id => 6, :parent_type => 'bananas').map(&:id)
+
+    assert_equal 1, ArrayScopeListMixin.find(13).pos
+    assert_equal 2, ArrayScopeListMixin.find(14).pos
+    assert_equal 3, ArrayScopeListMixin.find(15).pos
+    assert_equal 4, ArrayScopeListMixin.find(16).pos
+    assert_equal 5, ArrayScopeListMixin.find(2).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
 
@@ -638,12 +817,12 @@ class ArrayScopeListTest < Test::Unit::TestCase
 
   def test_higher_items
     assert_equal [1, 2], ArrayScopeListMixin.find(3).higher_items.map(&:id)
-    assert_equal [], ArrayScopeListMixin.find(1).higher_items.map(&:id)
+    assert_equal     [], ArrayScopeListMixin.find(1).higher_items.map(&:id)
   end
 
   def test_lower_items
     assert_equal [3, 4], ArrayScopeListMixin.find(2).lower_items.map(&:id)
-    assert_equal [], ArrayScopeListMixin.find(4).lower_items.map(&:id)
+    assert_equal     [], ArrayScopeListMixin.find(4).lower_items.map(&:id)
   end
 
 end
@@ -652,16 +831,16 @@ class AssociationScopeListTest < Test::Unit::TestCase
 
   def setup
     setup_db
-    (1..4).each do |counter|
+    (1..4).each do |i|
       AssociationScopeListMixin.create!(
-        :pos => counter,
+        :pos => i,
         :parent_id => 5
       )
     end
 
-    (1..4).each do |counter|
+    (1..4).each do |i|
       PolymorphicAssociationScopeListMixin.create!(
-        :pos => counter,
+        :pos => i,
         :parent_id => 5,
         :parent_type => 'ParentClass'
       )

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: sortifiable
 version: !ruby/object:Gem::Version 
-  hash: 23
+  hash: 21
   prerelease: 
   segments: 
   - 0
   - 2
-  - 0
-  version: 0.2.0
+  - 1
+  version: 0.2.1
 platform: ruby
 authors: 
 - Andrew White
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-04-07 00:00:00 +01:00
+date: 2011-04-20 00:00:00 +01:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency