acts_as_list 0.7.4 → 0.8.2

data/test/shared_top_addition.rb

@@ -4,23 +4,26 @@ module Shared
       (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)
@@ -71,16 +74,19 @@ 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
     end
 
   end

data/test/test_joined_list.rb

@@ -0,0 +1,64 @@
+require 'helper'
+
+ActiveRecord::Base.establish_connection(adapter: "sqlite3", database: ":memory:")
+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
+    ActiveRecord::Base.connection.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,7 +1,10 @@
 # NOTE: following now done in helper.rb (better Readability)
 require 'helper'
 
-ActiveRecord::Base.establish_connection(adapter: "sqlite3", database: ":memory:")
+ActiveRecord::Base.establish_connection(
+  adapter: "sqlite3",
+  database: 'file:memdb1?mode=memory&cache=shared'
+)
 ActiveRecord::Schema.verbose = false
 
 def setup_db(position_options = {})
@@ -16,9 +19,14 @@ def setup_db(position_options = {})
     t.column :state, :integer
   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 +50,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
@@ -149,6 +163,18 @@ end
 class TheBaseSubclass < TheBaseClass
 end
 
+class DBConfigTest < Minitest::Test
+  def test_db_config
+    # make sure sqlite3 accepts multi threaded access
+    assert_equal "file:memdb1?mode=memory&cache=shared", ActiveRecord::Base.connection.pool.spec.config[:database]
+  end
+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 +210,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 +300,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
@@ -512,19 +578,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 +622,159 @@ 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
+
+class TouchTest < ActsAsListTestCase
+  def setup
+    setup_db
+    4.times { ListMixin.create! updated_at: yesterday }
+  end
+
+  def now
+    Time.now.utc
+  end
+
+  def yesterday
+    1.day.ago
+  end
+
+  def updated_ats
+    ListMixin.pluck(:updated_at)
+  end
+
+  def test_moving_item_lower_touches_self_and_lower_item
+    ListMixin.first.move_lower
+    updated_ats[0..1].each do |updated_at|
+      assert_in_delta updated_at, now, 1.second
+    end
+    updated_ats[2..3].each do |updated_at|
+      assert_in_delta updated_at, yesterday, 1.second
+    end
+  end
+
+  def test_moving_item_higher_touches_self_and_higher_item
+    ListMixin.all.second.move_higher
+    updated_ats[0..1].each do |updated_at|
+      assert_in_delta updated_at, now, 1.second
+    end
+    updated_ats[2..3].each do |updated_at|
+      assert_in_delta updated_at, yesterday, 1.second
+    end
+  end
+
+  def test_moving_item_to_bottom_touches_all_other_items
+    ListMixin.first.move_to_bottom
+    updated_ats.each do |updated_at|
+      assert_in_delta updated_at, now, 1.second
+    end
+  end
+
+  def test_moving_item_to_top_touches_all_other_items
+    ListMixin.last.move_to_top
+    updated_ats.each do |updated_at|
+      assert_in_delta updated_at, now, 1.second
+    end
+  end
+
+  def test_removing_item_touches_all_lower_items
+    ListMixin.all.third.remove_from_list
+    updated_ats[0..1].each do |updated_at|
+      assert_in_delta updated_at, yesterday, 1.second
+    end
+    updated_ats[2..2].each do |updated_at|
+      assert_in_delta updated_at, now, 1.second
+    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 [nil, 1, 2], DefaultScopedMixin.all.map(&:pos)
+    assert_equal [2, 3, 1], DefaultScopedMixin.all.map(&:id)
+
+    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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: acts_as_list
 version: !ruby/object:Gem::Version
-  version: 0.7.4
+  version: 0.8.2
 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: 2016-09-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,6 +62,7 @@ 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/list.rb
@@ -72,8 +73,10 @@ files:
 - 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 +88,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: []
@@ -107,6 +110,8 @@ test_files:
 - 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