mongoid_orderable 4.1.0 → 4.1.1

data/lib/mongoid_orderable.rb

@@ -1,3 +1,7 @@
+require 'active_support'
+I18n.enforce_available_locales = false
+I18n.load_path << File.join(File.dirname(__FILE__), 'config', 'locales', 'en.yml')
+
 module MongoidOrderable
   def self.mongoid2?
     ::Mongoid.const_defined? :Contexts
@@ -35,3 +39,18 @@ else
 end
 
 require 'mongoid/orderable'
+require 'mongoid/orderable/errors'
+require 'mongoid/orderable/configuration'
+require 'mongoid/orderable/helpers'
+require 'mongoid/orderable/callbacks'
+require 'mongoid/orderable/listable'
+require 'mongoid/orderable/movable'
+
+require 'mongoid/orderable/generator/listable'
+require 'mongoid/orderable/generator/movable'
+require 'mongoid/orderable/generator/position'
+require 'mongoid/orderable/generator/scope'
+require 'mongoid/orderable/generator/helpers'
+require 'mongoid/orderable/generator'
+
+require 'mongoid/orderable/orderable_class'

data/lib/mongoid_orderable/version.rb

@@ -1,3 +1,3 @@
 module MongoidOrderable
-  VERSION = '4.1.0'
+  VERSION = '4.1.1'
 end

data/spec/mongoid/orderable_spec.rb

@@ -13,6 +13,7 @@ describe Mongoid::Orderable do
     include Mongoid::Document
 
     has_many :scoped_orderables
+    has_many :multiple_columns_orderables
   end
 
   class ScopedOrderable
@@ -93,6 +94,30 @@ describe Mongoid::Orderable do
     orderable :scope => :different_scope
   end
 
+  class MultipleColumnsOrderable
+    include Mongoid::Document
+    include Mongoid::Orderable
+
+    field :group_id
+
+    belongs_to :scoped_group
+
+    orderable :column => :pos, :base => 0, :index => false, :as => :position
+    orderable :column => :serial_no, :default => true
+    orderable :column => :groups, :scope => :group
+  end
+
+  class MultipleScopedOrderable
+    include Mongoid::Document
+    include Mongoid::Orderable
+
+    belongs_to :apple
+    belongs_to :orange
+
+    orderable :column => :posa, :scope => :apple_id
+    orderable :column => :poso, :scope => :orange_id
+  end
+
   describe SimpleOrderable do
 
     before :each do
@@ -107,43 +132,43 @@ describe Mongoid::Orderable do
     end
 
     it 'should have proper position column' do
-      SimpleOrderable.fields.key?('position').should be_true
-      SimpleOrderable.fields['position'].options[:type].should == Integer
+      expect(SimpleOrderable.fields.key?('position')).to be true
+      expect(SimpleOrderable.fields['position'].options[:type]).to eq(Integer)
     end
 
     it 'should have index on position column' do
       if MongoidOrderable.mongoid2?
-        SimpleOrderable.index_options[:position].should_not be_nil
+        expect(SimpleOrderable.index_options[[[:position, 1]]]).not_to be_nil
       elsif MongoidOrderable.mongoid3?
-        SimpleOrderable.index_options[{:position => 1}].should_not be_nil
+        expect(SimpleOrderable.index_options[{:position => 1}]).not_to be_nil
       else
-        SimpleOrderable.index_specifications.detect { |spec| spec.key == {:position => 1} }.should_not be_nil
+        expect(SimpleOrderable.index_specifications.detect { |spec| spec.key == {:position => 1} }).not_to be_nil
       end
     end
 
     it 'should have a orderable base of 1' do
-      SimpleOrderable.create!.orderable_base.should == 1
+      expect(SimpleOrderable.create!.orderable_base).to eq(1)
     end
 
     it 'should set proper position while creation' do
-      positions.should == [1, 2, 3, 4, 5]
+      expect(positions).to eq([1, 2, 3, 4, 5])
     end
 
     describe 'removement' do
 
       it 'top' do
         SimpleOrderable.where(:position => 1).destroy
-        positions.should == [1, 2, 3, 4]
+        expect(positions).to eq([1, 2, 3, 4])
       end
 
       it 'bottom' do
         SimpleOrderable.where(:position => 5).destroy
-        positions.should == [1, 2, 3, 4]
+        expect(positions).to eq([1, 2, 3, 4])
       end
 
       it 'middle' do
         SimpleOrderable.where(:position => 3).destroy
-        positions.should == [1, 2, 3, 4]
+        expect(positions).to eq([1, 2, 3, 4])
       end
     end
 
@@ -151,20 +176,32 @@ describe Mongoid::Orderable do
 
       it 'top' do
         newbie = SimpleOrderable.create! :move_to => :top
-        positions.should == [1, 2, 3, 4, 5, 6]
-        newbie.position.should == 1
+        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
-        positions.should == [1, 2, 3, 4, 5, 6]
-        newbie.position.should == 6
+        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
-        positions.should == [1, 2, 3, 4, 5, 6]
-        newbie.position.should == 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
     end
 
@@ -173,50 +210,50 @@ describe Mongoid::Orderable do
       it 'higher from top' do
         record = SimpleOrderable.where(:position => 1).first
         record.update_attributes :move_to => :higher
-        positions.should == [1, 2, 3, 4, 5]
-        record.reload.position.should == 1
+        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
-        positions.should == [1, 2, 3, 4, 5]
-        record.reload.position.should == 4
+        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
-        positions.should == [1, 2, 3, 4, 5]
-        record.reload.position.should == 2
+        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
-        positions.should == [1, 2, 3, 4, 5]
-        record.reload.position.should == 2
+        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
-        positions.should == [1, 2, 3, 4, 5]
-        record.reload.position.should == 5
+        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
-        positions.should == [1, 2, 3, 4, 5]
-        record.reload.position.should == 4
+        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
-        positions.should == [1, 2, 3, 4, 5]
-        record.reload.position.should == 3
+        expect(positions).to eq([1, 2, 3, 4, 5])
+        expect(record.reload.position).to eq(3)
       end
     end
 
@@ -253,24 +290,24 @@ describe Mongoid::Orderable do
     end
 
     it 'should set proper position while creation' do
-      positions.should == [1, 2, 1, 2, 3]
+      expect(positions).to eq([1, 2, 1, 2, 3])
     end
 
     describe 'removement' do
 
       it 'top' do
         ScopedOrderable.where(:position => 1, :group_id => 1).destroy
-        positions.should == [1, 1, 2, 3]
+        expect(positions).to eq([1, 1, 2, 3])
       end
 
       it 'bottom' do
         ScopedOrderable.where(:position => 3, :group_id => 2).destroy
-        positions.should == [1, 2, 1, 2]
+        expect(positions).to eq([1, 2, 1, 2])
       end
 
       it 'middle' do
         ScopedOrderable.where(:position => 2, :group_id => 2).destroy
-        positions.should == [1, 2, 1, 2]
+        expect(positions).to eq([1, 2, 1, 2])
       end
     end
 
@@ -278,20 +315,55 @@ describe Mongoid::Orderable do
 
       it 'top' do
         newbie = ScopedOrderable.create! :move_to => :top, :group_id => 1
-        positions.should == [1, 2, 3, 1, 2, 3]
-        newbie.position.should == 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
-        positions.should == [1, 2, 1, 2, 3, 4]
-        newbie.position.should == 4
+        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
-        positions.should == [1, 2, 1, 2, 3, 4]
-        newbie.position.should == 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
+        if MongoidOrderable.mongoid2?
+          expect(ScopedOrderable.index_options[[[:position, 1]]]).to be_nil
+        elsif MongoidOrderable.mongoid3?
+          expect(ScopedOrderable.index_options[{:position => 1}]).to be_nil
+        else
+          expect(ScopedOrderable.index_specifications.detect { |spec| spec.key == {:position => 1} }).to be_nil
+        end
+      end
+
+      it 'is on compound fields' do
+        if MongoidOrderable.mongoid2?
+          expect(ScopedOrderable.index_options[[[:group_id, 1], [:position, 1]]]).to_not be_nil
+        elsif MongoidOrderable.mongoid3?
+          expect(ScopedOrderable.index_options[{:group_id => 1, :position => 1}]).to_not be_nil
+        else
+          expect(ScopedOrderable.index_specifications.detect { |spec| spec.key == {:group_id => 1, :position => 1} }).to_not be_nil
+        end
       end
     end
 
@@ -301,28 +373,40 @@ describe Mongoid::Orderable do
 
       it 'to a new scope group' do
         record.update_attributes :group_id => 3
-        positions.should == [1, 2, 1, 2, 1]
-        record.position.should == 1
+        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
-          positions.should == [1, 2, 3, 1, 2]
-          record.reload.position.should == 3
+          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
-          positions.should == [1, 2, 3, 1, 2]
-          record.reload.position.should == 1
+          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
-          positions.should == [1, 2, 3, 1, 2]
-          record.reload.position.should == 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
@@ -344,14 +428,26 @@ describe Mongoid::Orderable do
 
         it 'to a new scope group' do
           record.update_attributes :group_id => 3
-          positions.should == [1, 2, 1, 2, 1]
-          record.position.should == 1
+          expect(positions).to eq([1, 2, 1, 2, 1])
+          expect(record.position).to eq(1)
         end
 
         it 'to an existing scope group' do
           record.update_attributes :group_id => 1, :move_to => 2
-          positions.should == [1, 2, 3, 1, 2]
-          record.reload.position.should == 2
+          expect(positions).to eq([1, 2, 3, 1, 2])
+          expect(record.reload.position).to eq(2)
+        end
+
+        it 'to an existing scope group (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 'to an existing scope group (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
@@ -408,30 +504,30 @@ describe Mongoid::Orderable do
     end
 
     it 'sets proper position while creation' do
-      positions.should == [[1, 2], [1, 2, 3]]
+      expect(positions).to eq([[1, 2], [1, 2, 3]])
     end
 
     it 'moves an item returned by a query to position' do
       embedded_orderable_1 = EmbedsOrderable.first.embedded_orderables.where(:position => 1).first
       embedded_orderable_2 = EmbedsOrderable.first.embedded_orderables.where(:position => 2).first
       embedded_orderable_1.move_to! 2
-      embedded_orderable_2.reload.position.should == 1
+      expect(embedded_orderable_2.reload.position).to eq(1)
     end
   end
 
   describe CustomizedOrderable do
 
     it 'does not have default position field' do
-      CustomizedOrderable.fields.should_not have_key('position')
+      expect(CustomizedOrderable.fields).not_to have_key('position')
     end
 
     it 'should have custom pos field' do
-      CustomizedOrderable.fields.should have_key('pos')
+      expect(CustomizedOrderable.fields).to have_key('pos')
     end
 
     it 'should have an alias my_position which points to pos field on Mongoid 3+' do
       if CustomizedOrderable.respond_to?(:database_field_name)
-        CustomizedOrderable.database_field_name('my_position').should eq('pos')
+        expect(CustomizedOrderable.database_field_name('my_position')).to eq('pos')
       end
     end
   end
@@ -440,9 +536,9 @@ describe Mongoid::Orderable do
 
     it 'should not have index on position column' do
       if MongoidOrderable.mongoid2? || MongoidOrderable.mongoid3?
-        NoIndexOrderable.index_options[:position].should be_nil
+        expect(NoIndexOrderable.index_options[[[:position, 1]]]).to be_nil
       else
-        NoIndexOrderable.index_specifications.detect { |spec| spec.key == :position }.should be_nil
+        expect(NoIndexOrderable.index_specifications.detect { |spec| spec.key == :position }).to be_nil
       end
     end
   end
@@ -461,28 +557,36 @@ describe Mongoid::Orderable do
     end
 
     it 'should have a orderable base of 0' do
-      ZeroBasedOrderable.create!.orderable_base.should == 0
+      expect(ZeroBasedOrderable.create!.orderable_base).to eq(0)
     end
 
     it 'should set proper position while creation' do
-      positions.should == [0, 1, 2, 3, 4]
+      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
-        positions.should == [0, 1, 2, 3]
+        expect(positions).to eq([0, 1, 2, 3])
       end
 
       it 'bottom' do
         ZeroBasedOrderable.where(:position => 4).destroy
-        positions.should == [0, 1, 2, 3]
+        expect(positions).to eq([0, 1, 2, 3])
       end
 
       it 'middle' do
         ZeroBasedOrderable.where(:position => 2).destroy
-        positions.should == [0, 1, 2, 3]
+        expect(positions).to eq([0, 1, 2, 3])
       end
     end
 
@@ -490,20 +594,32 @@ describe Mongoid::Orderable do
 
       it 'top' do
         newbie = ZeroBasedOrderable.create! :move_to => :top
-        positions.should == [0, 1, 2, 3, 4, 5]
-        newbie.position.should == 0
+        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
-        positions.should == [0, 1, 2, 3, 4, 5]
-        newbie.position.should == 5
+        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
-        positions.should == [0, 1, 2, 3, 4, 5]
-        newbie.position.should == 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
 
@@ -512,50 +628,50 @@ describe Mongoid::Orderable do
       it 'higher from top' do
         record = ZeroBasedOrderable.where(:position => 0).first
         record.update_attributes :move_to => :higher
-        positions.should == [0, 1, 2, 3, 4]
-        record.reload.position.should == 0
+        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
-        positions.should == [0, 1, 2, 3, 4]
-        record.reload.position.should == 3
+        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
-        positions.should == [0, 1, 2, 3, 4]
-        record.reload.position.should == 2
+        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
-        positions.should == [0, 1, 2, 3, 4]
-        record.reload.position.should == 1
+        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
-        positions.should == [0, 1, 2, 3, 4]
-        record.reload.position.should == 4
+        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
-        positions.should == [0, 1, 2, 3, 4]
-        record.reload.position.should == 3
+        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
-        positions.should == [0, 1, 2, 3, 4]
-        record.reload.position.should == 3
+        expect(positions).to eq([0, 1, 2, 3, 4])
+        expect(record.reload.position).to eq(3)
       end
     end
 
@@ -585,8 +701,46 @@ describe Mongoid::Orderable do
     it 'should set proper position' do
       fruit1 = Apple.create
       fruit2 = Orange.create
-      fruit1.position.should == 1
-      fruit2.position.should == 2
+      expect(fruit1.position).to eq(1)
+      expect(fruit2.position).to eq(2)
+    end
+
+    describe 'movement' do
+      before :each do
+        Fruit.delete_all
+        5.times do
+          Apple.create!
+        end
+      end
+
+      it 'with symbol position' do
+        first_apple = Apple.first
+        top_pos = first_apple.position
+        bottom_pos = Apple.last.position
+        expect do
+          first_apple.move_to! :bottom
+        end.to change(first_apple, :position).from(top_pos).to bottom_pos
+      end
+
+      it 'with point position' do
+        first_apple = Apple.first
+        top_pos = first_apple.position
+        bottom_pos = Apple.last.position
+        expect do
+          first_apple.move_to! bottom_pos
+        end.to change(first_apple, :position).from(top_pos).to bottom_pos
+      end
+    end
+
+    describe 'add orderable configurations in inherited class' do
+      it 'does not affect the orderable configurations of parent class and sibling class' do
+        class Apple
+          orderable :column => :serial
+        end
+        expect(Fruit.orderable_configurations).not_to eq Apple.orderable_configurations
+        expect(Orange.orderable_configurations).not_to eq Apple.orderable_configurations
+        expect(Fruit.orderable_configurations).to eq Orange.orderable_configurations
+      end
     end
   end
 
@@ -606,4 +760,649 @@ describe Mongoid::Orderable do
       expect(orderable3.position).to eq 1
     end
   end
+
+  describe MultipleColumnsOrderable do
+
+    before :each do
+      MultipleColumnsOrderable.delete_all
+      5.times do
+        MultipleColumnsOrderable.create!
+      end
+    end
+
+    context 'default orderable' do
+      let(:serial_nos){ MultipleColumnsOrderable.all.map(&:serial_no).sort }
+
+      describe 'inserting' do
+        let(:newbie){ MultipleColumnsOrderable.create! }
+
+        before { @position = newbie.position }
+
+        it 'top' do
+          newbie.move_to! :top
+          expect(serial_nos).to eq([1, 2, 3, 4, 5, 6])
+          expect(newbie.serial_no).to eq(1)
+          expect(newbie.position).to eq(@position)
+        end
+
+        it 'bottom' do
+          newbie.move_to! :bottom
+          expect(serial_nos).to eq([1, 2, 3, 4, 5, 6])
+          expect(newbie.serial_no).to eq(6)
+          expect(newbie.position).to eq(@position)
+        end
+
+        it 'middle' do
+          newbie.move_to! 4
+          expect(serial_nos).to eq([1, 2, 3, 4, 5, 6])
+          expect(newbie.serial_no).to eq(4)
+          expect(newbie.position).to eq(@position)
+        end
+      end
+
+      describe 'movement' do
+        it 'higher from top' do
+          record = MultipleColumnsOrderable.where(:serial_no => 1).first
+          position = record.position
+          record.move_higher!
+          expect(serial_nos).to eq([1, 2, 3, 4, 5])
+          expect(record.serial_no).to eq(1)
+          expect(record.position).to eq(position)
+        end
+
+        it 'higher from bottom' do
+          record = MultipleColumnsOrderable.where(:serial_no => 5).first
+          position = record.position
+          record.move_higher!
+          expect(serial_nos).to eq([1, 2, 3, 4, 5])
+          expect(record.serial_no).to eq(4)
+          expect(record.position).to eq(position)
+        end
+        
+        it 'higher from middle' do
+          record = MultipleColumnsOrderable.where(:serial_no => 3).first
+          position = record.position
+          record.move_higher!
+          expect(serial_nos).to eq([1, 2, 3, 4, 5])
+          expect(record.serial_no).to eq(2)
+          expect(record.position).to eq(position)
+        end
+        
+        it 'lower from top' do
+          record = MultipleColumnsOrderable.where(:serial_no => 1).first
+          position = record.position
+          record.move_lower!
+          expect(serial_nos).to eq([1, 2, 3, 4, 5])
+          expect(record.serial_no).to eq(2)
+          expect(record.position).to eq(position)
+        end
+        
+        it 'lower from bottom' do
+          record = MultipleColumnsOrderable.where(:serial_no => 5).first
+          position = record.position
+          record.move_lower!
+          expect(serial_nos).to eq([1, 2, 3, 4, 5])
+          expect(record.serial_no).to eq(5)
+          expect(record.position).to eq(position)
+        end
+        
+        it 'lower from middle' do
+          record = MultipleColumnsOrderable.where(:serial_no => 3).first
+          position = record.position
+          record.move_lower!
+          expect(serial_nos).to eq([1, 2, 3, 4, 5])
+          expect(record.serial_no).to eq(4)
+          expect(record.position).to eq(position)
+        end
+      end
+
+      describe 'utility methods' do
+
+        before do
+          @record_1 = MultipleColumnsOrderable.where(:serial_no => 1).first
+          @record_2 = MultipleColumnsOrderable.where(:serial_no => 2).first
+          @record_3 = MultipleColumnsOrderable.where(:serial_no => 3).first
+          @record_4 = MultipleColumnsOrderable.where(:serial_no => 4).first
+          @record_5 = MultipleColumnsOrderable.where(:serial_no => 5).first
+        end
+
+        it "should return the lower/higher item on the list for next_item/previous_item" do
+          expect(@record_1.next_item).to eq(@record_2)
+          expect(@record_3.next_item).to eq(@record_4)
+          expect(@record_5.next_item).to eq(nil)
+          expect(@record_1.prev_item).to eq(nil)
+          expect(@record_3.prev_item).to eq(@record_2)
+          expect(@record_5.prev_item).to eq(@record_4)
+        end
+
+        it "should return a collection of items lower/higher on the list for next_items/previous_items" do
+          expect(@record_1.next_items.to_a).to eq([@record_2, @record_3, @record_4, @record_5])
+          expect(@record_3.next_items.to_a).to eq([@record_4, @record_5])
+          expect(@record_5.next_items.to_a).to eq([])
+          expect(@record_1.previous_items.to_a).to eq([])
+          expect(@record_3.previous_items.to_a).to eq([@record_1, @record_2])
+          expect(@record_5.previous_items.to_a).to eq([@record_1, @record_2, @record_3, @record_4])
+        end
+      end
+    end
+
+    context 'serial_no orderable' do
+
+      let(:serial_nos){ MultipleColumnsOrderable.all.map(&:serial_no).sort }
+
+      it 'should have proper serial_no column' do
+        expect(MultipleColumnsOrderable.fields.key?('serial_no')).to be true
+        expect(MultipleColumnsOrderable.fields['serial_no'].options[:type]).to eq(Integer)
+      end
+
+      it 'should have index on serial_no column' do
+        if MongoidOrderable.mongoid2?
+          expect(MultipleColumnsOrderable.index_options[[[:serial_no, 1]]]).not_to be_nil
+        elsif MongoidOrderable.mongoid3?
+          expect(MultipleColumnsOrderable.index_options[{:serial_no => 1}]).not_to be_nil
+        else
+          expect(MultipleColumnsOrderable.index_specifications.detect { |spec| spec.key == {:serial_no => 1} }).not_to be_nil
+        end
+      end
+
+      it 'should have a orderable base of 1' do
+        expect(MultipleColumnsOrderable.first.orderable_base(:serial_no)).to eq(1)
+      end
+
+      it 'should set proper position while creation' do
+        expect(serial_nos).to eq([1, 2, 3, 4, 5])
+      end
+
+      describe 'removement' do
+
+        it 'top' do
+          MultipleColumnsOrderable.where(:serial_no => 1).destroy
+          expect(serial_nos).to eq([1, 2, 3, 4])
+        end
+
+        it 'bottom' do
+          MultipleColumnsOrderable.where(:serial_no => 5).destroy
+          expect(serial_nos).to eq([1, 2, 3, 4])
+        end
+
+        it 'middle' do
+          MultipleColumnsOrderable.where(:serial_no => 3).destroy
+          expect(serial_nos).to eq([1, 2, 3, 4])
+        end
+      end
+
+      describe 'inserting' do
+        let(:newbie){ MultipleColumnsOrderable.create! }
+
+        before { @position = newbie.position }
+
+        it 'top' do
+          newbie.move_serial_no_to! :top
+          expect(serial_nos).to eq([1, 2, 3, 4, 5, 6])
+          expect(newbie.serial_no).to eq(1)
+          expect(newbie.position).to eq(@position)
+        end
+
+        it 'bottom' do
+          newbie.move_serial_no_to! :bottom
+          expect(serial_nos).to eq([1, 2, 3, 4, 5, 6])
+          expect(newbie.serial_no).to eq(6)
+          expect(newbie.position).to eq(@position)
+        end
+
+        it 'middle' do
+          newbie.move_serial_no_to! 4
+          expect(serial_nos).to eq([1, 2, 3, 4, 5, 6])
+          expect(newbie.serial_no).to eq(4)
+          expect(newbie.position).to eq(@position)
+        end
+      end
+
+      describe 'movement' do
+        it 'higher from top' do
+          record = MultipleColumnsOrderable.where(:serial_no => 1).first
+          position = record.position
+          record.move_serial_no_higher!
+          expect(serial_nos).to eq([1, 2, 3, 4, 5])
+          expect(record.serial_no).to eq(1)
+          expect(record.position).to eq(position)
+        end
+
+        it 'higher from bottom' do
+          record = MultipleColumnsOrderable.where(:serial_no => 5).first
+          position = record.position
+          record.move_serial_no_higher!
+          expect(serial_nos).to eq([1, 2, 3, 4, 5])
+          expect(record.serial_no).to eq(4)
+          expect(record.position).to eq(position)
+        end
+        
+        it 'higher from middle' do
+          record = MultipleColumnsOrderable.where(:serial_no => 3).first
+          position = record.position
+          record.move_serial_no_higher!
+          expect(serial_nos).to eq([1, 2, 3, 4, 5])
+          expect(record.serial_no).to eq(2)
+          expect(record.position).to eq(position)
+        end
+        
+        it 'lower from top' do
+          record = MultipleColumnsOrderable.where(:serial_no => 1).first
+          position = record.position
+          record.move_serial_no_lower!
+          expect(serial_nos).to eq([1, 2, 3, 4, 5])
+          expect(record.serial_no).to eq(2)
+          expect(record.position).to eq(position)
+        end
+        
+        it 'lower from bottom' do
+          record = MultipleColumnsOrderable.where(:serial_no => 5).first
+          position = record.position
+          record.move_serial_no_lower!
+          expect(serial_nos).to eq([1, 2, 3, 4, 5])
+          expect(record.serial_no).to eq(5)
+          expect(record.position).to eq(position)
+        end
+        
+        it 'lower from middle' do
+          record = MultipleColumnsOrderable.where(:serial_no => 3).first
+          position = record.position
+          record.move_serial_no_lower!
+          expect(serial_nos).to eq([1, 2, 3, 4, 5])
+          expect(record.serial_no).to eq(4)
+          expect(record.position).to eq(position)
+        end
+      end
+
+      describe 'utility methods' do
+
+        before do
+          @record_1 = MultipleColumnsOrderable.where(:serial_no => 1).first
+          @record_2 = MultipleColumnsOrderable.where(:serial_no => 2).first
+          @record_3 = MultipleColumnsOrderable.where(:serial_no => 3).first
+          @record_4 = MultipleColumnsOrderable.where(:serial_no => 4).first
+          @record_5 = MultipleColumnsOrderable.where(:serial_no => 5).first
+        end
+
+        it "should return the lower/higher item on the list for next_item/previous_item" do
+          expect(@record_1.next_serial_no_item).to eq(@record_2)
+          expect(@record_3.next_serial_no_item).to eq(@record_4)
+          expect(@record_5.next_serial_no_item).to eq(nil)
+          expect(@record_1.prev_serial_no_item).to eq(nil)
+          expect(@record_3.prev_serial_no_item).to eq(@record_2)
+          expect(@record_5.prev_serial_no_item).to eq(@record_4)
+        end
+
+        it "should return a collection of items lower/higher on the list for next_items/previous_items" do
+          expect(@record_1.next_serial_no_items.to_a).to eq([@record_2, @record_3, @record_4, @record_5])
+          expect(@record_3.next_serial_no_items.to_a).to eq([@record_4, @record_5])
+          expect(@record_5.next_serial_no_items.to_a).to eq([])
+          expect(@record_1.previous_serial_no_items.to_a).to eq([])
+          expect(@record_3.previous_serial_no_items.to_a).to eq([@record_1, @record_2])
+          expect(@record_5.previous_serial_no_items.to_a).to eq([@record_1, @record_2, @record_3, @record_4])
+        end
+      end
+
+    end
+
+    context 'position orderable' do
+
+      let(:positions){ MultipleColumnsOrderable.all.map(&:position).sort }
+
+      it 'should not have default position field' do
+        expect(MultipleColumnsOrderable.fields).not_to have_key('position')
+      end
+
+      it 'should have custom pos field' do
+        expect(MultipleColumnsOrderable.fields).to have_key('pos')
+        expect(MultipleColumnsOrderable.fields['pos'].options[:type]).to eq(Integer)
+      end
+
+      it 'should have index on position column' do
+        if MongoidOrderable.mongoid2?
+          expect(MultipleColumnsOrderable.index_options[[[:position, 1]]]).to be_nil
+        elsif MongoidOrderable.mongoid3?
+          expect(MultipleColumnsOrderable.index_options[{:position => 1}]).to be_nil
+        else
+          expect(MultipleColumnsOrderable.index_specifications.detect { |spec| spec.key == {:position => 1} }).to be_nil
+        end
+      end
+
+      it 'should have a orderable base of 0' do
+        expect(MultipleColumnsOrderable.first.orderable_base(:position)).to eq(0)
+      end
+
+      it 'should set proper position while creation' do
+        expect(positions).to eq([0, 1, 2, 3, 4])
+      end
+
+      describe 'removement' do
+
+        it 'top' do
+          MultipleColumnsOrderable.where(:pos => 1).destroy
+          expect(positions).to eq([0, 1, 2, 3])
+        end
+
+        it 'bottom' do
+          MultipleColumnsOrderable.where(:pos => 4).destroy
+          expect(positions).to eq([0, 1, 2, 3])
+        end
+
+        it 'middle' do
+          MultipleColumnsOrderable.where(:pos => 3).destroy
+          expect(positions).to eq([0, 1, 2, 3])
+        end
+      end
+
+      describe 'inserting' do
+        let(:newbie){ MultipleColumnsOrderable.create! }
+
+        before { @serial_no = newbie.serial_no }
+
+        it 'top' do
+          newbie.move_position_to! :top
+          expect(positions).to eq([0, 1, 2, 3, 4, 5])
+          expect(newbie.position).to eq(0)
+          expect(newbie.serial_no).to eq(@serial_no)
+        end
+
+        it 'bottom' do
+          newbie.move_position_to! :bottom
+          expect(positions).to eq([0, 1, 2, 3, 4, 5])
+          expect(newbie.position).to eq(5)
+          expect(newbie.serial_no).to eq(@serial_no)
+        end
+
+        it 'middle' do
+          newbie.move_position_to! 4
+          expect(positions).to eq([0, 1, 2, 3, 4, 5])
+          expect(newbie.position).to eq(4)
+          expect(newbie.serial_no).to eq(@serial_no)
+        end
+      end
+
+      describe 'movement' do
+        it 'higher from top' do
+          record = MultipleColumnsOrderable.where(:pos => 0).first
+          position = record.serial_no
+          record.move_position_higher!
+          expect(positions).to eq([0, 1, 2, 3, 4])
+          expect(record.position).to eq(0)
+          expect(record.serial_no).to eq(position)
+        end
+
+        it 'higher from bottom' do
+          record = MultipleColumnsOrderable.where(:pos => 4).first
+          position = record.serial_no
+          record.move_position_higher!
+          expect(positions).to eq([0, 1, 2, 3, 4])
+          expect(record.position).to eq(3)
+          expect(record.serial_no).to eq(position)
+        end
+        
+        it 'higher from middle' do
+          record = MultipleColumnsOrderable.where(:pos => 3).first
+          position = record.serial_no
+          record.move_position_higher!
+          expect(positions).to eq([0, 1, 2, 3, 4])
+          expect(record.position).to eq(2)
+          expect(record.serial_no).to eq(position)
+        end
+        
+        it 'lower from top' do
+          record = MultipleColumnsOrderable.where(:pos => 0).first
+          position = record.serial_no
+          record.move_position_lower!
+          expect(positions).to eq([0, 1, 2, 3, 4])
+          expect(record.position).to eq(1)
+          expect(record.serial_no).to eq(position)
+        end
+        
+        it 'lower from bottom' do
+          record = MultipleColumnsOrderable.where(:pos => 4).first
+          position = record.serial_no
+          record.move_position_lower!
+          expect(positions).to eq([0, 1, 2, 3, 4])
+          expect(record.position).to eq(4)
+          expect(record.serial_no).to eq(position)
+        end
+        
+        it 'lower from middle' do
+          record = MultipleColumnsOrderable.where(:pos => 3).first
+          position = record.serial_no
+          record.move_position_lower!
+          expect(positions).to eq([0, 1, 2, 3, 4])
+          expect(record.position).to eq(4)
+          expect(record.serial_no).to eq(position)
+        end
+      end
+
+      describe 'utility methods' do
+
+        before do
+          @record_1 = MultipleColumnsOrderable.where(:pos => 0).first
+          @record_2 = MultipleColumnsOrderable.where(:pos => 1).first
+          @record_3 = MultipleColumnsOrderable.where(:pos => 2).first
+          @record_4 = MultipleColumnsOrderable.where(:pos => 3).first
+          @record_5 = MultipleColumnsOrderable.where(:pos => 4).first
+        end
+
+        it "should return the lower/higher item on the list for next_item/previous_item" do
+          expect(@record_1.next_position_item).to eq(@record_2)
+          expect(@record_3.next_position_item).to eq(@record_4)
+          expect(@record_5.next_position_item).to eq(nil)
+          expect(@record_1.prev_position_item).to eq(nil)
+          expect(@record_3.prev_position_item).to eq(@record_2)
+          expect(@record_5.prev_position_item).to eq(@record_4)
+        end
+
+        it "should return a collection of items lower/higher on the list for next_items/previous_items" do
+          expect(@record_1.next_position_items.to_a).to eq([@record_2, @record_3, @record_4, @record_5])
+          expect(@record_3.next_position_items.to_a).to eq([@record_4, @record_5])
+          expect(@record_5.next_position_items.to_a).to eq([])
+          expect(@record_1.previous_position_items.to_a).to eq([])
+          expect(@record_3.previous_position_items.to_a).to eq([@record_1, @record_2])
+          expect(@record_5.previous_position_items.to_a).to eq([@record_1, @record_2, @record_3, @record_4])
+        end
+      end
+
+    end
+
+    context 'group_count orderable' do
+      before :each do
+        MultipleColumnsOrderable.delete_all
+        2.times { MultipleColumnsOrderable.create! :group_id => 1 }
+        3.times { MultipleColumnsOrderable.create! :group_id => 2 }
+      end
+
+      let(:all_groups){ MultipleColumnsOrderable.order_by([:group_id, :asc], [:groups, :asc]).map(&:groups) }
+
+      it 'should set proper position while creation' do
+        expect(all_groups).to eq([1, 2, 1, 2, 3])
+      end
+
+      describe 'removement' do
+
+        it 'top' do
+          MultipleColumnsOrderable.where(:groups => 1, :group_id => 1).destroy
+          expect(all_groups).to eq([1, 1, 2, 3])
+        end
+
+        it 'bottom' do
+          MultipleColumnsOrderable.where(:groups => 3, :group_id => 2).destroy
+          expect(all_groups).to eq([1, 2, 1, 2])
+        end
+
+        it 'middle' do
+          MultipleColumnsOrderable.where(:groups => 2, :group_id => 2).destroy
+          expect(all_groups).to eq([1, 2, 1, 2])
+        end
+      end
+
+      describe 'inserting' do
+
+        it 'top' do
+          newbie = MultipleColumnsOrderable.create! :group_id => 1
+          newbie.move_groups_to! :top
+          expect(all_groups).to eq([1, 2, 3, 1, 2, 3])
+          expect(newbie.groups).to eq(1)
+        end
+
+        it 'bottom' do
+          newbie = MultipleColumnsOrderable.create! :group_id => 2
+          newbie.move_groups_to! :bottom
+          expect(all_groups).to eq([1, 2, 1, 2, 3, 4])
+          expect(newbie.groups).to eq(4)
+        end
+
+        it 'middle' do
+          newbie = MultipleColumnsOrderable.create! :group_id => 2
+          newbie.move_groups_to! 2
+          expect(all_groups).to eq([1, 2, 1, 2, 3, 4])
+          expect(newbie.groups).to eq(2)
+        end
+      end
+
+      describe 'scope movement' do
+      
+        let(:record){ MultipleColumnsOrderable.where(:group_id => 2, :groups => 2).first }
+      
+        it 'to a new scope group' do
+          record.update_attributes :group_id => 3
+          expect(all_groups).to eq([1, 2, 1, 2, 1])
+          expect(record.groups).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(all_groups).to eq([1, 2, 3, 1, 2])
+            expect(record.reload.groups).to eq(3)
+          end
+      
+          it 'with symbol position' do
+            record.update_attributes :group_id => 1
+            record.move_groups_to! :top
+            expect(all_groups).to eq([1, 2, 3, 1, 2])
+            expect(record.reload.groups).to eq(1)
+          end
+      
+          it 'with point position' do
+            record.update_attributes :group_id => 1
+            record.move_groups_to! 2
+            expect(all_groups).to eq([1, 2, 3, 1, 2])
+            expect(record.reload.groups).to eq(2)
+          end
+        end
+      end
+
+      if defined?(Mongoid::IdentityMap)
+
+        context 'when identity map is enabled' do
+
+          let(:record){ MultipleColumnsOrderable.where(:group_id => 2, :groups => 2).first }
+
+          before do
+            Mongoid.identity_map_enabled = true
+            Mongoid::IdentityMap[MultipleColumnsOrderable.collection_name] = { record.id => record }
+          end
+
+          after { Mongoid.identity_map_enabled = false }
+
+          it 'to a new scope group' do
+            record.update_attributes :group_id => 3
+            expect(all_groups).to eq([1, 2, 1, 2, 1])
+            expect(record.groups).to eq(1)
+          end
+
+          it 'to an existing scope group' do
+            record.update_attributes :group_id => 1
+            record.move_groups_to! 2
+            expect(all_groups).to eq([1, 2, 3, 1, 2])
+            expect(record.groups).to eq(2)
+          end
+        end
+      end
+
+      describe 'utility methods' do
+
+        before do
+          @record_1 = MultipleColumnsOrderable.where(:group_id => 2, :groups => 1).first
+          @record_2 = MultipleColumnsOrderable.where(:group_id => 2, :groups => 2).first
+          @record_3 = MultipleColumnsOrderable.where(:group_id => 2, :groups => 3).first
+          @record_4 = MultipleColumnsOrderable.where(:group_id => 1, :groups => 1).first
+          @record_5 = MultipleColumnsOrderable.where(:group_id => 1, :groups => 2).first
+        end
+
+        it "should return the lower/higher item on the list for next_item/previous_item" do
+          expect(@record_1.next_groups_item).to eq(@record_2)
+          expect(@record_4.next_groups_item).to eq(@record_5)
+          expect(@record_3.next_groups_item).to eq(nil)
+          expect(@record_1.prev_groups_item).to eq(nil)
+          expect(@record_3.prev_groups_item).to eq(@record_2)
+          expect(@record_5.prev_groups_item).to eq(@record_4)
+        end
+
+        it "should return a collection of items lower/higher on the list for next_items/previous_items" do
+          expect(@record_1.next_groups_items.to_a).to eq([@record_2, @record_3])
+          expect(@record_3.next_groups_items.to_a).to eq([])
+          expect(@record_4.next_groups_items.to_a).to eq([@record_5])
+          expect(@record_1.previous_groups_items.to_a).to eq([])
+          expect(@record_3.previous_groups_items.to_a).to eq([@record_1, @record_2])
+          expect(@record_5.previous_groups_items.to_a).to eq([@record_4])
+        end
+      end
+    end
+  end
+
+  describe MultipleScopedOrderable do
+    before :each do
+      Apple.delete_all; Orange.delete_all;
+      MultipleScopedOrderable.delete_all
+
+      3.times do
+        Apple.create; Orange.create
+      end
+
+      MultipleScopedOrderable.create! :apple_id => 1, :orange_id => 1
+      MultipleScopedOrderable.create! :apple_id => 2, :orange_id => 1
+      MultipleScopedOrderable.create! :apple_id => 2, :orange_id => 2
+      MultipleScopedOrderable.create! :apple_id => 1, :orange_id => 3
+      MultipleScopedOrderable.create! :apple_id => 1, :orange_id => 1
+      MultipleScopedOrderable.create! :apple_id => 3, :orange_id => 3
+      MultipleScopedOrderable.create! :apple_id => 2, :orange_id => 3
+      MultipleScopedOrderable.create! :apple_id => 3, :orange_id => 2
+      MultipleScopedOrderable.create! :apple_id => 1, :orange_id => 3
+    end
+
+    def apple_positions
+      MultipleScopedOrderable.order_by([:apple_id, :asc], [:posa, :asc]).map(&:posa)
+    end
+
+    def orange_positions
+      MultipleScopedOrderable.order_by([:orange_id, :asc], [:poso, :asc]).map(&:poso)
+    end
+
+    describe 'default positions' do
+      it { expect(apple_positions).to eq([1, 2, 3, 4, 1, 2, 3, 1, 2]) }
+      it { expect(orange_positions).to eq([1, 2, 3, 1, 2, 1, 2, 3, 4]) }
+    end
+
+    describe 'change the scope of the apple' do
+      let(:record) { MultipleScopedOrderable.first }
+      before do
+        record.update_attribute(:apple_id, 2)
+      end
+
+      it 'should properly set the apple positions' do
+        expect(apple_positions).to eq([1, 2, 3, 1, 2, 3, 4, 1, 2])
+      end
+
+      it 'should not affect the orange positions' do
+        expect(orange_positions).to eq([1, 2, 3, 1, 2, 1, 2, 3, 4])
+      end
+    end
+  end
+
 end