acts_as_list 0.7.4 → 0.9.0

data/test/test_joined_list.rb

@@ -0,0 +1,70 @@
+require 'helper'
+
+db_config = YAML.load_file(File.expand_path("../database.yml", __FILE__)).fetch(ENV["DB"] || "sqlite")
+ActiveRecord::Base.establish_connection(db_config)
+ActiveRecord::Schema.verbose = false
+
+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
+    if ActiveRecord::VERSION::MAJOR >= 5
+      tables = ActiveRecord::Base.connection.data_sources
+    else
+      tables = ActiveRecord::Base.connection.tables
+    end
+    tables.each do |table|
+      ActiveRecord::Base.connection.drop_table(table)
+    end
+    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

data/test/test_list.rb

@@ -1,13 +1,19 @@
 # NOTE: following now done in helper.rb (better Readability)
 require 'helper'
 
-ActiveRecord::Base.establish_connection(adapter: "sqlite3", database: ":memory:")
+db_config = YAML.load_file(File.expand_path("../database.yml", __FILE__)).fetch(ENV["DB"] || "sqlite")
+ActiveRecord::Base.establish_connection(db_config)
 ActiveRecord::Schema.verbose = false
 
 def setup_db(position_options = {})
+  $default_position = position_options[:default]
+  
+  # sqlite cannot drop/rename/alter columns and add constraints after table creation
+  sqlite = ENV.fetch("DB", "sqlite") == "sqlite"
+
   # AR caches columns options like defaults etc. Clear them!
   ActiveRecord::Base.connection.create_table :mixins do |t|
-    t.column :pos, :integer, position_options
+    t.column :pos, :integer, position_options unless position_options[:positive] && sqlite
     t.column :active, :boolean, default: true
     t.column :parent_id, :integer
     t.column :parent_type, :string
@@ -16,9 +22,28 @@ def setup_db(position_options = {})
     t.column :state, :integer
   end
 
+  if position_options[:unique] && !(sqlite && position_options[:positive])
+    ActiveRecord::Base.connection.add_index :mixins, :pos, unique: true
+  end
+  
+  if position_options[:positive]
+    if sqlite
+      # SQLite cannot add constraint after table creation, also cannot add unique inside ADD COLUMN
+      ActiveRecord::Base.connection.execute('ALTER TABLE mixins ADD COLUMN pos integer8 NOT NULL CHECK (pos > 0) DEFAULT 1')
+      ActiveRecord::Base.connection.execute('CREATE UNIQUE INDEX index_mixins_on_pos ON mixins(pos)')
+    else
+      ActiveRecord::Base.connection.execute('ALTER TABLE mixins ADD CONSTRAINT pos_check CHECK (pos > 0)')
+    end
+  end
+
+  # This table is used to test table names and column names quoting
+  ActiveRecord::Base.connection.create_table 'table-name' do |t|
+    t.column :order, :integer
+  end
+
   mixins = [ Mixin, ListMixin, ListMixinSub1, ListMixinSub2, ListWithStringScopeMixin,
     ArrayScopeListMixin, ZeroBasedMixin, DefaultScopedMixin,
-    DefaultScopedWhereMixin, TopAdditionMixin, NoAdditionMixin ]
+    DefaultScopedWhereMixin, TopAdditionMixin, NoAdditionMixin, QuotedList ]
 
   mixins << EnumArrayScopeListMixin if rails_4
 
@@ -42,7 +67,13 @@ def rails_4
 end
 
 def teardown_db
-  ActiveRecord::Base.connection.tables.each do |table|
+  if ActiveRecord::VERSION::MAJOR >= 5
+    tables = ActiveRecord::Base.connection.data_sources
+  else
+    tables = ActiveRecord::Base.connection.tables
+  end
+
+  tables.each do |table|
     ActiveRecord::Base.connection.drop_table(table)
   end
 end
@@ -101,6 +132,14 @@ class DefaultScopedWhereMixin < Mixin
   end
 end
 
+class SequentialUpdatesDefault < Mixin
+  acts_as_list column: "pos"
+end
+
+class SequentialUpdatesFalseMixin < Mixin
+  acts_as_list column: "pos", sequential_updates: false
+end
+
 class TopAdditionMixin < Mixin
   acts_as_list column: "pos", add_new_at: :top, scope: :parent_id
 end
@@ -149,6 +188,11 @@ end
 class TheBaseSubclass < TheBaseClass
 end
 
+class QuotedList < ActiveRecord::Base
+  self.table_name = 'table-name'
+  acts_as_list column: :order
+end
+
 class ActsAsListTestCase < Minitest::Test
   # No default test required as this class is abstract.
   # Need for test/unit.
@@ -184,6 +228,37 @@ class ListTest < ActsAsListTestCase
     setup_db
     super
   end
+
+  def test_insert_race_condition
+    # the bigger n is the more likely we will have a race condition
+    n = 1000
+    (1..n).each do |counter|
+      node = ListMixin.new parent_id: 1
+      node.pos = counter
+      node.save!
+    end
+
+    wait_for_it  = true
+    threads = []
+    4.times do |i|
+      threads << Thread.new do
+        true while wait_for_it
+        ActiveRecord::Base.connection_pool.with_connection do |c|
+          n.times do
+            begin
+              ListMixin.where(parent_id: 1).order('pos').last.insert_at(1)
+            rescue Exception
+              # ignore SQLite3::SQLException due to table locking
+            end
+          end
+        end
+      end
+    end
+    wait_for_it = false
+    threads.each(&:join)
+
+    assert_equal((1..n).to_a, ListMixin.where(parent_id: 1).order('pos').map(&:pos))
+  end
 end
 
 class ListWithCallbackTest < ActsAsListTestCase
@@ -243,6 +318,15 @@ class ArrayScopeListTestWithDefault < ActsAsListTestCase
   end
 end
 
+class QuotingTestList < ActsAsListTestCase
+  include Shared::Quoting
+
+  def setup
+    setup_db_with_default
+    super
+  end
+end
+
 class DefaultScopedTest < ActsAsListTestCase
   def setup
     setup_db
@@ -260,6 +344,11 @@ class DefaultScopedTest < ActsAsListTestCase
     assert !new.first?
     assert new.last?
 
+    new = DefaultScopedMixin.acts_as_list_no_update { DefaultScopedMixin.create }
+    assert_equal_or_nil $default_position, new.pos
+    assert_equal $default_position.is_a?(Fixnum), new.first?
+    assert !new.last?
+
     new = DefaultScopedMixin.create
     assert_equal 7, new.pos
     assert !new.first?
@@ -295,6 +384,9 @@ class DefaultScopedTest < ActsAsListTestCase
     new = DefaultScopedMixin.create
     assert_equal 6, new.pos
 
+    new_noup = DefaultScopedMixin.acts_as_list_no_update { DefaultScopedMixin.create }
+    assert_equal_or_nil $default_position, new_noup.pos
+
     new = DefaultScopedMixin.create
     assert_equal 7, new.pos
 
@@ -321,6 +413,9 @@ class DefaultScopedTest < ActsAsListTestCase
 
     new4.reload
     assert_equal 4, new4.pos
+
+    new_noup.reload
+    assert_equal_or_nil $default_position, new_noup.pos
   end
 
   def test_update_position
@@ -353,6 +448,11 @@ class DefaultScopedWhereTest < ActsAsListTestCase
     assert !new.first?
     assert new.last?
 
+    new = DefaultScopedWhereMixin.acts_as_list_no_update { DefaultScopedWhereMixin.create }
+    assert_equal_or_nil $default_position, new.pos
+    assert_equal $default_position.is_a?(Fixnum), new.first?
+    assert !new.last?
+
     new = DefaultScopedWhereMixin.create
     assert_equal 7, new.pos
     assert !new.first?
@@ -391,6 +491,9 @@ class DefaultScopedWhereTest < ActsAsListTestCase
     new = DefaultScopedWhereMixin.create
     assert_equal 7, new.pos
 
+    new_noup = DefaultScopedWhereMixin.acts_as_list_no_update { DefaultScopedWhereMixin.create }
+    assert_equal_or_nil $default_position, new_noup.pos
+
     new4 = DefaultScopedWhereMixin.create
     assert_equal 8, new4.pos
 
@@ -414,6 +517,9 @@ class DefaultScopedWhereTest < ActsAsListTestCase
 
     new4.reload
     assert_equal 4, new4.pos
+
+    new_noup.reload
+    assert_equal_or_nil $default_position, new_noup.pos
   end
 
   def test_update_position
@@ -468,10 +574,20 @@ class MultiDestroyTest < ActsAsListTestCase
     new3 = DefaultScopedMixin.create
     assert_equal 3, new3.pos
 
+    new4 = DefaultScopedMixin.create
+    assert_equal 4, new4.pos
+
     new1.destroy
     new2.destroy
     new3.reload
+    new4.reload
     assert_equal 1, new3.pos
+    assert_equal 2, new4.pos
+
+    DefaultScopedMixin.acts_as_list_no_update { new3.destroy }
+
+    new4.reload
+    assert_equal 2, new4.pos
   end
 end
 
@@ -512,19 +628,19 @@ class MultipleListsTest < ActsAsListTestCase
   end
 
   def test_check_scope_order
-    assert_equal [1, 2, 3, 4], ListMixin.where(:parent_id => 1).order(:pos).map(&:id)
-    assert_equal [5, 6, 7, 8], ListMixin.where(:parent_id => 2).order(:pos).map(&:id)
+    assert_equal [1, 2, 3, 4], ListMixin.where(:parent_id => 1).order('pos').map(&:id)
+    assert_equal [5, 6, 7, 8], ListMixin.where(:parent_id => 2).order('pos').map(&:id)
     ListMixin.find(4).update_attributes(:parent_id => 2, :pos => 2)
-    assert_equal [1, 2, 3], ListMixin.where(:parent_id => 1).order(:pos).map(&:id)
-    assert_equal [5, 4, 6, 7, 8], ListMixin.where(:parent_id => 2).order(:pos).map(&:id)
+    assert_equal [1, 2, 3], ListMixin.where(:parent_id => 1).order('pos').map(&:id)
+    assert_equal [5, 4, 6, 7, 8], ListMixin.where(:parent_id => 2).order('pos').map(&:id)
   end
 
   def test_check_scope_position
     assert_equal [1, 2, 3, 4], ListMixin.where(:parent_id => 1).map(&:pos)
     assert_equal [1, 2, 3, 4], ListMixin.where(:parent_id => 2).map(&:pos)
     ListMixin.find(4).update_attributes(:parent_id => 2, :pos => 2)
-    assert_equal [1, 2, 3], ListMixin.where(:parent_id => 1).order(:pos).map(&:pos)
-    assert_equal [1, 2, 3, 4, 5], ListMixin.where(:parent_id => 2).order(:pos).map(&:pos)
+    assert_equal [1, 2, 3], ListMixin.where(:parent_id => 1).order('pos').map(&:pos)
+    assert_equal [1, 2, 3, 4, 5], ListMixin.where(:parent_id => 2).order('pos').map(&:pos)
   end
 end
 
@@ -556,50 +672,213 @@ class MultipleListsArrayScopeTest < ActsAsListTestCase
   end
 
   def test_order_after_all_scope_properties_are_changed
-    assert_equal [1, 2, 3, 4], ArrayScopeListMixin.where(:parent_id => 1, :parent_type => 'anything').order(:pos).map(&:id)
-    assert_equal [5, 6, 7, 8], ArrayScopeListMixin.where(:parent_id => 2, :parent_type => 'something').order(:pos).map(&:id)
+    assert_equal [1, 2, 3, 4], ArrayScopeListMixin.where(:parent_id => 1, :parent_type => 'anything').order('pos').map(&:id)
+    assert_equal [5, 6, 7, 8], ArrayScopeListMixin.where(:parent_id => 2, :parent_type => 'something').order('pos').map(&:id)
     ArrayScopeListMixin.find(2).update_attributes(:parent_id => 2, :pos => 2,:parent_type => 'something')
-    assert_equal [1, 3, 4], ArrayScopeListMixin.where(:parent_id => 1,:parent_type => 'anything').order(:pos).map(&:id)
-    assert_equal [5, 2, 6, 7, 8], ArrayScopeListMixin.where(:parent_id => 2,:parent_type => 'something').order(:pos).map(&:id)
+    assert_equal [1, 3, 4], ArrayScopeListMixin.where(:parent_id => 1,:parent_type => 'anything').order('pos').map(&:id)
+    assert_equal [5, 2, 6, 7, 8], ArrayScopeListMixin.where(:parent_id => 2,:parent_type => 'something').order('pos').map(&:id)
   end
 
   def test_position_after_all_scope_properties_are_changed
     assert_equal [1, 2, 3, 4], ArrayScopeListMixin.where(:parent_id => 1, :parent_type => 'anything').map(&:pos)
     assert_equal [1, 2, 3, 4], ArrayScopeListMixin.where(:parent_id => 2, :parent_type => 'something').map(&:pos)
     ArrayScopeListMixin.find(4).update_attributes(:parent_id => 2, :pos => 2, :parent_type => 'something')
-    assert_equal [1, 2, 3], ArrayScopeListMixin.where(:parent_id => 1, :parent_type => 'anything').order(:pos).map(&:pos)
-    assert_equal [1, 2, 3, 4, 5], ArrayScopeListMixin.where(:parent_id => 2, :parent_type => 'something').order(:pos).map(&:pos)
+    assert_equal [1, 2, 3], ArrayScopeListMixin.where(:parent_id => 1, :parent_type => 'anything').order('pos').map(&:pos)
+    assert_equal [1, 2, 3, 4, 5], ArrayScopeListMixin.where(:parent_id => 2, :parent_type => 'something').order('pos').map(&:pos)
   end
 
   def test_order_after_one_scope_property_is_changed
-    assert_equal [1, 2, 3, 4], ArrayScopeListMixin.where(:parent_id => 1, :parent_type => 'anything').order(:pos).map(&:id)
-    assert_equal [9, 10, 11, 12], ArrayScopeListMixin.where(:parent_id => 3, :parent_type => 'anything').order(:pos).map(&:id)
+    assert_equal [1, 2, 3, 4], ArrayScopeListMixin.where(:parent_id => 1, :parent_type => 'anything').order('pos').map(&:id)
+    assert_equal [9, 10, 11, 12], ArrayScopeListMixin.where(:parent_id => 3, :parent_type => 'anything').order('pos').map(&:id)
     ArrayScopeListMixin.find(2).update_attributes(:parent_id => 3, :pos => 2)
-    assert_equal [1, 3, 4], ArrayScopeListMixin.where(:parent_id => 1,:parent_type => 'anything').order(:pos).map(&:id)
-    assert_equal [9, 2, 10, 11, 12], ArrayScopeListMixin.where(:parent_id => 3,:parent_type => 'anything').order(:pos).map(&:id)
+    assert_equal [1, 3, 4], ArrayScopeListMixin.where(:parent_id => 1,:parent_type => 'anything').order('pos').map(&:id)
+    assert_equal [9, 2, 10, 11, 12], ArrayScopeListMixin.where(:parent_id => 3,:parent_type => 'anything').order('pos').map(&:id)
   end
 
   def test_position_after_one_scope_property_is_changed
     assert_equal [1, 2, 3, 4], ArrayScopeListMixin.where(:parent_id => 1, :parent_type => 'anything').map(&:pos)
     assert_equal [1, 2, 3, 4], ArrayScopeListMixin.where(:parent_id => 3, :parent_type => 'anything').map(&:pos)
     ArrayScopeListMixin.find(4).update_attributes(:parent_id => 3, :pos => 2)
-    assert_equal [1, 2, 3], ArrayScopeListMixin.where(:parent_id => 1, :parent_type => 'anything').order(:pos).map(&:pos)
-    assert_equal [1, 2, 3, 4, 5], ArrayScopeListMixin.where(:parent_id => 3, :parent_type => 'anything').order(:pos).map(&:pos)
+    assert_equal [1, 2, 3], ArrayScopeListMixin.where(:parent_id => 1, :parent_type => 'anything').order('pos').map(&:pos)
+    assert_equal [1, 2, 3, 4, 5], ArrayScopeListMixin.where(:parent_id => 3, :parent_type => 'anything').order('pos').map(&:pos)
   end
 
   def test_order_after_moving_to_empty_list
-    assert_equal [1, 2, 3, 4], ArrayScopeListMixin.where(:parent_id => 1, :parent_type => 'anything').order(:pos).map(&:id)
-    assert_equal [], ArrayScopeListMixin.where(:parent_id => 4, :parent_type => 'anything').order(:pos).map(&:id)
+    assert_equal [1, 2, 3, 4], ArrayScopeListMixin.where(:parent_id => 1, :parent_type => 'anything').order('pos').map(&:id)
+    assert_equal [], ArrayScopeListMixin.where(:parent_id => 4, :parent_type => 'anything').order('pos').map(&:id)
     ArrayScopeListMixin.find(2).update_attributes(:parent_id => 4, :pos => 1)
-    assert_equal [1, 3, 4], ArrayScopeListMixin.where(:parent_id => 1,:parent_type => 'anything').order(:pos).map(&:id)
-    assert_equal [2], ArrayScopeListMixin.where(:parent_id => 4,:parent_type => 'anything').order(:pos).map(&:id)
+    assert_equal [1, 3, 4], ArrayScopeListMixin.where(:parent_id => 1,:parent_type => 'anything').order('pos').map(&:id)
+    assert_equal [2], ArrayScopeListMixin.where(:parent_id => 4,:parent_type => 'anything').order('pos').map(&:id)
   end
 
   def test_position_after_moving_to_empty_list
     assert_equal [1, 2, 3, 4], ArrayScopeListMixin.where(:parent_id => 1, :parent_type => 'anything').map(&:pos)
     assert_equal [], ArrayScopeListMixin.where(:parent_id => 4, :parent_type => 'anything').map(&:pos)
     ArrayScopeListMixin.find(2).update_attributes(:parent_id => 4, :pos => 1)
-    assert_equal [1, 2, 3], ArrayScopeListMixin.where(:parent_id => 1, :parent_type => 'anything').order(:pos).map(&:pos)
-    assert_equal [1], ArrayScopeListMixin.where(:parent_id => 4, :parent_type => 'anything').order(:pos).map(&:pos)
+    assert_equal [1, 2, 3], ArrayScopeListMixin.where(:parent_id => 1, :parent_type => 'anything').order('pos').map(&:pos)
+    assert_equal [1], ArrayScopeListMixin.where(:parent_id => 4, :parent_type => 'anything').order('pos').map(&:pos)
+  end
+end
+
+require 'timecop'
+
+class TouchTest < ActsAsListTestCase
+  def setup
+    setup_db
+    Timecop.freeze(yesterday) do
+      4.times { ListMixin.create! }
+    end
+  end
+
+  def now
+    @now ||= Time.current
+  end
+
+  def yesterday
+    @yesterday ||= 1.day.ago
+  end
+
+  def updated_ats
+    ListMixin.order(:id).pluck(:updated_at)
+  end
+
+  def test_moving_item_lower_touches_self_and_lower_item
+    Timecop.freeze(now) do
+      ListMixin.first.move_lower
+      updated_ats[0..1].each do |updated_at|
+        assert_equal updated_at.to_i, now.to_i
+      end
+      updated_ats[2..3].each do |updated_at|
+        assert_equal updated_at.to_i, yesterday.to_i
+      end
+    end
+  end
+
+  def test_moving_item_higher_touches_self_and_higher_item
+    Timecop.freeze(now) do
+      ListMixin.all.second.move_higher
+      updated_ats[0..1].each do |updated_at|
+        assert_equal updated_at.to_i, now.to_i
+      end
+      updated_ats[2..3].each do |updated_at|
+        assert_equal updated_at.to_i, yesterday.to_i
+      end
+    end
+  end
+
+  def test_moving_item_to_bottom_touches_all_other_items
+    Timecop.freeze(now) do
+      ListMixin.first.move_to_bottom
+      updated_ats.each do |updated_at|
+        assert_equal updated_at.to_i, now.to_i
+      end
+    end
+  end
+
+  def test_moving_item_to_top_touches_all_other_items
+    Timecop.freeze(now) do
+      ListMixin.last.move_to_top
+      updated_ats.each do |updated_at|
+        assert_equal updated_at.to_i, now.to_i
+      end
+    end
+  end
+
+  def test_removing_item_touches_all_lower_items
+    Timecop.freeze(now) do
+      ListMixin.all.third.remove_from_list
+      updated_ats[0..1].each do |updated_at|
+        assert_equal updated_at.to_i, yesterday.to_i
+      end
+      updated_ats[2..2].each do |updated_at|
+        assert_equal updated_at.to_i, now.to_i
+      end
+    end
+  end
+end
+
+class ActsAsListTopTest < ActsAsListTestCase
+  def setup
+    setup_db
+  end
+
+  def test_acts_as_list_top
+    assert_equal 1, TheBaseSubclass.new.acts_as_list_top
+    assert_equal 0, ZeroBasedMixin.new.acts_as_list_top
+  end
+
+  def test_class_acts_as_list_top
+    assert_equal 1, TheBaseSubclass.acts_as_list_top
+    assert_equal 0, ZeroBasedMixin.acts_as_list_top
+  end
+end
+
+class NilPositionTest < ActsAsListTestCase
+  def setup
+    setup_db
+  end
+
+  def test_nil_position_ordering
+    new1 = DefaultScopedMixin.create pos: nil
+    new2 = DefaultScopedMixin.create pos: nil
+    new3 = DefaultScopedMixin.create pos: nil
+    DefaultScopedMixin.update_all(pos: nil)
+
+    assert_equal [nil, nil, nil], DefaultScopedMixin.all.map(&:pos)
+
+    new1.reload.pos = 1
+    new1.save
+
+    new3.reload.pos = 1
+    new3.save
+
+    assert_equal [1, 2], DefaultScopedMixin.where("pos IS NOT NULL").map(&:pos)
+    assert_equal [3, 1], DefaultScopedMixin.where("pos IS NOT NULL").map(&:id)
+    assert_nil new2.reload.pos
+
+    new2.reload.pos = 1
+    new2.save
+
+    assert_equal [1, 2, 3], DefaultScopedMixin.all.map(&:pos)
+    assert_equal [2, 3, 1], DefaultScopedMixin.all.map(&:id)
+  end
+end
+
+class SequentialUpdatesOptionDefaultTest < ActsAsListTestCase
+  def setup
+    setup_db
+  end
+
+  def test_sequential_updates_default_to_false_without_unique_index
+    assert_equal false, SequentialUpdatesDefault.new.send(:sequential_updates?)
+  end
+end
+
+class SequentialUpdatesMixinNotNullUniquePositiveConstraintsTest < ActsAsListTestCase
+  def setup
+    setup_db null: false, unique: true, positive: true
+    (1..4).each { |counter| SequentialUpdatesDefault.create!({pos: counter}) }
+  end
+
+  def test_sequential_updates_default_to_true_with_unique_index
+    assert_equal true, SequentialUpdatesDefault.new.send(:sequential_updates?)
+  end
+
+  def test_sequential_updates_option_override_with_false
+    assert_equal false, SequentialUpdatesFalseMixin.new.send(:sequential_updates?)
+  end
+
+  def test_insert_at
+    new = SequentialUpdatesDefault.create
+    assert_equal 5, new.pos
+
+    new.insert_at(1)
+    assert_equal 1, new.pos
+
+    new.insert_at(5)
+    assert_equal 5, new.pos
+
+    new.insert_at(3)
+    assert_equal 3, new.pos
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: acts_as_list
 version: !ruby/object:Gem::Version
-  version: 0.7.4
+  version: 0.9.0
 platform: ruby
 authors:
 - David Heinemeier Hansson
@@ -10,34 +10,34 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-04-15 00:00:00.000000000 Z
+date: 2017-01-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '3.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '3.0'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: 1.0.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: 1.0.0
 description: This "acts_as" extension provides the capabilities for sorting and reordering
@@ -49,9 +49,9 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- .gemtest
-- .gitignore
-- .travis.yml
+- ".gemtest"
+- ".gitignore"
+- ".travis.yml"
 - Appraisals
 - CHANGELOG.md
 - Gemfile
@@ -62,18 +62,30 @@ files:
 - gemfiles/rails_3_2.gemfile
 - gemfiles/rails_4_1.gemfile
 - gemfiles/rails_4_2.gemfile
+- gemfiles/rails_5_0.gemfile
 - init.rb
 - lib/acts_as_list.rb
+- lib/acts_as_list/active_record/acts/add_new_at_method_definer.rb
+- lib/acts_as_list/active_record/acts/aux_method_definer.rb
+- lib/acts_as_list/active_record/acts/callback_definer.rb
+- lib/acts_as_list/active_record/acts/column_method_definer.rb
 - lib/acts_as_list/active_record/acts/list.rb
+- lib/acts_as_list/active_record/acts/no_update.rb
+- lib/acts_as_list/active_record/acts/scope_method_definer.rb
+- lib/acts_as_list/active_record/acts/sequential_updates_method_definer.rb
+- lib/acts_as_list/active_record/acts/top_of_list_method_definer.rb
 - lib/acts_as_list/version.rb
+- test/database.yml
 - test/helper.rb
 - test/shared.rb
 - test/shared_array_scope_list.rb
 - test/shared_list.rb
 - test/shared_list_sub.rb
 - test/shared_no_addition.rb
+- test/shared_quoting.rb
 - test/shared_top_addition.rb
 - test/shared_zero_based.rb
+- test/test_joined_list.rb
 - test/test_list.rb
 homepage: http://github.com/swanandp/acts_as_list
 licenses:
@@ -85,12 +97,12 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: 1.9.2
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
@@ -101,12 +113,15 @@ specification_version: 4
 summary: A gem adding sorting, reordering capabilities to an active_record model,
   allowing it to act as a list
 test_files:
+- test/database.yml
 - test/helper.rb
 - test/shared.rb
 - test/shared_array_scope_list.rb
 - test/shared_list.rb
 - test/shared_list_sub.rb
 - test/shared_no_addition.rb
+- test/shared_quoting.rb
 - test/shared_top_addition.rb
 - test/shared_zero_based.rb
+- test/test_joined_list.rb
 - test/test_list.rb