acts_as_list 0.7.4 → 1.1.0

data/test/shared_list.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Shared
   module List
     def setup
@@ -8,6 +10,13 @@ module Shared
       end
     end
 
+    def test_current_position
+      first_item = ListMixin.where(parent_id: 5).first
+      assert_equal 1, first_item.current_position
+      first_item.remove_from_list
+      assert_nil first_item.current_position
+    end
+
     def test_reordering
       assert_equal [1, 2, 3, 4], ListMixin.where(parent_id: 5).order('pos').map(&:id)
 
@@ -60,6 +69,11 @@ module Shared
       assert !new.first?
       assert new.last?
 
+      new = ListMixin.acts_as_list_no_update { ListMixin.create(parent_id: 20) }
+      assert_equal_or_nil $default_position, new.pos
+      assert_equal $default_position.is_a?(Integer), new.first?
+      assert !new.last?
+
       new = ListMixin.create(parent_id: 20)
       assert_equal 3, new.pos
       assert !new.first?
@@ -81,6 +95,9 @@ module Shared
       new = ListMixin.create(parent_id: 20)
       assert_equal 3, new.pos
 
+      new_noup = ListMixin.acts_as_list_no_update { ListMixin.create(parent_id: 20) }
+      assert_equal_or_nil $default_position, new_noup.pos
+
       new4 = ListMixin.create(parent_id: 20)
       assert_equal 4, new4.pos
 
@@ -104,12 +121,32 @@ module Shared
 
       new4.reload
       assert_equal 5, new4.pos
+
+      new_noup.reload
+      assert_equal_or_nil $default_position, new_noup.pos
+
+      last1 = ListMixin.where('pos IS NOT NULL').order('pos').last
+      last2 = ListMixin.where('pos IS NOT NULL').order('pos').last
+      last1.insert_at(1)
+      last2.insert_at(1)
+      pos_list = ListMixin.where(parent_id: 20).order("pos ASC#{' NULLS FIRST' if ENV['DB'] == 'postgresql'}").map(&:pos)
+      assert_equal [$default_position, 1, 2, 3, 4, 5], pos_list
     end
 
-    def test_delete_middle
-      assert_equal [1, 2, 3, 4], ListMixin.where(parent_id: 5).order('pos').map(&:id)
+    def test_insert_at_after_dup
+      new1 = ListMixin.create(parent_id: 20)
+      new2 = ListMixin.create(parent_id: 20)
+      new3 = ListMixin.create(parent_id: 20)
+
+      duped = new1.dup
+      duped.save
+      [new1, new2, new3, duped].map(&:reload)
 
+      assert_equal [1, 2, 3, 4], [duped.pos, new1.pos, new2.pos, new3.pos]
+    end
 
+    def test_delete_middle
+      assert_equal [1, 2, 3, 4], ListMixin.where(parent_id: 5).order('pos').map(&:id)
 
       ListMixin.where(id: 2).first.destroy
 
@@ -125,6 +162,12 @@ module Shared
 
       assert_equal 1, ListMixin.where(id: 3).first.pos
       assert_equal 2, ListMixin.where(id: 4).first.pos
+
+      ListMixin.acts_as_list_no_update { ListMixin.where(id: 3).first.destroy }
+
+      assert_equal [4], ListMixin.where(parent_id: 5).order('pos').map(&:id)
+
+      assert_equal 2, ListMixin.where(id: 4).first.pos
     end
 
     def test_with_string_based_scope
@@ -142,7 +185,7 @@ module Shared
 
     def test_update_position_when_scope_changes
       assert_equal [1, 2, 3, 4], ListMixin.where(parent_id: 5).order('pos').map(&:id)
-      parent = ListMixin.create(parent_id: 6)
+      ListMixin.create(parent_id: 6)
 
       ListMixin.where(id: 2).first.move_within_scope(6)
 
@@ -169,10 +212,8 @@ module Shared
 
       ListMixin.where(id: 2).first.remove_from_list
 
-      assert_equal [2, 1, 3, 4], ListMixin.where(parent_id: 5).order('pos').map(&:id)
-
       assert_equal 1,   ListMixin.where(id: 1).first.pos
-      assert_equal nil, ListMixin.where(id: 2).first.pos
+      assert_nil        ListMixin.where(id: 2).first.pos
       assert_equal 2,   ListMixin.where(id: 3).first.pos
       assert_equal 3,   ListMixin.where(id: 4).first.pos
     end
@@ -196,12 +237,9 @@ module Shared
       # We need to trigger all the before_destroy callbacks without actually
       # destroying the record so we can see the affect the callbacks have on
       # the record.
-      # NOTE: Hotfix for rails3 ActiveRecord
       list = ListMixin.where(id: 2).first
       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) if rails_3
-        list.run_callbacks(:before_destroy) if !rails_3
+        list.run_callbacks(:destroy)
       else
         list.send(:callback, :before_destroy)
       end
@@ -237,14 +275,50 @@ module Shared
 
       assert_equal [5, 1, 2, 3, 4], ListMixin.where(parent_id: 5).order('pos').map(&:id)
 
+      new6 = ListMixin.new(parent_id: 5)
+      new6.pos = 3
+      new6.save!
+      assert_equal 3, new6.pos
+      assert !new6.first?
+      assert !new6.last?
+
+      assert_equal [5, 1, 6, 2, 3, 4], ListMixin.where(parent_id: 5).order('pos').map(&:id)
+
       new = ListMixin.new(parent_id: 5)
       new.pos = 3
-      new.save!
+      ListMixin.acts_as_list_no_update { new.save! }
       assert_equal 3, new.pos
+      assert_equal 3, new6.pos
       assert !new.first?
       assert !new.last?
 
-      assert_equal [5, 1, 6, 2, 3, 4], ListMixin.where(parent_id: 5).order('pos').map(&:id)
+      assert_equal [5, 1, 6, 7, 2, 3, 4], ListMixin.where(parent_id: 5).order('pos, id').map(&:id)
+    end
+
+    def test_non_persisted_records_dont_get_lock_called
+      new = ListMixin.new(parent_id: 5)
+      new.destroy
+    end
+
+    def test_invalid_records_dont_get_inserted
+      new = ListMixinError.new(parent_id: 5, state: nil)
+      assert !new.valid?
+      new.insert_at(1)
+      assert !new.persisted?
+    end
+
+    def test_invalid_records_raise_error_with_insert_at!
+      new = ListMixinError.new(parent_id: 5, state: nil)
+      assert !new.valid?
+      assert_raises ActiveRecord::RecordInvalid do
+        new.insert_at!(1)
+      end
+    end
+
+    def test_find_or_create_doesnt_raise_deprecation_warning
+      assert_no_deprecation_warning_raised_by('ActiveRecord deprecation warning raised when using `find_or_create_by` when we didn\'t expect it') do
+        ListMixin.where(parent_id: 5).find_or_create_by(pos: 5)
+      end
     end
   end
 end

data/test/shared_list_sub.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Shared
   module ListSub
     def setup
@@ -43,6 +45,36 @@ module Shared
       assert_nil ListMixin.where(id: 4).first.lower_item
     end
 
+    def test_next_prev_not_regular_sequence
+      ListMixin.all.each do |item|
+        item.update pos: item.pos * 5
+      end
+
+      assert_equal [1, 2, 3, 4], ListMixin.where(parent_id: 5000).order('pos').map(&:id)
+      assert_equal [5, 10, 15, 20], ListMixin.where(parent_id: 5000).order('id').map(&:pos)
+
+      ListMixin.where(id: 2).first.move_lower
+      assert_equal [1, 3, 2, 4], ListMixin.where(parent_id: 5000).order('pos').map(&:id)
+      assert_equal [5, 15, 10, 20], ListMixin.where(parent_id: 5000).order('id').map(&:pos)
+
+
+      ListMixin.where(id: 2).first.move_higher
+      assert_equal [1, 2, 3, 4], ListMixin.where(parent_id: 5000).order('pos').map(&:id)
+      assert_equal [5, 10, 15, 20], ListMixin.where(parent_id: 5000).order('id').map(&:pos)
+
+      ListMixin.where(id: 1).first.move_to_bottom
+      assert_equal [2, 3, 4, 1], ListMixin.where(parent_id: 5000).order('pos').map(&:id)
+
+      ListMixin.where(id: 1).first.move_to_top
+      assert_equal [1, 2, 3, 4], ListMixin.where(parent_id: 5000).order('pos').map(&:id)
+
+      ListMixin.where(id: 2).first.move_to_bottom
+      assert_equal [1, 3, 4, 2], ListMixin.where(parent_id: 5000).order('pos').map(&:id)
+
+      ListMixin.where(id: 4).first.move_to_top
+      assert_equal [4, 1, 3, 2], ListMixin.where(parent_id: 5000).order('pos').map(&:id)
+    end
+
     def test_next_prev_groups
       li1 = ListMixin.where(id: 1).first
       li2 = ListMixin.where(id: 2).first
@@ -53,12 +85,29 @@ module Shared
       assert_equal [li2, li3], li1.lower_items(2)
       assert_equal [], li4.lower_items
 
-      assert_equal [li1, li2], li3.higher_items
+      assert_equal [li2, li1], li3.higher_items
       assert_equal [li1], li2.higher_items
-      assert_equal [li2, li3], li4.higher_items(2)
+      assert_equal [li3, li2], li4.higher_items(2)
       assert_equal [], li1.higher_items
     end
 
+    def test_next_prev_groups_with_same_position
+      li1 = ListMixin.where(id: 1).first
+      li2 = ListMixin.where(id: 2).first
+      li3 = ListMixin.where(id: 3).first
+      li4 = ListMixin.where(id: 4).first
+
+      li3.update_column(:pos, 2) # Make the same position as li2
+
+      assert_equal [1, 2, 2, 4], ListMixin.order(:pos).pluck(:pos)
+
+      assert_equal [li3, li4], li2.lower_items
+      assert_equal [li2, li4], li3.lower_items
+
+      assert_equal [li3, li1], li2.higher_items
+      assert_equal [li2, li1], li3.higher_items
+    end
+
     def test_injection
       item = ListMixin.new("parent_id"=>1)
       assert_equal({ parent_id: 1 }, item.scope_condition)
@@ -75,6 +124,9 @@ module Shared
       new = ListMixinSub1.create("parent_id" => 20)
       assert_equal 3, new.pos
 
+      new_noup = ListMixinSub1.acts_as_list_no_update { ListMixinSub1.create("parent_id" => 20) }
+      assert_equal_or_nil $default_position, new_noup.pos
+
       new4 = ListMixin.create("parent_id" => 20)
       assert_equal 4, new4.pos
 
@@ -98,6 +150,9 @@ module Shared
 
       new4.reload
       assert_equal 5, new4.pos
+
+      new_noup.reload
+      assert_equal_or_nil $default_position, new_noup.pos
     end
 
     def test_delete_middle
@@ -117,6 +172,12 @@ module Shared
 
       assert_equal 1, ListMixin.where(id: 3).first.pos
       assert_equal 2, ListMixin.where(id: 4).first.pos
+
+      ListMixin.acts_as_list_no_update { ListMixin.where(id: 3).first.destroy }
+
+      assert_equal [4], ListMixin.where(parent_id: 5000).order('pos').map(&:id)
+
+      assert_equal 2, ListMixin.where(id: 4).first.pos
     end
 
     def test_acts_as_list_class

data/test/shared_no_addition.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Shared
   module NoAddition
     def setup
@@ -6,11 +8,11 @@ module Shared
 
     def test_insert
       new = NoAdditionMixin.create(parent_id: 20)
-      assert_equal nil, new.pos
+      assert_nil new.pos
       assert !new.in_list?
 
       new = NoAdditionMixin.create(parent_id: 20)
-      assert_equal nil, new.pos
+      assert_nil new.pos
     end
 
     def test_update_does_not_add_to_list
@@ -21,5 +23,51 @@ module Shared
       assert !new.in_list?
     end
 
+    def test_update_scope_does_not_add_to_list
+      new = NoAdditionMixin.create
+
+      new.update_attribute(:parent_id, 20)
+      new.reload
+      assert !new.in_list?
+
+      new.update_attribute(:parent_id, 5)
+      new.reload
+      assert !new.in_list?
+    end
+
+    def test_collision_avoidance_with_explicit_position
+      first = NoAdditionMixin.create(parent_id: 20, pos: 1)
+      second = NoAdditionMixin.create(parent_id: 20, pos: 1)
+      third = NoAdditionMixin.create(parent_id: 30, pos: 1)
+
+      first.reload
+      second.reload
+      third.reload
+
+      assert_equal 2, first.pos
+      assert_equal 1, second.pos
+      assert_equal 1, third.pos
+
+      first.update(pos: 1)
+
+      first.reload
+      second.reload
+
+      assert_equal 1, first.pos
+      assert_equal 2, second.pos
+
+      first.update(parent_id: 30)
+
+      first.reload
+      second.reload
+      third.reload
+
+      assert_equal 1, first.pos
+      assert_equal 30, first.parent_id
+      assert_equal 1, second.pos
+      assert_equal 20, second.parent_id
+      assert_equal 2, third.pos
+      assert_equal 30, third.parent_id
+    end
   end
 end

data/test/shared_quoting.rb

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

data/test/shared_top_addition.rb

@@ -1,26 +1,31 @@
+# frozen_string_literal: true
+
 module Shared
   module TopAddition
     def setup
       (1..4).each { |counter| TopAdditionMixin.create! pos: counter, parent_id: 5 }
     end
 
-    def test_reordering
-      assert_equal [4, 3, 2, 1], TopAdditionMixin.where(parent_id: 5).order('pos').map(&:id)
+    def test_setup_state
+      # If we explicitly define a position (as above) then that position is what gets applied
+      assert_equal [1, 2, 3, 4], TopAdditionMixin.where(parent_id: 5).order('pos').map(&:id)
+    end
 
+    def test_reordering
       TopAdditionMixin.where(id: 2).first.move_lower
-      assert_equal [4, 3, 1, 2], TopAdditionMixin.where(parent_id: 5).order('pos').map(&:id)
+      assert_equal [1, 3, 2, 4], TopAdditionMixin.where(parent_id: 5).order('pos').map(&:id)
 
       TopAdditionMixin.where(id: 2).first.move_higher
-      assert_equal [4, 3, 2, 1], TopAdditionMixin.where(parent_id: 5).order('pos').map(&:id)
+      assert_equal [1, 2, 3, 4], TopAdditionMixin.where(parent_id: 5).order('pos').map(&:id)
 
       TopAdditionMixin.where(id: 1).first.move_to_bottom
-      assert_equal [4, 3, 2, 1], TopAdditionMixin.where(parent_id: 5).order('pos').map(&:id)
+      assert_equal [2, 3, 4, 1], TopAdditionMixin.where(parent_id: 5).order('pos').map(&:id)
 
       TopAdditionMixin.where(id: 1).first.move_to_top
-      assert_equal [1, 4, 3, 2], TopAdditionMixin.where(parent_id: 5).order('pos').map(&:id)
+      assert_equal [1, 2, 3, 4], TopAdditionMixin.where(parent_id: 5).order('pos').map(&:id)
 
       TopAdditionMixin.where(id: 2).first.move_to_bottom
-      assert_equal [1, 4, 3, 2], TopAdditionMixin.where(parent_id: 5).order('pos').map(&:id)
+      assert_equal [1, 3, 4, 2], TopAdditionMixin.where(parent_id: 5).order('pos').map(&:id)
 
       TopAdditionMixin.where(id: 4).first.move_to_top
       assert_equal [4, 1, 3, 2], TopAdditionMixin.where(parent_id: 5).order('pos').map(&:id)
@@ -43,9 +48,14 @@ module Shared
       assert new.first?
       assert !new.last?
 
+      new = TopAdditionMixin.acts_as_list_no_update { TopAdditionMixin.create(parent_id: 20) }
+      assert_equal_or_nil $default_position, new.pos
+      assert_equal $default_position.is_a?(Integer), new.first?
+      assert !new.last?
+
       new = TopAdditionMixin.create(parent_id: 20)
       assert_equal 1, new.pos
-      assert new.first?
+      assert_equal $default_position.nil?, new.first?
       assert !new.last?
 
       new = TopAdditionMixin.create(parent_id: 0)
@@ -64,6 +74,9 @@ module Shared
       new = TopAdditionMixin.create(parent_id: 20)
       assert_equal 1, new.pos
 
+      new = TopAdditionMixin.acts_as_list_no_update { TopAdditionMixin.create(parent_id: 20) }
+      assert_equal_or_nil $default_position, new.pos
+
       new4 = TopAdditionMixin.create(parent_id: 20)
       assert_equal 1, new4.pos
 
@@ -71,16 +84,26 @@ module Shared
       assert_equal 3, new4.pos
     end
 
-    def test_delete_middle
-      assert_equal [4, 3, 2, 1], TopAdditionMixin.where(parent_id: 5).order('pos').map(&:id)
+    def test_supplied_position
+      new = TopAdditionMixin.create(parent_id: 20, pos: 3)
+      assert_equal 3, new.pos
+    end
 
+    def test_delete_middle
       TopAdditionMixin.where(id: 2).first.destroy
 
-      assert_equal [4, 3, 1], TopAdditionMixin.where(parent_id: 5).order('pos').map(&:id)
+      assert_equal [1, 3, 4], TopAdditionMixin.where(parent_id: 5).order('pos').map(&:id)
 
-      assert_equal 3, TopAdditionMixin.where(id: 1).first.pos
+      assert_equal 1, TopAdditionMixin.where(id: 1).first.pos
       assert_equal 2, TopAdditionMixin.where(id: 3).first.pos
-      assert_equal 1, TopAdditionMixin.where(id: 4).first.pos
+      assert_equal 3, TopAdditionMixin.where(id: 4).first.pos
+
+      TopAdditionMixin.acts_as_list_no_update { TopAdditionMixin.where(id: 3).first.destroy }
+
+      assert_equal [1, 4], TopAdditionMixin.where(parent_id: 5).order('pos').map(&:id)
+
+      assert_equal 1, TopAdditionMixin.where(id: 1).first.pos
+      assert_equal 3, TopAdditionMixin.where(id: 4).first.pos
     end
 
   end

data/test/shared_zero_based.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Shared
   module ZeroBased
     def setup
@@ -15,6 +17,11 @@ module Shared
       assert !new.first?
       assert new.last?
 
+      new = ZeroBasedMixin.acts_as_list_no_update { ZeroBasedMixin.create(parent_id: 20) }
+      assert_equal_or_nil $default_position, new.pos
+      assert !new.first?
+      assert !new.last?
+
       new = ZeroBasedMixin.create(parent_id: 20)
       assert_equal 2, new.pos
       assert !new.first?
@@ -63,6 +70,9 @@ module Shared
       new = ZeroBasedMixin.create(parent_id: 20)
       assert_equal 2, new.pos
 
+      new_noup = ZeroBasedMixin.acts_as_list_no_update { ZeroBasedMixin.create(parent_id: 20) }
+      assert_equal_or_nil $default_position, new_noup.pos
+
       new4 = ZeroBasedMixin.create(parent_id: 20)
       assert_equal 3, new4.pos
 
@@ -86,6 +96,9 @@ module Shared
 
       new4.reload
       assert_equal 4, new4.pos
+
+      new_noup.reload
+      assert_equal_or_nil $default_position, new_noup.pos
     end
   end
 end

data/test/test_default_scope_with_select.rb

@@ -0,0 +1,33 @@
+require 'helper'
+
+class Animal < ActiveRecord::Base
+  acts_as_list
+  default_scope -> { select(:name) }
+end
+
+class DefaultScopeWithSelectTest < Minitest::Test
+  def setup
+    ActiveRecord::Base.connection.create_table :animals do |t|
+      t.column :position, :integer
+      t.column :name, :string
+    end
+
+    ActiveRecord::Base.connection.schema_cache.clear!
+    Animal.reset_column_information
+    super
+  end
+
+  def teardown
+    teardown_db
+    super
+  end
+
+  def test_default_scope_with_select
+    animal1 = Animal.create name: 'Fox'
+    animal2 = Animal.create name: 'Panda'
+    animal3 = Animal.create name: 'Wildebeast'
+    assert_equal 1, animal1.position
+    assert_equal 2, animal2.position
+    assert_equal 3, animal3.position
+  end
+end

data/test/test_joined_list.rb

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