acts_as_list 0.2.0 → 0.3.0

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    NzM4YWNhZmE0NzViMmFhNDI0OGM0ZDFkM2RkYzAxMDIxODY2M2E2Mg==
+  data.tar.gz: !binary |-
+    MWYwZDU4MzgwNzhjMGQwYmU2YTJmOGZlZTUwODViOTc4NjBmZTlkYQ==
+!binary "U0hBNTEy":
+  metadata.gz: !binary |-
+    MzFmMjljMTNmMjY1ZGU5YTJjMzgzYjc2NjQ1ZjMyOWYyOWUwMmExMmJjMGQ5
+    OGEwYjlhNjQ4YTdiM2RlZmQ3M2IxMzA1N2E3Y2I1MjE0NDE0OWZhNWU1Y2I5
+    NzI1ZjgwZWNiOTE1MGNiZDE5NDBmNDZkNDA3ZjdlMGZjMThmYmM=
+  data.tar.gz: !binary |-
+    YTk3YjgxYThlYzE3MmQxY2QzNGNiN2QyNGZkYjY1ZGVmNzVkM2ZkM2QyNGI4
+    MjI5OTUzZTNhNjY2Nzk1ZWMxYmI4NmZlNTFiMjgyMTI1MWY5ZTk1NzBlYTMz
+    YzljYmY3MzMyZTUxZDk3M2QzNTEyNDJjNmVhODE1YzM0MTNlNTM=

data/.travis.yml

@@ -1,6 +1,14 @@
 language: ruby
 rvm:
-  - 1.8.7
   - 1.9.2
   - 1.9.3
   - 2.0.0
+gemfile:
+ - gemfiles/rails3/Gemfile
+ - gemfiles/rails4/Gemfile
+matrix:
+  allow_failures:
+    - rvm: 1.8.7
+      gemfile: gemfiles/rails4/Gemfile
+    - rvm: 1.9.2
+      gemfile: gemfiles/rails4/Gemfile

data/gemfiles/rails3/Gemfile

@@ -0,0 +1,8 @@
+source "https://rubygems.org"
+
+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,8 @@
+source "https://rubygems.org"
+
+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,16 @@ 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
+
+            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 +181,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 +214,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 +234,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
@@ -279,7 +307,7 @@ module ActiveRecord
           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
+            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.
@@ -390,17 +418,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

data/lib/acts_as_list/version.rb

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

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