mongoid_orderable 6.0.3 → 6.0.5

data/spec/integration/scoped_spec.rb

@@ -1,151 +0,0 @@
-require 'spec_helper'
-
-describe ScopedOrderable do
-
-  shared_examples_for 'scoped_orderable' do
-
-    def positions
-      ScopedOrderable.order_by([:group_id, :asc], [:position, :asc]).map(&:position)
-    end
-
-    before :each do
-      2.times { ScopedOrderable.create! group_id: 1 }
-      3.times { ScopedOrderable.create! group_id: 2 }
-    end
-
-    it 'should set proper position while creation' do
-      expect(positions).to eq([1, 2, 1, 2, 3])
-    end
-
-    describe 'removement' do
-      it 'top' do
-        ScopedOrderable.where(position: 1, group_id: 1).destroy
-        expect(positions).to eq([1, 1, 2, 3])
-      end
-
-      it 'bottom' do
-        ScopedOrderable.where(position: 3, group_id: 2).destroy
-        expect(positions).to eq([1, 2, 1, 2])
-      end
-
-      it 'middle' do
-        ScopedOrderable.where(position: 2, group_id: 2).destroy
-        expect(positions).to eq([1, 2, 1, 2])
-      end
-    end
-
-    describe 'inserting' do
-      it 'top' do
-        newbie = ScopedOrderable.create! move_to: :top, group_id: 1
-        expect(positions).to eq([1, 2, 3, 1, 2, 3])
-        expect(newbie.position).to eq(1)
-      end
-
-      it 'bottom' do
-        newbie = ScopedOrderable.create! move_to: :bottom, group_id: 2
-        expect(positions).to eq([1, 2, 1, 2, 3, 4])
-        expect(newbie.position).to eq(4)
-      end
-
-      it 'middle' do
-        newbie = ScopedOrderable.create! move_to: 2, group_id: 2
-        expect(positions).to eq([1, 2, 1, 2, 3, 4])
-        expect(newbie.position).to eq(2)
-      end
-
-      it 'middle (with a numeric string)' do
-        newbie = ScopedOrderable.create! move_to: '2', group_id: 2
-        expect(positions).to eq([1, 2, 1, 2, 3, 4])
-        expect(newbie.position).to eq(2)
-      end
-
-      it 'middle (with a non-numeric string)' do
-        expect do
-          ScopedOrderable.create! move_to: 'two', group_id: 2
-        end.to raise_error Mongoid::Orderable::Errors::InvalidTargetPosition
-      end
-    end
-
-    describe 'index' do
-      it 'is not on position alone' do
-        expect(ScopedOrderable.index_specifications.detect { |spec| spec.key == { position: 1 } }).to be_nil
-      end
-
-      it 'is on compound fields' do
-        expect(ScopedOrderable.index_specifications.detect { |spec| spec.key == { group_id: 1, position: 1 } }).to_not be_nil
-      end
-    end
-
-    describe 'scope movement' do
-      let(:record) { ScopedOrderable.where(group_id: 2, position: 2).first }
-
-      it 'to a new scope group' do
-        record.update_attributes group_id: 3
-        expect(positions).to eq([1, 2, 1, 2, 1])
-        expect(record.position).to eq(1)
-      end
-
-      context 'when moving to an existing scope group' do
-        it 'without a position' do
-          record.update_attributes group_id: 1
-          expect(positions).to eq([1, 2, 3, 1, 2])
-          expect(record.reload.position).to eq(3)
-        end
-
-        it 'with symbol position' do
-          record.update_attributes group_id: 1, move_to: :top
-          expect(positions).to eq([1, 2, 3, 1, 2])
-          expect(record.reload.position).to eq(1)
-        end
-
-        it 'with point position' do
-          record.update_attributes group_id: 1, move_to: 2
-          expect(positions).to eq([1, 2, 3, 1, 2])
-          expect(record.reload.position).to eq(2)
-        end
-
-        it 'with point position (with a numeric string)' do
-          record.update_attributes group_id: 1, move_to: '2'
-          expect(positions).to eq([1, 2, 3, 1, 2])
-          expect(record.reload.position).to eq(2)
-        end
-
-        it 'with point position (with a non-numeric string)' do
-          expect do
-            record.update_attributes group_id: 1, move_to: 'two'
-          end.to raise_error Mongoid::Orderable::Errors::InvalidTargetPosition
-        end
-      end
-    end
-
-    describe 'utility methods' do
-      it 'should return a collection of items lower/higher on the list for next_items/previous_items' do
-        record1 = ScopedOrderable.where(group_id: 1, position: 1).first
-        record2 = ScopedOrderable.where(group_id: 1, position: 2).first
-        record3 = ScopedOrderable.where(group_id: 2, position: 1).first
-        record4 = ScopedOrderable.where(group_id: 2, position: 2).first
-        record5 = ScopedOrderable.where(group_id: 2, position: 3).first
-        expect(record1.next_items.to_a).to eq([record2])
-        expect(record5.previous_items.to_a).to eq([record3, record4])
-        expect(record3.previous_items.to_a).to eq([])
-        expect(record3.next_items.to_a).to eq([record4, record5])
-        expect(record1.next_item).to eq(record2)
-        expect(record2.previous_item).to eq(record1)
-        expect(record1.previous_item).to eq(nil)
-        expect(record2.next_item).to eq(nil)
-      end
-    end
-  end
-
-  context 'with transactions' do
-    enable_transactions!
-
-    it_behaves_like 'scoped_orderable'
-  end
-
-  context 'without transactions' do
-    disable_transactions!
-
-    it_behaves_like 'scoped_orderable'
-  end
-end

data/spec/integration/simple_spec.rb

@@ -1,184 +0,0 @@
-require 'spec_helper'
-
-describe SimpleOrderable do
-
-  shared_examples_for 'simple_orderable' do
-
-    def positions
-      SimpleOrderable.pluck(:position).sort
-    end
-
-    before :each do
-      5.times { SimpleOrderable.create! }
-    end
-
-    it 'should have proper position field' do
-      expect(SimpleOrderable.fields.key?('position')).to be true
-      expect(SimpleOrderable.fields['position'].options[:type]).to eq(Integer)
-    end
-
-    it 'should have index on position field' do
-      expect(SimpleOrderable.index_specifications.detect { |spec| spec.key == { position: 1 } }).not_to be_nil
-    end
-
-    it 'should have a orderable base of 1' do
-      expect(SimpleOrderable.create!.orderable_top).to eq(1)
-    end
-
-    it 'should set proper position while creation' do
-      expect(positions).to eq([1, 2, 3, 4, 5])
-    end
-
-    describe 'removement' do
-      it 'top' do
-        SimpleOrderable.where(position: 1).destroy
-        expect(positions).to eq([1, 2, 3, 4])
-      end
-
-      it 'bottom' do
-        SimpleOrderable.where(position: 5).destroy
-        expect(positions).to eq([1, 2, 3, 4])
-      end
-
-      it 'middle' do
-        SimpleOrderable.where(position: 3).destroy
-        expect(positions).to eq([1, 2, 3, 4])
-      end
-    end
-
-    describe 'inserting' do
-      it 'top' do
-        newbie = SimpleOrderable.create! move_to: :top
-        expect(positions).to eq([1, 2, 3, 4, 5, 6])
-        expect(newbie.position).to eq(1)
-      end
-
-      it 'bottom' do
-        newbie = SimpleOrderable.create! move_to: :bottom
-        expect(positions).to eq([1, 2, 3, 4, 5, 6])
-        expect(newbie.position).to eq(6)
-      end
-
-      it 'middle' do
-        newbie = SimpleOrderable.create! move_to: 4
-        expect(positions).to eq([1, 2, 3, 4, 5, 6])
-        expect(newbie.position).to eq(4)
-      end
-
-      it 'middle (with a numeric string)' do
-        newbie = SimpleOrderable.create! move_to: '4'
-        expect(positions).to eq([1, 2, 3, 4, 5, 6])
-        expect(newbie.position).to eq(4)
-      end
-
-      it 'middle (with a non-numeric string)' do
-        expect do
-          SimpleOrderable.create! move_to: 'four'
-        end.to raise_error Mongoid::Orderable::Errors::InvalidTargetPosition
-      end
-
-      it 'simultaneous create and update' do
-        newbie = SimpleOrderable.new
-        newbie.send(:orderable_before_update) { }
-        expect(newbie.position).to eq(6)
-        another = SimpleOrderable.create!
-        expect(another.position).to eq(6)
-        newbie.save!
-        expect(positions).to eq([1, 2, 3, 4, 5, 6, 7])
-        expect(newbie.position).to eq(7)
-        expect(another.position).to eq(6)
-      end
-
-      it 'parallel updates' do
-        newbie = SimpleOrderable.new
-        newbie.send(:orderable_before_update) { }
-        another = SimpleOrderable.create!
-        newbie.save!
-        expect(positions).to eq([1, 2, 3, 4, 5, 6, 7])
-        expect(newbie.position).to eq(7)
-        expect(another.position).to eq(6)
-      end
-    end
-
-    describe 'movement' do
-      it 'higher from top' do
-        record = SimpleOrderable.where(position: 1).first
-        record.update_attributes move_to: :higher
-        expect(positions).to eq([1, 2, 3, 4, 5])
-        expect(record.reload.position).to eq(1)
-      end
-
-      it 'higher from bottom' do
-        record = SimpleOrderable.where(position: 5).first
-        record.update_attributes move_to: :higher
-        expect(positions).to eq([1, 2, 3, 4, 5])
-        expect(record.reload.position).to eq(4)
-      end
-
-      it 'higher from middle' do
-        record = SimpleOrderable.where(position: 3).first
-        record.update_attributes move_to: :higher
-        expect(positions).to eq([1, 2, 3, 4, 5])
-        expect(record.reload.position).to eq(2)
-      end
-
-      it 'lower from top' do
-        record = SimpleOrderable.where(position: 1).first
-        record.update_attributes move_to: :lower
-        expect(positions).to eq([1, 2, 3, 4, 5])
-        expect(record.reload.position).to eq(2)
-      end
-
-      it 'lower from bottom' do
-        record = SimpleOrderable.where(position: 5).first
-        record.update_attributes move_to: :lower
-        expect(positions).to eq([1, 2, 3, 4, 5])
-        expect(record.reload.position).to eq(5)
-      end
-
-      it 'lower from middle' do
-        record = SimpleOrderable.where(position: 3).first
-        record.update_attributes move_to: :lower
-        expect(positions).to eq([1, 2, 3, 4, 5])
-        expect(record.reload.position).to eq(4)
-      end
-
-      it 'does nothing if position not change' do
-        record = SimpleOrderable.where(position: 3).first
-        record.save
-        expect(positions).to eq([1, 2, 3, 4, 5])
-        expect(record.reload.position).to eq(3)
-      end
-    end
-
-    describe 'utility methods' do
-      it 'should return a collection of items lower/higher on the list for next_items/previous_items' do
-        record1 = SimpleOrderable.where(position: 1).first
-        record2 = SimpleOrderable.where(position: 2).first
-        record3 = SimpleOrderable.where(position: 3).first
-        record4 = SimpleOrderable.where(position: 4).first
-        record5 = SimpleOrderable.where(position: 5).first
-        expect(record1.next_items.to_a).to eq([record2, record3, record4, record5])
-        expect(record5.previous_items.to_a).to eq([record1, record2, record3, record4])
-        expect(record3.previous_items.to_a).to eq([record1, record2])
-        expect(record3.next_items.to_a).to eq([record4, record5])
-        expect(record1.next_item).to eq(record2)
-        expect(record2.previous_item).to eq(record1)
-        expect(record1.previous_item).to eq(nil)
-        expect(record5.next_item).to eq(nil)
-      end
-    end
-  end
-
-  context 'with transactions' do
-    enable_transactions!
-
-    it_behaves_like 'simple_orderable'
-  end
-
-  context 'without transactions' do
-    disable_transactions!
-
-    it_behaves_like 'simple_orderable'
-  end
-end

data/spec/integration/string_scoped_spec.rb

@@ -1,28 +0,0 @@
-require 'spec_helper'
-
-describe StringScopedOrderable do
-
-  shared_examples_for 'string_scoped_orderable' do
-
-    it 'uses the foreign key of the relationship as scope' do
-      orderable1 = StringScopedOrderable.create!(some_scope: 1)
-      orderable2 = StringScopedOrderable.create!(some_scope: 1)
-      orderable3 = StringScopedOrderable.create!(some_scope: 2)
-      expect(orderable1.position).to eq 1
-      expect(orderable2.position).to eq 2
-      expect(orderable3.position).to eq 1
-    end
-  end
-
-  context 'with transactions' do
-    enable_transactions!
-
-    it_behaves_like 'string_scoped_orderable'
-  end
-
-  context 'without transactions' do
-    disable_transactions!
-
-    it_behaves_like 'string_scoped_orderable'
-  end
-end

data/spec/integration/zero_based_spec.rb

@@ -1,161 +0,0 @@
-require 'spec_helper'
-
-describe ZeroBasedOrderable do
-
-  shared_examples_for 'zero_based_orderable' do
-
-    before :each do
-      5.times { ZeroBasedOrderable.create! }
-    end
-
-    def positions
-      ZeroBasedOrderable.pluck(:position).sort
-    end
-
-    it 'should have a orderable base of 0' do
-      expect(ZeroBasedOrderable.create!.orderable_top).to eq(0)
-    end
-
-    it 'should set proper position while creation' do
-      expect(positions).to eq([0, 1, 2, 3, 4])
-    end
-
-    describe 'reset position' do
-      before { ZeroBasedOrderable.update_all(position: nil) }
-      it 'should properly reset position' do
-        ZeroBasedOrderable.all.map(&:save)
-        expect(positions).to eq([0, 1, 2, 3, 4])
-      end
-    end
-
-    describe 'removement' do
-      it 'top' do
-        ZeroBasedOrderable.where(position: 0).destroy
-        expect(positions).to eq([0, 1, 2, 3])
-      end
-
-      it 'bottom' do
-        ZeroBasedOrderable.where(position: 4).destroy
-        expect(positions).to eq([0, 1, 2, 3])
-      end
-
-      it 'middle' do
-        ZeroBasedOrderable.where(position: 2).destroy
-        expect(positions).to eq([0, 1, 2, 3])
-      end
-    end
-
-    describe 'inserting' do
-      it 'top' do
-        newbie = ZeroBasedOrderable.create! move_to: :top
-        expect(positions).to eq([0, 1, 2, 3, 4, 5])
-        expect(newbie.position).to eq(0)
-      end
-
-      it 'bottom' do
-        newbie = ZeroBasedOrderable.create! move_to: :bottom
-        expect(positions).to eq([0, 1, 2, 3, 4, 5])
-        expect(newbie.position).to eq(5)
-      end
-
-      it 'middle' do
-        newbie = ZeroBasedOrderable.create! move_to: 3
-        expect(positions).to eq([0, 1, 2, 3, 4, 5])
-        expect(newbie.position).to eq(3)
-      end
-
-      it 'middle (with a numeric string)' do
-        newbie = ZeroBasedOrderable.create! move_to: '3'
-        expect(positions).to eq([0, 1, 2, 3, 4, 5])
-        expect(newbie.position).to eq(3)
-      end
-
-      it 'middle (with a non-numeric string)' do
-        expect do
-          ZeroBasedOrderable.create! move_to: 'three'
-        end.to raise_error Mongoid::Orderable::Errors::InvalidTargetPosition
-      end
-    end
-
-    describe 'movement' do
-      it 'higher from top' do
-        record = ZeroBasedOrderable.where(position: 0).first
-        record.update_attributes move_to: :higher
-        expect(positions).to eq([0, 1, 2, 3, 4])
-        expect(record.reload.position).to eq(0)
-      end
-
-      it 'higher from bottom' do
-        record = ZeroBasedOrderable.where(position: 4).first
-        record.update_attributes move_to: :higher
-        expect(positions).to eq([0, 1, 2, 3, 4])
-        expect(record.reload.position).to eq(3)
-      end
-
-      it 'higher from middle' do
-        record = ZeroBasedOrderable.where(position: 3).first
-        record.update_attributes move_to: :higher
-        expect(positions).to eq([0, 1, 2, 3, 4])
-        expect(record.reload.position).to eq(2)
-      end
-
-      it 'lower from top' do
-        record = ZeroBasedOrderable.where(position: 0).first
-        record.update_attributes move_to: :lower
-        expect(positions).to eq([0, 1, 2, 3, 4])
-        expect(record.reload.position).to eq(1)
-      end
-
-      it 'lower from bottom' do
-        record = ZeroBasedOrderable.where(position: 4).first
-        record.update_attributes move_to: :lower
-        expect(positions).to eq([0, 1, 2, 3, 4])
-        expect(record.reload.position).to eq(4)
-      end
-
-      it 'lower from middle' do
-        record = ZeroBasedOrderable.where(position: 2).first
-        record.update_attributes move_to: :lower
-        expect(positions).to eq([0, 1, 2, 3, 4])
-        expect(record.reload.position).to eq(3)
-      end
-
-      it 'does nothing if position not change' do
-        record = ZeroBasedOrderable.where(position: 3).first
-        record.save
-        expect(positions).to eq([0, 1, 2, 3, 4])
-        expect(record.reload.position).to eq(3)
-      end
-    end
-
-    describe 'utility methods' do
-      it 'should return a collection of items lower/higher on the list for next_items/previous_items' do
-        record1 = ZeroBasedOrderable.where(position: 0).first
-        record2 = ZeroBasedOrderable.where(position: 1).first
-        record3 = ZeroBasedOrderable.where(position: 2).first
-        record4 = ZeroBasedOrderable.where(position: 3).first
-        record5 = ZeroBasedOrderable.where(position: 4).first
-        expect(record1.next_items.to_a).to eq([record2, record3, record4, record5])
-        expect(record5.previous_items.to_a).to eq([record1, record2, record3, record4])
-        expect(record3.previous_items.to_a).to eq([record1, record2])
-        expect(record3.next_items.to_a).to eq([record4, record5])
-        expect(record1.next_item).to eq(record2)
-        expect(record2.previous_item).to eq(record1)
-        expect(record1.previous_item).to eq(nil)
-        expect(record5.next_item).to eq(nil)
-      end
-    end
-  end
-
-  context 'with transactions' do
-    enable_transactions!
-
-    it_behaves_like 'zero_based_orderable'
-  end
-
-  context 'without transactions' do
-    disable_transactions!
-
-    it_behaves_like 'zero_based_orderable'
-  end
-end

data/spec/spec_helper.rb

@@ -1,42 +0,0 @@
-require 'bundler'
-Bundler.require
-require 'rspec'
-require 'rspec/retry'
-
-Mongoid.configure do |config|
-  config.connect_to 'mongoid_orderable_test'
-end
-
-Mongoid.logger.level = Logger::INFO
-Mongo::Logger.logger.level = Logger::INFO
-Mongoid::Config.belongs_to_required_by_default = false
-
-RSpec.configure do |config|
-  config.order = 'random'
-
-  config.before(:each) do
-    Mongoid.purge!
-    Mongoid.models.each do |model|
-      model.create_indexes if model.name =~ /Mongoid::Orderable::Models/
-    end
-  end
-end
-
-require_relative 'support/models'
-
-def set_transactions(enabled)
-  Mongoid.models.each do |model|
-    next unless model.respond_to?(:orderable_configs)
-    model.orderable_configs.values.each do |config|
-      config[:use_transactions] = enabled
-    end
-  end
-end
-
-def enable_transactions!
-  before { set_transactions(true) }
-end
-
-def disable_transactions!
-  before { set_transactions(false) }
-end

data/spec/support/models.rb

@@ -1,134 +0,0 @@
-
-
-Mongoid::Orderable.configure do |c|
-  c.use_transactions = true
-  c.transaction_max_retries = 100
-  c.lock_collection = :foo_bar_locks
-end
-
-class SimpleOrderable
-  include Mongoid::Document
-  include Mongoid::Orderable
-
-  orderable
-end
-
-class ConditionalOrderable
-  include Mongoid::Document
-  include Mongoid::Orderable
-
-  field :cond_a, type: Boolean
-  field :cond_b, type: Integer
-
-  orderable field: :pos_a, if: :cond_a, unless: ->(obj) { obj.cond_b&.<(2) }
-  orderable field: :pos_b, if: -> { cond_b&.<=(4) }
-  orderable field: :pos_c, unless: false
-end
-
-class ScopedGroup
-  include Mongoid::Document
-
-  has_many :scoped_orderables
-  has_many :multiple_fields_orderables
-end
-
-class ScopedOrderable
-  include Mongoid::Document
-  include Mongoid::Orderable
-
-  belongs_to :group, class_name: 'ScopedGroup', optional: true
-
-  orderable scope: :group
-end
-
-class StringScopedOrderable
-  include Mongoid::Document
-  include Mongoid::Orderable
-
-  field :some_scope, type: Integer
-
-  orderable scope: 'some_scope'
-end
-
-class EmbedsOrderable
-  include Mongoid::Document
-
-  embeds_many :embedded_orderables
-end
-
-class EmbeddedOrderable
-  include Mongoid::Document
-  include Mongoid::Orderable
-
-  embedded_in :embeds_orderable
-
-  orderable
-end
-
-class CustomizedOrderable
-  include Mongoid::Document
-  include Mongoid::Orderable
-
-  orderable field: :pos, as: :my_position
-end
-
-class NoIndexOrderable
-  include Mongoid::Document
-  include Mongoid::Orderable
-
-  orderable index: false
-end
-
-class ZeroBasedOrderable
-  include Mongoid::Document
-  include Mongoid::Orderable
-
-  orderable base: 0
-end
-
-class InheritedOrderable
-  include Mongoid::Document
-  include Mongoid::Orderable
-
-  orderable inherited: true
-end
-
-class Apple < InheritedOrderable
-  orderable field: :serial
-end
-
-class Orange < InheritedOrderable
-end
-
-class ForeignKeyDiffersOrderable
-  include Mongoid::Document
-  include Mongoid::Orderable
-
-  belongs_to :different_scope, class_name: 'ForeignKeyDiffersOrderable',
-             foreign_key: 'different_orderable_id',
-             optional: true
-
-  orderable scope: :different_scope
-end
-
-class MultipleFieldsOrderable
-  include Mongoid::Document
-  include Mongoid::Orderable
-
-  belongs_to :group, class_name: 'ScopedGroup', optional: true
-
-  orderable field: :pos, base: 0, index: false, as: :position
-  orderable field: :serial_no, default: true
-  orderable field: :groups, scope: :group
-end
-
-class MultipleScopedOrderable
-  include Mongoid::Document
-  include Mongoid::Orderable
-
-  belongs_to :apple, optional: true
-  belongs_to :orange, optional: true
-
-  orderable field: :posa, scope: :apple_id
-  orderable field: :poso, scope: :orange_id
-end