acts_as_list 0.7.4 → 0.9.0

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

@@ -1,10 +1,42 @@
+class << ActiveRecord::Base
+  # 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
+  #   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+)
+  #                   `nil` will result in new items not being added to the list on create.
+  # * +sequential_updates+ - specifies whether insert_at should update objects positions during shuffling
+  #   one by one to respect position column unique not null constraint. 
+  #   Defaults to true if position column has unique index, otherwise false.
+  #   If constraint is <tt>deferrable initially deferred<tt>, overriding it with false will speed up insert_at.
+  def acts_as_list(options = {})
+    configuration = { column: "position", scope: "1 = 1", top_of_list: 1, add_new_at: :bottom }
+    configuration.update(options) if options.is_a?(Hash)
+
+    caller_class = self
+
+    ActiveRecord::Acts::List::ColumnMethodDefiner.call(caller_class, configuration[:column])
+    ActiveRecord::Acts::List::ScopeMethodDefiner.call(caller_class, configuration[:scope])
+    ActiveRecord::Acts::List::TopOfListMethodDefiner.call(caller_class, configuration[:top_of_list])
+    ActiveRecord::Acts::List::AddNewAtMethodDefiner.call(caller_class, configuration[:add_new_at])
+
+    ActiveRecord::Acts::List::AuxMethodDefiner.call(caller_class)
+    ActiveRecord::Acts::List::CallbackDefiner.call(caller_class, configuration[:add_new_at])
+    ActiveRecord::Acts::List::SequentialUpdatesMethodDefiner.call(caller_class, configuration[:column], configuration[:sequential_updates])
+
+    include ActiveRecord::Acts::List::InstanceMethods
+    include ActiveRecord::Acts::List::NoUpdate
+  end
+end
+
 module ActiveRecord
   module Acts #:nodoc:
     module List #:nodoc:
-      def self.included(base)
-        base.extend(ClassMethods)
-      end
-
       # 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.
@@ -22,114 +54,6 @@ module ActiveRecord
       #
       #   todo_list.first.move_to_bottom
       #   todo_list.last.move_higher
-      module ClassMethods
-        # 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
-        #   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+)
-        #                   `nil` will result in new items not being added to the list on create
-        def acts_as_list(options = {})
-          configuration = { column: "position", scope: "1 = 1", top_of_list: 1, add_new_at: :bottom}
-          configuration.update(options) if options.is_a?(Hash)
-
-          if configuration[:scope].is_a?(Symbol) && configuration[:scope].to_s !~ /_id$/
-            configuration[:scope] = :"#{configuration[:scope]}_id"
-          end
-
-          if configuration[:scope].is_a?(Symbol)
-            scope_methods = %(
-              def scope_condition
-                { #{configuration[:scope]}: send(:#{configuration[:scope]}) }
-              end
-
-              def scope_changed?
-                changed.include?(scope_name.to_s)
-              end
-            )
-          elsif configuration[:scope].is_a?(Array)
-            scope_methods = %(
-              def scope_condition
-                #{configuration[:scope]}.inject({}) do |hash, column|
-                  hash.merge!({ column.to_sym => read_attribute(column.to_sym) })
-                end
-              end
-
-              def scope_changed?
-                (scope_condition.keys & changed.map(&:to_sym)).any?
-              end
-            )
-          else
-            scope_methods = %(
-              def scope_condition
-                "#{configuration[:scope]}"
-              end
-
-              def scope_changed?() false end
-            )
-          end
-
-          class_eval <<-EOV, __FILE__, __LINE__ + 1
-            include ::ActiveRecord::Acts::List::InstanceMethods
-
-            def acts_as_list_top
-              #{configuration[:top_of_list]}.to_i
-            end
-
-            def acts_as_list_class
-              ::#{self.name}
-            end
-
-            def position_column
-              '#{configuration[:column]}'
-            end
-
-            def scope_name
-              '#{configuration[:scope]}'
-            end
-
-            def add_new_at
-              '#{configuration[:add_new_at]}'
-            end
-
-            def #{configuration[:column]}=(position)
-              write_attribute(:#{configuration[:column]}, position)
-              @position_changed = true
-            end
-
-            #{scope_methods}
-
-            # 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_validation :check_top_position
-            
-            before_destroy :reload_position
-            after_destroy :decrement_positions_on_lower_items
-            
-            before_update :check_scope
-            after_update :update_positions
-
-            after_commit 'remove_instance_variable(:@scope_changed) if defined?(@scope_changed)'
-
-            scope :in_list, lambda { where("#{table_name}.#{configuration[:column]} IS NOT NULL") }
-          EOV
-
-          if configuration[:add_new_at].present?
-            self.send :before_create, :"add_to_list_#{configuration[:add_new_at]}"
-          end
-
-        end
-      end
 
       # All the methods available to a record that has had <tt>acts_as_list</tt> specified. Each method works
       # by assuming the object to be the item in the list, so <tt>chapter.move_lower</tt> would move that chapter
@@ -146,8 +70,12 @@ module ActiveRecord
           return unless lower_item
 
           acts_as_list_class.transaction do
-            lower_item.decrement_position
-            increment_position
+            if lower_item.send(position_column) != self.send(position_column)
+              swap_positions(lower_item, self)
+            else
+              lower_item.decrement_position
+              increment_position
+            end
           end
         end
 
@@ -156,8 +84,12 @@ module ActiveRecord
           return unless higher_item
 
           acts_as_list_class.transaction do
-            higher_item.increment_position
-            decrement_position
+            if higher_item.send(position_column) != self.send(position_column)
+              swap_positions(higher_item, self)
+            else
+              higher_item.increment_position
+              decrement_position
+            end
           end
         end
 
@@ -208,16 +140,14 @@ module ActiveRecord
           set_list_position(self.send(position_column).to_i - 1)
         end
 
-        # Return +true+ if this object is the first in the list.
         def first?
           return false unless in_list?
-          self.send(position_column) == acts_as_list_top
+          !higher_item
         end
 
-        # Return +true+ if this object is the last in the list.
         def last?
           return false unless in_list?
-          self.send(position_column) == bottom_position_in_list
+          !lower_item
         end
 
         # Return the next higher item in the list.
@@ -232,10 +162,10 @@ module ActiveRecord
           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")
+            where("#{quoted_position_column_with_table_name} <= ?", position_value).
+            where("#{quoted_table_name}.#{self.class.primary_key} != ?", self.send(self.class.primary_key)).
+            order("#{quoted_position_column_with_table_name} DESC").
+            limit(limit)
         end
 
         # Return the next lower item in the list.
@@ -250,10 +180,10 @@ module ActiveRecord
           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")
+            where("#{quoted_position_column_with_table_name} >= ?", position_value).
+            where("#{quoted_table_name}.#{self.class.primary_key} != ?", self.send(self.class.primary_key)).
+            order("#{quoted_position_column_with_table_name} ASC").
+            limit(limit)
         end
 
         # Test if this record is in a list
@@ -280,214 +210,240 @@ module ActiveRecord
         end
 
         private
-          def acts_as_list_list
-            acts_as_list_class.unscoped do
-              acts_as_list_class.where(scope_condition)
-            end
+
+        def swap_positions(item1, item2)
+          item1_position = item1.send(position_column)
+
+          item1.set_list_position(item2.send(position_column))
+          item2.set_list_position(item1_position)
+        end
+
+        def acts_as_list_list
+          acts_as_list_class.unscoped do
+            acts_as_list_class.where(scope_condition)
           end
+        end
 
-          def add_to_list_top
+        # Poorly named methods. They will insert the item at the desired position if the position
+        # has been set manually using position=, not necessarily the top or bottom of the list:
+
+        def add_to_list_top
+          if not_in_list? || internal_scope_changed? && !position_changed || default_position?
             increment_positions_on_all_items
             self[position_column] = acts_as_list_top
-            # Make sure we know that we've processed this scope change already
-            @scope_changed = false
-            #dont halt the callback chain
-            true
+          else
+            increment_positions_on_lower_items(self[position_column], id)
           end
 
-          # A poorly named method. It will insert the item at the desired position if the position
-          # has been set manually using position=, not necessarily the bottom of the list
-          def add_to_list_bottom
-            if not_in_list? || internal_scope_changed? && !@position_changed || default_position?
-              self[position_column] = bottom_position_in_list.to_i + 1
-            else
-              increment_positions_on_lower_items(self[position_column], id)
-            end
+          # Make sure we know that we've processed this scope change already
+          @scope_changed = false
 
-            # Make sure we know that we've processed this scope change already
-            @scope_changed = false
+          # Don't halt the callback chain
+          true
+        end
 
-            #dont halt the callback chain
-            true
+        def add_to_list_bottom
+          if not_in_list? || internal_scope_changed? && !position_changed || default_position?
+            self[position_column] = bottom_position_in_list.to_i + 1
+          else
+            increment_positions_on_lower_items(self[position_column], id)
           end
 
-          # Overwrite this method to define the scope of the list changes
-          def scope_condition() {} end
+          # Make sure we know that we've processed this scope change already
+          @scope_changed = false
 
-          # Returns the bottom position number in the list.
-          #   bottom_position_in_list    # => 2
-          def bottom_position_in_list(except = nil)
-            item = bottom_item(except)
-            item ? item.send(position_column) : acts_as_list_top - 1
-          end
+          # Don't halt the callback chain
+          true
+        end
 
-          # Returns the bottom item
-          def bottom_item(except = nil)
-            conditions = scope_condition
-            conditions = except ? "#{self.class.primary_key} != #{self.class.connection.quote(except.id)}" : {}
-            acts_as_list_list.in_list.where(
-              conditions
-            ).order(
-              "#{acts_as_list_class.table_name}.#{position_column} DESC"
-            ).first
-          end
+        # Overwrite this method to define the scope of the list changes
+        def scope_condition() {} end
 
-          # Forces item to assume the bottom position in the list.
-          def assume_bottom_position
-            set_list_position(bottom_position_in_list(self).to_i + 1)
-          end
+        # Returns the bottom position number in the list.
+        #   bottom_position_in_list    # => 2
+        def bottom_position_in_list(except = nil)
+          item = bottom_item(except)
+          item ? item.send(position_column) : acts_as_list_top - 1
+        end
 
-          # Forces item to assume the top position in the list.
-          def assume_top_position
-            set_list_position(acts_as_list_top)
-          end
+        # Returns the bottom item
+        def bottom_item(except = nil)
+          conditions = except ? "#{quoted_table_name}.#{self.class.primary_key} != #{self.class.connection.quote(except.id)}" : {}
+          acts_as_list_list.in_list.where(
+            conditions
+          ).order(
+            "#{quoted_position_column_with_table_name} DESC"
+          ).first
+        end
 
-          # This has the effect of moving all the higher items up one.
-          def decrement_positions_on_higher_items(position)
-            acts_as_list_list.where(
-              "#{position_column} <= #{position}"
-            ).update_all(
-              "#{position_column} = (#{position_column} - 1)"
-            )
-          end
+        # Forces item to assume the bottom position in the list.
+        def assume_bottom_position
+          set_list_position(bottom_position_in_list(self).to_i + 1)
+        end
 
-          # This has the effect of moving all the lower items up one.
-          def decrement_positions_on_lower_items(position=nil)
-            return unless in_list?
-            position ||= send(position_column).to_i
-            acts_as_list_list.where(
-              "#{position_column} > #{position}"
-            ).update_all(
-              "#{position_column} = (#{position_column} - 1)"
-            )
-          end
+        # Forces item to assume the top position in the list.
+        def assume_top_position
+          set_list_position(acts_as_list_top)
+        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_list.where(
-              "#{position_column} < #{send(position_column).to_i}"
-            ).update_all(
-              "#{position_column} = (#{position_column} + 1)"
-            )
+        # 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_list.where("#{quoted_position_column_with_table_name} < ?", send(position_column).to_i).increment_all
+        end
+
+        # This has the effect of moving all the lower items down one.
+        def increment_positions_on_lower_items(position, avoid_id = nil)
+          scope = acts_as_list_list
+
+          if avoid_id
+            scope = scope.where("#{quoted_table_name}.#{self.class.primary_key} != ?", self.class.connection.quote(avoid_id))
           end
 
-          # This has the effect of moving all the lower items down one.
-          def increment_positions_on_lower_items(position, avoid_id = nil)
-            avoid_id_condition = avoid_id ? " AND #{self.class.primary_key} != #{self.class.connection.quote(avoid_id)}" : ''
+          scope.where("#{quoted_position_column_with_table_name} >= ?", position).increment_all
+        end
 
-            acts_as_list_list.where(
-              "#{position_column} >= #{position}#{avoid_id_condition}"
-            ).update_all(
-              "#{position_column} = (#{position_column} + 1)"
-            )
+        # This has the effect of moving all the higher items up one.
+        def decrement_positions_on_higher_items(position)
+          acts_as_list_list.where("#{quoted_position_column_with_table_name} <= ?", position).decrement_all
+        end
+
+        # This has the effect of moving all the lower items up one.
+        def decrement_positions_on_lower_items(position=nil)
+          return unless in_list?
+          position ||= send(position_column).to_i
+          acts_as_list_list.where("#{quoted_position_column_with_table_name} > ?", position).decrement_all
+        end
+
+        # Increments position (<tt>position_column</tt>) of all items in the list.
+        def increment_positions_on_all_items
+          acts_as_list_list.increment_all
+        end
+
+        # Reorders intermediate items to support moving an item from old_position to new_position.
+        # unique constraint prevents regular increment_all and forces to do increments one by one
+        # http://stackoverflow.com/questions/7703196/sqlite-increment-unique-integer-field
+        # both SQLite and PostgreSQL (and most probably MySQL too) has same issue
+        # that's why *sequential_updates?* check alters implementation behavior
+        def shuffle_positions_on_intermediate_items(old_position, new_position, avoid_id = nil)
+          return if old_position == new_position
+          scope = acts_as_list_list
+
+          if avoid_id
+            scope = scope.where("#{quoted_table_name}.#{self.class.primary_key} != ?", self.class.connection.quote(avoid_id))
           end
 
-          # Increments position (<tt>position_column</tt>) of all items in the list.
-          def increment_positions_on_all_items
-            acts_as_list_list.update_all(
-              "#{position_column} = (#{position_column} + 1)"
+          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]
+            items = scope.where(
+              "#{quoted_position_column_with_table_name} > ?", old_position
+            ).where(
+              "#{quoted_position_column_with_table_name} <= ?", new_position
             )
-          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} != #{self.class.connection.quote(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_list.where(
-                "#{position_column} > #{old_position}"
-              ).where(
-                "#{position_column} <= #{new_position}#{avoid_id_condition}"
-              ).update_all(
-                "#{position_column} = (#{position_column} - 1)"
-              )
+            if sequential_updates?
+              items.order("#{quoted_position_column_with_table_name} ASC").each do |item|
+                item.decrement!(position_column)
+              end
             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_list.where(
-                "#{position_column} >= #{new_position}"
-              ).where(
-                "#{position_column} < #{old_position}#{avoid_id_condition}"
-              ).update_all(
-                "#{position_column} = (#{position_column} + 1)"
-              )
+              items.decrement_all
             end
-          end
+          else
+            # Increment position of intermediate items
+            #
+            # e.g., if moving an item from 5 to 2,
+            # move [2, 3, 4] to [3, 4, 5]
+            items = scope.where(
+              "#{quoted_position_column_with_table_name} >= ?", new_position
+            ).where(
+              "#{quoted_position_column_with_table_name} < ?", old_position
+            )
 
-          def insert_at_position(position)
-            return set_list_position(position) if new_record?
+            if sequential_updates?
+              items.order("#{quoted_position_column_with_table_name} DESC").each do |item|
+                item.increment!(position_column)
+              end
+            else
+              items.increment_all
+            end
+          end
+        end
+        
+        def insert_at_position(position)
+          return set_list_position(position) if new_record?
+          with_lock do
             if in_list?
               old_position = send(position_column).to_i
               return if position == old_position
-              shuffle_positions_on_intermediate_items(old_position, position)
+              # temporary move after bottom with gap, avoiding duplicate values
+              # gap is required to leave room for position increments
+              # positive number will be valid with unique not null check (>= 0) db constraint
+              temporary_position = acts_as_list_class.maximum(position_column).to_i + 2
+              set_list_position(temporary_position)
+              shuffle_positions_on_intermediate_items(old_position, position, id)
             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") || bottom_position_in_list + 1
+          new_position = send(position_column).to_i
 
-          def update_positions
-            old_position = send("#{position_column}_was").to_i
-            new_position = send(position_column).to_i
+          return unless acts_as_list_list.where(
+            "#{quoted_position_column_with_table_name} = #{new_position}"
+          ).count > 1
+          shuffle_positions_on_intermediate_items old_position, new_position, id
+        end
 
-            return unless acts_as_list_list.where(
-              "#{position_column} = #{new_position}"
-            ).count > 1
-            shuffle_positions_on_intermediate_items old_position, new_position, id
-          end
+        def internal_scope_changed?
+          return @scope_changed if defined?(@scope_changed)
 
-          def internal_scope_changed?
-            return @scope_changed if defined?(@scope_changed)
-            
-            @scope_changed = scope_changed?
-          end
+          @scope_changed = scope_changed?
+        end
 
-          # Temporarily swap changes attributes with current attributes
-          def swap_changed_attributes
-            @changed_attributes.each do |k, _|
-              if self.class.column_names.include? k
-                @changed_attributes[k], self[k] = self[k], @changed_attributes[k]
-              end
-            end
-          end
+        def clear_scope_changed
+          remove_instance_variable(:@scope_changed) if defined?(@scope_changed)
+        end
 
-          def check_scope
-            if internal_scope_changed?
-              swap_changed_attributes
-              send('decrement_positions_on_lower_items') if lower_item
-              swap_changed_attributes
-              send("add_to_list_#{add_new_at}")
-            end
-          end
+        def check_scope
+          if internal_scope_changed?
+            cached_changes = changes
 
-          def reload_position
-            self.reload
+            cached_changes.each { |attribute, values| self[attribute] = values[0] }
+            send('decrement_positions_on_lower_items') if lower_item
+            cached_changes.each { |attribute, values| self[attribute] = values[1] }
+
+            send("add_to_list_#{add_new_at}") if add_new_at.present?
           end
+        end
 
-          # This check is skipped if the position is currently the default position from the table
-          # as modifying the default position on creation is handled elsewhere
-          def check_top_position
-            if send(position_column) && !default_position? && send(position_column) < acts_as_list_top
-              self[position_column] = acts_as_list_top
-            end
+        # This check is skipped if the position is currently the default position from the table
+        # as modifying the default position on creation is handled elsewhere
+        def check_top_position
+          if send(position_column) && !default_position? && send(position_column) < acts_as_list_top
+            self[position_column] = acts_as_list_top
           end
+        end
+
+        # When using raw column name it must be quoted otherwise it can raise syntax errors with SQL keywords (e.g. order)
+        def quoted_position_column
+          @_quoted_position_column ||= self.class.connection.quote_column_name(position_column)
+        end
+
+        # Used in order clauses
+        def quoted_table_name
+          @_quoted_table_name ||= acts_as_list_class.quoted_table_name
+        end
+
+        def quoted_position_column_with_table_name
+          @_quoted_position_column_with_table_name ||= "#{quoted_table_name}.#{quoted_position_column}"
+        end
       end
     end
   end