acts_as_list 0.1.4 → 0.1.8

data/.gitignore

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

data/.travis.yml

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

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

@@ -0,0 +1,60 @@
+# 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.
+
+## 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
+    
+    class TodoItem < ActiveRecord::Base
+      belongs_to :todo_list
+      acts_as_list :scope => :todo_list
+    end
+    
+    todo_list.first.move_to_bottom
+    todo_list.last.move_higher
+    
+## Notes
+If the `position` column has a default value, then there is a slight change in behavior, i.e if you have 4 items in the list, and you insert 1, with a default position 0, it would be pushed to the bottom of the list. Please look at the tests for this and some recent pull requests for discussions related to this.
+
+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.
+
+## 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
+- 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.
+- 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
+
+Copyright (c) 2007 David Heinemeier Hansson, released under the MIT license

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,7 +24,7 @@ Gem::Specification.new do |s|
 
 
   # Dependencies (installed via 'bundle install')...
-  s.add_development_dependency("bundler", ["~> 1.0.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")

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 line an array in it's indexing.
+        #   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
@@ -74,8 +75,9 @@ module ActiveRecord
 
             #{scope_condition_method}
 
-            before_destroy :decrement_positions_on_lower_items
-            before_create  :add_to_list_bottom
+            after_destroy :decrement_positions_on_lower_items
+            before_create :add_to_list_#{configuration[:add_new_at]}
+            after_update :update_positions
           EOV
         end
       end
@@ -134,20 +136,20 @@ module ActiveRecord
         def remove_from_list
           if in_list?
             decrement_positions_on_lower_items
-            update_attribute position_column, nil
+            update_attributes! position_column => 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
+          update_attributes! position_column => 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
+          update_attributes! position_column => self.send(position_column).to_i - 1
         end
 
         # Return +true+ if this object is the first in the list.
@@ -165,7 +167,7 @@ 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 =>
+          acts_as_list_class.unscoped.find(:first, :conditions =>
             "#{scope_condition} AND #{position_column} = #{(send(position_column).to_i - 1).to_s}"
           )
         end
@@ -173,23 +175,36 @@ module ActiveRecord
         # Return the next lower item in the list.
         def lower_item
           return nil unless in_list?
-          acts_as_list_class.find(:first, :conditions =>
+          acts_as_list_class.unscoped.find(:first, :conditions =>
             "#{scope_condition} AND #{position_column} = #{(send(position_column).to_i + 1).to_s}"
           )
         end
 
         # Test if this record is in a list
         def in_list?
-          !send(position_column).nil?
+          !not_in_list?
+        end
+
+        def not_in_list?
+          send(position_column).nil?
+        end
+
+        def default_position
+          acts_as_list_class.columns_hash[position_column.to_s].default
+        end
+
+        def default_position?
+          default_position == send(position_column)
         end
 
         private
           def add_to_list_top
             increment_positions_on_all_items
+            self[position_column] = acts_as_list_top
           end
 
           def add_to_list_bottom
-            if self[position_column].nil?
+            if not_in_list? || default_position?
               self[position_column] = bottom_position_in_list.to_i + 1
             else
               increment_positions_on_lower_items(self[position_column])
@@ -210,62 +225,107 @@ module ActiveRecord
           def bottom_item(except = nil)
             conditions = scope_condition
             conditions = "#{conditions} AND #{self.class.primary_key} != #{except.id}" if except
-            acts_as_list_class.find(:first, :conditions => conditions, :order => "#{position_column} DESC")
+            acts_as_list_class.unscoped.find(:first, :conditions => conditions, :order => "#{acts_as_list_class.table_name}.#{position_column} DESC")
           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)
+            update_attributes!(position_column => 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)
+            update_attributes!(position_column => 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(
+            acts_as_list_class.unscoped.update_all(
               "#{position_column} = (#{position_column} - 1)", "#{scope_condition} AND #{position_column} <= #{position}"
             )
           end
 
           # This has the effect of moving all the lower items up one.
-          def decrement_positions_on_lower_items
+          def decrement_positions_on_lower_items(position=nil)
             return unless in_list?
-            acts_as_list_class.update_all(
-              "#{position_column} = (#{position_column} - 1)", "#{scope_condition} AND #{position_column} > #{send(position_column).to_i}"
+            position ||= send(position_column).to_i
+            acts_as_list_class.unscoped.update_all(
+              "#{position_column} = (#{position_column} - 1)", "#{scope_condition} AND #{position_column} > #{position}"
             )
           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(
+            acts_as_list_class.unscoped.update_all(
               "#{position_column} = (#{position_column} + 1)", "#{scope_condition} AND #{position_column} < #{send(position_column).to_i}"
             )
           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(
+            acts_as_list_class.unscoped.update_all(
               "#{position_column} = (#{position_column} + 1)", "#{scope_condition} AND #{position_column} >= #{position}"
            )
           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(
+            acts_as_list_class.unscoped.update_all(
               "#{position_column} = (#{position_column} + 1)",  "#{scope_condition}"
             )
           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, 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.unscoped.update_all(
+                "#{position_column} = (#{position_column} - 1)", "#{scope_condition} AND #{position_column} > #{old_position} AND #{position_column} <= #{new_position}#{avoid_id_condition}"
+              )
+            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}"
+              )
+            end
+          end
+
           def insert_at_position(position)
-            remove_from_list
-            increment_positions_on_lower_items(position)
-            self.update_attribute(position_column, position)
+            if in_list?
+              old_position = send(position_column).to_i
+              return if position == old_position
+              shuffle_positions_on_intermediate_items(old_position, position)
+            else
+              increment_positions_on_lower_items(position)
+            end
+            self.update_attributes!(position_column => position)
           end
-      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_attributes!(position_column => 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("#{scope_condition} AND #{position_column} = #{new_position}").count > 1
+            shuffle_positions_on_intermediate_items old_position, new_position, id
+          end
+      end
     end
   end
 end

data/lib/acts_as_list/version.rb

@@ -1,7 +1,7 @@
 module ActiveRecord
   module Acts
     module List
-      VERSION = "0.1.4"
+      VERSION = "0.1.8"
     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/helper.rb

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

data/test/shared.rb

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

data/test/shared_array_scope_list.rb

@@ -0,0 +1,160 @@
+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
+      assert_equal [1, 2, 3, 4], ArrayScopeListMixin.find(:all, :conditions => "parent_id = 5 AND parent_type = 'ParentClass'", :order => 'pos').map(&:id)
+
+      ArrayScopeListMixin.find(2).move_lower
+      assert_equal [1, 3, 2, 4], ArrayScopeListMixin.find(:all, :conditions => "parent_id = 5 AND parent_type = 'ParentClass'", :order => 'pos').map(&:id)
+
+      ArrayScopeListMixin.find(2).move_higher
+      assert_equal [1, 2, 3, 4], ArrayScopeListMixin.find(:all, :conditions => "parent_id = 5 AND parent_type = 'ParentClass'", :order => 'pos').map(&:id)
+
+      ArrayScopeListMixin.find(1).move_to_bottom
+      assert_equal [2, 3, 4, 1], ArrayScopeListMixin.find(:all, :conditions => "parent_id = 5 AND parent_type = 'ParentClass'", :order => 'pos').map(&:id)
+
+      ArrayScopeListMixin.find(1).move_to_top
+      assert_equal [1, 2, 3, 4], ArrayScopeListMixin.find(:all, :conditions => "parent_id = 5 AND parent_type = 'ParentClass'", :order => 'pos').map(&:id)
+
+      ArrayScopeListMixin.find(2).move_to_bottom
+      assert_equal [1, 3, 4, 2], ArrayScopeListMixin.find(:all, :conditions => "parent_id = 5 AND parent_type = 'ParentClass'", :order => 'pos').map(&:id)
+
+      ArrayScopeListMixin.find(4).move_to_top
+      assert_equal [4, 1, 3, 2], ArrayScopeListMixin.find(:all, :conditions => "parent_id = 5 AND parent_type = 'ParentClass'", :order => 'pos').map(&:id)
+      
+      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
+      assert_equal [1, 2, 3, 4], ArrayScopeListMixin.find(:all, :conditions => "parent_id = 5 AND parent_type = 'ParentClass'", :order => 'pos').map(&:id)
+      ArrayScopeListMixin.find(3).move_to_bottom
+      assert_equal [1, 2, 4, 3], ArrayScopeListMixin.find(:all, :conditions => "parent_id = 5 AND parent_type = 'ParentClass'", :order => 'pos').map(&:id)
+    end
+
+    def test_next_prev
+      assert_equal ArrayScopeListMixin.find(2), ArrayScopeListMixin.find(1).lower_item
+      assert_nil ArrayScopeListMixin.find(1).higher_item
+      assert_equal ArrayScopeListMixin.find(3), ArrayScopeListMixin.find(4).higher_item
+      assert_nil ArrayScopeListMixin.find(4).lower_item
+    end
+
+    def test_injection
+      item = ArrayScopeListMixin.new(:parent_id => 1, :parent_type => 'ParentClass')
+      assert_equal "pos", item.position_column
+    end
+
+    def test_insert
+      new = ArrayScopeListMixin.create(:parent_id => 20, :parent_type => 'ParentClass')
+      assert_equal 1, new.pos
+      assert new.first?
+      assert new.last?
+
+      new = ArrayScopeListMixin.create(:parent_id => 20, :parent_type => 'ParentClass')
+      assert_equal 2, new.pos
+      assert !new.first?
+      assert new.last?
+
+      new = ArrayScopeListMixin.create(:parent_id => 20, :parent_type => 'ParentClass')
+      assert_equal 3, new.pos
+      assert !new.first?
+      assert new.last?
+
+      new = ArrayScopeListMixin.create(:parent_id => 0, :parent_type => 'ParentClass')
+      assert_equal 1, new.pos
+      assert new.first?
+      assert new.last?
+    end
+
+    def test_insert_at
+      new = ArrayScopeListMixin.create(:parent_id => 20, :parent_type => 'ParentClass')
+      assert_equal 1, new.pos
+
+      new = ArrayScopeListMixin.create(:parent_id => 20, :parent_type => 'ParentClass')
+      assert_equal 2, new.pos
+
+      new = ArrayScopeListMixin.create(:parent_id => 20, :parent_type => 'ParentClass')
+      assert_equal 3, new.pos
+
+      new4 = ArrayScopeListMixin.create(:parent_id => 20, :parent_type => 'ParentClass')
+      assert_equal 4, new4.pos
+
+      new4.insert_at(3)
+      assert_equal 3, new4.pos
+
+      new.reload
+      assert_equal 4, new.pos
+
+      new.insert_at(2)
+      assert_equal 2, new.pos
+
+      new4.reload
+      assert_equal 4, new4.pos
+
+      new5 = ArrayScopeListMixin.create(:parent_id => 20, :parent_type => 'ParentClass')
+      assert_equal 5, new5.pos
+
+      new5.insert_at(1)
+      assert_equal 1, new5.pos
+
+      new4.reload
+      assert_equal 5, new4.pos
+    end
+
+    def test_delete_middle
+      assert_equal [1, 2, 3, 4], ArrayScopeListMixin.find(:all, :conditions => "parent_id = 5 AND parent_type = 'ParentClass'", :order => 'pos').map(&:id)
+
+      ArrayScopeListMixin.find(2).destroy
+
+      assert_equal [1, 3, 4], ArrayScopeListMixin.find(:all, :conditions => "parent_id = 5 AND parent_type = 'ParentClass'", :order => 'pos').map(&:id)
+
+      assert_equal 1, ArrayScopeListMixin.find(1).pos
+      assert_equal 2, ArrayScopeListMixin.find(3).pos
+      assert_equal 3, ArrayScopeListMixin.find(4).pos
+
+      ArrayScopeListMixin.find(1).destroy
+
+      assert_equal [3, 4], ArrayScopeListMixin.find(:all, :conditions => "parent_id = 5 AND parent_type = 'ParentClass'", :order => 'pos').map(&:id)
+
+      assert_equal 1, ArrayScopeListMixin.find(3).pos
+      assert_equal 2, ArrayScopeListMixin.find(4).pos
+    end
+
+    def test_remove_from_list_should_then_fail_in_list?
+      assert_equal true, ArrayScopeListMixin.find(1).in_list?
+      ArrayScopeListMixin.find(1).remove_from_list
+      assert_equal false, ArrayScopeListMixin.find(1).in_list?
+    end
+
+    def test_remove_from_list_should_set_position_to_nil
+      assert_equal [1, 2, 3, 4], ArrayScopeListMixin.find(:all, :conditions => "parent_id = 5 AND parent_type = 'ParentClass'", :order => 'pos').map(&:id)
+
+      ArrayScopeListMixin.find(2).remove_from_list
+
+      assert_equal [2, 1, 3, 4], ArrayScopeListMixin.find(:all, :conditions => "parent_id = 5 AND parent_type = 'ParentClass'", :order => 'pos').map(&:id)
+
+      assert_equal 1,   ArrayScopeListMixin.find(1).pos
+      assert_equal nil, ArrayScopeListMixin.find(2).pos
+      assert_equal 2,   ArrayScopeListMixin.find(3).pos
+      assert_equal 3,   ArrayScopeListMixin.find(4).pos
+    end
+
+    def test_remove_before_destroy_does_not_shift_lower_items_twice
+      assert_equal [1, 2, 3, 4], ArrayScopeListMixin.find(:all, :conditions => "parent_id = 5 AND parent_type = 'ParentClass'", :order => 'pos').map(&:id)
+
+      ArrayScopeListMixin.find(2).remove_from_list
+      ArrayScopeListMixin.find(2).destroy
+
+      assert_equal [1, 3, 4], ArrayScopeListMixin.find(:all, :conditions => "parent_id = 5 AND parent_type = 'ParentClass'", :order => 'pos').map(&:id)
+
+      assert_equal 1, ArrayScopeListMixin.find(1).pos
+      assert_equal 2, ArrayScopeListMixin.find(3).pos
+      assert_equal 3, ArrayScopeListMixin.find(4).pos
+    end
+  end
+end