acts_as_list 0.1.4 → 0.2.0

data/.gitignore

@@ -2,3 +2,6 @@
 .bundle
 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

@@ -0,0 +1,103 @@
+# 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
+
+At first, you need to add a `position` column to desired table:
+
+    rails g migration AddPositionToTodoItem position:integer
+    rake db:migrate
+    
+After that you can use `acts_as_list` method in the model: 
+
+```ruby
+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
+```
+
+## 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
+- 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,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 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
@@ -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}
 
-            before_destroy :decrement_positions_on_lower_items
-            before_create  :add_to_list_bottom
+            # 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
@@ -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,31 +184,81 @@ 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?
-          !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
+
+        # 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
-            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 +279,136 @@ 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.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
 
           # 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.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, 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.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.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
+
           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
+            set_list_position(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
+              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("#{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.4"
+      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/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