acts_as_list 0.7.2 → 0.7.7

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

@@ -38,32 +38,30 @@ module ActiveRecord
           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$/
+          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].to_s} => send(:#{configuration[:scope].to_s}) }
+                { #{configuration[:scope]}: send(:#{configuration[:scope]}) }
               end
 
               def scope_changed?
-                changes.include?(scope_name.to_s)
+                changed.include?(scope_name.to_s)
               end
             )
           elsif configuration[:scope].is_a?(Array)
             scope_methods = %(
-              def attrs
-                %w(#{configuration[:scope].join(" ")}).inject({}) do |memo,column|
-                  memo[column.intern] = read_attribute(column.intern); memo
+              def scope_condition
+                #{configuration[:scope]}.inject({}) do |hash, column|
+                  hash.merge!({ column.to_sym => read_attribute(column.to_sym) })
                 end
               end
 
               def scope_changed?
-                (attrs.keys & changes.keys.map(&:to_sym)).any?
-              end
-
-              def scope_condition
-                attrs
+                (scope_condition.keys & changed.map(&:to_sym)).any?
               end
             )
           else
@@ -76,8 +74,13 @@ module ActiveRecord
             )
           end
 
-          class_eval <<-EOV
-            include ::ActiveRecord::Acts::List::InstanceMethods
+          quoted_position_column = connection.quote_column_name(configuration[:column])
+          quoted_position_column_with_table_name = "#{quoted_table_name}.#{quoted_position_column}"
+
+          class_eval <<-EOV, __FILE__, __LINE__ + 1
+            def self.acts_as_list_top
+              #{configuration[:top_of_list]}.to_i
+            end
 
             def acts_as_list_top
               #{configuration[:top_of_list]}.to_i
@@ -113,19 +116,46 @@ module ActiveRecord
               attr_accessible :#{configuration[:column]}
             end
 
-            before_destroy :reload_position
-            after_destroy :decrement_positions_on_lower_items
-            before_update :check_scope
-            after_update :update_positions
-            before_validation :check_top_position
+            scope :in_list, lambda { where(%q{#{quoted_position_column_with_table_name} IS NOT NULL}) }
+
+            def self.decrement_all
+              update_all_with_touch %q(#{quoted_position_column} = (#{quoted_position_column_with_table_name} - 1))
+            end
+
+            def self.increment_all
+              update_all_with_touch %q(#{quoted_position_column} = (#{quoted_position_column_with_table_name} + 1))
+            end
+
+            def self.update_all_with_touch(updates)
+              record = new
+              attrs = record.send(:timestamp_attributes_for_update_in_model)
+              now = record.send(:current_time_from_proper_timezone)
+
+              query = attrs.map { |attr| %(\#{connection.quote_column_name(attr)} = :now) }
+              query.push updates
+              query = query.join(", ")
 
-            scope :in_list, lambda { where("#{table_name}.#{configuration[:column]} IS NOT NULL") }
+              update_all([query, now: now])
+            end
           EOV
 
+          attr_reader :position_changed
+
+          before_validation :check_top_position
+
+          before_destroy :lock!
+          after_destroy :decrement_positions_on_lower_items
+
+          before_update :check_scope
+          after_update :update_positions
+
+          after_commit :clear_scope_changed
+
           if configuration[:add_new_at].present?
-            self.send(:before_create, "add_to_list_#{configuration[:add_new_at]}")
+            before_create "add_to_list_#{configuration[:add_new_at]}".to_sym
           end
 
+          include ::ActiveRecord::Acts::List::InstanceMethods
         end
       end
 
@@ -221,10 +251,7 @@ module ActiveRecord
         # Return the next higher item in the list.
         def higher_item
           return nil unless in_list?
-          acts_as_list_class.unscoped do
-            acts_as_list_class.where(scope_condition).where("#{position_column} < #{(send(position_column).to_i).to_s}").
-            order("#{acts_as_list_class.table_name}.#{position_column} DESC").first
-          end
+          higher_items(1).first
         end
 
         # Return the next n higher items in the list
@@ -233,19 +260,16 @@ 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).
+            where("#{quoted_position_column_with_table_name} < ?", position_value).
+            where("#{quoted_position_column_with_table_name} >= ?", position_value - limit).
             limit(limit).
-            order("#{acts_as_list_class.table_name}.#{position_column} ASC")
+            order("#{quoted_position_column_with_table_name} ASC")
         end
 
         # Return the next lower item in the list.
         def lower_item
           return nil unless in_list?
-          acts_as_list_class.unscoped do
-            acts_as_list_class.where(scope_condition).where("#{position_column} > #{(send(position_column).to_i).to_s}").
-            order("#{acts_as_list_class.table_name}.#{position_column} ASC").first
-          end
+          lower_items(1).first
         end
 
         # Return the next n lower items in the list
@@ -254,10 +278,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).
+            where("#{quoted_position_column_with_table_name} > ?", position_value).
+            where("#{quoted_position_column_with_table_name} <= ?", position_value + limit).
             limit(limit).
-            order("#{acts_as_list_class.table_name}.#{position_column} ASC")
+            order("#{quoted_position_column_with_table_name} ASC")
         end
 
         # Test if this record is in a list
@@ -293,14 +317,26 @@ module ActiveRecord
           def add_to_list_top
             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
           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? || scope_changed? && !@position_changed || default_position?
+            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
+
+            #dont halt the callback chain
+            true
           end
 
           # Overwrite this method to define the scope of the list changes
@@ -315,11 +351,12 @@ module ActiveRecord
 
           # 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_class.unscoped do
-              acts_as_list_class.in_list.where(scope_condition).where(conditions).order("#{acts_as_list_class.table_name}.#{position_column} DESC").first
-            end
+            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
 
           # Forces item to assume the bottom position in the list.
@@ -334,110 +371,74 @@ module ActiveRecord
 
           # This has the effect of moving all the higher items up one.
           def decrement_positions_on_higher_items(position)
-            acts_as_list_class.unscoped do
-              acts_as_list_class.where(scope_condition).where(
-                "#{position_column} <= #{position}"
-              ).update_all(
-                "#{position_column} = (#{position_column} - 1)"
-              )
-            end
+            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_class.unscoped do
-              acts_as_list_class.where(scope_condition).where(
-                "#{position_column} > #{position}"
-              ).update_all(
-                "#{position_column} = (#{position_column} - 1)"
-              )
-            end
+            acts_as_list_list.where("#{quoted_position_column_with_table_name} > ?", position).decrement_all
           end
 
           # This has the effect of moving all the higher items down one.
           def increment_positions_on_higher_items
             return unless in_list?
-            acts_as_list_class.unscoped do
-              acts_as_list_class.where(scope_condition).where(
-                "#{position_column} < #{send(position_column).to_i}"
-              ).update_all(
-                "#{position_column} = (#{position_column} + 1)"
-              )
-            end
+            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)
-            avoid_id_condition = avoid_id ? " AND #{self.class.primary_key} != #{self.class.connection.quote(avoid_id)}" : ''
+            avoid_id_condition = avoid_id ? " AND #{quoted_table_name}.#{self.class.primary_key} != #{self.class.connection.quote(avoid_id)}" : ''
 
-            acts_as_list_class.unscoped do
-              acts_as_list_class.where(scope_condition).where(
-                "#{position_column} >= #{position}#{avoid_id_condition}"
-              ).update_all(
-                "#{position_column} = (#{position_column} + 1)"
-              )
-            end
+            acts_as_list_list.where("#{quoted_position_column_with_table_name} >= #{position}#{avoid_id_condition}").increment_all
           end
 
           # Increments position (<tt>position_column</tt>) of all items in the list.
           def increment_positions_on_all_items
-            acts_as_list_class.unscoped do
-              acts_as_list_class.where(
-                scope_condition
-              ).update_all(
-                "#{position_column} = (#{position_column} + 1)"
-              )
-            end
+            acts_as_list_list.increment_all
           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)}" : ''
+            avoid_id_condition = avoid_id ? " AND #{quoted_table_name}.#{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_class.unscoped do
-                acts_as_list_class.where(scope_condition).where(
-                  "#{position_column} > #{old_position}"
-                ).where(
-                  "#{position_column} <= #{new_position}#{avoid_id_condition}"
-                ).update_all(
-                  "#{position_column} = (#{position_column} - 1)"
-                )
-              end
+              acts_as_list_list.where(
+                "#{quoted_position_column_with_table_name} > ?", old_position
+              ).where(
+                "#{quoted_position_column_with_table_name} <= #{new_position}#{avoid_id_condition}"
+              ).decrement_all
             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 do
-                acts_as_list_class.where(scope_condition).where(
-                  "#{position_column} >= #{new_position}"
-                ).where(
-                  "#{position_column} < #{old_position}#{avoid_id_condition}"
-                ).update_all(
-                  "#{position_column} = (#{position_column} + 1)"
-                )
-              end
+              acts_as_list_list.where(
+                "#{quoted_position_column_with_table_name} >= ?", new_position
+              ).where(
+                "#{quoted_position_column_with_table_name} < #{old_position}#{avoid_id_condition}"
+              ).increment_all
             end
           end
 
           def insert_at_position(position)
             return set_list_position(position) if new_record?
-            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)
+            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)
+              else
+                increment_positions_on_lower_items(position)
+              end
+              set_list_position(position)
             end
-            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
@@ -453,29 +454,32 @@ module ActiveRecord
             old_position = send("#{position_column}_was").to_i
             new_position = send(position_column).to_i
 
-            return unless acts_as_list_class.unscoped do
-              acts_as_list_class.where(scope_condition).where("#{position_column} = #{new_position}").count > 1
-            end
+            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
 
-          # Temporarily swap changes attributes with current attributes
-          def swap_changed_attributes
-            @changed_attributes.each { |k, _| @changed_attributes[k], self[k] =
-              self[k], @changed_attributes[k] }
+          def internal_scope_changed?
+            return @scope_changed if defined?(@scope_changed)
+
+            @scope_changed = scope_changed?
+          end
+
+          def clear_scope_changed
+            remove_instance_variable(:@scope_changed) if defined?(@scope_changed)
           end
 
           def check_scope
-            if scope_changed?
-              swap_changed_attributes
+            if internal_scope_changed?
+              cached_changes = changes
+
+              cached_changes.each { |attribute, values| self[attribute] = values[0] }
               send('decrement_positions_on_lower_items') if lower_item
-              swap_changed_attributes
-              send("add_to_list_#{add_new_at}")
-            end
-          end
+              cached_changes.each { |attribute, values| self[attribute] = values[1] }
 
-          def reload_position
-            self.reload
+              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
@@ -485,6 +489,20 @@ module ActiveRecord
               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

data/lib/acts_as_list/version.rb

@@ -1,7 +1,7 @@
 module ActiveRecord
   module Acts
     module List
-      VERSION = '0.7.2'
+      VERSION = '0.7.7'
     end
   end
 end

data/test/helper.rb

@@ -11,4 +11,11 @@ require "active_record"
 require "minitest/autorun"
 require "#{File.dirname(__FILE__)}/../init"
 
+if defined?(ActiveRecord::VERSION) &&
+  ActiveRecord::VERSION::MAJOR == 4 && ActiveRecord::VERSION::MINOR >= 2
+
+  # Was removed in Rails 5 and is effectively true.
+  ActiveRecord::Base.raise_in_transactional_callbacks = true
+end
+
 require "shared"

data/test/shared.rb

@@ -6,4 +6,5 @@ module Shared
   autoload :ArrayScopeList, 'shared_array_scope_list'
   autoload :TopAddition,    'shared_top_addition'
   autoload :NoAddition,     'shared_no_addition'
+  autoload :Quoting,        'shared_quoting'
 end

data/test/shared_list.rb

@@ -104,6 +104,12 @@ module Shared
 
       new4.reload
       assert_equal 5, new4.pos
+
+      last1 = ListMixin.order('pos').last
+      last2 = ListMixin.order('pos').last
+      last1.insert_at(1)
+      last2.insert_at(1)
+      assert_equal [1, 2, 3, 4, 5], ListMixin.where(parent_id: 20).order('pos').map(&:pos)
     end
 
     def test_delete_middle
@@ -142,7 +148,7 @@ module Shared
 
     def test_update_position_when_scope_changes
       assert_equal [1, 2, 3, 4], ListMixin.where(parent_id: 5).order('pos').map(&:id)
-      parent = ListMixin.create(parent_id: 6)
+      ListMixin.create(parent_id: 6)
 
       ListMixin.where(id: 2).first.move_within_scope(6)
 
@@ -246,5 +252,11 @@ module Shared
 
       assert_equal [5, 1, 6, 2, 3, 4], ListMixin.where(parent_id: 5).order('pos').map(&:id)
     end
+
+    def test_non_persisted_records_dont_get_lock_called
+      new = ListMixin.new(parent_id: 5)
+
+      new.destroy
+    end
   end
 end

data/test/shared_no_addition.rb

@@ -21,5 +21,16 @@ module Shared
       assert !new.in_list?
     end
 
+    def test_update_scope_does_not_add_to_list
+      new = NoAdditionMixin.create
+
+      new.update_attribute(:parent_id, 20)
+      new.reload
+      assert !new.in_list?
+
+      new.update_attribute(:parent_id, 5)
+      new.reload
+      assert !new.in_list?
+    end
   end
 end

data/test/shared_quoting.rb

@@ -0,0 +1,21 @@
+module Shared
+  module Quoting
+
+    def setup
+      3.times { |counter| QuotedList.create! order: counter }
+    end
+
+    def test_create
+      assert_equal QuotedList.in_list.size, 3
+    end
+
+    # This test execute raw queries involving table name
+    def test_moving
+      item = QuotedList.first
+      item.higher_items
+      item.lower_items
+      item.send :bottom_item # Part of private api
+    end
+
+  end
+end

data/test/test_joined_list.rb

@@ -0,0 +1,64 @@
+require 'helper'
+
+ActiveRecord::Base.establish_connection(adapter: "sqlite3", database: ":memory:")
+ActiveRecord::Schema.verbose = false
+
+class Section < ActiveRecord::Base
+  has_many :items
+  acts_as_list
+
+  scope :visible, -> { where(visible: true) }
+end
+
+class Item < ActiveRecord::Base
+  belongs_to :section
+  acts_as_list scope: :section
+
+  scope :visible, -> { where(visible: true).joins(:section).merge(Section.visible) }
+end
+
+class JoinedTestCase < Minitest::Test
+  def setup
+    ActiveRecord::Base.connection.create_table :sections do |t|
+      t.column :position, :integer
+      t.column :visible, :boolean, default: true
+    end
+
+    ActiveRecord::Base.connection.create_table :items do |t|
+      t.column :position, :integer
+      t.column :section_id, :integer
+      t.column :visible, :boolean, default: true
+    end
+
+    ActiveRecord::Base.connection.schema_cache.clear!
+    [Section, Item].each(&:reset_column_information)
+    super
+  end
+
+  def teardown
+    ActiveRecord::Base.connection.tables.each do |table|
+      ActiveRecord::Base.connection.drop_table(table)
+    end
+    super
+  end
+end
+
+# joining the relation returned by `#higher_items` or `#lower_items` to another table
+# previously could result in ambiguous column names in the query
+class TestHigherLowerItems < JoinedTestCase
+  def test_higher_items
+    section = Section.create
+    item1 = Item.create section: section
+    item2 = Item.create section: section
+    item3 = Item.create section: section
+    assert_equal item3.higher_items.visible, [item1, item2]
+  end
+
+  def test_lower_items
+    section = Section.create
+    item1 = Item.create section: section
+    item2 = Item.create section: section
+    item3 = Item.create section: section
+    assert_equal item1.lower_items.visible, [item2, item3]
+  end
+end