acts_as_silent_list 1.2.0 → 1.3.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 4aaab2e363a459ad3c00182e51967c28e0880aee
+  data.tar.gz: 2546f7bdf9f53ef7ab4e6b877f0c70bfd3c8882f
+SHA512:
+  metadata.gz: bfd2f6c4d8429839e58f0169dbd8706265ec88c59710f9cee42a862e9a0a80fd6d173a7f37d71191ff96d638eb358902d6f124257914d83d0004dec024baec3f
+  data.tar.gz: b0ab4990e99488e0a3e83e78e716532053ea9ff9a0a066601d0ea51c2a51e9a878e019393db8d404deccf8a199c4f6d8b0a832bafe2157a30e5db5a198ca296a

data/CHANGELOG.rdoc

@@ -1,3 +1,7 @@
+= 1.3.0 - 2013-03-26
+
+* migrated to Rails3/4
+
 = 1.2.0 - 2011-10-26
 
 == Features

data/Gemfile

@@ -1,3 +1,14 @@
-source :rubygems
+source "https://rubygems.org"
 
+# Declare your gem's dependencies in acts_as_silent_list.gemspec.
+# Bundler will treat runtime dependencies like base dependencies, and
+# development dependencies will be added by default to the :development group.
 gemspec
+
+# Declare any dependencies that are still in development here instead of in
+# your gemspec. These might include edge Rails or gems from your path or
+# Git. Remember to move these dependencies to your gemspec before releasing
+# your gem to rubygems.org.
+
+# To use debugger
+# gem 'debugger'

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2013 Finn GmbH
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -1,31 +1,31 @@
-require 'bundler'
-Bundler::GemHelper.install_tasks
-
-#require 'rake'
-require 'rake/testtask'
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
 
-# Run the test with 'rake' or 'rake test'
-desc 'Default: run acts_as_silent_list unit tests.'
-task :default => :test
+require 'rdoc/task'
 
-desc 'Test the acts_as_silent_list plugin.'
-Rake::TestTask.new(:test) do |t|
-  t.libs << 'lib' << 'test'
-  t.pattern = 'test/**/test_*.rb'
-  t.verbose = true
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'ActsAsSilentList'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.rdoc')
+  rdoc.rdoc_files.include('lib/**/*.rb')
 end
 
 
+Bundler::GemHelper.install_tasks
 
-# Run the rdoc task to generate rdocs for this gem
-require 'rdoc/task'
-RDoc::Task.new do |rdoc|
-  require "acts_as_silent_list/version"
-  version = ActiveRecord::Acts::SilentList::VERSION
+require 'rake/testtask'
 
-  rdoc.rdoc_dir = 'rdoc'
-  rdoc.title = "acts_as_silent_list #{version}"
-  rdoc.rdoc_files.include('README*')
-  rdoc.rdoc_files.include('lib/**/*.rb')
+desc 'Test the acts_as_silent_list plugin.'
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = true
 end
 
+desc 'Default: run acts_as_silent_list unit tests.'
+task default: :test

data/acts_as_silent_list.gemspec

@@ -1,29 +1,26 @@
-# -*- encoding: utf-8 -*-
-$:.push File.expand_path('../lib', __FILE__)
-require 'acts_as_silent_list/version'
+$:.push File.expand_path("../lib", __FILE__)
 
-Gem::Specification.new do |s|
+# Maintain your gem's version:
+require "acts_as_silent_list/version"
 
-  # Description Meta...
-  s.name        = 'acts_as_silent_list'
+# Describe your gem and declare its dependencies:
+Gem::Specification.new do |s|
+  s.name        = "acts_as_silent_list"
   s.version     = ActiveRecord::Acts::SilentList::VERSION
-  s.platform    = Gem::Platform::RUBY
-  s.authors     = ['David Heinemeier Hansson', 'Swanand Pagnis', 'Quinn Chaffee', 'Gregor Schmidt']
-  s.email       = ['swanand.pagnis@gmail.com']
-  s.homepage    = 'http://github.com/swanandp/acts_as_silent_list'
+  s.authors     = ['David Heinemeier Hansson', 'Swanand Pagnis', 'Quinn Chaffee', 'Finn GmbH']
+  s.email       = ["info@finn.de"]
+  s.homepage    = "http://www.finn.de/"
   s.summary     = %q{A gem allowing a active_record model to be ordered, without triggering active record callbacks.}
   s.description = %q{This "acts_as" extension is a clone of the well known acts_as_list, only it avoids triggering active record callbacks.}
 
-
   # 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']
 
-
   # Dependencies (installed via 'bundle install')...
-  s.add_development_dependency("bundler", ["~> 1.0.0"])
+  s.add_development_dependency("bundler", [">= 1.0.0"])
   s.add_development_dependency("activerecord", [">= 1.15.4.7794"])
   s.add_development_dependency("rake")
   s.add_development_dependency("rdoc")

data/init.rb

@@ -1,2 +1,4 @@
 $:.unshift "#{File.dirname(__FILE__)}/lib"
 require 'acts_as_silent_list'
+
+ActsAsSilentList::Railtie.insert

data/lib/acts_as_silent_list.rb

@@ -1,2 +1,24 @@
 require 'acts_as_silent_list/active_record/acts/silent_list'
-ActiveRecord::Base.class_eval { include ActiveRecord::Acts::SilentList }
+
+module ActsAsSilentList
+  if defined? Rails::Railtie
+    require 'rails'
+    class Railtie < Rails::Railtie
+      initializer 'acts_as_silent_list.insert_into_active_record' do
+        ActiveSupport.on_load :active_record do
+          ActsAsSilentList::Railtie.insert
+        end
+      end
+    end
+  end
+
+  class Railtie
+    def self.insert
+      if defined?(ActiveRecord)
+        ActiveRecord::Base.send(:include, ActiveRecord::Acts::SilentList)
+      end
+    end
+  end
+end
+
+ActsAsSilentList::Railtie.insert

data/lib/acts_as_silent_list/active_record/acts/silent_list.rb

@@ -194,28 +194,28 @@ module ActiveRecord
         # Return the next higher item in the list.
         def higher_item
           return nil unless in_list?
-          acts_as_silent_list_class.find(:first, :conditions =>
-            "#{scope_condition} AND #{position_column} = #{(send(position_column).to_i - 1).to_s}"
-          )
+          acts_as_silent_list_class
+          .where("#{scope_condition} AND #{position_column} = #{(send(position_column).to_i - 1).to_s}")
+          .first
         end
 
         # Return the next lower item in the list.
         def lower_item
           return nil unless in_list?
-          acts_as_silent_list_class.find(:first, :conditions =>
-            "#{scope_condition} AND #{position_column} = #{(send(position_column).to_i + 1).to_s}"
-          )
+          acts_as_silent_list_class
+          .where("#{scope_condition} AND #{position_column} = #{(send(position_column).to_i + 1).to_s}")
+          .first
         end
 
         # Test if this record is in a list
         def in_list?
           !not_in_list?
         end
-        
+
         def not_in_list?
           send(position_column).nil?
         end
-        
+
         def default_position
           acts_as_silent_list_class.columns_hash[position_column.to_s].default
         end
@@ -252,9 +252,9 @@ module ActiveRecord
             conditions = scope_condition
             conditions = "#{conditions} AND #{self.class.primary_key} != #{except.id}" if except
             acts_as_silent_list_class.unscoped do
-              acts_as_silent_list_class.find(:first,
-                                             :conditions => conditions,
-                                             :order => "#{position_column} DESC")
+               acts_as_silent_list_class
+               .where(conditions).order("#{position_column} DESC")
+               .first
             end
           end
 
@@ -276,45 +276,40 @@ module ActiveRecord
 
           # This has the effect of moving all the higher items up one.
           def decrement_positions_on_higher_items(position)
-            acts_as_silent_list_class.update_all(
-              "#{position_column} = (#{position_column} - 1)",
-              "#{scope_condition} AND #{position_column} <= #{position}"
-            )
+            acts_as_silent_list_class
+            .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
             return unless in_list?
-            acts_as_silent_list_class.update_all(
-              "#{position_column} = (#{position_column} - 1)",
-              "#{scope_condition} AND #{position_column} > #{send(position_column).to_i}"
-            )
+            acts_as_silent_list_class
+            .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 higher items down one.
           def increment_positions_on_higher_items
             return unless in_list?
-            acts_as_silent_list_class.update_all(
-              "#{position_column} = (#{position_column} + 1)",
-              "#{scope_condition} AND #{position_column} < #{send(position_column).to_i}"
-            )
+             acts_as_silent_list_class
+             .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_silent_list_class.update_all(
-              "#{position_column} = (#{position_column} + 1)",
-              "#{scope_condition} AND #{position_column} >= #{position}"
-            )
+          acts_as_silent_list_class
+          .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_silent_list_class.update_all(
-              "#{position_column} = (#{position_column} + 1)",
-              "#{scope_condition}"
-            )
+            acts_as_silent_list_class
+            .where("#{scope_condition}")
+            .update_all("#{position_column} = (#{position_column} + 1)")
           end
 
           def insert_at_position(position)
@@ -339,7 +334,7 @@ module ActiveRecord
               write_attribute(attr, value)
               changed_attributes.delete(attr)
             end
-            self.class.update_all({attr => value}, {:id => id})
+            self.class.where({:id => id}).update_all({attr => value})
           end
       end
     end

data/lib/acts_as_silent_list/version.rb

@@ -1,7 +1,7 @@
 module ActiveRecord
   module Acts
     module SilentList
-      VERSION = "1.2.0"
+      VERSION = "1.3.0"
     end
   end
 end

data/test/{test_list.rb → acts_as_silent_list_test.rb}

@@ -1,5 +1,13 @@
-# NOTE: following now done in helper.rb (better Readability)
-require 'helper.rb'
+require 'test_helper'
+
+# class ActsAsSilentListTest < ActiveSupport::TestCase
+#   test "truth" do
+#     assert_kind_of Module, ActsAsSilentList
+#   end
+# end
+
+# # NOTE: following now done in helper.rb (better Readability)
+# require 'helper.rb'
 
 ActiveRecord::Base.establish_connection(:adapter => "sqlite3", :database => ":memory:")
 
@@ -29,7 +37,12 @@ end
 
 # Returns true if ActiveRecord is rails3 version
 def rails_3
-  defined?(ActiveRecord::VERSION) && ActiveRecord::VERSION::MAJOR >= 3
+  defined?(ActiveRecord::VERSION) && ActiveRecord::VERSION::MAJOR >= 3 && ActiveRecord::VERSION::MAJOR < 4
+end
+
+# Returns true if ActiveRecord is rails4 version
+def rails_4_or_above
+  defined?(ActiveRecord::VERSION) && ActiveRecord::VERSION::MAJOR >= 4
 end
 
 def teardown_db
@@ -72,17 +85,17 @@ class ZeroBasedMixin < ActiveRecord::Base
 end
 
 class DefaultScopedMixin < ActiveRecord::Base
-  set_table_name 'mixins'
+  self.table_name = 'mixins'
   acts_as_silent_list :column => "pos"
-  if rails_3
-    default_scope order('pos ASC')
+  if rails_3 || rails_4_or_above
+    default_scope { order('pos ASC') }
   else
     default_scope :order => 'pos ASC'
   end
 end
 
 class CallbackMixin < ActiveRecord::Base
-  set_table_name 'mixins'
+  self.table_name = 'mixins'
   acts_as_silent_list :column => "pos"
 
   before_save :store_before_save
@@ -132,25 +145,25 @@ class ZeroBasedTest < Test::Unit::TestCase
   end
 
   def test_reordering
-    assert_equal [1, 2, 3, 4], ZeroBasedMixin.find(:all, :conditions => 'parent_id = 5', :order => 'pos').map(&:id)
+    assert_equal [1, 2, 3, 4], ZeroBasedMixin.where(parent_id: 5).order(:pos).map(&:id)
 
     ListMixin.find(2).move_lower
-    assert_equal [1, 3, 2, 4], ZeroBasedMixin.find(:all, :conditions => 'parent_id = 5', :order => 'pos').map(&:id)
+    assert_equal [1, 3, 2, 4], ZeroBasedMixin.where(parent_id: 5).order(:pos).map(&:id)
 
     ListMixin.find(2).move_higher
-    assert_equal [1, 2, 3, 4], ZeroBasedMixin.find(:all, :conditions => 'parent_id = 5', :order => 'pos').map(&:id)
+    assert_equal [1, 2, 3, 4], ZeroBasedMixin.where(parent_id: 5).order(:pos).map(&:id)
 
     ListMixin.find(1).move_to_bottom
-    assert_equal [2, 3, 4, 1], ZeroBasedMixin.find(:all, :conditions => 'parent_id = 5', :order => 'pos').map(&:id)
+    assert_equal [2, 3, 4, 1], ZeroBasedMixin.where(parent_id: 5).order(:pos).map(&:id)
 
     ListMixin.find(1).move_to_top
-    assert_equal [1, 2, 3, 4], ZeroBasedMixin.find(:all, :conditions => 'parent_id = 5', :order => 'pos').map(&:id)
+    assert_equal [1, 2, 3, 4], ZeroBasedMixin.where(parent_id: 5).order(:pos).map(&:id)
 
     ListMixin.find(2).move_to_bottom
-    assert_equal [1, 3, 4, 2], ZeroBasedMixin.find(:all, :conditions => 'parent_id = 5', :order => 'pos').map(&:id)
+    assert_equal [1, 3, 4, 2], ZeroBasedMixin.where(parent_id: 5).order(:pos).map(&:id)
 
     ListMixin.find(4).move_to_top
-    assert_equal [4, 1, 3, 2], ZeroBasedMixin.find(:all, :conditions => 'parent_id = 5', :order => 'pos').map(&:id)
+    assert_equal [4, 1, 3, 2], ZeroBasedMixin.where(parent_id: 5).order(:pos).map(&:id)
   end
 
   def test_insert_at
@@ -203,31 +216,31 @@ class ListTest < Test::Unit::TestCase
   end
 
   def test_reordering
-    assert_equal [1, 2, 3, 4], ListMixin.find(:all, :conditions => 'parent_id = 5', :order => 'pos').map(&:id)
+    assert_equal [1, 2, 3, 4], ListMixin.where(parent_id: 5).order(:pos).map(&:id)
 
     ListMixin.find(2).move_lower
-    assert_equal [1, 3, 2, 4], ListMixin.find(:all, :conditions => 'parent_id = 5', :order => 'pos').map(&:id)
+    assert_equal [1, 3, 2, 4], ListMixin.where(parent_id: 5).order(:pos).map(&:id)
 
     ListMixin.find(2).move_higher
-    assert_equal [1, 2, 3, 4], ListMixin.find(:all, :conditions => 'parent_id = 5', :order => 'pos').map(&:id)
+    assert_equal [1, 2, 3, 4], ListMixin.where(parent_id: 5).order(:pos).map(&:id)
 
     ListMixin.find(1).move_to_bottom
-    assert_equal [2, 3, 4, 1], ListMixin.find(:all, :conditions => 'parent_id = 5', :order => 'pos').map(&:id)
+    assert_equal [2, 3, 4, 1], ListMixin.where(parent_id: 5).order(:pos).map(&:id)
 
     ListMixin.find(1).move_to_top
-    assert_equal [1, 2, 3, 4], ListMixin.find(:all, :conditions => 'parent_id = 5', :order => 'pos').map(&:id)
+    assert_equal [1, 2, 3, 4], ListMixin.where(parent_id: 5).order(:pos).map(&:id)
 
     ListMixin.find(2).move_to_bottom
-    assert_equal [1, 3, 4, 2], ListMixin.find(:all, :conditions => 'parent_id = 5', :order => 'pos').map(&:id)
+    assert_equal [1, 3, 4, 2], ListMixin.where(parent_id: 5).order(:pos).map(&:id)
 
     ListMixin.find(4).move_to_top
-    assert_equal [4, 1, 3, 2], ListMixin.find(:all, :conditions => 'parent_id = 5', :order => 'pos').map(&:id)
+    assert_equal [4, 1, 3, 2], ListMixin.where(parent_id: 5).order(:pos).map(&:id)
   end
 
   def test_move_to_bottom_with_next_to_last_item
-    assert_equal [1, 2, 3, 4], ListMixin.find(:all, :conditions => 'parent_id = 5', :order => 'pos').map(&:id)
+    assert_equal [1, 2, 3, 4], ListMixin.where(parent_id: 5).order(:pos).map(&:id)
     ListMixin.find(3).move_to_bottom
-    assert_equal [1, 2, 4, 3], ListMixin.find(:all, :conditions => 'parent_id = 5', :order => 'pos').map(&:id)
+    assert_equal [1, 2, 4, 3], ListMixin.where(parent_id: 5).order(:pos).map(&:id)
   end
 
   def test_next_prev
@@ -301,11 +314,11 @@ class ListTest < Test::Unit::TestCase
   end
 
   def test_delete_middle
-    assert_equal [1, 2, 3, 4], ListMixin.find(:all, :conditions => 'parent_id = 5', :order => 'pos').map(&:id)
+    assert_equal [1, 2, 3, 4], ListMixin.where(parent_id: 5).order(:pos).map(&:id)
 
     ListMixin.find(2).destroy
 
-    assert_equal [1, 3, 4], ListMixin.find(:all, :conditions => 'parent_id = 5', :order => 'pos').map(&:id)
+    assert_equal [1, 3, 4], ListMixin.where(parent_id: 5).order(:pos).map(&:id)
 
     assert_equal 1, ListMixin.find(1).pos
     assert_equal 2, ListMixin.find(3).pos
@@ -313,7 +326,7 @@ class ListTest < Test::Unit::TestCase
 
     ListMixin.find(1).destroy
 
-    assert_equal [3, 4], ListMixin.find(:all, :conditions => 'parent_id = 5', :order => 'pos').map(&:id)
+    assert_equal [3, 4], ListMixin.where(parent_id: 5).order(:pos).map(&:id)
 
     assert_equal 1, ListMixin.find(3).pos
     assert_equal 2, ListMixin.find(4).pos
@@ -329,7 +342,7 @@ class ListTest < Test::Unit::TestCase
   def test_nil_scope
     new1, new2, new3 = ListMixin.create, ListMixin.create, ListMixin.create
     new2.move_higher
-    assert_equal [new2, new1, new3], ListMixin.find(:all, :conditions => 'parent_id IS NULL', :order => 'pos')
+    assert_equal [new2, new1, new3], ListMixin.where(parent_id: nil).order(:pos)
   end
 
   def test_remove_from_list_should_then_fail_in_list?
@@ -339,11 +352,11 @@ class ListTest < Test::Unit::TestCase
   end
 
   def test_remove_from_list_should_set_position_to_nil
-    assert_equal [1, 2, 3, 4], ListMixin.find(:all, :conditions => 'parent_id = 5', :order => 'pos').map(&:id)
+    assert_equal [1, 2, 3, 4], ListMixin.where(parent_id: 5).order(:pos).map(&:id)
 
     ListMixin.find(2).remove_from_list
 
-    assert_equal [2, 1, 3, 4], ListMixin.find(:all, :conditions => 'parent_id = 5', :order => 'pos').map(&:id)
+    assert_equal [2, 1, 3, 4], ListMixin.where(parent_id: 5).order(:pos).map(&:id)
 
     assert_equal 1,   ListMixin.find(1).pos
     assert_equal nil, ListMixin.find(2).pos
@@ -352,12 +365,12 @@ class ListTest < Test::Unit::TestCase
   end
 
   def test_remove_before_destroy_does_not_shift_lower_items_twice
-    assert_equal [1, 2, 3, 4], ListMixin.find(:all, :conditions => 'parent_id = 5', :order => 'pos').map(&:id)
+    assert_equal [1, 2, 3, 4], ListMixin.where(parent_id: 5).order(:pos).map(&:id)
 
     ListMixin.find(2).remove_from_list
     ListMixin.find(2).destroy
 
-    assert_equal [1, 3, 4], ListMixin.find(:all, :conditions => 'parent_id = 5', :order => 'pos').map(&:id)
+    assert_equal [1, 3, 4], ListMixin.where(parent_id: 5).order(:pos).map(&:id)
 
     assert_equal 1, ListMixin.find(1).pos
     assert_equal 2, ListMixin.find(3).pos
@@ -365,7 +378,7 @@ class ListTest < Test::Unit::TestCase
   end
 
   def test_before_destroy_callbacks_do_not_update_position_to_nil_before_deleting_the_record
-    assert_equal [1, 2, 3, 4], ListMixin.find(:all, :conditions => 'parent_id = 5', :order => 'pos').map(&:id)
+    assert_equal [1, 2, 3, 4], ListMixin.where(parent_id: 5).order(:pos).map(&:id)
 
     # We need to trigger all the before_destroy callbacks without actually
     # destroying the record so we can see the affect the callbacks have on
@@ -374,13 +387,19 @@ class ListTest < Test::Unit::TestCase
     list = ListMixin.find(2)
     if list.respond_to?(:run_callbacks)
       # Refactored to work according to Rails3 ActiveRSupport Callbacks <http://api.rubyonrails.org/classes/ActiveSupport/Callbacks.html>
-      list.run_callbacks :destroy, :before if rails_3
-      list.run_callbacks(:before_destroy) if !rails_3
+      # Refactored again to also work with Rails4 which does not allow to pick only before callbacks to fire
+      if rails_3
+        list.run_callbacks :destroy, :before
+      elsif rails_4_or_above
+        list.run_callbacks :destroy
+      else
+        list.run_callbacks :before_destroy
+      end
     else
       list.send(:callback, :before_destroy)
     end
 
-    assert_equal [1, 2, 3, 4], ListMixin.find(:all, :conditions => 'parent_id = 5', :order => 'pos').map(&:id)
+    assert_equal [1, 2, 3, 4], ListMixin.where(parent_id: 5).order(:pos).map(&:id)
 
     assert_equal 1, ListMixin.find(1).pos
     assert_equal 2, ListMixin.find(2).pos
@@ -389,32 +408,32 @@ class ListTest < Test::Unit::TestCase
   end
 
   def test_before_create_callback_adds_to_bottom
-    assert_equal [1, 2, 3, 4], ListMixin.find(:all, :conditions => 'parent_id = 5', :order => 'pos').map(&:id)
+    assert_equal [1, 2, 3, 4], ListMixin.where(parent_id: 5).order(:pos).map(&:id)
 
     new = ListMixin.create(:parent_id => 5)
     assert_equal 5, new.pos
     assert !new.first?
     assert new.last?
 
-    assert_equal [1, 2, 3, 4, 5], ListMixin.find(:all, :conditions => 'parent_id = 5', :order => 'pos').map(&:id)
+    assert_equal [1, 2, 3, 4, 5], ListMixin.where(parent_id: 5).order(:pos).map(&:id)
   end
 
   def test_before_create_callback_adds_to_given_position
-    assert_equal [1, 2, 3, 4], ListMixin.find(:all, :conditions => 'parent_id = 5', :order => 'pos').map(&:id)
+    assert_equal [1, 2, 3, 4], ListMixin.where(parent_id: 5).order(:pos).map(&:id)
 
     new = ListMixin.create(:pos => 1, :parent_id => 5)
     assert_equal 1, new.pos
     assert new.first?
     assert !new.last?
 
-    assert_equal [5, 1, 2, 3, 4], ListMixin.find(:all, :conditions => 'parent_id = 5', :order => 'pos').map(&:id)
+    assert_equal [5, 1, 2, 3, 4], ListMixin.where(parent_id: 5).order(:pos).map(&:id)
 
     new = ListMixin.create(:pos => 3, :parent_id => 5)
     assert_equal 3, new.pos
     assert !new.first?
     assert !new.last?
 
-    assert_equal [5, 1, 6, 2, 3, 4], ListMixin.find(:all, :conditions => 'parent_id = 5', :order => 'pos').map(&:id)
+    assert_equal [5, 1, 6, 2, 3, 4], ListMixin.where(parent_id: 5).order(:pos).map(&:id)
   end
 
   def test_insert_at_top
@@ -423,7 +442,7 @@ class ListTest < Test::Unit::TestCase
     new.insert_at_top
 
     assert new.first?
-    assert_equal [5, 1, 2, 3, 4], ListMixin.find(:all, :conditions => 'parent_id = 5', :order => 'pos').map(&:id)
+    assert_equal [5, 1, 2, 3, 4], ListMixin.where(parent_id: 5).order(:pos).map(&:id)
   end
 
   def test_insert_at_bottom
@@ -432,7 +451,7 @@ class ListTest < Test::Unit::TestCase
     new.insert_at_bottom
 
     assert new.last?
-    assert_equal [1, 2, 3, 4, 5], ListMixin.find(:all, :conditions => 'parent_id = 5', :order => 'pos').map(&:id)
+    assert_equal [1, 2, 3, 4, 5], ListMixin.where(parent_id: 5).order(:pos).map(&:id)
   end
 end
 
@@ -448,31 +467,31 @@ class ListSubTest < Test::Unit::TestCase
   end
 
   def test_reordering
-    assert_equal [1, 2, 3, 4], ListMixin.find(:all, :conditions => 'parent_id = 5000', :order => 'pos').map(&:id)
+    assert_equal [1, 2, 3, 4], ListMixin.where(parent_id: 5000).order(:pos).map(&:id)
 
     ListMixin.find(2).move_lower
-    assert_equal [1, 3, 2, 4], ListMixin.find(:all, :conditions => 'parent_id = 5000', :order => 'pos').map(&:id)
+    assert_equal [1, 3, 2, 4], ListMixin.where(parent_id: 5000).order(:pos).map(&:id)
 
     ListMixin.find(2).move_higher
-    assert_equal [1, 2, 3, 4], ListMixin.find(:all, :conditions => 'parent_id = 5000', :order => 'pos').map(&:id)
+    assert_equal [1, 2, 3, 4], ListMixin.where(parent_id: 5000).order(:pos).map(&:id)
 
     ListMixin.find(1).move_to_bottom
-    assert_equal [2, 3, 4, 1], ListMixin.find(:all, :conditions => 'parent_id = 5000', :order => 'pos').map(&:id)
+    assert_equal [2, 3, 4, 1], ListMixin.where(parent_id: 5000).order(:pos).map(&:id)
 
     ListMixin.find(1).move_to_top
-    assert_equal [1, 2, 3, 4], ListMixin.find(:all, :conditions => 'parent_id = 5000', :order => 'pos').map(&:id)
+    assert_equal [1, 2, 3, 4], ListMixin.where(parent_id: 5000).order(:pos).map(&:id)
 
     ListMixin.find(2).move_to_bottom
-    assert_equal [1, 3, 4, 2], ListMixin.find(:all, :conditions => 'parent_id = 5000', :order => 'pos').map(&:id)
+    assert_equal [1, 3, 4, 2], ListMixin.where(parent_id: 5000).order(:pos).map(&:id)
 
     ListMixin.find(4).move_to_top
-    assert_equal [4, 1, 3, 2], ListMixin.find(:all, :conditions => 'parent_id = 5000', :order => 'pos').map(&:id)
+    assert_equal [4, 1, 3, 2], ListMixin.where(parent_id: 5000).order(:pos).map(&:id)
   end
 
   def test_move_to_bottom_with_next_to_last_item
-    assert_equal [1, 2, 3, 4], ListMixin.find(:all, :conditions => 'parent_id = 5000', :order => 'pos').map(&:id)
+    assert_equal [1, 2, 3, 4], ListMixin.where(parent_id: 5000).order(:pos).map(&:id)
     ListMixin.find(3).move_to_bottom
-    assert_equal [1, 2, 4, 3], ListMixin.find(:all, :conditions => 'parent_id = 5000', :order => 'pos').map(&:id)
+    assert_equal [1, 2, 4, 3], ListMixin.where(parent_id: 5000).order(:pos).map(&:id)
   end
 
   def test_next_prev
@@ -524,11 +543,11 @@ class ListSubTest < Test::Unit::TestCase
   end
 
   def test_delete_middle
-    assert_equal [1, 2, 3, 4], ListMixin.find(:all, :conditions => 'parent_id = 5000', :order => 'pos').map(&:id)
+    assert_equal [1, 2, 3, 4], ListMixin.where(parent_id: 5000).order(:pos).map(&:id)
 
     ListMixin.find(2).destroy
 
-    assert_equal [1, 3, 4], ListMixin.find(:all, :conditions => 'parent_id = 5000', :order => 'pos').map(&:id)
+    assert_equal [1, 3, 4], ListMixin.where(parent_id: 5000).order(:pos).map(&:id)
 
     assert_equal 1, ListMixin.find(1).pos
     assert_equal 2, ListMixin.find(3).pos
@@ -536,7 +555,7 @@ class ListSubTest < Test::Unit::TestCase
 
     ListMixin.find(1).destroy
 
-    assert_equal [3, 4], ListMixin.find(:all, :conditions => 'parent_id = 5000', :order => 'pos').map(&:id)
+    assert_equal [3, 4], ListMixin.where(parent_id: 5000).order(:pos).map(&:id)
 
     assert_equal 1, ListMixin.find(3).pos
     assert_equal 2, ListMixin.find(4).pos
@@ -556,31 +575,31 @@ class ArrayScopeListTest < Test::Unit::TestCase
   end
 
   def test_reordering
-    assert_equal [1, 2, 3, 4], ArrayScopeListMixin.find(:all, :conditions => "parent_id = 5 AND parent_type = 'ParentClass'", :order => 'pos').map(&:id)
+    assert_equal [1, 2, 3, 4], ArrayScopeListMixin.where(parent_id: 5, parent_type: :ParentClass).order(:pos).map(&:id)
 
     ArrayScopeListMixin.find(2).move_lower
-    assert_equal [1, 3, 2, 4], ArrayScopeListMixin.find(:all, :conditions => "parent_id = 5 AND parent_type = 'ParentClass'", :order => 'pos').map(&:id)
+    assert_equal [1, 3, 2, 4], ArrayScopeListMixin.where(parent_id: 5, parent_type: :ParentClass).order(:pos).map(&:id)
 
     ArrayScopeListMixin.find(2).move_higher
-    assert_equal [1, 2, 3, 4], ArrayScopeListMixin.find(:all, :conditions => "parent_id = 5 AND parent_type = 'ParentClass'", :order => 'pos').map(&:id)
+    assert_equal [1, 2, 3, 4], ArrayScopeListMixin.where(parent_id: 5, parent_type: :ParentClass).order(:pos).map(&:id)
 
     ArrayScopeListMixin.find(1).move_to_bottom
-    assert_equal [2, 3, 4, 1], ArrayScopeListMixin.find(:all, :conditions => "parent_id = 5 AND parent_type = 'ParentClass'", :order => 'pos').map(&:id)
+    assert_equal [2, 3, 4, 1], ArrayScopeListMixin.where(parent_id: 5, parent_type: :ParentClass).order(:pos).map(&:id)
 
     ArrayScopeListMixin.find(1).move_to_top
-    assert_equal [1, 2, 3, 4], ArrayScopeListMixin.find(:all, :conditions => "parent_id = 5 AND parent_type = 'ParentClass'", :order => 'pos').map(&:id)
+    assert_equal [1, 2, 3, 4], ArrayScopeListMixin.where(parent_id: 5, parent_type: :ParentClass).order(:pos).map(&:id)
 
     ArrayScopeListMixin.find(2).move_to_bottom
-    assert_equal [1, 3, 4, 2], ArrayScopeListMixin.find(:all, :conditions => "parent_id = 5 AND parent_type = 'ParentClass'", :order => 'pos').map(&:id)
+    assert_equal [1, 3, 4, 2], ArrayScopeListMixin.where(parent_id: 5, parent_type: :ParentClass).order(:pos).map(&:id)
 
     ArrayScopeListMixin.find(4).move_to_top
-    assert_equal [4, 1, 3, 2], ArrayScopeListMixin.find(:all, :conditions => "parent_id = 5 AND parent_type = 'ParentClass'", :order => 'pos').map(&:id)
+    assert_equal [4, 1, 3, 2], ArrayScopeListMixin.where(parent_id: 5, parent_type: :ParentClass).order(:pos).map(&:id)
   end
 
   def test_move_to_bottom_with_next_to_last_item
-    assert_equal [1, 2, 3, 4], ArrayScopeListMixin.find(:all, :conditions => "parent_id = 5 AND parent_type = 'ParentClass'", :order => 'pos').map(&:id)
+    assert_equal [1, 2, 3, 4], ArrayScopeListMixin.where(parent_id: 5, parent_type: :ParentClass).order(:pos).map(&:id)
     ArrayScopeListMixin.find(3).move_to_bottom
-    assert_equal [1, 2, 4, 3], ArrayScopeListMixin.find(:all, :conditions => "parent_id = 5 AND parent_type = 'ParentClass'", :order => 'pos').map(&:id)
+    assert_equal [1, 2, 4, 3], ArrayScopeListMixin.where(parent_id: 5, parent_type: :ParentClass).order(:pos).map(&:id)
   end
 
   def test_next_prev
@@ -654,11 +673,11 @@ class ArrayScopeListTest < Test::Unit::TestCase
   end
 
   def test_delete_middle
-    assert_equal [1, 2, 3, 4], ArrayScopeListMixin.find(:all, :conditions => "parent_id = 5 AND parent_type = 'ParentClass'", :order => 'pos').map(&:id)
+    assert_equal [1, 2, 3, 4], ArrayScopeListMixin.where(parent_id: 5, parent_type: :ParentClass).order(:pos).map(&:id)
 
     ArrayScopeListMixin.find(2).destroy
 
-    assert_equal [1, 3, 4], ArrayScopeListMixin.find(:all, :conditions => "parent_id = 5 AND parent_type = 'ParentClass'", :order => 'pos').map(&:id)
+    assert_equal [1, 3, 4], ArrayScopeListMixin.where(parent_id: 5, parent_type: :ParentClass).order(:pos).map(&:id)
 
     assert_equal 1, ArrayScopeListMixin.find(1).pos
     assert_equal 2, ArrayScopeListMixin.find(3).pos
@@ -666,7 +685,7 @@ class ArrayScopeListTest < Test::Unit::TestCase
 
     ArrayScopeListMixin.find(1).destroy
 
-    assert_equal [3, 4], ArrayScopeListMixin.find(:all, :conditions => "parent_id = 5 AND parent_type = 'ParentClass'", :order => 'pos').map(&:id)
+    assert_equal [3, 4], ArrayScopeListMixin.where(parent_id: 5, parent_type: :ParentClass).order(:pos).map(&:id)
 
     assert_equal 1, ArrayScopeListMixin.find(3).pos
     assert_equal 2, ArrayScopeListMixin.find(4).pos
@@ -679,11 +698,11 @@ class ArrayScopeListTest < Test::Unit::TestCase
   end
 
   def test_remove_from_list_should_set_position_to_nil
-    assert_equal [1, 2, 3, 4], ArrayScopeListMixin.find(:all, :conditions => "parent_id = 5 AND parent_type = 'ParentClass'", :order => 'pos').map(&:id)
+    assert_equal [1, 2, 3, 4], ArrayScopeListMixin.where(parent_id: 5, parent_type: :ParentClass).order(:pos).map(&:id)
 
     ArrayScopeListMixin.find(2).remove_from_list
 
-    assert_equal [2, 1, 3, 4], ArrayScopeListMixin.find(:all, :conditions => "parent_id = 5 AND parent_type = 'ParentClass'", :order => 'pos').map(&:id)
+    assert_equal [2, 1, 3, 4], ArrayScopeListMixin.where(parent_id: 5, parent_type: :ParentClass).order(:pos).map(&:id)
 
     assert_equal 1,   ArrayScopeListMixin.find(1).pos
     assert_equal nil, ArrayScopeListMixin.find(2).pos
@@ -692,12 +711,12 @@ class ArrayScopeListTest < Test::Unit::TestCase
   end
 
   def test_remove_before_destroy_does_not_shift_lower_items_twice
-    assert_equal [1, 2, 3, 4], ArrayScopeListMixin.find(:all, :conditions => "parent_id = 5 AND parent_type = 'ParentClass'", :order => 'pos').map(&:id)
+    assert_equal [1, 2, 3, 4], ArrayScopeListMixin.where(parent_id: 5, parent_type: :ParentClass).order(:pos).map(&:id)
 
     ArrayScopeListMixin.find(2).remove_from_list
     ArrayScopeListMixin.find(2).destroy
 
-    assert_equal [1, 3, 4], ArrayScopeListMixin.find(:all, :conditions => "parent_id = 5 AND parent_type = 'ParentClass'", :order => 'pos').map(&:id)
+    assert_equal [1, 3, 4], ArrayScopeListMixin.where(parent_id: 5, parent_type: :ParentClass).order(:pos).map(&:id)
 
     assert_equal 1, ArrayScopeListMixin.find(1).pos
     assert_equal 2, ArrayScopeListMixin.find(3).pos
@@ -738,26 +757,26 @@ class ZeroBasedTestWithDefault < Test::Unit::TestCase
     assert new.last?
   end
 
-  def test_reordering
-    assert_equal [1, 2, 3, 4], ZeroBasedMixin.find(:all, :conditions => 'parent_id = 5', :order => 'pos').map(&:id)
+   def test_reordering
+    assert_equal [1, 2, 3, 4], ZeroBasedMixin.where(parent_id: 5).order(:pos).map(&:id)
 
     ListMixin.find(2).move_lower
-    assert_equal [1, 3, 2, 4], ZeroBasedMixin.find(:all, :conditions => 'parent_id = 5', :order => 'pos').map(&:id)
+    assert_equal [1, 3, 2, 4], ZeroBasedMixin.where(parent_id: 5).order(:pos).map(&:id)
 
     ListMixin.find(2).move_higher
-    assert_equal [1, 2, 3, 4], ZeroBasedMixin.find(:all, :conditions => 'parent_id = 5', :order => 'pos').map(&:id)
+    assert_equal [1, 2, 3, 4], ZeroBasedMixin.where(parent_id: 5).order(:pos).map(&:id)
 
     ListMixin.find(1).move_to_bottom
-    assert_equal [2, 3, 4, 1], ZeroBasedMixin.find(:all, :conditions => 'parent_id = 5', :order => 'pos').map(&:id)
+    assert_equal [2, 3, 4, 1], ZeroBasedMixin.where(parent_id: 5).order(:pos).map(&:id)
 
     ListMixin.find(1).move_to_top
-    assert_equal [1, 2, 3, 4], ZeroBasedMixin.find(:all, :conditions => 'parent_id = 5', :order => 'pos').map(&:id)
+    assert_equal [1, 2, 3, 4], ZeroBasedMixin.where(parent_id: 5).order(:pos).map(&:id)
 
     ListMixin.find(2).move_to_bottom
-    assert_equal [1, 3, 4, 2], ZeroBasedMixin.find(:all, :conditions => 'parent_id = 5', :order => 'pos').map(&:id)
+    assert_equal [1, 3, 4, 2], ZeroBasedMixin.where(parent_id: 5).order(:pos).map(&:id)
 
     ListMixin.find(4).move_to_top
-    assert_equal [4, 1, 3, 2], ZeroBasedMixin.find(:all, :conditions => 'parent_id = 5', :order => 'pos').map(&:id)
+    assert_equal [4, 1, 3, 2], ZeroBasedMixin.where(parent_id: 5).order(:pos).map(&:id)
   end
 
   def test_insert_at
@@ -810,31 +829,31 @@ class ListTestWithDefault < Test::Unit::TestCase
   end
 
   def test_reordering
-    assert_equal [1, 2, 3, 4], ListMixin.find(:all, :conditions => 'parent_id = 5', :order => 'pos').map(&:id)
+    assert_equal [1, 2, 3, 4], ListMixin.where(parent_id: 5).order(:pos).map(&:id)
 
     ListMixin.find(2).move_lower
-    assert_equal [1, 3, 2, 4], ListMixin.find(:all, :conditions => 'parent_id = 5', :order => 'pos').map(&:id)
+    assert_equal [1, 3, 2, 4], ListMixin.where(parent_id: 5).order(:pos).map(&:id)
 
     ListMixin.find(2).move_higher
-    assert_equal [1, 2, 3, 4], ListMixin.find(:all, :conditions => 'parent_id = 5', :order => 'pos').map(&:id)
+    assert_equal [1, 2, 3, 4], ListMixin.where(parent_id: 5).order(:pos).map(&:id)
 
     ListMixin.find(1).move_to_bottom
-    assert_equal [2, 3, 4, 1], ListMixin.find(:all, :conditions => 'parent_id = 5', :order => 'pos').map(&:id)
+    assert_equal [2, 3, 4, 1], ListMixin.where(parent_id: 5).order(:pos).map(&:id)
 
     ListMixin.find(1).move_to_top
-    assert_equal [1, 2, 3, 4], ListMixin.find(:all, :conditions => 'parent_id = 5', :order => 'pos').map(&:id)
+    assert_equal [1, 2, 3, 4], ListMixin.where(parent_id: 5).order(:pos).map(&:id)
 
     ListMixin.find(2).move_to_bottom
-    assert_equal [1, 3, 4, 2], ListMixin.find(:all, :conditions => 'parent_id = 5', :order => 'pos').map(&:id)
+    assert_equal [1, 3, 4, 2], ListMixin.where(parent_id: 5).order(:pos).map(&:id)
 
     ListMixin.find(4).move_to_top
-    assert_equal [4, 1, 3, 2], ListMixin.find(:all, :conditions => 'parent_id = 5', :order => 'pos').map(&:id)
+    assert_equal [4, 1, 3, 2], ListMixin.where(parent_id: 5).order(:pos).map(&:id)
   end
 
   def test_move_to_bottom_with_next_to_last_item
-    assert_equal [1, 2, 3, 4], ListMixin.find(:all, :conditions => 'parent_id = 5', :order => 'pos').map(&:id)
+    assert_equal [1, 2, 3, 4], ListMixin.where(parent_id: 5).order(:pos).map(&:id)
     ListMixin.find(3).move_to_bottom
-    assert_equal [1, 2, 4, 3], ListMixin.find(:all, :conditions => 'parent_id = 5', :order => 'pos').map(&:id)
+    assert_equal [1, 2, 4, 3], ListMixin.where(parent_id: 5).order(:pos).map(&:id)
   end
 
   def test_next_prev
@@ -908,11 +927,11 @@ class ListTestWithDefault < Test::Unit::TestCase
   end
 
   def test_delete_middle
-    assert_equal [1, 2, 3, 4], ListMixin.find(:all, :conditions => 'parent_id = 5', :order => 'pos').map(&:id)
+    assert_equal [1, 2, 3, 4], ListMixin.where(parent_id: 5).order(:pos).map(&:id)
 
     ListMixin.find(2).destroy
 
-    assert_equal [1, 3, 4], ListMixin.find(:all, :conditions => 'parent_id = 5', :order => 'pos').map(&:id)
+    assert_equal [1, 3, 4], ListMixin.where(parent_id: 5).order(:pos).map(&:id)
 
     assert_equal 1, ListMixin.find(1).pos
     assert_equal 2, ListMixin.find(3).pos
@@ -920,7 +939,7 @@ class ListTestWithDefault < Test::Unit::TestCase
 
     ListMixin.find(1).destroy
 
-    assert_equal [3, 4], ListMixin.find(:all, :conditions => 'parent_id = 5', :order => 'pos').map(&:id)
+    assert_equal [3, 4], ListMixin.where(parent_id: 5).order(:pos).map(&:id)
 
     assert_equal 1, ListMixin.find(3).pos
     assert_equal 2, ListMixin.find(4).pos
@@ -936,7 +955,7 @@ class ListTestWithDefault < Test::Unit::TestCase
   def test_nil_scope
     new1, new2, new3 = ListMixin.create, ListMixin.create, ListMixin.create
     new2.move_higher
-    assert_equal [new2, new1, new3], ListMixin.find(:all, :conditions => 'parent_id IS NULL', :order => 'pos')
+    assert_equal [new2, new1, new3], ListMixin.where(parent_id: nil).order(:pos)
   end
 
   def test_remove_from_list_should_then_fail_in_list?
@@ -946,11 +965,11 @@ class ListTestWithDefault < Test::Unit::TestCase
   end
 
   def test_remove_from_list_should_set_position_to_nil
-    assert_equal [1, 2, 3, 4], ListMixin.find(:all, :conditions => 'parent_id = 5', :order => 'pos').map(&:id)
+    assert_equal [1, 2, 3, 4], ListMixin.where(parent_id: 5).order(:pos).map(&:id)
 
     ListMixin.find(2).remove_from_list
 
-    assert_equal [2, 1, 3, 4], ListMixin.find(:all, :conditions => 'parent_id = 5', :order => 'pos').map(&:id)
+    assert_equal [2, 1, 3, 4], ListMixin.where(parent_id: 5).order(:pos).map(&:id)
 
     assert_equal 1,   ListMixin.find(1).pos
     assert_equal nil, ListMixin.find(2).pos
@@ -959,12 +978,12 @@ class ListTestWithDefault < Test::Unit::TestCase
   end
 
   def test_remove_before_destroy_does_not_shift_lower_items_twice
-    assert_equal [1, 2, 3, 4], ListMixin.find(:all, :conditions => 'parent_id = 5', :order => 'pos').map(&:id)
+    assert_equal [1, 2, 3, 4], ListMixin.where(parent_id: 5).order(:pos).map(&:id)
 
     ListMixin.find(2).remove_from_list
     ListMixin.find(2).destroy
 
-    assert_equal [1, 3, 4], ListMixin.find(:all, :conditions => 'parent_id = 5', :order => 'pos').map(&:id)
+    assert_equal [1, 3, 4], ListMixin.where(parent_id: 5).order(:pos).map(&:id)
 
     assert_equal 1, ListMixin.find(1).pos
     assert_equal 2, ListMixin.find(3).pos
@@ -972,7 +991,7 @@ class ListTestWithDefault < Test::Unit::TestCase
   end
 
   def test_before_destroy_callbacks_do_not_update_position_to_nil_before_deleting_the_record
-    assert_equal [1, 2, 3, 4], ListMixin.find(:all, :conditions => 'parent_id = 5', :order => 'pos').map(&:id)
+    assert_equal [1, 2, 3, 4], ListMixin.where(parent_id: 5).order(:pos).map(&:id)
 
     # We need to trigger all the before_destroy callbacks without actually
     # destroying the record so we can see the affect the callbacks have on
@@ -981,13 +1000,19 @@ class ListTestWithDefault < Test::Unit::TestCase
     list = ListMixin.find(2)
     if list.respond_to?(:run_callbacks)
       # Refactored to work according to Rails3 ActiveRSupport Callbacks <http://api.rubyonrails.org/classes/ActiveSupport/Callbacks.html>
-      list.run_callbacks :destroy, :before if rails_3
-      list.run_callbacks(:before_destroy) if !rails_3
+      # Refactored again to also work with Rails4 which does not allow to pick only before callbacks to fire
+      if rails_3
+        list.run_callbacks :destroy, :before
+      elsif rails_4_or_above
+        list.run_callbacks :destroy
+      else
+        list.run_callbacks :before_destroy
+      end
     else
       list.send(:callback, :before_destroy)
     end
 
-    assert_equal [1, 2, 3, 4], ListMixin.find(:all, :conditions => 'parent_id = 5', :order => 'pos').map(&:id)
+    assert_equal [1, 2, 3, 4], ListMixin.where(parent_id: 5).order(:pos).map(&:id)
 
     assert_equal 1, ListMixin.find(1).pos
     assert_equal 2, ListMixin.find(2).pos
@@ -996,32 +1021,32 @@ class ListTestWithDefault < Test::Unit::TestCase
   end
 
   def test_before_create_callback_adds_to_bottom
-    assert_equal [1, 2, 3, 4], ListMixin.find(:all, :conditions => 'parent_id = 5', :order => 'pos').map(&:id)
+    assert_equal [1, 2, 3, 4], ListMixin.where(parent_id: 5).order(:pos).map(&:id)
 
     new = ListMixin.create(:parent_id => 5)
     assert_equal 5, new.pos
     assert !new.first?
     assert new.last?
 
-    assert_equal [1, 2, 3, 4, 5], ListMixin.find(:all, :conditions => 'parent_id = 5', :order => 'pos').map(&:id)
+    assert_equal [1, 2, 3, 4, 5], ListMixin.where(parent_id: 5).order(:pos).map(&:id)
   end
 
   def test_before_create_callback_adds_to_given_position
-    assert_equal [1, 2, 3, 4], ListMixin.find(:all, :conditions => 'parent_id = 5', :order => 'pos').map(&:id)
+    assert_equal [1, 2, 3, 4], ListMixin.where(parent_id: 5).order(:pos).map(&:id)
 
     new = ListMixin.create(:pos => 1, :parent_id => 5)
     assert_equal 1, new.pos
     assert new.first?
     assert !new.last?
 
-    assert_equal [5, 1, 2, 3, 4], ListMixin.find(:all, :conditions => 'parent_id = 5', :order => 'pos').map(&:id)
+    assert_equal [5, 1, 2, 3, 4], ListMixin.where(parent_id: 5).order(:pos).map(&:id)
 
     new = ListMixin.create(:pos => 3, :parent_id => 5)
     assert_equal 3, new.pos
     assert !new.first?
     assert !new.last?
 
-    assert_equal [5, 1, 6, 2, 3, 4], ListMixin.find(:all, :conditions => 'parent_id = 5', :order => 'pos').map(&:id)
+    assert_equal [5, 1, 6, 2, 3, 4], ListMixin.where(parent_id: 5).order(:pos).map(&:id)
   end
 end
 
@@ -1037,31 +1062,31 @@ class ListSubTestWithDefault < Test::Unit::TestCase
   end
 
   def test_reordering
-    assert_equal [1, 2, 3, 4], ListMixin.find(:all, :conditions => 'parent_id = 5000', :order => 'pos').map(&:id)
+    assert_equal [1, 2, 3, 4], ListMixin.where(parent_id: 5000).order(:pos).map(&:id)
 
     ListMixin.find(2).move_lower
-    assert_equal [1, 3, 2, 4], ListMixin.find(:all, :conditions => 'parent_id = 5000', :order => 'pos').map(&:id)
+    assert_equal [1, 3, 2, 4], ListMixin.where(parent_id: 5000).order(:pos).map(&:id)
 
     ListMixin.find(2).move_higher
-    assert_equal [1, 2, 3, 4], ListMixin.find(:all, :conditions => 'parent_id = 5000', :order => 'pos').map(&:id)
+    assert_equal [1, 2, 3, 4], ListMixin.where(parent_id: 5000).order(:pos).map(&:id)
 
     ListMixin.find(1).move_to_bottom
-    assert_equal [2, 3, 4, 1], ListMixin.find(:all, :conditions => 'parent_id = 5000', :order => 'pos').map(&:id)
+    assert_equal [2, 3, 4, 1], ListMixin.where(parent_id: 5000).order(:pos).map(&:id)
 
     ListMixin.find(1).move_to_top
-    assert_equal [1, 2, 3, 4], ListMixin.find(:all, :conditions => 'parent_id = 5000', :order => 'pos').map(&:id)
+    assert_equal [1, 2, 3, 4], ListMixin.where(parent_id: 5000).order(:pos).map(&:id)
 
     ListMixin.find(2).move_to_bottom
-    assert_equal [1, 3, 4, 2], ListMixin.find(:all, :conditions => 'parent_id = 5000', :order => 'pos').map(&:id)
+    assert_equal [1, 3, 4, 2], ListMixin.where(parent_id: 5000).order(:pos).map(&:id)
 
     ListMixin.find(4).move_to_top
-    assert_equal [4, 1, 3, 2], ListMixin.find(:all, :conditions => 'parent_id = 5000', :order => 'pos').map(&:id)
+    assert_equal [4, 1, 3, 2], ListMixin.where(parent_id: 5000).order(:pos).map(&:id)
   end
 
   def test_move_to_bottom_with_next_to_last_item
-    assert_equal [1, 2, 3, 4], ListMixin.find(:all, :conditions => 'parent_id = 5000', :order => 'pos').map(&:id)
+    assert_equal [1, 2, 3, 4], ListMixin.where(parent_id: 5000).order(:pos).map(&:id)
     ListMixin.find(3).move_to_bottom
-    assert_equal [1, 2, 4, 3], ListMixin.find(:all, :conditions => 'parent_id = 5000', :order => 'pos').map(&:id)
+    assert_equal [1, 2, 4, 3], ListMixin.where(parent_id: 5000).order(:pos).map(&:id)
   end
 
   def test_next_prev
@@ -1113,11 +1138,11 @@ class ListSubTestWithDefault < Test::Unit::TestCase
   end
 
   def test_delete_middle
-    assert_equal [1, 2, 3, 4], ListMixin.find(:all, :conditions => 'parent_id = 5000', :order => 'pos').map(&:id)
+    assert_equal [1, 2, 3, 4], ListMixin.where(parent_id: 5000).order(:pos).map(&:id)
 
     ListMixin.find(2).destroy
 
-    assert_equal [1, 3, 4], ListMixin.find(:all, :conditions => 'parent_id = 5000', :order => 'pos').map(&:id)
+    assert_equal [1, 3, 4], ListMixin.where(parent_id: 5000).order(:pos).map(&:id)
 
     assert_equal 1, ListMixin.find(1).pos
     assert_equal 2, ListMixin.find(3).pos
@@ -1125,7 +1150,7 @@ class ListSubTestWithDefault < Test::Unit::TestCase
 
     ListMixin.find(1).destroy
 
-    assert_equal [3, 4], ListMixin.find(:all, :conditions => 'parent_id = 5000', :order => 'pos').map(&:id)
+    assert_equal [3, 4], ListMixin.where(parent_id: 5000).order(:pos).map(&:id)
 
     assert_equal 1, ListMixin.find(3).pos
     assert_equal 2, ListMixin.find(4).pos
@@ -1145,31 +1170,31 @@ class ArrayScopeListTestWithDefault < Test::Unit::TestCase
   end
 
   def test_reordering
-    assert_equal [1, 2, 3, 4], ArrayScopeListMixin.find(:all, :conditions => "parent_id = 5 AND parent_type = 'ParentClass'", :order => 'pos').map(&:id)
+    assert_equal [1, 2, 3, 4], ArrayScopeListMixin.where(parent_id: 5, parent_type: :ParentClass).order(:pos).map(&:id)
 
     ArrayScopeListMixin.find(2).move_lower
-    assert_equal [1, 3, 2, 4], ArrayScopeListMixin.find(:all, :conditions => "parent_id = 5 AND parent_type = 'ParentClass'", :order => 'pos').map(&:id)
+    assert_equal [1, 3, 2, 4], ArrayScopeListMixin.where(parent_id: 5, parent_type: :ParentClass).order(:pos).map(&:id)
 
     ArrayScopeListMixin.find(2).move_higher
-    assert_equal [1, 2, 3, 4], ArrayScopeListMixin.find(:all, :conditions => "parent_id = 5 AND parent_type = 'ParentClass'", :order => 'pos').map(&:id)
+    assert_equal [1, 2, 3, 4], ArrayScopeListMixin.where(parent_id: 5, parent_type: :ParentClass).order(:pos).map(&:id)
 
     ArrayScopeListMixin.find(1).move_to_bottom
-    assert_equal [2, 3, 4, 1], ArrayScopeListMixin.find(:all, :conditions => "parent_id = 5 AND parent_type = 'ParentClass'", :order => 'pos').map(&:id)
+    assert_equal [2, 3, 4, 1], ArrayScopeListMixin.where(parent_id: 5, parent_type: :ParentClass).order(:pos).map(&:id)
 
     ArrayScopeListMixin.find(1).move_to_top
-    assert_equal [1, 2, 3, 4], ArrayScopeListMixin.find(:all, :conditions => "parent_id = 5 AND parent_type = 'ParentClass'", :order => 'pos').map(&:id)
+    assert_equal [1, 2, 3, 4], ArrayScopeListMixin.where(parent_id: 5, parent_type: :ParentClass).order(:pos).map(&:id)
 
     ArrayScopeListMixin.find(2).move_to_bottom
-    assert_equal [1, 3, 4, 2], ArrayScopeListMixin.find(:all, :conditions => "parent_id = 5 AND parent_type = 'ParentClass'", :order => 'pos').map(&:id)
+    assert_equal [1, 3, 4, 2], ArrayScopeListMixin.where(parent_id: 5, parent_type: :ParentClass).order(:pos).map(&:id)
 
     ArrayScopeListMixin.find(4).move_to_top
-    assert_equal [4, 1, 3, 2], ArrayScopeListMixin.find(:all, :conditions => "parent_id = 5 AND parent_type = 'ParentClass'", :order => 'pos').map(&:id)
+    assert_equal [4, 1, 3, 2], ArrayScopeListMixin.where(parent_id: 5, parent_type: :ParentClass).order(:pos).map(&:id)
   end
 
   def test_move_to_bottom_with_next_to_last_item
-    assert_equal [1, 2, 3, 4], ArrayScopeListMixin.find(:all, :conditions => "parent_id = 5 AND parent_type = 'ParentClass'", :order => 'pos').map(&:id)
+    assert_equal [1, 2, 3, 4], ArrayScopeListMixin.where(parent_id: 5, parent_type: :ParentClass).order(:pos).map(&:id)
     ArrayScopeListMixin.find(3).move_to_bottom
-    assert_equal [1, 2, 4, 3], ArrayScopeListMixin.find(:all, :conditions => "parent_id = 5 AND parent_type = 'ParentClass'", :order => 'pos').map(&:id)
+    assert_equal [1, 2, 4, 3], ArrayScopeListMixin.where(parent_id: 5, parent_type: :ParentClass).order(:pos).map(&:id)
   end
 
   def test_next_prev
@@ -1243,11 +1268,11 @@ class ArrayScopeListTestWithDefault < Test::Unit::TestCase
   end
 
   def test_delete_middle
-    assert_equal [1, 2, 3, 4], ArrayScopeListMixin.find(:all, :conditions => "parent_id = 5 AND parent_type = 'ParentClass'", :order => 'pos').map(&:id)
+    assert_equal [1, 2, 3, 4], ArrayScopeListMixin.where(parent_id: 5, parent_type: :ParentClass).order(:pos).map(&:id)
 
     ArrayScopeListMixin.find(2).destroy
 
-    assert_equal [1, 3, 4], ArrayScopeListMixin.find(:all, :conditions => "parent_id = 5 AND parent_type = 'ParentClass'", :order => 'pos').map(&:id)
+    assert_equal [1, 3, 4], ArrayScopeListMixin.where(parent_id: 5, parent_type: :ParentClass).order(:pos).map(&:id)
 
     assert_equal 1, ArrayScopeListMixin.find(1).pos
     assert_equal 2, ArrayScopeListMixin.find(3).pos
@@ -1255,7 +1280,7 @@ class ArrayScopeListTestWithDefault < Test::Unit::TestCase
 
     ArrayScopeListMixin.find(1).destroy
 
-    assert_equal [3, 4], ArrayScopeListMixin.find(:all, :conditions => "parent_id = 5 AND parent_type = 'ParentClass'", :order => 'pos').map(&:id)
+    assert_equal [3, 4], ArrayScopeListMixin.where(parent_id: 5, parent_type: :ParentClass).order(:pos).map(&:id)
 
     assert_equal 1, ArrayScopeListMixin.find(3).pos
     assert_equal 2, ArrayScopeListMixin.find(4).pos
@@ -1268,11 +1293,11 @@ class ArrayScopeListTestWithDefault < Test::Unit::TestCase
   end
 
   def test_remove_from_list_should_set_position_to_nil
-    assert_equal [1, 2, 3, 4], ArrayScopeListMixin.find(:all, :conditions => "parent_id = 5 AND parent_type = 'ParentClass'", :order => 'pos').map(&:id)
+    assert_equal [1, 2, 3, 4], ArrayScopeListMixin.where(parent_id: 5, parent_type: :ParentClass).order(:pos).map(&:id)
 
     ArrayScopeListMixin.find(2).remove_from_list
 
-    assert_equal [2, 1, 3, 4], ArrayScopeListMixin.find(:all, :conditions => "parent_id = 5 AND parent_type = 'ParentClass'", :order => 'pos').map(&:id)
+    assert_equal [2, 1, 3, 4], ArrayScopeListMixin.where(parent_id: 5, parent_type: :ParentClass).order(:pos).map(&:id)
 
     assert_equal 1,   ArrayScopeListMixin.find(1).pos
     assert_equal nil, ArrayScopeListMixin.find(2).pos
@@ -1281,12 +1306,12 @@ class ArrayScopeListTestWithDefault < Test::Unit::TestCase
   end
 
   def test_remove_before_destroy_does_not_shift_lower_items_twice
-    assert_equal [1, 2, 3, 4], ArrayScopeListMixin.find(:all, :conditions => "parent_id = 5 AND parent_type = 'ParentClass'", :order => 'pos').map(&:id)
+    assert_equal [1, 2, 3, 4], ArrayScopeListMixin.where(parent_id: 5, parent_type: :ParentClass).order(:pos).map(&:id)
 
     ArrayScopeListMixin.find(2).remove_from_list
     ArrayScopeListMixin.find(2).destroy
 
-    assert_equal [1, 3, 4], ArrayScopeListMixin.find(:all, :conditions => "parent_id = 5 AND parent_type = 'ParentClass'", :order => 'pos').map(&:id)
+    assert_equal [1, 3, 4], ArrayScopeListMixin.where(parent_id: 5, parent_type: :ParentClass).order(:pos).map(&:id)
 
     assert_equal 1, ArrayScopeListMixin.find(1).pos
     assert_equal 2, ArrayScopeListMixin.find(3).pos
@@ -1323,25 +1348,25 @@ class DefaultScopedTest < Test::Unit::TestCase
   end
 
   def test_reordering
-    assert_equal [1, 2, 3, 4], DefaultScopedMixin.find(:all).map(&:id)
+    assert_equal [1, 2, 3, 4], DefaultScopedMixin.all.map(&:id)
 
     DefaultScopedMixin.find(2).move_lower
-    assert_equal [1, 3, 2, 4], DefaultScopedMixin.find(:all).map(&:id)
+    assert_equal [1, 3, 2, 4], DefaultScopedMixin.all.map(&:id)
 
     DefaultScopedMixin.find(2).move_higher
-    assert_equal [1, 2, 3, 4], DefaultScopedMixin.find(:all).map(&:id)
+    assert_equal [1, 2, 3, 4], DefaultScopedMixin.all.map(&:id)
 
     DefaultScopedMixin.find(1).move_to_bottom
-    assert_equal [2, 3, 4, 1], DefaultScopedMixin.find(:all).map(&:id)
+    assert_equal [2, 3, 4, 1], DefaultScopedMixin.all.map(&:id)
 
     DefaultScopedMixin.find(1).move_to_top
-    assert_equal [1, 2, 3, 4], DefaultScopedMixin.find(:all).map(&:id)
+    assert_equal [1, 2, 3, 4], DefaultScopedMixin.all.map(&:id)
 
     DefaultScopedMixin.find(2).move_to_bottom
-    assert_equal [1, 3, 4, 2], DefaultScopedMixin.find(:all).map(&:id)
+    assert_equal [1, 3, 4, 2], DefaultScopedMixin.all.map(&:id)
 
     DefaultScopedMixin.find(4).move_to_top
-    assert_equal [4, 1, 3, 2], DefaultScopedMixin.find(:all).map(&:id)
+    assert_equal [4, 1, 3, 2], DefaultScopedMixin.all.map(&:id)
   end
 
   def test_insert_at