acts_as_list 0.1.5 → 0.2.0

data/.gitignore

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

data/.travis.yml

@@ -0,0 +1,6 @@
+language: ruby
+rvm:
+  - 1.8.7
+  - 1.9.2
+  - 1.9.3
+  - 2.0.0

data/Gemfile

@@ -2,3 +2,5 @@ source "http://rubygems.org"
 
 # Specify your gem's dependencies in acts_as_list-rails3.gemspec
 gemspec
+
+gem 'rake'

data/README.md

@@ -2,26 +2,91 @@
 
 ## 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.
+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.
+
+## Build Status
+[![Build Status](https://secure.travis-ci.org/swanandp/acts_as_list.png)](https://secure.travis-ci.org/swanandp/acts_as_list)
+
+## Roadmap
+
+1. Sort based feature
+2. Rails 4 compatibility and bye bye Rails 2! Older versions would of course continue to work with Rails 2, but there won't be any support on those.
+
 ## Contributing to `acts_as_list`
  
 - Check out the latest master to make sure the feature hasn't been implemented or the bug hasn't been fixed yet
@@ -31,6 +96,7 @@ If the `position` column has a default value, then there is a slight change in b
 - Commit and push until you are happy with your contribution
 - Make sure to add tests for it. This is important so I don't break it in a future version unintentionally.
 - Please try not to mess with the Rakefile, version, or history. If you want to have your own version, or is otherwise necessary, that is fine, but please isolate to its own commit so I can cherry-pick around it.
+- I would recommend using Rails 3.1.x and higher for testing the build before a pull request. The current test harness does not quite work with 3.0.x. The plugin itself works, but the issue lies with testing infrastructure.
 
 ## Copyright
 

data/Rakefile

@@ -12,11 +12,9 @@ desc 'Test the acts_as_list plugin.'
 Rake::TestTask.new(:test) do |t|
   t.libs << 'lib' << 'test'
   t.pattern = 'test/**/test_*.rb'
-  t.verbose = true
+  t.verbose = false
 end
 
-
-
 # Run the rdoc task to generate rdocs for this gem
 require 'rdoc/task'
 RDoc::Task.new do |rdoc|

data/acts_as_list.gemspec

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

data/init.rb

@@ -1,2 +1,4 @@
 $:.unshift "#{File.dirname(__FILE__)}/lib"
 require 'acts_as_list'
+
+ActsAsList::Railtie.insert

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

@@ -26,14 +26,15 @@ 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
         #   act more like an array in its indexing.
+        # * +add_new_at+ - specifies whether objects get added to the :top or :bottom of the list. (default: +bottom+)
         def acts_as_list(options = {})
-          configuration = { :column => "position", :scope => "1 = 1", :top_of_list => 1}
+          configuration = { :column => "position", :scope => "1 = 1", :top_of_list => 1, :add_new_at => :bottom}
           configuration.update(options) if options.is_a?(Hash)
 
           configuration[:scope] = "#{configuration[:scope]}_id".intern if configuration[:scope].is_a?(Symbol) && configuration[:scope].to_s !~ /_id$/
@@ -47,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)
@@ -58,7 +59,7 @@ module ActiveRecord
           end
 
           class_eval <<-EOV
-            include ActiveRecord::Acts::List::InstanceMethods
+            include ::ActiveRecord::Acts::List::InstanceMethods
 
             def acts_as_list_top
               #{configuration[:top_of_list]}.to_i
@@ -72,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_validation :add_to_list_bottom, :on => :create
+            before_create :add_to_list_#{configuration[:add_new_at]}
+            after_update :update_positions
+            before_update :check_scope
           EOV
         end
       end
@@ -134,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.
@@ -165,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
@@ -195,9 +240,21 @@ 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
           end
 
           def add_to_list_bottom
@@ -222,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
 
@@ -246,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
@@ -304,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.5"
+      VERSION = "0.2.0"
     end
   end
 end

data/lib/acts_as_list.rb

@@ -1,2 +1,24 @@
 require 'acts_as_list/active_record/acts/list'
-ActiveRecord::Base.class_eval { include ActiveRecord::Acts::List }
+
+module ActsAsList
+  if defined? Rails::Railtie
+    require 'rails'
+    class Railtie < Rails::Railtie
+      initializer 'acts_as_list.insert_into_active_record' do
+        ActiveSupport.on_load :active_record do
+          ActsAsList::Railtie.insert
+        end
+      end
+    end
+  end
+
+  class Railtie
+    def self.insert
+      if defined?(ActiveRecord)
+        ActiveRecord::Base.send(:include, ActiveRecord::Acts::List)
+      end
+    end
+  end
+end
+
+ActsAsList::Railtie.insert

data/test/shared.rb

@@ -4,4 +4,5 @@ module Shared
   autoload :ListSub,        'shared_list_sub'
   autoload :ZeroBased,      'shared_zero_based'
   autoload :ArrayScopeList, 'shared_array_scope_list'
+  autoload :TopAddition,    'shared_top_addition'
 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
@@ -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
@@ -102,17 +106,6 @@ module Shared
       assert_equal 5, new4.pos
     end
 
-    def test_insert_middle_with_unsaved_item
-      assert_equal [1, 2, 3, 4], ListMixin.find(:all, :conditions => 'parent_id = 5', :order => 'pos').map(&:id)
-
-      # new item, not saved yet
-      insert_this = ListMixin.new(:parent_id => 5)
-      insert_this.insert_at(2)
-
-      assert_equal [1, 2, 3, 4, 5], ListMixin.find(:all, :conditions => 'parent_id = 5', :order => 'pos').map(&:pos)
-      assert_equal [1, 5, 2, 3, 4], ListMixin.find(:all, :conditions => 'parent_id = 5', :order => 'pos').map(&:id)
-    end
-
     def test_delete_middle
       assert_equal [1, 2, 3, 4], ListMixin.find(:all, :conditions => 'parent_id = 5', :order => 'pos').map(&:id)
 
@@ -215,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
@@ -52,7 +72,7 @@ module Shared
       new = ListMixinSub1.create("parent_id" => 20)
       assert_equal 2, new.pos
 
-      new = ListMixinSub2.create("parent_id" => 20)
+      new = ListMixinSub1.create("parent_id" => 20)
       assert_equal 3, new.pos
 
       new4 = ListMixin.create("parent_id" => 20)

data/test/shared_top_addition.rb

@@ -0,0 +1,87 @@
+module Shared
+  module TopAddition
+    def setup
+      (1..4).each { |counter| TopAdditionMixin.create! :pos => counter, :parent_id => 5 }
+    end
+
+    def test_reordering
+      assert_equal [4, 3, 2, 1], TopAdditionMixin.find(:all, :conditions => 'parent_id = 5', :order => 'pos').map(&:id)
+
+      TopAdditionMixin.find(2).move_lower
+      assert_equal [4, 3, 1, 2], TopAdditionMixin.find(:all, :conditions => 'parent_id = 5', :order => 'pos').map(&:id)
+
+      TopAdditionMixin.find(2).move_higher
+      assert_equal [4, 3, 2, 1], TopAdditionMixin.find(:all, :conditions => 'parent_id = 5', :order => 'pos').map(&:id)
+
+      TopAdditionMixin.find(1).move_to_bottom
+      assert_equal [4, 3, 2, 1], TopAdditionMixin.find(:all, :conditions => 'parent_id = 5', :order => 'pos').map(&:id)
+
+      TopAdditionMixin.find(1).move_to_top
+      assert_equal [1, 4, 3, 2], TopAdditionMixin.find(:all, :conditions => 'parent_id = 5', :order => 'pos').map(&:id)
+
+      TopAdditionMixin.find(2).move_to_bottom
+      assert_equal [1, 4, 3, 2], TopAdditionMixin.find(:all, :conditions => 'parent_id = 5', :order => 'pos').map(&:id)
+
+      TopAdditionMixin.find(4).move_to_top
+      assert_equal [4, 1, 3, 2], TopAdditionMixin.find(:all, :conditions => 'parent_id = 5', :order => 'pos').map(&:id)
+    end
+
+    def test_injection
+      item = TopAdditionMixin.new(:parent_id => 1)
+      assert_equal '"mixins"."parent_id" = 1', item.scope_condition
+      assert_equal "pos", item.position_column
+    end
+
+    def test_insert
+      new = TopAdditionMixin.create(:parent_id => 20)
+      assert_equal 1, new.pos
+      assert new.first?
+      assert new.last?
+
+      new = TopAdditionMixin.create(:parent_id => 20)
+      assert_equal 1, new.pos
+      assert new.first?
+      assert !new.last?
+
+      new = TopAdditionMixin.create(:parent_id => 20)
+      assert_equal 1, new.pos
+      assert new.first?
+      assert !new.last?
+
+      new = TopAdditionMixin.create(:parent_id => 0)
+      assert_equal 1, new.pos
+      assert new.first?
+      assert new.last?
+    end
+
+    def test_insert_at
+      new = TopAdditionMixin.create(:parent_id => 20)
+      assert_equal 1, new.pos
+
+      new = TopAdditionMixin.create(:parent_id => 20)
+      assert_equal 1, new.pos
+
+      new = TopAdditionMixin.create(:parent_id => 20)
+      assert_equal 1, new.pos
+
+      new4 = TopAdditionMixin.create(:parent_id => 20)
+      assert_equal 1, new4.pos
+
+      new4.insert_at(3)
+      assert_equal 3, new4.pos
+    end
+
+    def test_delete_middle
+      assert_equal [4, 3, 2, 1], TopAdditionMixin.find(:all, :conditions => 'parent_id = 5', :order => 'pos').map(&:id)
+
+      TopAdditionMixin.find(2).destroy
+
+      assert_equal [4, 3, 1], TopAdditionMixin.find(:all, :conditions => 'parent_id = 5', :order => 'pos').map(&:id)
+
+      assert_equal 3, TopAdditionMixin.find(1).pos
+      assert_equal 2, TopAdditionMixin.find(3).pos
+      assert_equal 1, TopAdditionMixin.find(4).pos
+    end
+
+  end
+end

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,15 @@ 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
+
 class ActsAsListTestCase < Test::Unit::TestCase
   # No default test required a this class is abstract.
   # Need for test/unit.
@@ -154,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
@@ -231,4 +260,217 @@ 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
+
+  def setup
+    setup_db_with_default
+    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,76 +1,98 @@
---- !ruby/object:Gem::Specification
+--- !ruby/object:Gem::Specification 
 name: acts_as_list
-version: !ruby/object:Gem::Version
-  version: 0.1.5
+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-02-24 00:00:00.000000000 Z
-dependencies:
-- !ruby/object:Gem::Dependency
-  name: bundler
-  requirement: &2152300140 !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: *2152300140
-- !ruby/object:Gem::Dependency
-  name: activerecord
-  requirement: &2152299540 !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: *2152299540
-- !ruby/object:Gem::Dependency
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
   name: rdoc
-  requirement: &2152299080 !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: *2152299080
-- !ruby/object:Gem::Dependency
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
   name: sqlite3
-  requirement: &2152298480 !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: *2152298480
-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
 - Gemfile
 - README.md
-- README.rdoc
 - Rakefile
 - acts_as_list.gemspec
 - init.rb
@@ -82,37 +104,48 @@ files:
 - test/shared_array_scope_list.rb
 - test/shared_list.rb
 - test/shared_list_sub.rb
+- test/shared_top_addition.rb
 - test/shared_zero_based.rb
 - 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
 - test/shared_list.rb
 - test/shared_list_sub.rb
+- test/shared_top_addition.rb
 - test/shared_zero_based.rb
 - test/test_list.rb

data/README.rdoc

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