acts_as_list 0.9.17 → 1.0.2

data/Gemfile

@@ -1,7 +1,5 @@
 source "http://rubygems.org"
 
-gem "rack", "~> 1", platforms: [:ruby_19, :ruby_20, :ruby_21]
-
 gemspec
 
 gem "rake"
@@ -13,15 +11,18 @@ end
 
 group :test do
   gem "minitest", "~> 5.0"
-  gem "test_after_commit", "~> 0.4.2"
   gem "timecop"
   gem "mocha"
 end
 
 group :sqlite do
-  gem "sqlite3", platforms: [:ruby]
+  gem "sqlite3", "~> 1.3.13"
 end
 
 group :postgresql do
-  gem "pg", "~> 0.18.0", platforms: [:ruby]
+  gem "pg", "~> 1.1.4"
+end
+
+group :mysql do
+  gem "mysql2", "~> 0.5.0"
 end

data/README.md

@@ -1,7 +1,8 @@
-# ActsAsList
+# Acts As List
 
 ## Build Status
-[![Build Status](https://secure.travis-ci.org/swanandp/acts_as_list.png)](https://secure.travis-ci.org/swanandp/acts_as_list)
+[![Build Status](https://travis-ci.org/brendon/acts_as_list.svg?branch=master)](https://travis-ci.org/brendon/acts_as_list)
+[![Gem Version](https://badge.fury.io/rb/acts_as_list.svg)](https://badge.fury.io/rb/acts_as_list)
 
 ## Description
 
@@ -11,8 +12,8 @@ This `acts_as` extension provides the capabilities for sorting and reordering a
 
 There are a couple of changes of behaviour from `0.8.0` onwards:
 
-- If you specify `add_new_at: :top`, new items will be added to the top of the list like always. But now, if you specify a position at insert time: `.create(position: 3)`, the position will be respected. In this example, the item will end up at position `3` and will move other items further down the list. Before `0.8.0` the position would be ignored and the item would still be added to the top of the list. [#220](https://github.com/swanandp/acts_as_list/pull/220)
-- `acts_as_list` now copes with disparate position integers (i.e. gaps between the numbers). There has been a change in behaviour for the `higher_items` method. It now returns items with the first item in the collection being the closest item to the reference item, and the last item in the collection being the furthest from the reference item (a.k.a. the first item in the list). [#223](https://github.com/swanandp/acts_as_list/pull/223)
+- If you specify `add_new_at: :top`, new items will be added to the top of the list like always. But now, if you specify a position at insert time: `.create(position: 3)`, the position will be respected. In this example, the item will end up at position `3` and will move other items further down the list. Before `0.8.0` the position would be ignored and the item would still be added to the top of the list. [#220](https://github.com/brendon/acts_as_list/pull/220)
+- `acts_as_list` now copes with disparate position integers (i.e. gaps between the numbers). There has been a change in behaviour for the `higher_items` method. It now returns items with the first item in the collection being the closest item to the reference item, and the last item in the collection being the furthest from the reference item (a.k.a. the first item in the list). [#223](https://github.com/brendon/acts_as_list/pull/223)
 
 ## Installation
 
@@ -104,6 +105,25 @@ TodoList.all.each do |todo_list|
 end
 ```
 
+When using PostgreSQL, it is also possible to leave this migration up to the database layer. Inside of the `change` block you could write:
+
+```ruby
+ execute <<~SQL.squish
+   UPDATE todo_items
+   SET position = mapping.new_position
+   FROM (
+     SELECT
+       id,
+       ROW_NUMBER() OVER (
+         PARTITION BY todo_list_id
+         ORDER BY updated_at
+       ) as new_position
+     FROM todo_items
+   ) AS mapping
+   WHERE todo_items.id = mapping.id;
+ SQL
+```
+
 ## Notes
 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.
 
@@ -141,6 +161,10 @@ default: `position`. Use this option if the column name in your database is diff
 default: `1`. Use this option to define the top of the list. Use 0 to make the collection act more like an array in its indexing.
 - `add_new_at`
 default: `:bottom`. Use this option to specify whether objects get added to the `:top` or `:bottom` of the list. `nil` will result in new items not being added to the list on create, i.e, position will be kept nil after create.
+- `touch_on_update`
+default: `true`. Use `touch_on_update: false` if you don't want to update the timestamps of the associated records.
+- `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 `deferrable initially deferred` (PostgreSQL), overriding it with false will speed up insert_at.
 
 ## Disabling temporarily
 
@@ -180,15 +204,89 @@ TodoItem.acts_as_list_no_update([TodoAttachment]) do
 end
 ```
 
+## Troubleshooting Database Deadlock Errors
+When using this gem in an app with a high amount of concurrency, you may see "deadlock" errors raised by your database server.
+It's difficult for the gem to provide a solution that fits every app.
+Here are some steps you can take to mitigate and handle these kinds of errors.
+
+### 1) Use the Most Concise API
+One easy way to reduce deadlocks is to use the most concise gem API available for what you want to accomplish.
+In this specific example, the more concise API for creating a list item at a position results in one transaction instead of two,
+and it issues fewer SQL statements. Issuing fewer statements tends to lead to faster transactions.
+Faster transactions are less likely to deadlock.
+
+Example:
+```ruby
+# Good
+TodoItem.create(todo_list: todo_list, position: 1)
+
+# Bad
+item = TodoItem.create(todo_list: todo_list)
+item.insert_at(1)
+```
+
+### 2) Rescue then Retry
+Deadlocks are always a possibility when updating tables rows concurrently.
+The general advice from MySQL documentation is to catch these errors and simply retry the transaction; it will probably succeed on another attempt. (see [How to Minimize and Handle Deadlocks](https://dev.mysql.com/doc/refman/8.0/en/innodb-deadlocks-handling.html))
+Retrying transactions sounds simple, but there are many details that need to be chosen on a per-app basis:
+How many retry attempts should be made?
+Should there be a wait time between attempts?
+What _other_ statements were in the transaction that got rolled back?
+
+Here a simple example of rescuing from deadlock and retrying the operation:
+*  `ActiveRecord::Deadlocked` is available in Rails >= 5.1.0.
+* If you have Rails < 5.1.0, you will need to rescue `ActiveRecord::StatementInvalid` and check `#cause`.
+```ruby
+  attempts_left = 2
+  while attempts_left > 0
+    attempts_left -= 1
+    begin
+      TodoItem.transaction do
+        TodoItem.create(todo_list: todo_list, position: 1)
+      end
+      attempts_left = 0
+    rescue ActiveRecord::Deadlocked
+      raise unless attempts_left > 0
+    end
+  end
+```
+
+You can also use the approach suggested in this StackOverflow post:
+https://stackoverflow.com/questions/4027659/activerecord3-deadlock-retry
+
+### 3) Lock Parent Record
+In addition to reacting to deadlocks, it is possible to reduce their frequency with more pessimistic locking.
+This approach uses the parent record as a mutex for the entire list.
+This kind of locking is very effective at reducing the frequency of deadlocks while updating list items.
+However, there are some things to keep in mind:
+* This locking pattern needs to be used around *every* call that modifies the list; even if it does not reorder list items.
+* This locking pattern effectively serializes operations on the list. The throughput of operations on the list will decrease.
+* Locking the parent record may lead to deadlock elsewhere if some other code also locks the parent table.
+
+Example:
+```ruby
+todo_list = TodoList.create(name: "The List")
+todo_list.with_lock do
+  item = TodoItem.create(description: "Buy Groceries", todo_list: todo_list, position: 1)
+end
+```
+
 ## Versions
-Version `0.9.0` adds `acts_as_list_no_update` (https://github.com/swanandp/acts_as_list/pull/244) and compatibility with not-null and uniqueness constraints on the database (https://github.com/swanandp/acts_as_list/pull/246). These additions shouldn't break compatibility with existing implementations.
+Version `0.9.0` adds `acts_as_list_no_update` (https://github.com/brendon/acts_as_list/pull/244) and compatibility with not-null and uniqueness constraints on the database (https://github.com/brendon/acts_as_list/pull/246). These additions shouldn't break compatibility with existing implementations.
 
 As of version `0.7.5` Rails 5 is supported.
 
 All versions `0.1.5` onwards require Rails 3.0.x and higher.
 
-## Workflow Status
-[![WIP Issues](https://badge.waffle.io/swanandp/acts_as_list.png)](http://waffle.io/swanandp/acts_as_list)
+## A note about data integrity
+
+We often hear complaints that `position` values are repeated, incorrect etc. For example, #254. To ensure data integrity, you should rely on your database. There are two things you can do:
+
+1. Use constraints.  If you model `Item` that `belongs_to` an `Order`, and it has a `position` column, then add a unique constraint on `items` with `[:order_id, :position]`.  Think of it as a list invariant. What are the properties of your list that don't change no matter how many items you have in it?  One such propery is that each item has a distinct position. Another _could be_ that position is always greater than 0. It is strongly recommended that you rely on your database to enforce these invariants or constraints. Here are the docs for [PostgreSQL](https://www.postgresql.org/docs/9.5/static/ddl-constraints.html) and [MySQL](https://dev.mysql.com/doc/refman/8.0/en/alter-table.html).
+2. Use mutexes or row level locks. At its heart the duplicate problem is that of handling concurrency. Adding a contention resolution mechanism like locks will solve it to some extent.  But it is not a solution or replacement for constraints.  Locks are also prone to deadlocks.
+
+As a library, `acts_as_list` may not always have all the context needed to apply these tools. They are much better suited at the application level.
+
 
 ## Roadmap
 

data/Rakefile

@@ -38,5 +38,5 @@ end
 require 'github_changelog_generator/task'
 GitHubChangelogGenerator::RakeTask.new :changelog do |config|
   config.project = 'acts_as_list'
-  config.user = 'swanandp'
+  config.user = 'brendon'
 end

data/acts_as_list.gemspec

@@ -7,23 +7,28 @@ Gem::Specification.new do |s|
   s.name                  = "acts_as_list"
   s.version               = ActiveRecord::Acts::List::VERSION
   s.platform              = Gem::Platform::RUBY
-  s.authors               = ["David Heinemeier Hansson", "Swanand Pagnis", "Quinn Chaffee"]
-  s.email                 = ["swanand.pagnis@gmail.com"]
-  s.homepage              = "http://github.com/swanandp/acts_as_list"
+  s.authors               = ["Swanand Pagnis", "Brendon Muir"]
+  s.email                 = %w(swanand.pagnis@gmail.com brendon@spikeatschool.co.nz)
+  s.homepage              = "http://github.com/brendon/acts_as_list"
   s.summary               = "A gem adding sorting, reordering capabilities to an active_record model, allowing it to act as a list"
   s.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.'
   s.license               = "MIT"
-  s.rubyforge_project     = "acts_as_list"
-  s.required_ruby_version = ">= 1.9.2"
+  s.required_ruby_version = ">= 2.4.7"
+
+  if s.respond_to?(:metadata)
+    s.metadata['changelog_uri']   = 'https://github.com/brendon/acts_as_list/blob/master/CHANGELOG.md'
+    s.metadata['source_code_uri'] = 'https://github.com/brendon/acts_as_list'
+    s.metadata['bug_tracker_uri'] = 'https://github.com/brendon/acts_as_list/issues'
+  end
 
   # Load Paths...
-  s.files                 = `git ls-files`.split("\n")
-  s.test_files            = `git ls-files -- {test,spec,features}/*`.split("\n")
-  s.executables           = `git ls-files -- bin/*`.split("\n").map { |f| File.basename(f) }
-  s.require_paths         = ["lib"]
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map {|f| File.basename(f)}
+  s.require_paths = ["lib"]
 
 
   # Dependencies (installed via "bundle install")
-  s.add_dependency "activerecord", ">= 3.0"
+  s.add_dependency "activerecord", ">= 4.2"
   s.add_development_dependency "bundler", ">= 1.0.0"
 end

data/gemfiles/rails_4_2.gemfile

@@ -2,10 +2,9 @@
 
 source "http://rubygems.org"
 
-gem "rack", "~> 1", platforms: [:ruby_19, :ruby_20, :ruby_21]
 gem "rake"
 gem "appraisal"
-gem "activerecord", "~> 4.2.10"
+gem "activerecord", "~> 4.2.0"
 
 group :development do
   gem "github_changelog_generator", "1.9.0"
@@ -13,21 +12,21 @@ end
 
 group :test do
   gem "minitest", "~> 5.0"
-  gem "test_after_commit", "~> 0.4.2"
   gem "timecop"
   gem "mocha"
+  gem "test_after_commit", "~> 0.4.2"
 end
 
 group :sqlite do
-  gem "sqlite3", platforms: [:ruby]
+  gem "sqlite3", "~> 1.3.13"
 end
 
 group :postgresql do
-  gem "pg", "~> 0.18.0", platforms: [:ruby]
+  gem "pg", "~> 0.18.4"
 end
 
 group :mysql do
-  gem "mysql2", "~> 0.4.10", platforms: [:ruby]
+  gem "mysql2", "~> 0.4.0"
 end
 
 gemspec path: "../"

data/gemfiles/rails_5_0.gemfile

@@ -2,10 +2,9 @@
 
 source "http://rubygems.org"
 
-gem "rack", "~> 1", platforms: [:ruby_19, :ruby_20, :ruby_21]
 gem "rake"
 gem "appraisal"
-gem "activerecord", "~> 5.0.6"
+gem "activerecord", "~> 5.0.0"
 
 group :development do
   gem "github_changelog_generator", "1.9.0"
@@ -13,21 +12,20 @@ end
 
 group :test do
   gem "minitest", "~> 5.0"
-  gem "test_after_commit", "~> 0.4.2"
   gem "timecop"
   gem "mocha"
 end
 
 group :sqlite do
-  gem "sqlite3", platforms: [:ruby]
+  gem "sqlite3", "~> 1.3.13"
 end
 
 group :postgresql do
-  gem "pg", "~> 0.18.0", platforms: [:ruby]
+  gem "pg", "~> 1.1.4"
 end
 
 group :mysql do
-  gem "mysql2", "~> 0.4.10", platforms: [:ruby]
+  gem "mysql2", "~> 0.5.0"
 end
 
 gemspec path: "../"

data/gemfiles/rails_5_1.gemfile

@@ -2,10 +2,9 @@
 
 source "http://rubygems.org"
 
-gem "rack", "~> 1", platforms: [:ruby_19, :ruby_20, :ruby_21]
 gem "rake"
 gem "appraisal"
-gem "activerecord", "~> 5.1.4"
+gem "activerecord", "~> 5.1.0"
 
 group :development do
   gem "github_changelog_generator", "1.9.0"
@@ -13,21 +12,20 @@ end
 
 group :test do
   gem "minitest", "~> 5.0"
-  gem "test_after_commit", "~> 0.4.2"
   gem "timecop"
   gem "mocha"
 end
 
 group :sqlite do
-  gem "sqlite3", platforms: [:ruby]
+  gem "sqlite3", "~> 1.3.13"
 end
 
 group :postgresql do
-  gem "pg", "~> 0.18.0", platforms: [:ruby]
+  gem "pg", "~> 1.1.4"
 end
 
 group :mysql do
-  gem "mysql2", "~> 0.4.10", platforms: [:ruby]
+  gem "mysql2", "~> 0.5.0"
 end
 
 gemspec path: "../"

data/gemfiles/rails_5_2.gemfile

@@ -2,10 +2,9 @@
 
 source "http://rubygems.org"
 
-gem "rack", "~> 1", platforms: [:ruby_19, :ruby_20, :ruby_21]
 gem "rake"
 gem "appraisal"
-gem "activerecord", "~> 5.2.0.rc1"
+gem "activerecord", "~> 5.2.0"
 
 group :development do
   gem "github_changelog_generator", "1.9.0"
@@ -13,21 +12,20 @@ end
 
 group :test do
   gem "minitest", "~> 5.0"
-  gem "test_after_commit", "~> 0.4.2"
   gem "timecop"
   gem "mocha"
 end
 
 group :sqlite do
-  gem "sqlite3", platforms: [:ruby]
+  gem "sqlite3", "~> 1.3.13"
 end
 
 group :postgresql do
-  gem "pg", "~> 0.18.0", platforms: [:ruby]
+  gem "pg", "~> 1.1.4"
 end
 
 group :mysql do
-  gem "mysql2", "~> 0.4.10", platforms: [:ruby]
+  gem "mysql2", "~> 0.5.0"
 end
 
 gemspec path: "../"

data/gemfiles/{rails_4_1.gemfile → rails_6_0.gemfile}

@@ -2,10 +2,9 @@
 
 source "http://rubygems.org"
 
-gem "rack", "~> 1", platforms: [:ruby_19, :ruby_20, :ruby_21]
 gem "rake"
 gem "appraisal"
-gem "activerecord", "~> 4.1.16"
+gem "activerecord", "~> 6.0.0"
 
 group :development do
   gem "github_changelog_generator", "1.9.0"
@@ -13,22 +12,20 @@ end
 
 group :test do
   gem "minitest", "~> 5.0"
-  gem "test_after_commit", "~> 0.4.2"
   gem "timecop"
   gem "mocha"
-  gem "after_commit_exception_notification"
 end
 
 group :sqlite do
-  gem "sqlite3", platforms: [:ruby]
+  gem "sqlite3", "~> 1.4"
 end
 
 group :postgresql do
-  gem "pg", "~> 0.18.0", platforms: [:ruby]
+  gem "pg", "~> 1.1.4"
 end
 
 group :mysql do
-  gem "mysql2", "~> 0.3.21", platforms: [:ruby]
+  gem "mysql2", "~> 0.5.0"
 end
 
 gemspec path: "../"

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

@@ -20,13 +20,14 @@ module ActiveRecord
         #   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.
+        # * +touch_on_update+ - configuration to disable the update of the model timestamps when the positions are updated.
         def acts_as_list(options = {})
-          configuration = { column: "position", scope: "1 = 1", top_of_list: 1, add_new_at: :bottom }
+          configuration = { column: "position", scope: "1 = 1", top_of_list: 1, add_new_at: :bottom, touch_on_update: true }
           configuration.update(options) if options.is_a?(Hash)
 
           caller_class = self
 
-          ActiveRecord::Acts::List::PositionColumnMethodDefiner.call(caller_class, configuration[:column])
+          ActiveRecord::Acts::List::PositionColumnMethodDefiner.call(caller_class, configuration[:column], configuration[:touch_on_update])
           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])
@@ -64,6 +65,12 @@ module ActiveRecord
       end
 
       module InstanceMethods
+        # Get the current position of the item in the list
+        def current_position
+          position = send(position_column)
+          position ? position.to_i : nil
+        end
+
         # Insert the item at the given position (defaults to the top position of 1).
         def insert_at(position = acts_as_list_top)
           insert_at_position(position)
@@ -78,8 +85,8 @@ module ActiveRecord
           return unless lower_item
 
           acts_as_list_class.transaction do
-            if lower_item.send(position_column) != self.send(position_column)
-              swap_positions(lower_item, self)
+            if lower_item.current_position != current_position
+              swap_positions_with(lower_item)
             else
               lower_item.decrement_position
               increment_position
@@ -92,8 +99,8 @@ module ActiveRecord
           return unless higher_item
 
           acts_as_list_class.transaction do
-            if higher_item.send(position_column) != self.send(position_column)
-              swap_positions(higher_item, self)
+            if higher_item.current_position != current_position
+              swap_positions_with(higher_item)
             else
               higher_item.increment_position
               decrement_position
@@ -133,13 +140,13 @@ module ActiveRecord
         # Increase the position of this item without adjusting the rest of the list.
         def increment_position
           return unless in_list?
-          set_list_position(self.send(position_column).to_i + 1)
+          set_list_position(current_position + 1)
         end
 
         # Decrease the position of this item without adjusting the rest of the list.
         def decrement_position
           return unless in_list?
-          set_list_position(self.send(position_column).to_i - 1)
+          set_list_position(current_position - 1)
         end
 
         def first?
@@ -162,9 +169,8 @@ module ActiveRecord
         # 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("#{quoted_position_column_with_table_name} <= ?", position_value).
+            where("#{quoted_position_column_with_table_name} <= ?", current_position).
             where("#{quoted_table_name}.#{self.class.primary_key} != ?", self.send(self.class.primary_key)).
             reorder(acts_as_list_order_argument(:desc)).
             limit(limit)
@@ -180,9 +186,8 @@ module ActiveRecord
         # 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("#{quoted_position_column_with_table_name} >= ?", position_value).
+            where("#{quoted_position_column_with_table_name} >= ?", current_position).
             where("#{quoted_table_name}.#{self.class.primary_key} != ?", self.send(self.class.primary_key)).
             reorder(acts_as_list_order_argument(:asc)).
             limit(limit)
@@ -194,40 +199,34 @@ module ActiveRecord
         end
 
         def not_in_list?
-          send(position_column).nil?
+          current_position.nil?
         end
 
         def default_position
-          acts_as_list_class.columns_hash[position_column.to_s].default
+          acts_as_list_class.column_defaults[position_column.to_s]
         end
 
         def default_position?
-          default_position && default_position.to_i == send(position_column)
+          default_position && default_position == current_position
         end
 
         # Sets the new position and saves it
         def set_list_position(new_position, raise_exception_if_save_fails=false)
-          write_attribute position_column, new_position
+          self[position_column] = new_position
           raise_exception_if_save_fails ? save! : save
         end
 
         private
 
-        def swap_positions(item1, item2)
-          item1_position = item1.send(position_column)
+        def swap_positions_with(item)
+          item_position = item.current_position
 
-          item1.set_list_position(item2.send(position_column))
-          item2.set_list_position(item1_position)
+          item.set_list_position(current_position)
+          set_list_position(item_position)
         end
 
         def acts_as_list_list
-          if ActiveRecord::VERSION::MAJOR < 4
-            acts_as_list_class.unscoped do
-              acts_as_list_class.where(scope_condition)
-            end
-          else
-            acts_as_list_class.unscope(:select, :where).where(scope_condition)
-          end
+          acts_as_list_class.unscope(:select, :where).where(scope_condition)
         end
 
         # Poorly named methods. They will insert the item at the desired position if the position
@@ -275,7 +274,7 @@ module ActiveRecord
         #   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
+          item ? item.current_position : acts_as_list_top - 1
         end
 
         # Returns the bottom item
@@ -302,7 +301,7 @@ module ActiveRecord
         # 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
+          acts_as_list_list.where("#{quoted_position_column_with_table_name} < ?", current_position).increment_all
         end
 
         # This has the effect of moving all the lower items down one.
@@ -313,7 +312,11 @@ module ActiveRecord
             scope = scope.where("#{quoted_table_name}.#{self.class.primary_key} != ?", avoid_id)
           end
 
-          scope.where("#{quoted_position_column_with_table_name} >= ?", position).increment_all
+          if sequential_updates?
+            scope.where("#{quoted_position_column_with_table_name} >= ?", position).reorder(acts_as_list_order_argument(:desc)).increment_sequentially
+          else
+            scope.where("#{quoted_position_column_with_table_name} >= ?", position).increment_all
+          end
         end
 
         # This has the effect of moving all the higher items up one.
@@ -322,14 +325,11 @@ module ActiveRecord
         end
 
         # This has the effect of moving all the lower items up one.
-        def decrement_positions_on_lower_items(position=nil)
+        def decrement_positions_on_lower_items(position=current_position)
           return unless in_list?
-          position ||= send(position_column).to_i
 
           if sequential_updates?
-            acts_as_list_list.where("#{quoted_position_column_with_table_name} > ?", position).reorder(acts_as_list_order_argument(:asc)).each do |item|
-              item.decrement!(position_column)
-            end
+            acts_as_list_list.where("#{quoted_position_column_with_table_name} > ?", position).reorder(acts_as_list_order_argument(:asc)).decrement_sequentially
           else
             acts_as_list_list.where("#{quoted_position_column_with_table_name} > ?", position).decrement_all
           end
@@ -365,9 +365,7 @@ module ActiveRecord
             )
 
             if sequential_updates?
-              items.reorder(acts_as_list_order_argument(:asc)).each do |item|
-                item.decrement!(position_column)
-              end
+              items.reorder(acts_as_list_order_argument(:asc)).decrement_sequentially
             else
               items.decrement_all
             end
@@ -383,9 +381,7 @@ module ActiveRecord
             )
 
             if sequential_updates?
-              items.reorder(acts_as_list_order_argument(:desc)).each do |item|
-                item.increment!(position_column)
-              end
+              items.reorder(acts_as_list_order_argument(:desc)).increment_sequentially
             else
               items.increment_all
             end
@@ -397,7 +393,7 @@ module ActiveRecord
           return set_list_position(position, raise_exception_if_save_fails) if new_record?
           with_lock do
             if in_list?
-              old_position = send(position_column).to_i
+              old_position = current_position
               return if position == old_position
               # temporary move after bottom with gap, avoiding duplicate values
               # gap is required to leave room for position increments
@@ -416,31 +412,27 @@ module ActiveRecord
           return unless position_before_save_changed?
 
           old_position = position_before_save || bottom_position_in_list + 1
-          new_position = send(position_column).to_i
 
-          return unless acts_as_list_list.where(
-            "#{quoted_position_column_with_table_name} = #{new_position}"
+          return unless current_position && acts_as_list_list.where(
+            "#{quoted_position_column_with_table_name} = #{current_position}"
           ).count > 1
-          shuffle_positions_on_intermediate_items old_position, new_position, id
+
+          shuffle_positions_on_intermediate_items old_position, current_position, id
         end
 
         def position_before_save_changed?
-          if ActiveRecord::VERSION::MAJOR == 5 && ActiveRecord::VERSION::MINOR >= 1 ||
-              ActiveRecord::VERSION::MAJOR > 5
-
+          if active_record_version_is?('>= 5.1')
             saved_change_to_attribute? position_column
           else
-            send "#{position_column}_changed?"
+            attribute_changed? position_column
           end
         end
 
         def position_before_save
-          if ActiveRecord::VERSION::MAJOR == 5 && ActiveRecord::VERSION::MINOR >= 1 ||
-              ActiveRecord::VERSION::MAJOR > 5
-
+          if active_record_version_is?('>= 5.1')
             attribute_before_last_save position_column
           else
-            send "#{position_column}_was"
+            attribute_was position_column
           end
         end
 
@@ -469,7 +461,7 @@ module ActiveRecord
         # 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
+          if current_position && !default_position? && current_position < acts_as_list_top
             self[position_column] = acts_as_list_top
           end
         end
@@ -489,11 +481,13 @@ module ActiveRecord
         end
 
         def acts_as_list_order_argument(direction = :asc)
-          if ActiveRecord::VERSION::MAJOR >= 4
-            { position_column => direction }
-          else
-            "#{quoted_position_column_with_table_name} #{direction.to_s.upcase}"
-          end
+          { position_column => direction }
+        end
+
+        def active_record_version_is?(version_requirement)
+          requirement = Gem::Requirement.new(version_requirement)
+          version = Gem.loaded_specs['activerecord'].version
+          requirement.satisfied_by?(version)
         end
       end