acts_as_list 0.1.6 → 0.2.0

data/.gitignore

@@ -4,3 +4,4 @@ Gemfile.lock
 pkg/*
 .rvmrc
 *.tmproj
+.rbenv-version

data/.travis.yml

@@ -3,3 +3,4 @@ rvm:
   - 1.8.7
   - 1.9.2
   - 1.9.3
+  - 2.0.0

data/README.md

@@ -4,24 +4,78 @@
 
 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.
 
+## Installation
+
+In your Gemfile:
+
+    gem 'acts_as_list'
+
+Or, from the command line:
+
+    gem install acts_as_list
 
 ## Example
 
-    class TodoList < ActiveRecord::Base
-      has_many :todo_items, :order => "position"
-    end
+At first, you need to add a `position` column to desired table:
+
+    rails g migration AddPositionToTodoItem position:integer
+    rake db:migrate
     
-    class TodoItem < ActiveRecord::Base
-      belongs_to :todo_list
-      acts_as_list :scope => :todo_list
-    end
+After that you can use `acts_as_list` method in the model: 
+
+```ruby
+class TodoList < ActiveRecord::Base
+  has_many :todo_items, order: :position
+end
     
-    todo_list.first.move_to_bottom
-    todo_list.last.move_higher
+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
+```
+
+## Instance Methods Added To ActiveRecord Models
+
+You'll have a number of methods added to each instance of the ActiveRecord model that to which `acts_as_list` is added. 
+
+In `acts_as_list`, "higher" means further up the list (a lower `position`), and "lower" means further down the list (a higher `position`). That can be confusing, so it might make sense to add tests that validate that you're using the right method given your context.
+
+### Methods That Change Position and Reorder List
+
+- `list_item.insert_at(2)`
+- `list_item.move_lower` will do nothing if the item is the lowest item
+- `list_item.move_higher` will do nothing if the item is the highest item
+- `list_item.move_to_bottom`
+- `list_item.move_to_top`
+- `list_item.remove_from_list`
+
+### Methods That Change Position Without Reordering List
+
+- `list_item.increment_position`
+- `list_item.decrement_position`
+- `list_item.set_list_position(3)`
+
+### Methods That Return Attributes of the Item's List Position
+- `list_item.first?`
+- `list_item.last?`
+- `list_item.in_list?`
+- `list_item.not_in_list?`
+- `list_item.default_position?`
+- `list_item.higher_item`
+- `list_item.higher_items` will return all the items above `list_item` in the list (ordered by the position, ascending)
+- `list_item.lower_item`
+- `list_item.lower_items` will return all the items below `list_item` in the list (ordered by the position, ascending)
+
 ## 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.
 
+All `position` queries (select, update, etc.) inside gem methods are executed without the default scope (i.e. `Model.unscoped`), this will prevent nasty issues when the default scope is different from `acts_as_list` scope.
+
+The `position` column is set after validations are called, so you should not put a `presence` validation on the `position` column.
+
 ## Versions
 All versions `0.1.5` onwards require Rails 3.0.x and higher.
 

data/acts_as_list.gemspec

@@ -24,8 +24,8 @@ Gem::Specification.new do |s|
 
 
   # Dependencies (installed via 'bundle install')...
+  s.add_dependency("activerecord", [">= 3.0"])
   s.add_development_dependency("bundler", [">= 1.0.0"])
-  s.add_development_dependency("activerecord", [">= 1.15.4.7794"])
   s.add_development_dependency("rdoc")
   s.add_development_dependency("sqlite3")
 end

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

@@ -26,8 +26,8 @@ module ActiveRecord
         # Configuration options are:
         #
         # * +column+ - specifies the column name to use for keeping the position integer (default: +position+)
-        # * +scope+ - restricts what is to be considered a list. Given a symbol, it'll attach <tt>_id</tt> 
-        #   (if it hasn't already been added) and use that as the foreign key restriction. It's also possible 
+        # * +scope+ - restricts what is to be considered a list. Given a symbol, it'll attach <tt>_id</tt>
+        #   (if it hasn't already been added) and use that as the foreign key restriction. It's also possible
         #   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
@@ -48,7 +48,7 @@ module ActiveRecord
           elsif configuration[:scope].is_a?(Array)
             scope_condition_method = %(
               def scope_condition
-                attrs = %w(#{configuration[:scope].join(" ")}).inject({}) do |memo,column| 
+                attrs = %w(#{configuration[:scope].join(" ")}).inject({}) do |memo,column|
                   memo[column.intern] = send(column.intern); memo
                 end
                 self.class.send(:sanitize_sql_hash_for_conditions, attrs)
@@ -73,10 +73,28 @@ module ActiveRecord
               '#{configuration[:column]}'
             end
 
+            def scope_name
+              '#{configuration[:scope]}'
+            end
+
+            def add_new_at
+              '#{configuration[:add_new_at]}'
+            end
+
             #{scope_condition_method}
 
+            # only add to attr_accessible
+            # if the class has some mass_assignment_protection
+
+            if defined?(accessible_attributes) and !accessible_attributes.blank?
+              attr_accessible :#{configuration[:column]}
+            end
+
+            before_destroy :reload_position
             after_destroy :decrement_positions_on_lower_items
             before_create :add_to_list_#{configuration[:add_new_at]}
+            after_update :update_positions
+            before_update :check_scope
           EOV
         end
       end
@@ -135,20 +153,20 @@ module ActiveRecord
         def remove_from_list
           if in_list?
             decrement_positions_on_lower_items
-            update_attribute position_column, nil
+            set_list_position(nil)
           end
         end
 
         # Increase the position of this item without adjusting the rest of the list.
         def increment_position
           return unless in_list?
-          update_attribute position_column, self.send(position_column).to_i + 1
+          set_list_position(self.send(position_column).to_i + 1)
         end
 
         # Decrease the position of this item without adjusting the rest of the list.
         def decrement_position
           return unless in_list?
-          update_attribute position_column, self.send(position_column).to_i - 1
+          set_list_position(self.send(position_column).to_i - 1)
         end
 
         # Return +true+ if this object is the first in the list.
@@ -166,28 +184,54 @@ module ActiveRecord
         # Return the next higher item in the list.
         def higher_item
           return nil unless in_list?
-          acts_as_list_class.find(:first, :conditions =>
-            "#{scope_condition} AND #{position_column} = #{(send(position_column).to_i - 1).to_s}"
+          acts_as_list_class.unscoped.find(:first, :conditions =>
+            "#{scope_condition} AND #{position_column} < #{(send(position_column).to_i).to_s}",
+            :order => "#{acts_as_list_class.table_name}.#{position_column} DESC"
           )
         end
 
+        # Return the next n higher items in the list
+        # selects all higher items by default
+        def higher_items(limit=nil)
+          limit ||= acts_as_list_list.count
+          position_value = send(position_column)
+          acts_as_list_list.
+            where("#{position_column} < ?", position_value).
+            where("#{position_column} >= ?", position_value - limit).
+            limit(limit).
+            order("#{acts_as_list_class.table_name}.#{position_column} ASC")
+        end
+
         # Return the next lower item in the list.
         def lower_item
           return nil unless in_list?
-          acts_as_list_class.find(:first, :conditions =>
-            "#{scope_condition} AND #{position_column} = #{(send(position_column).to_i + 1).to_s}"
+          acts_as_list_class.unscoped.find(:first, :conditions =>
+            "#{scope_condition} AND #{position_column} > #{(send(position_column).to_i).to_s}",
+            :order => "#{acts_as_list_class.table_name}.#{position_column} ASC"
           )
         end
 
+        # Return the next n lower items in the list
+        # selects all lower items by default
+        def lower_items(limit=nil)
+          limit ||= acts_as_list_list.count
+          position_value = send(position_column)
+          acts_as_list_list.
+            where("#{position_column} > ?", position_value).
+            where("#{position_column} <= ?", position_value + limit).
+            limit(limit).
+            order("#{acts_as_list_class.table_name}.#{position_column} ASC")
+        end
+
         # Test if this record is in a list
         def in_list?
           !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
@@ -196,7 +240,18 @@ module ActiveRecord
           default_position == send(position_column)
         end
 
+        # Sets the new position and saves it
+        def set_list_position(new_position)
+          send("#{position_column}=", new_position)
+          save!
+        end
+
         private
+          def acts_as_list_list
+            acts_as_list_class.unscoped.
+              where(scope_condition)
+          end
+
           def add_to_list_top
             increment_positions_on_all_items
             self[position_column] = acts_as_list_top
@@ -224,23 +279,25 @@ 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.unscoped.find(:first, :conditions => conditions, :order => "#{position_column} DESC")
+            acts_as_list_class.unscoped.where(conditions).order("#{acts_as_list_class.table_name}.#{position_column} DESC").first
           end
 
           # Forces item to assume the bottom position in the list.
           def assume_bottom_position
-            update_attribute(position_column, bottom_position_in_list(self).to_i + 1)
+            set_list_position(bottom_position_in_list(self).to_i + 1)
           end
 
           # Forces item to assume the top position in the list.
           def assume_top_position
-            update_attribute(position_column, acts_as_list_top)
+            set_list_position(acts_as_list_top)
           end
 
           # This has the effect of moving all the higher items up one.
           def decrement_positions_on_higher_items(position)
-            acts_as_list_class.update_all(
-              "#{position_column} = (#{position_column} - 1)", "#{scope_condition} AND #{position_column} <= #{position}"
+            acts_as_list_class.unscoped.where(
+              "#{scope_condition} AND #{position_column} <= #{position}"
+            ).update_all(
+              "#{position_column} = (#{position_column} - 1)"
             )
           end
 
@@ -248,52 +305,64 @@ module ActiveRecord
           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} > #{position}"
+            acts_as_list_class.unscoped.where(
+              "#{scope_condition} AND #{position_column} > #{position}"
+            ).update_all(
+              "#{position_column} = (#{position_column} - 1)"
             )
           end
 
           # This has the effect of moving all the higher items down one.
           def increment_positions_on_higher_items
             return unless in_list?
-            acts_as_list_class.update_all(
-              "#{position_column} = (#{position_column} + 1)", "#{scope_condition} AND #{position_column} < #{send(position_column).to_i}"
+            acts_as_list_class.unscoped.where(
+              "#{scope_condition} AND #{position_column} < #{send(position_column).to_i}"
+            ).update_all(
+              "#{position_column} = (#{position_column} + 1)"
             )
           end
 
           # This has the effect of moving all the lower items down one.
           def increment_positions_on_lower_items(position)
-            acts_as_list_class.update_all(
-              "#{position_column} = (#{position_column} + 1)", "#{scope_condition} AND #{position_column} >= #{position}"
-           )
+            acts_as_list_class.unscoped.where(
+              "#{scope_condition} AND #{position_column} >= #{position}"
+            ).update_all(
+              "#{position_column} = (#{position_column} + 1)"
+            )
           end
 
           # Increments position (<tt>position_column</tt>) of all items in the list.
           def increment_positions_on_all_items
-            acts_as_list_class.update_all(
-              "#{position_column} = (#{position_column} + 1)",  "#{scope_condition}"
+            acts_as_list_class.unscoped.where(
+              "#{scope_condition}"
+            ).update_all(
+              "#{position_column} = (#{position_column} + 1)"
             )
           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)
+          def shuffle_positions_on_intermediate_items(old_position, new_position, avoid_id = nil)
             return if old_position == new_position
-
+            avoid_id_condition = avoid_id ? " AND #{self.class.primary_key} != #{avoid_id}" : ''
             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}"
+              acts_as_list_class.unscoped.where(
+                "#{scope_condition} AND #{position_column} > #{old_position} AND #{position_column} <= #{new_position}#{avoid_id_condition}"
+              ).update_all(
+                "#{position_column} = (#{position_column} - 1)"
               )
             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}"
+              acts_as_list_class.unscoped.where(
+                "#{scope_condition} AND #{position_column} >= #{new_position} AND #{position_column} < #{old_position}#{avoid_id_condition}"
+              ).update_all(
+                "#{position_column} = (#{position_column} + 1)"
               )
             end
           end
@@ -306,18 +375,40 @@ module ActiveRecord
             else
               increment_positions_on_lower_items(position)
             end
-            self.update_attribute(position_column, position)
+            set_list_position(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)
+              set_list_position(0)
               decrement_positions_on_lower_items(old_position)
             end
           end
-      end 
+
+          def update_positions
+            old_position = send("#{position_column}_was").to_i
+            new_position = send(position_column).to_i
+            return unless acts_as_list_class.unscoped.where("#{scope_condition} AND #{position_column} = #{new_position}").count > 1
+            shuffle_positions_on_intermediate_items old_position, new_position, id
+          end
+
+          def check_scope
+            if changes.include?("#{scope_name}")
+              old_scope_id = changes["#{scope_name}"].first
+              new_scope_id = changes["#{scope_name}"].last
+              self["#{scope_name}"] = old_scope_id
+              send("decrement_positions_on_lower_items")
+              self["#{scope_name}"] = new_scope_id
+              send("add_to_list_#{add_new_at}")
+            end
+          end
+
+          def reload_position
+            self.reload
+          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.6"
+      VERSION = "0.2.0"
     end
   end
 end

data/lib/acts_as_list.rb

@@ -20,3 +20,5 @@ module ActsAsList
     end
   end
 end
+
+ActsAsList::Railtie.insert

data/test/shared_array_scope_list.rb

@@ -2,6 +2,7 @@ module Shared
   module ArrayScopeList
     def setup
       (1..4).each { |counter| ArrayScopeListMixin.create! :pos => counter, :parent_id => 5, :parent_type => 'ParentClass' }
+      (1..4).each { |counter| ArrayScopeListMixin.create! :pos => counter, :parent_id => 6, :parent_type => 'ParentClass' }
     end
 
     def test_reordering
@@ -24,6 +25,10 @@ module Shared
 
       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)
+      
+      ArrayScopeListMixin.find(4).insert_at(4)
+      assert_equal [1, 3, 2, 4], ArrayScopeListMixin.find(:all, :conditions => "parent_id = 5 AND parent_type = 'ParentClass'", :order => 'pos').map(&:id)
+      assert_equal [1, 2, 3, 4], ArrayScopeListMixin.find(:all, :conditions => "parent_id = 5 AND parent_type = 'ParentClass'", :order => 'pos').map(&:pos)
     end
 
     def test_move_to_bottom_with_next_to_last_item
@@ -41,7 +46,6 @@ module Shared
 
     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
 

data/test/shared_list.rb

@@ -1,7 +1,11 @@
 module Shared
   module List
     def setup
-      (1..4).each { |counter| ListMixin.create! :pos => counter, :parent_id => 5 }
+      (1..4).each do |counter|
+        node = ListMixin.new :parent_id => 5
+        node.pos = counter
+        node.save!
+      end
     end
 
     def test_reordering
@@ -204,14 +208,18 @@ module Shared
     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)
+      new = ListMixin.new(:parent_id => 5)
+      new.pos = 1
+      new.save!
       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)
+      new = ListMixin.new(:parent_id => 5)
+      new.pos = 3
+      new.save!
       assert_equal 3, new.pos
       assert !new.first?
       assert !new.last?

data/test/shared_list_sub.rb

@@ -1,7 +1,11 @@
 module Shared
   module ListSub
     def setup
-      (1..4).each { |i| ((i % 2 == 1) ? ListMixinSub1 : ListMixinSub2).create! :pos => i, :parent_id => 5000 }
+      (1..4).each do |i|
+        node = ((i % 2 == 1) ? ListMixinSub1 : ListMixinSub2).new :parent_id => 5000
+        node.pos = i
+        node.save!
+      end
     end
 
     def test_reordering
@@ -39,6 +43,22 @@ module Shared
       assert_nil ListMixin.find(4).lower_item
     end
 
+    def test_next_prev_groups
+      li1 = ListMixin.find(1)
+      li2 = ListMixin.find(2)
+      li3 = ListMixin.find(3)
+      li4 = ListMixin.find(4)
+      assert_equal [li2, li3, li4], li1.lower_items
+      assert_equal [li4], li3.lower_items
+      assert_equal [li2, li3], li1.lower_items(2)
+      assert_equal [], li4.lower_items
+
+      assert_equal [li1, li2], li3.higher_items
+      assert_equal [li1], li2.higher_items
+      assert_equal [li2, li3], li4.higher_items(2)
+      assert_equal [], li1.higher_items
+    end
+
     def test_injection
       item = ListMixin.new("parent_id"=>1)
       assert_equal '"mixins"."parent_id" = 1', item.scope_condition

data/test/test_list.rb

@@ -10,6 +10,7 @@ def setup_db(position_options = {})
   ActiveRecord::Schema.define(:version => 1) do
     create_table :mixins do |t|
       t.column :pos, :integer, position_options
+      t.column :active, :boolean, :default => true
       t.column :parent_id, :integer
       t.column :parent_type, :string
       t.column :created_at, :datetime
@@ -35,8 +36,27 @@ end
 
 class Mixin < ActiveRecord::Base
   self.table_name = 'mixins'
+  attr_accessible :active, :parent_id, :parent_type
 end
 
+class ProtectedMixin < ActiveRecord::Base
+  self.table_name = 'mixins'
+  attr_protected :active
+end
+
+class ProtectedListMixin < ProtectedMixin
+  acts_as_list :column => "pos"
+end
+
+class UnProtectedMixin < ActiveRecord::Base
+  self.table_name = 'mixins'
+end
+
+class UnProtectedListMixin < UnProtectedMixin
+  acts_as_list :column => "pos"
+end
+
+
 class ListMixin < Mixin
   acts_as_list :column => "pos", :scope => :parent
 end
@@ -69,6 +89,11 @@ class DefaultScopedMixin < Mixin
   default_scope { order('pos ASC') }
 end
 
+class DefaultScopedWhereMixin < Mixin
+  acts_as_list :column => "pos"
+  default_scope { order('pos ASC').where(:active => true) }
+end
+
 class TopAdditionMixin < Mixin
   acts_as_list :column => "pos", :add_new_at => :top, :scope => :parent_id
 end
@@ -158,7 +183,7 @@ end
 class DefaultScopedTest < ActsAsListTestCase
   def setup
     setup_db
-    (1..4).each { |counter| DefaultScopedMixin.create! :pos => counter }
+    (1..4).each { |counter| DefaultScopedMixin.create!({:pos => counter}) }
   end
 
   def test_insert
@@ -235,18 +260,171 @@ class DefaultScopedTest < ActsAsListTestCase
     assert_equal 4, new4.pos
   end
 
+  def test_update_position
+    assert_equal [1, 2, 3, 4], DefaultScopedMixin.find(:all).map(&:id)
+    DefaultScopedMixin.find(2).set_list_position(4)
+    assert_equal [1, 3, 4, 2], DefaultScopedMixin.find(:all).map(&:id)
+    DefaultScopedMixin.find(2).set_list_position(2)
+    assert_equal [1, 2, 3, 4], DefaultScopedMixin.find(:all).map(&:id)
+    DefaultScopedMixin.find(1).set_list_position(4)
+    assert_equal [2, 3, 4, 1], DefaultScopedMixin.find(:all).map(&:id)
+    DefaultScopedMixin.find(1).set_list_position(1)
+    assert_equal [1, 2, 3, 4], DefaultScopedMixin.find(:all).map(&:id)
+  end
+
+end
+
+class DefaultScopedWhereTest < ActsAsListTestCase
+  def setup
+    setup_db
+    (1..4).each { |counter| DefaultScopedWhereMixin.create! :pos => counter, :active => false }
+  end
+
+  def test_insert
+    new = DefaultScopedWhereMixin.create
+    assert_equal 5, new.pos
+    assert !new.first?
+    assert new.last?
+
+    new = DefaultScopedWhereMixin.create
+    assert_equal 6, new.pos
+    assert !new.first?
+    assert new.last?
+
+    new = DefaultScopedWhereMixin.create
+    assert_equal 7, new.pos
+    assert !new.first?
+    assert new.last?
+  end
+
+  def test_reordering
+    assert_equal [1, 2, 3, 4], DefaultScopedWhereMixin.where(:active => false).map(&:id)
+
+    DefaultScopedWhereMixin.where(:active => false).find(2).move_lower
+    assert_equal [1, 3, 2, 4], DefaultScopedWhereMixin.where(:active => false).find(:all).map(&:id)
+
+    DefaultScopedWhereMixin.where(:active => false).find(2).move_higher
+    assert_equal [1, 2, 3, 4], DefaultScopedWhereMixin.where(:active => false).find(:all).map(&:id)
+
+    DefaultScopedWhereMixin.where(:active => false).find(1).move_to_bottom
+    assert_equal [2, 3, 4, 1], DefaultScopedWhereMixin.where(:active => false).find(:all).map(&:id)
+
+    DefaultScopedWhereMixin.where(:active => false).find(1).move_to_top
+    assert_equal [1, 2, 3, 4], DefaultScopedWhereMixin.where(:active => false).find(:all).map(&:id)
+
+    DefaultScopedWhereMixin.where(:active => false).find(2).move_to_bottom
+    assert_equal [1, 3, 4, 2], DefaultScopedWhereMixin.where(:active => false).find(:all).map(&:id)
+
+    DefaultScopedWhereMixin.where(:active => false).find(4).move_to_top
+    assert_equal [4, 1, 3, 2], DefaultScopedWhereMixin.where(:active => false).find(:all).map(&:id)
+  end
+
+  def test_insert_at
+    new = DefaultScopedWhereMixin.create
+    assert_equal 5, new.pos
+
+    new = DefaultScopedWhereMixin.create
+    assert_equal 6, new.pos
+
+    new = DefaultScopedWhereMixin.create
+    assert_equal 7, new.pos
+
+    new4 = DefaultScopedWhereMixin.create
+    assert_equal 8, new4.pos
+
+    new4.insert_at(2)
+    assert_equal 2, new4.pos
+
+    new.reload
+    assert_equal 8, new.pos
+
+    new.insert_at(2)
+    assert_equal 2, new.pos
+
+    new4.reload
+    assert_equal 3, new4.pos
+
+    new5 = DefaultScopedWhereMixin.create
+    assert_equal 9, new5.pos
+
+    new5.insert_at(1)
+    assert_equal 1, new5.pos
+
+    new4.reload
+    assert_equal 4, new4.pos
+  end
+
+  def test_update_position
+    assert_equal [1, 2, 3, 4], DefaultScopedWhereMixin.where(:active => false).find(:all).map(&:id)
+    DefaultScopedWhereMixin.where(:active => false).find(2).set_list_position(4)
+    assert_equal [1, 3, 4, 2], DefaultScopedWhereMixin.where(:active => false).find(:all).map(&:id)
+    DefaultScopedWhereMixin.where(:active => false).find(2).set_list_position(2)
+    assert_equal [1, 2, 3, 4], DefaultScopedWhereMixin.where(:active => false).find(:all).map(&:id)
+    DefaultScopedWhereMixin.where(:active => false).find(1).set_list_position(4)
+    assert_equal [2, 3, 4, 1], DefaultScopedWhereMixin.where(:active => false).find(:all).map(&:id)
+    DefaultScopedWhereMixin.where(:active => false).find(1).set_list_position(1)
+    assert_equal [1, 2, 3, 4], DefaultScopedWhereMixin.where(:active => false).find(:all).map(&:id)
+  end
+
+end
+
+class MultiDestroyTest < ActsAsListTestCase
+
+  def setup
+    setup_db
+  end
+
+  # example:
+  #
+  #   class TodoList < ActiveRecord::Base
+  #     has_many :todo_items, :order => "position"
+  #     accepts_nested_attributes_for :todo_items, :allow_destroy => true
+  #   end
+  #
+  #   class TodoItem < ActiveRecord::Base
+  #     belongs_to :todo_list
+  #     acts_as_list :scope => :todo_list
+  #   end
+  #
+  # Assume that there are three items.
+  # The user mark two items as deleted, click save button, form will be post:
+  #
+  # todo_list.todo_items_attributes = [
+  #   {id: 1, _destroy: true},
+  #   {id: 2, _destroy: true}
+  # ]
+  #
+  # Save toto_list, the position of item #3 should eql 1.
+  #
+  def test_destroy
+    new1 = DefaultScopedMixin.create
+    assert_equal 1, new1.pos
+
+    new2 = DefaultScopedMixin.create
+    assert_equal 2, new2.pos
+
+    new3 = DefaultScopedMixin.create
+    assert_equal 3, new3.pos
+
+    new1.destroy
+    new2.destroy
+    new3.reload
+    assert_equal 1, new3.pos
+  end
 end
 
 #class TopAdditionMixin < Mixin
 
 class TopAdditionTest < ActsAsListTestCase
   include Shared::TopAddition
+
   def setup
     setup_db
     super
   end
 end
 
+
 class TopAdditionTestWithDefault < ActsAsListTestCase
   include Shared::TopAddition
 
@@ -255,3 +433,44 @@ class TopAdditionTestWithDefault < ActsAsListTestCase
     super
   end
 end
+
+class RespectMixinProtection < ActsAsListTestCase
+  def setup
+    setup_db_with_default
+    super
+  end
+
+  # if an attribute is set attr_protected
+  # it should be unchanged by update_attributes
+  def test_unmodified_protection
+    a = ProtectedMixin.new
+    a.update_attributes({:active => false})
+    assert_equal true, a.active
+  end
+
+  # even after the acts_as_list mixin is joined
+  # that protection should continue to exist
+  def test_still_protected
+    b = ProtectedListMixin.new
+    b.update_attributes({:active => false})
+    assert_equal true, b.active
+  end
+
+  # similarly, if a class lacks mass_assignment protection
+  # it should be able to be changed
+  def test_unprotected
+    a = UnProtectedMixin.new
+    a.update_attributes({:active => false})
+    assert_equal false, a.active
+  end
+
+  # and it should continue to be mutable by mass_assignment
+  # even after the acts_as_list plugin has been joined
+  def test_still_unprotected_mixin
+    b = UnProtectedListMixin.new
+    b.assign_attributes({:active => false})
+    # p UnProtectedListMixin.accessible_attributes.length
+    assert_equal false, b.active
+  end
+
+end

metadata

@@ -1,71 +1,93 @@
---- !ruby/object:Gem::Specification
+--- !ruby/object:Gem::Specification 
 name: acts_as_list
-version: !ruby/object:Gem::Version
-  version: 0.1.6
+version: !ruby/object:Gem::Version 
+  hash: 23
   prerelease: 
+  segments: 
+  - 0
+  - 2
+  - 0
+  version: 0.2.0
 platform: ruby
-authors:
+authors: 
 - David Heinemeier Hansson
 - Swanand Pagnis
 - Quinn Chaffee
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-04-19 00:00:00.000000000 Z
-dependencies:
-- !ruby/object:Gem::Dependency
-  name: bundler
-  requirement: &2152347900 !ruby/object:Gem::Requirement
+
+date: 2013-02-28 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: activerecord
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
     none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: 1.0.0
-  type: :development
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 7
+        segments: 
+        - 3
+        - 0
+        version: "3.0"
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: bundler
   prerelease: false
-  version_requirements: *2152347900
-- !ruby/object:Gem::Dependency
-  name: activerecord
-  requirement: &2152347320 !ruby/object:Gem::Requirement
+  requirement: &id002 !ruby/object:Gem::Requirement 
     none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: 1.15.4.7794
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 23
+        segments: 
+        - 1
+        - 0
+        - 0
+        version: 1.0.0
   type: :development
-  prerelease: false
-  version_requirements: *2152347320
-- !ruby/object:Gem::Dependency
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
   name: rdoc
-  requirement: &2152346840 !ruby/object:Gem::Requirement
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
     none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '0'
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
   type: :development
-  prerelease: false
-  version_requirements: *2152346840
-- !ruby/object:Gem::Dependency
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
   name: sqlite3
-  requirement: &2152346240 !ruby/object:Gem::Requirement
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
     none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '0'
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
   type: :development
-  prerelease: false
-  version_requirements: *2152346240
-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.
-email:
+  version_requirements: *id004
+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.
+email: 
 - swanand.pagnis@gmail.com
 executables: []
+
 extensions: []
+
 extra_rdoc_files: []
-files:
+
+files: 
 - .gemtest
 - .gitignore
 - .travis.yml
@@ -87,29 +109,38 @@ files:
 - test/test_list.rb
 homepage: http://github.com/swanandp/acts_as_list
 licenses: []
+
 post_install_message: 
 rdoc_options: []
-require_paths:
+
+require_paths: 
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement
+required_ruby_version: !ruby/object:Gem::Requirement 
   none: false
-  requirements:
-  - - ! '>='
-    - !ruby/object:Gem::Version
-      version: '0'
-required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
   none: false
-  requirements:
-  - - ! '>='
-    - !ruby/object:Gem::Version
-      version: '0'
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
 requirements: []
+
 rubyforge_project: acts_as_list
 rubygems_version: 1.8.15
 signing_key: 
 specification_version: 3
 summary: A gem allowing a active_record model to act_as_list.
-test_files:
+test_files: 
 - test/helper.rb
 - test/shared.rb
 - test/shared_array_scope_list.rb