acts_as_list 0.1.7 → 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

@@ -16,23 +16,66 @@ Or, from the command line:
 
 ## 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,11 +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
@@ -136,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.
@@ -168,27 +185,53 @@ module ActiveRecord
         def higher_item
           return nil unless in_list?
           acts_as_list_class.unscoped.find(:first, :conditions =>
-            "#{scope_condition} AND #{position_column} = #{(send(position_column).to_i - 1).to_s}"
+            "#{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.unscoped.find(:first, :conditions =>
-            "#{scope_condition} AND #{position_column} = #{(send(position_column).to_i + 1).to_s}"
+            "#{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
@@ -197,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
@@ -225,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 => "#{acts_as_list_class.table_name}.#{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.unscoped.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
 
@@ -249,30 +305,38 @@ module ActiveRecord
           def decrement_positions_on_lower_items(position=nil)
             return unless in_list?
             position ||= send(position_column).to_i
-            acts_as_list_class.unscoped.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.unscoped.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.unscoped.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.unscoped.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
 
@@ -285,16 +349,20 @@ module ActiveRecord
               #
               # e.g., if moving an item from 2 to 5,
               # move [3, 4, 5] to [2, 3, 4]
-              acts_as_list_class.unscoped.update_all(
-                "#{position_column} = (#{position_column} - 1)", "#{scope_condition} AND #{position_column} > #{old_position} AND #{position_column} <= #{new_position}#{avoid_id_condition}"
+              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.unscoped.update_all(
-                "#{position_column} = (#{position_column} + 1)", "#{scope_condition} AND #{position_column} >= #{new_position} AND #{position_column} < #{old_position}#{avoid_id_condition}"
+              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
@@ -307,25 +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
-          
+
           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("#{position_column} = #{new_position}").count > 1
+            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
-      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.7"
+      VERSION = "0.2.0"
     end
   end
 end

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

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

@@ -36,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
@@ -164,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
@@ -243,13 +262,13 @@ class DefaultScopedTest < ActsAsListTestCase
 
   def test_update_position
     assert_equal [1, 2, 3, 4], DefaultScopedMixin.find(:all).map(&:id)
-    DefaultScopedMixin.find(2).update_attribute(:pos, 4)
+    DefaultScopedMixin.find(2).set_list_position(4)
     assert_equal [1, 3, 4, 2], DefaultScopedMixin.find(:all).map(&:id)
-    DefaultScopedMixin.find(2).update_attribute(:pos, 2)
+    DefaultScopedMixin.find(2).set_list_position(2)
     assert_equal [1, 2, 3, 4], DefaultScopedMixin.find(:all).map(&:id)
-    DefaultScopedMixin.find(1).update_attribute(:pos, 4)
+    DefaultScopedMixin.find(1).set_list_position(4)
     assert_equal [2, 3, 4, 1], DefaultScopedMixin.find(:all).map(&:id)
-    DefaultScopedMixin.find(1).update_attribute(:pos, 1)
+    DefaultScopedMixin.find(1).set_list_position(1)
     assert_equal [1, 2, 3, 4], DefaultScopedMixin.find(:all).map(&:id)
   end
 
@@ -337,18 +356,63 @@ class DefaultScopedWhereTest < ActsAsListTestCase
 
   def test_update_position
     assert_equal [1, 2, 3, 4], DefaultScopedWhereMixin.where(:active => false).find(:all).map(&:id)
-    DefaultScopedWhereMixin.where(:active => false).find(2).update_attribute(:pos, 4)
+    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).update_attribute(:pos, 2)
+    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).update_attribute(:pos, 4)
+    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).update_attribute(:pos, 1)
+    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
@@ -360,6 +424,7 @@ class TopAdditionTest < ActsAsListTestCase
   end
 end
 
+
 class TopAdditionTestWithDefault < ActsAsListTestCase
   include Shared::TopAddition
 
@@ -368,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.7
+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-07-25 00:00:00.000000000 Z
-dependencies:
-- !ruby/object:Gem::Dependency
-  name: bundler
-  requirement: &2156341060 !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: *2156341060
-- !ruby/object:Gem::Dependency
-  name: activerecord
-  requirement: &2156340520 !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: *2156340520
-- !ruby/object:Gem::Dependency
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
   name: rdoc
-  requirement: &2156340020 !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: *2156340020
-- !ruby/object:Gem::Dependency
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
   name: sqlite3
-  requirement: &2156339420 !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: *2156339420
-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