acts_as_list 0.2.0 → 0.4.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: d5cbf688ac985c43f61b4c0669030f5b6f6c6caa
+  data.tar.gz: aef8fc0d40ed0ee55bf73ff2b7989e14e9c6572e
+SHA512:
+  metadata.gz: de7f8dd3123cb1bf1fd5837517c221d8a6682207c3a75ac99a7457782b5ebf6d3fa995ee12664674cc7dfacaca6bd7e5ffaa484407502856aa8e9932ff066746
+  data.tar.gz: 20d069cc6a4420dd3dd6073f12ab8940cf2bb3c1003bd71faca489ddefe780349159696cd12ef37e65578ac796c0d4686af3c231cff832f3eb2b2a3306f2da62

data/.travis.yml

@@ -1,6 +1,15 @@
 language: ruby
 rvm:
-  - 1.8.7
   - 1.9.2
   - 1.9.3
   - 2.0.0
+  - 2.1.0
+  - jruby-19mode
+  - rbx
+gemfile:
+ - gemfiles/rails3/Gemfile
+ - gemfiles/rails4/Gemfile
+matrix:
+  allow_failures:
+    - rvm: 1.9.2
+      gemfile: gemfiles/rails4/Gemfile

data/Gemfile

@@ -1,5 +1,14 @@
 source "http://rubygems.org"
 
+gem 'sqlite3', :platforms => [:ruby]
+gem 'activerecord-jdbcsqlite3-adapter', :platforms => [:jruby]
+
+platforms :rbx do
+  gem 'rubysl', '~> 2.0'
+  gem 'rubinius-developer_tools'
+  gem 'rubysl-test-unit'
+end
+
 # Specify your gem's dependencies in acts_as_list-rails3.gemspec
 gemspec
 

data/MIT-LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2007 David Heinemeier Hansson
+
+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/README.md

@@ -25,7 +25,7 @@ After that you can use `acts_as_list` method in the model:
 
 ```ruby
 class TodoList < ActiveRecord::Base
-  has_many :todo_items, order: :position
+  has_many :todo_items, -> { order("position ASC") }
 end
     
 class TodoItem < ActiveRecord::Base
@@ -82,6 +82,9 @@ All versions `0.1.5` onwards require Rails 3.0.x and higher.
 ## Build Status
 [![Build Status](https://secure.travis-ci.org/swanandp/acts_as_list.png)](https://secure.travis-ci.org/swanandp/acts_as_list)
 
+## Workflow Status
+[![WIP Issues](https://badge.waffle.io/swanandp/acts_as_list.png)](http://waffle.io/swanandp/acts_as_list)
+
 ## Roadmap
 
 1. Sort based feature

data/Rakefile

@@ -15,15 +15,21 @@ Rake::TestTask.new(:test) do |t|
   t.verbose = false
 end
 
-# Run the rdoc task to generate rdocs for this gem
-require 'rdoc/task'
-RDoc::Task.new do |rdoc|
-  require "acts_as_list/version"
-  version = ActiveRecord::Acts::List::VERSION
+begin
+  # Run the rdoc task to generate rdocs for this gem
+  require 'rdoc/task'
+  RDoc::Task.new do |rdoc|
+    require "acts_as_list/version"
+    version = ActiveRecord::Acts::List::VERSION
 
-  rdoc.rdoc_dir = 'rdoc'
-  rdoc.title = "acts_as_list-rails3 #{version}"
-  rdoc.rdoc_files.include('README*')
-  rdoc.rdoc_files.include('lib/**/*.rb')
+    rdoc.rdoc_dir = 'rdoc'
+    rdoc.title = "acts_as_list-rails3 #{version}"
+    rdoc.rdoc_files.include('README*')
+    rdoc.rdoc_files.include('lib/**/*.rb')
+  end
+rescue LoadError
+  puts 'RDocTask is not supported on this platform.'
+rescue StandardError
+  puts 'RDocTask is not supported on this platform.'
 end
 

data/acts_as_list.gemspec

@@ -13,8 +13,9 @@ Gem::Specification.new do |s|
   s.homepage    = 'http://github.com/swanandp/acts_as_list'
   s.summary     = %q{A gem allowing a active_record model to act_as_list.}
   s.description = %q{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'
 
   # Load Paths...
   s.files         = `git ls-files`.split("\n")
@@ -26,6 +27,4 @@ Gem::Specification.new do |s|
   # Dependencies (installed via 'bundle install')...
   s.add_dependency("activerecord", [">= 3.0"])
   s.add_development_dependency("bundler", [">= 1.0.0"])
-  s.add_development_dependency("rdoc")
-  s.add_development_dependency("sqlite3")
 end

data/gemfiles/rails3/Gemfile

@@ -0,0 +1,17 @@
+source "https://rubygems.org"
+
+gem 'sqlite3', :platforms => [:ruby]
+gem 'activerecord-jdbcsqlite3-adapter', :platforms => [:jruby]
+
+platforms :rbx do
+  gem 'rubysl', '~> 2.0'
+  gem 'rubinius-developer_tools'
+  gem 'rubysl-test-unit'
+end
+
+gem 'activerecord', '>= 3.0', '< 4'
+
+# Specify your gem's dependencies in acts_as_list.gemspec
+gemspec :path => File.join('..', '..')
+
+gem 'rake'

data/gemfiles/rails4/Gemfile

@@ -0,0 +1,18 @@
+source "https://rubygems.org"
+
+gem 'sqlite3', :platforms => [:ruby]
+gem 'activerecord-jdbcsqlite3-adapter', :platforms => [:jruby]
+
+platforms :rbx do
+  gem 'rubysl', '~> 2.0'
+  gem 'rubinius-developer_tools'
+  gem 'rubysl-test-unit'
+end
+
+
+gem 'activerecord', '>= 4.0.0', '< 5'
+
+# Specify your gem's dependencies in acts_as_list.gemspec
+gemspec :path => File.join('..', '..')
+
+gem 'rake'

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

@@ -12,12 +12,12 @@ module ActiveRecord
       # Todo list example:
       #
       #   class TodoList < ActiveRecord::Base
-      #     has_many :todo_items, :order => "position"
+      #     has_many :todo_items, order: "position"
       #   end
       #
       #   class TodoItem < ActiveRecord::Base
       #     belongs_to :todo_list
-      #     acts_as_list :scope => :todo_list
+      #     acts_as_list scope: :todo_list
       #   end
       #
       #   todo_list.first.move_to_bottom
@@ -29,33 +29,51 @@ module ActiveRecord
         # * +scope+ - restricts what is to be considered a list. Given a symbol, it'll attach <tt>_id</tt>
         #   (if it hasn't already been added) and use that as the foreign key restriction. It's also possible
         #   to give it an entire string that is interpolated if you need a tighter scope than just a foreign key.
-        #   Example: <tt>acts_as_list :scope => 'todo_list_id = #{todo_list_id} AND completed = 0'</tt>
+        #   Example: <tt>acts_as_list scope: 'todo_list_id = #{todo_list_id} AND completed = 0'</tt>
         # * +top_of_list+ - defines the integer used for the top of the list. Defaults to 1. Use 0 to make the collection
         #   act more like an array in its indexing.
         # * +add_new_at+ - specifies whether objects get added to the :top or :bottom of the list. (default: +bottom+)
+        #                   `nil` will result in new items not being added to the list on create
         def acts_as_list(options = {})
-          configuration = { :column => "position", :scope => "1 = 1", :top_of_list => 1, :add_new_at => :bottom}
+          configuration = { 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)
-            scope_condition_method = %(
+            scope_methods = %(
               def scope_condition
                 self.class.send(:sanitize_sql_hash_for_conditions, { :#{configuration[:scope].to_s} => send(:#{configuration[:scope].to_s}) })
               end
+
+              def scope_changed?
+                changes.include?(scope_name.to_s)
+              end
             )
           elsif configuration[:scope].is_a?(Array)
-            scope_condition_method = %(
-              def scope_condition
-                attrs = %w(#{configuration[:scope].join(" ")}).inject({}) do |memo,column|
+            scope_methods = %(
+              def attrs
+                %w(#{configuration[:scope].join(" ")}).inject({}) do |memo,column|
                   memo[column.intern] = send(column.intern); memo
                 end
+              end
+
+              def scope_changed?
+                (attrs.keys & changes.keys.map(&:to_sym)).any?
+              end
+
+              def scope_condition
                 self.class.send(:sanitize_sql_hash_for_conditions, attrs)
               end
             )
           else
-            scope_condition_method = "def scope_condition() \"#{configuration[:scope]}\" end"
+            scope_methods = %(
+              def scope_condition
+                "#{configuration[:scope]}"
+              end
+
+              def scope_changed?() false end
+            )
           end
 
           class_eval <<-EOV
@@ -81,7 +99,7 @@ module ActiveRecord
               '#{configuration[:add_new_at]}'
             end
 
-            #{scope_condition_method}
+            #{scope_methods}
 
             # only add to attr_accessible
             # if the class has some mass_assignment_protection
@@ -92,10 +110,17 @@ module ActiveRecord
 
             before_destroy :reload_position
             after_destroy :decrement_positions_on_lower_items
-            before_create :add_to_list_#{configuration[:add_new_at]}
-            after_update :update_positions
             before_update :check_scope
+            after_update :update_positions
+            before_validation :check_top_position
+
+            scope :in_list, lambda { where("#{table_name}.#{configuration[:column]} IS NOT NULL") }
           EOV
+
+          if configuration[:add_new_at].present?
+            self.send(:before_create, "add_to_list_#{configuration[:add_new_at]}")
+          end
+
         end
       end
 
@@ -157,6 +182,12 @@ module ActiveRecord
           end
         end
 
+        # Move the item within scope
+        def move_within_scope(scope_id)
+          send("#{scope_name}=", scope_id)
+          save!
+        end
+
         # Increase the position of this item without adjusting the rest of the list.
         def increment_position
           return unless in_list?
@@ -184,10 +215,9 @@ module ActiveRecord
         # Return the next higher item in the list.
         def higher_item
           return nil unless in_list?
-          acts_as_list_class.unscoped.find(:first, :conditions =>
-            "#{scope_condition} AND #{position_column} < #{(send(position_column).to_i).to_s}",
-            :order => "#{acts_as_list_class.table_name}.#{position_column} DESC"
-          )
+          acts_as_list_class.unscoped.
+            where("#{scope_condition} AND #{position_column} < #{(send(position_column).to_i).to_s}").
+            order("#{acts_as_list_class.table_name}.#{position_column} DESC").first
         end
 
         # Return the next n higher items in the list
@@ -205,10 +235,9 @@ module ActiveRecord
         # Return the next lower item in the list.
         def lower_item
           return nil unless in_list?
-          acts_as_list_class.unscoped.find(:first, :conditions =>
-            "#{scope_condition} AND #{position_column} > #{(send(position_column).to_i).to_s}",
-            :order => "#{acts_as_list_class.table_name}.#{position_column} ASC"
-          )
+          acts_as_list_class.unscoped.
+            where("#{scope_condition} AND #{position_column} > #{(send(position_column).to_i).to_s}").
+            order("#{acts_as_list_class.table_name}.#{position_column} ASC").first
         end
 
         # Return the next n lower items in the list
@@ -278,8 +307,8 @@ module ActiveRecord
           # Returns the bottom item
           def bottom_item(except = nil)
             conditions = scope_condition
-            conditions = "#{conditions} AND #{self.class.primary_key} != #{except.id}" if except
-            acts_as_list_class.unscoped.where(conditions).order("#{acts_as_list_class.table_name}.#{position_column} DESC").first
+            conditions = "#{conditions} AND #{self.class.primary_key} != '#{except.id}'" if except
+            acts_as_list_class.unscoped.in_list.where(conditions).order("#{acts_as_list_class.table_name}.#{position_column} DESC").first
           end
 
           # Forces item to assume the bottom position in the list.
@@ -343,7 +372,7 @@ module ActiveRecord
           # Reorders intermediate items to support moving an item from old_position to new_position.
           def shuffle_positions_on_intermediate_items(old_position, new_position, avoid_id = nil)
             return if old_position == new_position
-            avoid_id_condition = avoid_id ? " AND #{self.class.primary_key} != #{avoid_id}" : ''
+            avoid_id_condition = avoid_id ? " AND #{self.class.primary_key} != '#{avoid_id}'" : ''
             if old_position < new_position
               # Decrement position of intermediate items
               #
@@ -368,6 +397,7 @@ module ActiveRecord
           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
@@ -390,17 +420,22 @@ module ActiveRecord
           def update_positions
             old_position = send("#{position_column}_was").to_i
             new_position = send(position_column).to_i
+
             return unless acts_as_list_class.unscoped.where("#{scope_condition} AND #{position_column} = #{new_position}").count > 1
             shuffle_positions_on_intermediate_items old_position, new_position, id
           end
 
+          # 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] }
+          end
+
           def check_scope
-            if changes.include?("#{scope_name}")
-              old_scope_id = changes["#{scope_name}"].first
-              new_scope_id = changes["#{scope_name}"].last
-              self["#{scope_name}"] = old_scope_id
-              send("decrement_positions_on_lower_items")
-              self["#{scope_name}"] = new_scope_id
+            if scope_changed?
+              swap_changed_attributes
+              send('decrement_positions_on_lower_items') if lower_item
+              swap_changed_attributes
               send("add_to_list_#{add_new_at}")
             end
           end
@@ -408,6 +443,12 @@ module ActiveRecord
           def reload_position
             self.reload
           end
+
+          def check_top_position
+            if send(position_column) && send(position_column) < acts_as_list_top
+              self[position_column] = acts_as_list_top
+            end
+          end
       end
     end
   end

data/lib/acts_as_list/version.rb

@@ -1,7 +1,7 @@
 module ActiveRecord
   module Acts
     module List
-      VERSION = "0.2.0"
+      VERSION = '0.4.0'
     end
   end
 end

data/test/helper.rb

@@ -7,8 +7,8 @@ rescue Bundler::BundlerError => e
   $stderr.puts "Run `bundle install` to install missing gems"
   exit e.status_code
 end
-require 'test/unit'
 require 'active_record'
+require 'minitest/autorun'
 require "#{File.dirname(__FILE__)}/../init"
 
 require 'shared'

data/test/shared.rb

@@ -5,4 +5,5 @@ module Shared
   autoload :ZeroBased,      'shared_zero_based'
   autoload :ArrayScopeList, 'shared_array_scope_list'
   autoload :TopAddition,    'shared_top_addition'
+  autoload :NoAddition,     'shared_no_addition'
 end

data/test/shared_array_scope_list.rb

@@ -1,87 +1,87 @@
 module Shared
   module ArrayScopeList
     def setup
-      (1..4).each { |counter| ArrayScopeListMixin.create! :pos => counter, :parent_id => 5, :parent_type => 'ParentClass' }
-      (1..4).each { |counter| ArrayScopeListMixin.create! :pos => counter, :parent_id => 6, :parent_type => 'ParentClass' }
+      (1..4).each { |counter| ArrayScopeListMixin.create! pos: counter, parent_id: 5, parent_type: 'ParentClass' }
+      (1..4).each { |counter| ArrayScopeListMixin.create! pos: counter, parent_id: 6, parent_type: 'ParentClass' }
     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)
+      ArrayScopeListMixin.where(id: 2).first.move_lower
+      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)
+      ArrayScopeListMixin.where(id: 2).first.move_higher
+      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)
+      ArrayScopeListMixin.where(id: 1).first.move_to_bottom
+      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)
+      ArrayScopeListMixin.where(id: 1).first.move_to_top
+      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)
+      ArrayScopeListMixin.where(id: 2).first.move_to_bottom
+      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)
+      ArrayScopeListMixin.where(id: 4).first.move_to_top
+      assert_equal [4, 1, 3, 2], ArrayScopeListMixin.where(parent_id: 5, parent_type: 'ParentClass').order('pos').map(&:id)
       
-      ArrayScopeListMixin.find(4).insert_at(4)
-      assert_equal [1, 3, 2, 4], ArrayScopeListMixin.find(:all, :conditions => "parent_id = 5 AND parent_type = 'ParentClass'", :order => 'pos').map(&:id)
-      assert_equal [1, 2, 3, 4], ArrayScopeListMixin.find(:all, :conditions => "parent_id = 5 AND parent_type = 'ParentClass'", :order => 'pos').map(&:pos)
+      ArrayScopeListMixin.where(id: 4).first.insert_at(4)
+      assert_equal [1, 3, 2, 4], ArrayScopeListMixin.where(parent_id: 5, parent_type: 'ParentClass').order('pos').map(&:id)
+      assert_equal [1, 2, 3, 4], ArrayScopeListMixin.where(parent_id: 5, parent_type: 'ParentClass').order('pos').map(&:pos)
     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)
-      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, 3, 4], ArrayScopeListMixin.where(parent_id: 5, parent_type: 'ParentClass').order('pos').map(&:id)
+      ArrayScopeListMixin.where(id: 3).first.move_to_bottom
+      assert_equal [1, 2, 4, 3], ArrayScopeListMixin.where(parent_id: 5, parent_type: 'ParentClass').order('pos').map(&:id)
     end
 
     def test_next_prev
-      assert_equal ArrayScopeListMixin.find(2), ArrayScopeListMixin.find(1).lower_item
-      assert_nil ArrayScopeListMixin.find(1).higher_item
-      assert_equal ArrayScopeListMixin.find(3), ArrayScopeListMixin.find(4).higher_item
-      assert_nil ArrayScopeListMixin.find(4).lower_item
+      assert_equal ArrayScopeListMixin.where(id: 2).first, ArrayScopeListMixin.where(id: 1).first.lower_item
+      assert_nil ArrayScopeListMixin.where(id: 1).first.higher_item
+      assert_equal ArrayScopeListMixin.where(id: 3).first, ArrayScopeListMixin.where(id: 4).first.higher_item
+      assert_nil ArrayScopeListMixin.where(id: 4).first.lower_item
     end
 
     def test_injection
-      item = ArrayScopeListMixin.new(:parent_id => 1, :parent_type => 'ParentClass')
+      item = ArrayScopeListMixin.new(parent_id: 1, parent_type: 'ParentClass')
       assert_equal "pos", item.position_column
     end
 
     def test_insert
-      new = ArrayScopeListMixin.create(:parent_id => 20, :parent_type => 'ParentClass')
+      new = ArrayScopeListMixin.create(parent_id: 20, parent_type: 'ParentClass')
       assert_equal 1, new.pos
       assert new.first?
       assert new.last?
 
-      new = ArrayScopeListMixin.create(:parent_id => 20, :parent_type => 'ParentClass')
+      new = ArrayScopeListMixin.create(parent_id: 20, parent_type: 'ParentClass')
       assert_equal 2, new.pos
       assert !new.first?
       assert new.last?
 
-      new = ArrayScopeListMixin.create(:parent_id => 20, :parent_type => 'ParentClass')
+      new = ArrayScopeListMixin.create(parent_id: 20, parent_type: 'ParentClass')
       assert_equal 3, new.pos
       assert !new.first?
       assert new.last?
 
-      new = ArrayScopeListMixin.create(:parent_id => 0, :parent_type => 'ParentClass')
+      new = ArrayScopeListMixin.create(parent_id: 0, parent_type: 'ParentClass')
       assert_equal 1, new.pos
       assert new.first?
       assert new.last?
     end
 
     def test_insert_at
-      new = ArrayScopeListMixin.create(:parent_id => 20, :parent_type => 'ParentClass')
+      new = ArrayScopeListMixin.create(parent_id: 20, parent_type: 'ParentClass')
       assert_equal 1, new.pos
 
-      new = ArrayScopeListMixin.create(:parent_id => 20, :parent_type => 'ParentClass')
+      new = ArrayScopeListMixin.create(parent_id: 20, parent_type: 'ParentClass')
       assert_equal 2, new.pos
 
-      new = ArrayScopeListMixin.create(:parent_id => 20, :parent_type => 'ParentClass')
+      new = ArrayScopeListMixin.create(parent_id: 20, parent_type: 'ParentClass')
       assert_equal 3, new.pos
 
-      new4 = ArrayScopeListMixin.create(:parent_id => 20, :parent_type => 'ParentClass')
+      new4 = ArrayScopeListMixin.create(parent_id: 20, parent_type: 'ParentClass')
       assert_equal 4, new4.pos
 
       new4.insert_at(3)
@@ -96,7 +96,7 @@ module Shared
       new4.reload
       assert_equal 4, new4.pos
 
-      new5 = ArrayScopeListMixin.create(:parent_id => 20, :parent_type => 'ParentClass')
+      new5 = ArrayScopeListMixin.create(parent_id: 20, parent_type: 'ParentClass')
       assert_equal 5, new5.pos
 
       new5.insert_at(1)
@@ -107,54 +107,54 @@ module Shared
     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
+      ArrayScopeListMixin.where(id: 2).first.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
-      assert_equal 3, ArrayScopeListMixin.find(4).pos
+      assert_equal 1, ArrayScopeListMixin.where(id: 1).first.pos
+      assert_equal 2, ArrayScopeListMixin.where(id: 3).first.pos
+      assert_equal 3, ArrayScopeListMixin.where(id: 4).first.pos
 
-      ArrayScopeListMixin.find(1).destroy
+      ArrayScopeListMixin.where(id: 1).first.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
+      assert_equal 1, ArrayScopeListMixin.where(id: 3).first.pos
+      assert_equal 2, ArrayScopeListMixin.where(id: 4).first.pos
     end
 
     def test_remove_from_list_should_then_fail_in_list?
-      assert_equal true, ArrayScopeListMixin.find(1).in_list?
-      ArrayScopeListMixin.find(1).remove_from_list
-      assert_equal false, ArrayScopeListMixin.find(1).in_list?
+      assert_equal true, ArrayScopeListMixin.where(id: 1).first.in_list?
+      ArrayScopeListMixin.where(id: 1).first.remove_from_list
+      assert_equal false, ArrayScopeListMixin.where(id: 1).first.in_list?
     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
+      ArrayScopeListMixin.where(id: 2).first.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
-      assert_equal 2,   ArrayScopeListMixin.find(3).pos
-      assert_equal 3,   ArrayScopeListMixin.find(4).pos
+      assert_equal 1,   ArrayScopeListMixin.where(id: 1).first.pos
+      assert_equal nil, ArrayScopeListMixin.where(id: 2).first.pos
+      assert_equal 2,   ArrayScopeListMixin.where(id: 3).first.pos
+      assert_equal 3,   ArrayScopeListMixin.where(id: 4).first.pos
     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
+      ArrayScopeListMixin.where(id: 2).first.remove_from_list
+      ArrayScopeListMixin.where(id: 2).first.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
-      assert_equal 3, ArrayScopeListMixin.find(4).pos
+      assert_equal 1, ArrayScopeListMixin.where(id: 1).first.pos
+      assert_equal 2, ArrayScopeListMixin.where(id: 3).first.pos
+      assert_equal 3, ArrayScopeListMixin.where(id: 4).first.pos
     end
   end
 end