mongoid_orderable 5.0.0 → 5.1.0

data/spec/mongoid/orderable_spec.rb

@@ -1,7 +1,6 @@
 require 'spec_helper'
 
 describe Mongoid::Orderable do
-
   class SimpleOrderable
     include Mongoid::Document
     include Mongoid::Orderable
@@ -23,16 +22,16 @@ describe Mongoid::Orderable do
     field :group_id
     belongs_to :scoped_group
 
-    orderable :scope => :group
+    orderable scope: :group
   end
 
   class StringScopedOrderable
     include Mongoid::Document
     include Mongoid::Orderable
 
-    field :some_scope, :type => Integer
+    field :some_scope, type: Integer
 
-    orderable :scope => 'some_scope'
+    orderable scope: 'some_scope'
   end
 
   class EmbedsOrderable
@@ -54,28 +53,28 @@ describe Mongoid::Orderable do
     include Mongoid::Document
     include Mongoid::Orderable
 
-    orderable :column => :pos, :as => :my_position
+    orderable column: :pos, as: :my_position
   end
 
   class NoIndexOrderable
     include Mongoid::Document
     include Mongoid::Orderable
 
-    orderable :index => false
+    orderable index: false
   end
 
   class ZeroBasedOrderable
     include Mongoid::Document
     include Mongoid::Orderable
 
-    orderable :base => 0
+    orderable base: 0
   end
 
   class Fruit
     include Mongoid::Document
     include Mongoid::Orderable
 
-    orderable :inherited => true
+    orderable inherited: true
   end
 
   class Apple < Fruit
@@ -88,10 +87,10 @@ describe Mongoid::Orderable do
     include Mongoid::Document
     include Mongoid::Orderable
 
-    belongs_to  :different_scope, :class_name => "ForeignKeyDiffersOrderable",
-                :foreign_key => "different_orderable_id"
+    belongs_to :different_scope, class_name: 'ForeignKeyDiffersOrderable',
+                                 foreign_key: 'different_orderable_id'
 
-    orderable :scope => :different_scope
+    orderable scope: :different_scope
   end
 
   class MultipleColumnsOrderable
@@ -102,9 +101,9 @@ describe Mongoid::Orderable do
 
     belongs_to :scoped_group
 
-    orderable :column => :pos, :base => 0, :index => false, :as => :position
-    orderable :column => :serial_no, :default => true
-    orderable :column => :groups, :scope => :group
+    orderable column: :pos, base: 0, index: false, as: :position
+    orderable column: :serial_no, default: true
+    orderable column: :groups, scope: :group
   end
 
   class MultipleScopedOrderable
@@ -114,12 +113,11 @@ describe Mongoid::Orderable do
     belongs_to :apple
     belongs_to :orange
 
-    orderable :column => :posa, :scope => :apple_id
-    orderable :column => :poso, :scope => :orange_id
+    orderable column: :posa, scope: :apple_id
+    orderable column: :poso, scope: :orange_id
   end
 
   describe SimpleOrderable do
-
     before :each do
       SimpleOrderable.delete_all
       5.times do
@@ -137,12 +135,10 @@ describe Mongoid::Orderable do
     end
 
     it 'should have index on position column' do
-      if ::Mongoid::Compatibility::Version.mongoid2?
-        expect(SimpleOrderable.index_options[[[:position, 1]]]).not_to be_nil
-      elsif ::Mongoid::Compatibility::Version.mongoid3?
-        expect(SimpleOrderable.index_options[{:position => 1}]).not_to be_nil
+      if ::Mongoid::Compatibility::Version.mongoid3?
+        expect(SimpleOrderable.index_options[{ position: 1 }]).not_to be_nil
       else
-        expect(SimpleOrderable.index_specifications.detect { |spec| spec.key == {:position => 1} }).not_to be_nil
+        expect(SimpleOrderable.index_specifications.detect { |spec| spec.key == { position: 1 } }).not_to be_nil
       end
     end
 
@@ -155,102 +151,99 @@ describe Mongoid::Orderable do
     end
 
     describe 'removement' do
-
       it 'top' do
-        SimpleOrderable.where(:position => 1).destroy
+        SimpleOrderable.where(position: 1).destroy
         expect(positions).to eq([1, 2, 3, 4])
       end
 
       it 'bottom' do
-        SimpleOrderable.where(:position => 5).destroy
+        SimpleOrderable.where(position: 5).destroy
         expect(positions).to eq([1, 2, 3, 4])
       end
 
       it 'middle' do
-        SimpleOrderable.where(:position => 3).destroy
+        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
+        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
+        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
+        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'
+        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'
+          SimpleOrderable.create! move_to: 'four'
         end.to raise_error Mongoid::Orderable::Errors::InvalidTargetPosition
       end
     end
 
     describe 'movement' do
-
       it 'higher from top' do
-        record = SimpleOrderable.where(:position => 1).first
-        record.update_attributes :move_to => :higher
+        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
+        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
+        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
+        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
+        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
+        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 = SimpleOrderable.where(position: 3).first
         record.save
         expect(positions).to eq([1, 2, 3, 4, 5])
         expect(record.reload.position).to eq(3)
@@ -258,30 +251,28 @@ describe Mongoid::Orderable do
     end
 
     describe 'utiity methods' do
-
-      it "should return a collection of items lower/higher on the list for next_items/previous_items" do
-        record_1 = SimpleOrderable.where(:position => 1).first
-        record_2 = SimpleOrderable.where(:position => 2).first
-        record_3 = SimpleOrderable.where(:position => 3).first
-        record_4 = SimpleOrderable.where(:position => 4).first
-        record_5 = SimpleOrderable.where(:position => 5).first
-        expect(record_1.next_items.to_a).to eq([record_2, record_3, record_4, record_5])
-        expect(record_5.previous_items.to_a).to eq([record_1, record_2, record_3, record_4])
-        expect(record_3.previous_items.to_a).to eq([record_1, record_2])
-        expect(record_3.next_items.to_a).to eq([record_4, record_5])
+      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])
       end
     end
   end
 
   describe ScopedOrderable do
-
     before :each do
       ScopedOrderable.delete_all
       2.times do
-        ScopedOrderable.create! :group_id => 1
+        ScopedOrderable.create! group_id: 1
       end
       3.times do
-        ScopedOrderable.create! :group_id => 2
+        ScopedOrderable.create! group_id: 2
       end
     end
 
@@ -294,118 +285,109 @@ describe Mongoid::Orderable do
     end
 
     describe 'removement' do
-
       it 'top' do
-        ScopedOrderable.where(:position => 1, :group_id => 1).destroy
+        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
+        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
+        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
+        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
+        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
+        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
+        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
+          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 ::Mongoid::Compatibility::Version.mongoid2?
-          expect(ScopedOrderable.index_options[[[:position, 1]]]).to be_nil
-        elsif ::Mongoid::Compatibility::Version.mongoid3?
-          expect(ScopedOrderable.index_options[{:position => 1}]).to be_nil
+        if ::Mongoid::Compatibility::Version.mongoid3?
+          expect(ScopedOrderable.index_options[{ position: 1 }]).to be_nil
         else
-          expect(ScopedOrderable.index_specifications.detect { |spec| spec.key == {:position => 1} }).to be_nil
+          expect(ScopedOrderable.index_specifications.detect { |spec| spec.key == { position: 1 } }).to be_nil
         end
       end
 
       it 'is on compound fields' do
-        if ::Mongoid::Compatibility::Version.mongoid2?
-          expect(ScopedOrderable.index_options[[[:group_id, 1], [:position, 1]]]).to_not be_nil
-        elsif ::Mongoid::Compatibility::Version.mongoid3?
-          expect(ScopedOrderable.index_options[{:group_id => 1, :position => 1}]).to_not be_nil
+        if ::Mongoid::Compatibility::Version.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
+          expect(ScopedOrderable.index_specifications.detect { |spec| spec.key == { group_id: 1, position: 1 } }).to_not be_nil
         end
       end
     end
 
     describe 'scope movement' do
-
-      let(:record){ ScopedOrderable.where(:group_id => 2, :position => 2).first }
+      let(:record) { ScopedOrderable.where(group_id: 2, position: 2).first }
 
       it 'to a new scope group' do
-        record.update_attributes :group_id => 3
+        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
+          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
+          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
+          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'
+          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'
+            record.update_attributes group_id: 1, move_to: 'two'
           end.to raise_error Mongoid::Orderable::Errors::InvalidTargetPosition
         end
       end
@@ -414,8 +396,7 @@ describe Mongoid::Orderable do
     if defined?(Mongoid::IdentityMap)
 
       context 'when identity map is enabled' do
-
-        let(:record){ ScopedOrderable.where(:group_id => 2, :position => 2).first }
+        let(:record) { ScopedOrderable.where(group_id: 2, position: 2).first }
 
         before do
           Mongoid.identity_map_enabled = true
@@ -427,63 +408,61 @@ describe Mongoid::Orderable do
         end
 
         it 'to a new scope group' do
-          record.update_attributes :group_id => 3
+          record.update_attributes group_id: 3
           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
+          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 numeric string)' do
-          record.update_attributes :group_id => 1, :move_to => '2'
+          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'
+            record.update_attributes group_id: 1, move_to: 'two'
           end.to raise_error Mongoid::Orderable::Errors::InvalidTargetPosition
         end
       end
     end
 
     describe 'utility methods' do
-
       before do
         ScopedOrderable.delete_all
         5.times { ScopedOrderable.create! }
       end
 
-      it "should return a collection of items lower/higher on the list for next_items/previous_items" do
-        record_1 = ScopedOrderable.where(:position => 1).first
-        record_2 = ScopedOrderable.where(:position => 2).first
-        record_3 = ScopedOrderable.where(:position => 3).first
-        record_4 = ScopedOrderable.where(:position => 4).first
-        record_5 = ScopedOrderable.where(:position => 5).first
-        expect(record_1.next_items.to_a).to eq([record_2, record_3, record_4, record_5])
-        expect(record_5.previous_items.to_a).to eq([record_1, record_2, record_3, record_4])
-        expect(record_3.previous_items.to_a).to eq([record_1, record_2])
-        expect(record_3.next_items.to_a).to eq([record_4, record_5])
+      it 'should return a collection of items lower/higher on the list for next_items/previous_items' do
+        record1 = ScopedOrderable.where(position: 1).first
+        record2 = ScopedOrderable.where(position: 2).first
+        record3 = ScopedOrderable.where(position: 3).first
+        record4 = ScopedOrderable.where(position: 4).first
+        record5 = ScopedOrderable.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])
         # next_item & previous_item testing
-        expect(record_1.next_item).to eq(record_2)
-        expect(record_2.previous_item).to eq(record_1)
-        expect(record_1.previous_item).to eq(nil)
-        expect(record_5.next_item).to eq(nil)
+        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
 
   describe StringScopedOrderable 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)
+      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
@@ -491,7 +470,6 @@ describe Mongoid::Orderable do
   end
 
   describe EmbeddedOrderable do
-
     before :each do
       EmbedsOrderable.delete_all
       eo = EmbedsOrderable.create!
@@ -505,7 +483,7 @@ describe Mongoid::Orderable do
     end
 
     def positions
-      EmbedsOrderable.order_by(:position => 1).all.map { |eo| eo.embedded_orderables.map(&:position).sort }
+      EmbedsOrderable.order_by(position: 1).all.map { |eo| eo.embedded_orderables.map(&:position).sort }
     end
 
     it 'sets proper position while creation' do
@@ -513,15 +491,14 @@ describe Mongoid::Orderable do
     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
-      expect(embedded_orderable_2.reload.position).to eq(1)
+      embedded_orderable1 = EmbedsOrderable.first.embedded_orderables.where(position: 1).first
+      embedded_orderable2 = EmbedsOrderable.first.embedded_orderables.where(position: 2).first
+      embedded_orderable1.move_to! 2
+      expect(embedded_orderable2.reload.position).to eq(1)
     end
   end
 
   describe CustomizedOrderable do
-
     it 'does not have default position field' do
       expect(CustomizedOrderable.fields).not_to have_key('position')
     end
@@ -538,9 +515,8 @@ describe Mongoid::Orderable do
   end
 
   describe NoIndexOrderable do
-
     it 'should not have index on position column' do
-      if ::Mongoid::Compatibility::Version.mongoid2? || ::Mongoid::Compatibility::Version.mongoid3?
+      if ::Mongoid::Compatibility::Version.mongoid3?
         expect(NoIndexOrderable.index_options[[[:position, 1]]]).to be_nil
       else
         expect(NoIndexOrderable.index_specifications.detect { |spec| spec.key == :position }).to be_nil
@@ -549,7 +525,6 @@ describe Mongoid::Orderable do
   end
 
   describe ZeroBasedOrderable do
-
     before :each do
       ZeroBasedOrderable.delete_all
       5.times do
@@ -570,7 +545,7 @@ describe Mongoid::Orderable do
     end
 
     describe 'reset position' do
-      before{ ZeroBasedOrderable.update_all({:position => nil}) }
+      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])
@@ -578,102 +553,99 @@ describe Mongoid::Orderable do
     end
 
     describe 'removement' do
-
       it 'top' do
-        ZeroBasedOrderable.where(:position => 0).destroy
+        ZeroBasedOrderable.where(position: 0).destroy
         expect(positions).to eq([0, 1, 2, 3])
       end
 
       it 'bottom' do
-        ZeroBasedOrderable.where(:position => 4).destroy
+        ZeroBasedOrderable.where(position: 4).destroy
         expect(positions).to eq([0, 1, 2, 3])
       end
 
       it 'middle' do
-        ZeroBasedOrderable.where(:position => 2).destroy
+        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
+        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
+        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
+        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'
+        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'
+          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
+        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
+        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
+        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
+        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
+        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
+        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 = ZeroBasedOrderable.where(position: 3).first
         record.save
         expect(positions).to eq([0, 1, 2, 3, 4])
         expect(record.reload.position).to eq(3)
@@ -681,28 +653,26 @@ describe Mongoid::Orderable do
     end
 
     describe 'utiity methods' do
-
-      it "should return a collection of items lower/higher on the list for next_items/previous_items" do
-        record_1 = SimpleOrderable.where(:position => 1).first
-        record_2 = SimpleOrderable.where(:position => 2).first
-        record_3 = SimpleOrderable.where(:position => 3).first
-        record_4 = SimpleOrderable.where(:position => 4).first
-        record_5 = SimpleOrderable.where(:position => 5).first
-        expect(record_1.next_items.to_a).to eq([record_2, record_3, record_4, record_5])
-        expect(record_5.previous_items.to_a).to eq([record_1, record_2, record_3, record_4])
-        expect(record_3.previous_items.to_a).to eq([record_1, record_2])
-        expect(record_3.next_items.to_a).to eq([record_4, record_5])
+      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])
         # next_item & previous_item testing
-        expect(record_1.next_item).to eq(record_2)
-        expect(record_2.previous_item).to eq(record_1)
-        expect(record_1.previous_item).to eq(nil)
-        expect(record_5.next_item).to eq(nil)
+        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
 
   describe Fruit do
-
     it 'should set proper position' do
       fruit1 = Apple.create
       fruit2 = Orange.create
@@ -740,7 +710,7 @@ describe Mongoid::Orderable do
     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
+          orderable column: :serial
         end
         expect(Fruit.orderable_configurations).not_to eq Apple.orderable_configurations
         expect(Orange.orderable_configurations).not_to eq Apple.orderable_configurations
@@ -750,15 +720,14 @@ describe Mongoid::Orderable do
   end
 
   describe ForeignKeyDiffersOrderable do
-
     it 'uses the foreign key of the relationship as scope' do
       orderable1, orderable2, orderable3 = nil
       parent_scope1 = ForeignKeyDiffersOrderable.create
       parent_scope2 = ForeignKeyDiffersOrderable.create
       expect do
-        orderable1 = ForeignKeyDiffersOrderable.create!(:different_scope => parent_scope1)
-        orderable2 = ForeignKeyDiffersOrderable.create!(:different_scope => parent_scope1)
-        orderable3 = ForeignKeyDiffersOrderable.create!(:different_scope => parent_scope2)
+        orderable1 = ForeignKeyDiffersOrderable.create!(different_scope: parent_scope1)
+        orderable2 = ForeignKeyDiffersOrderable.create!(different_scope: parent_scope1)
+        orderable3 = ForeignKeyDiffersOrderable.create!(different_scope: parent_scope2)
       end.to_not raise_error
       expect(orderable1.position).to eq 1
       expect(orderable2.position).to eq 2
@@ -767,7 +736,6 @@ describe Mongoid::Orderable do
   end
 
   describe MultipleColumnsOrderable do
-
     before :each do
       MultipleColumnsOrderable.delete_all
       5.times do
@@ -776,10 +744,10 @@ describe Mongoid::Orderable do
     end
 
     context 'default orderable' do
-      let(:serial_nos){ MultipleColumnsOrderable.all.map(&:serial_no).sort }
+      let(:serial_nos) { MultipleColumnsOrderable.all.map(&:serial_no).sort }
 
       describe 'inserting' do
-        let(:newbie){ MultipleColumnsOrderable.create! }
+        let(:newbie) { MultipleColumnsOrderable.create! }
 
         before { @position = newbie.position }
 
@@ -807,7 +775,7 @@ describe Mongoid::Orderable do
 
       describe 'movement' do
         it 'higher from top' do
-          record = MultipleColumnsOrderable.where(:serial_no => 1).first
+          record = MultipleColumnsOrderable.where(serial_no: 1).first
           position = record.position
           record.move_higher!
           expect(serial_nos).to eq([1, 2, 3, 4, 5])
@@ -816,7 +784,7 @@ describe Mongoid::Orderable do
         end
 
         it 'higher from bottom' do
-          record = MultipleColumnsOrderable.where(:serial_no => 5).first
+          record = MultipleColumnsOrderable.where(serial_no: 5).first
           position = record.position
           record.move_higher!
           expect(serial_nos).to eq([1, 2, 3, 4, 5])
@@ -825,7 +793,7 @@ describe Mongoid::Orderable do
         end
 
         it 'higher from middle' do
-          record = MultipleColumnsOrderable.where(:serial_no => 3).first
+          record = MultipleColumnsOrderable.where(serial_no: 3).first
           position = record.position
           record.move_higher!
           expect(serial_nos).to eq([1, 2, 3, 4, 5])
@@ -834,7 +802,7 @@ describe Mongoid::Orderable do
         end
 
         it 'lower from top' do
-          record = MultipleColumnsOrderable.where(:serial_no => 1).first
+          record = MultipleColumnsOrderable.where(serial_no: 1).first
           position = record.position
           record.move_lower!
           expect(serial_nos).to eq([1, 2, 3, 4, 5])
@@ -843,7 +811,7 @@ describe Mongoid::Orderable do
         end
 
         it 'lower from bottom' do
-          record = MultipleColumnsOrderable.where(:serial_no => 5).first
+          record = MultipleColumnsOrderable.where(serial_no: 5).first
           position = record.position
           record.move_lower!
           expect(serial_nos).to eq([1, 2, 3, 4, 5])
@@ -852,7 +820,7 @@ describe Mongoid::Orderable do
         end
 
         it 'lower from middle' do
-          record = MultipleColumnsOrderable.where(:serial_no => 3).first
+          record = MultipleColumnsOrderable.where(serial_no: 3).first
           position = record.position
           record.move_lower!
           expect(serial_nos).to eq([1, 2, 3, 4, 5])
@@ -862,38 +830,36 @@ describe Mongoid::Orderable do
       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
+          @record1 = MultipleColumnsOrderable.where(serial_no: 1).first
+          @record2 = MultipleColumnsOrderable.where(serial_no: 2).first
+          @record3 = MultipleColumnsOrderable.where(serial_no: 3).first
+          @record4 = MultipleColumnsOrderable.where(serial_no: 4).first
+          @record5 = 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)
+        it 'should return the lower/higher item on the list for next_item/previous_item' do
+          expect(@record1.next_item).to eq(@record2)
+          expect(@record3.next_item).to eq(@record4)
+          expect(@record5.next_item).to eq(nil)
+          expect(@record1.prev_item).to eq(nil)
+          expect(@record3.prev_item).to eq(@record2)
+          expect(@record5.prev_item).to eq(@record4)
         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])
+        it 'should return a collection of items lower/higher on the list for next_items/previous_items' do
+          expect(@record1.next_items.to_a).to eq([@record2, @record3, @record4, @record5])
+          expect(@record3.next_items.to_a).to eq([@record4, @record5])
+          expect(@record5.next_items.to_a).to eq([])
+          expect(@record1.previous_items.to_a).to eq([])
+          expect(@record3.previous_items.to_a).to eq([@record1, @record2])
+          expect(@record5.previous_items.to_a).to eq([@record1, @record2, @record3, @record4])
         end
       end
     end
 
     context 'serial_no orderable' do
-
-      let(:serial_nos){ MultipleColumnsOrderable.all.map(&:serial_no).sort }
+      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
@@ -901,12 +867,10 @@ describe Mongoid::Orderable do
       end
 
       it 'should have index on serial_no column' do
-        if ::Mongoid::Compatibility::Version.mongoid2?
-          expect(MultipleColumnsOrderable.index_options[[[:serial_no, 1]]]).not_to be_nil
-        elsif ::Mongoid::Compatibility::Version.mongoid3?
-          expect(MultipleColumnsOrderable.index_options[{:serial_no => 1}]).not_to be_nil
+        if ::Mongoid::Compatibility::Version.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
+          expect(MultipleColumnsOrderable.index_specifications.detect { |spec| spec.key == { serial_no: 1 } }).not_to be_nil
         end
       end
 
@@ -919,25 +883,24 @@ describe Mongoid::Orderable do
       end
 
       describe 'removement' do
-
         it 'top' do
-          MultipleColumnsOrderable.where(:serial_no => 1).destroy
+          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
+          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
+          MultipleColumnsOrderable.where(serial_no: 3).destroy
           expect(serial_nos).to eq([1, 2, 3, 4])
         end
       end
 
       describe 'inserting' do
-        let(:newbie){ MultipleColumnsOrderable.create! }
+        let(:newbie) { MultipleColumnsOrderable.create! }
 
         before { @position = newbie.position }
 
@@ -965,7 +928,7 @@ describe Mongoid::Orderable do
 
       describe 'movement' do
         it 'higher from top' do
-          record = MultipleColumnsOrderable.where(:serial_no => 1).first
+          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])
@@ -974,7 +937,7 @@ describe Mongoid::Orderable do
         end
 
         it 'higher from bottom' do
-          record = MultipleColumnsOrderable.where(:serial_no => 5).first
+          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])
@@ -983,7 +946,7 @@ describe Mongoid::Orderable do
         end
 
         it 'higher from middle' do
-          record = MultipleColumnsOrderable.where(:serial_no => 3).first
+          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])
@@ -992,7 +955,7 @@ describe Mongoid::Orderable do
         end
 
         it 'lower from top' do
-          record = MultipleColumnsOrderable.where(:serial_no => 1).first
+          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])
@@ -1001,7 +964,7 @@ describe Mongoid::Orderable do
         end
 
         it 'lower from bottom' do
-          record = MultipleColumnsOrderable.where(:serial_no => 5).first
+          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])
@@ -1010,7 +973,7 @@ describe Mongoid::Orderable do
         end
 
         it 'lower from middle' do
-          record = MultipleColumnsOrderable.where(:serial_no => 3).first
+          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])
@@ -1020,39 +983,36 @@ describe Mongoid::Orderable do
       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
+          @record1 = MultipleColumnsOrderable.where(serial_no: 1).first
+          @record2 = MultipleColumnsOrderable.where(serial_no: 2).first
+          @record3 = MultipleColumnsOrderable.where(serial_no: 3).first
+          @record4 = MultipleColumnsOrderable.where(serial_no: 4).first
+          @record5 = 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)
+        it 'should return the lower/higher item on the list for next_item/previous_item' do
+          expect(@record1.next_serial_no_item).to eq(@record2)
+          expect(@record3.next_serial_no_item).to eq(@record4)
+          expect(@record5.next_serial_no_item).to eq(nil)
+          expect(@record1.prev_serial_no_item).to eq(nil)
+          expect(@record3.prev_serial_no_item).to eq(@record2)
+          expect(@record5.prev_serial_no_item).to eq(@record4)
         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])
+        it 'should return a collection of items lower/higher on the list for next_items/previous_items' do
+          expect(@record1.next_serial_no_items.to_a).to eq([@record2, @record3, @record4, @record5])
+          expect(@record3.next_serial_no_items.to_a).to eq([@record4, @record5])
+          expect(@record5.next_serial_no_items.to_a).to eq([])
+          expect(@record1.previous_serial_no_items.to_a).to eq([])
+          expect(@record3.previous_serial_no_items.to_a).to eq([@record1, @record2])
+          expect(@record5.previous_serial_no_items.to_a).to eq([@record1, @record2, @record3, @record4])
         end
       end
-
     end
 
     context 'position orderable' do
-
-      let(:positions){ MultipleColumnsOrderable.all.map(&:position).sort }
+      let(:positions) { MultipleColumnsOrderable.all.map(&:position).sort }
 
       it 'should not have default position field' do
         expect(MultipleColumnsOrderable.fields).not_to have_key('position')
@@ -1064,12 +1024,10 @@ describe Mongoid::Orderable do
       end
 
       it 'should have index on position column' do
-        if ::Mongoid::Compatibility::Version.mongoid2?
-          expect(MultipleColumnsOrderable.index_options[[[:position, 1]]]).to be_nil
-        elsif ::Mongoid::Compatibility::Version.mongoid3?
-          expect(MultipleColumnsOrderable.index_options[{:position => 1}]).to be_nil
+        if ::Mongoid::Compatibility::Version.mongoid3?
+          expect(MultipleColumnsOrderable.index_options[{ position: 1 }]).to be_nil
         else
-          expect(MultipleColumnsOrderable.index_specifications.detect { |spec| spec.key == {:position => 1} }).to be_nil
+          expect(MultipleColumnsOrderable.index_specifications.detect { |spec| spec.key == { position: 1 } }).to be_nil
         end
       end
 
@@ -1082,25 +1040,24 @@ describe Mongoid::Orderable do
       end
 
       describe 'removement' do
-
         it 'top' do
-          MultipleColumnsOrderable.where(:pos => 1).destroy
+          MultipleColumnsOrderable.where(pos: 1).destroy
           expect(positions).to eq([0, 1, 2, 3])
         end
 
         it 'bottom' do
-          MultipleColumnsOrderable.where(:pos => 4).destroy
+          MultipleColumnsOrderable.where(pos: 4).destroy
           expect(positions).to eq([0, 1, 2, 3])
         end
 
         it 'middle' do
-          MultipleColumnsOrderable.where(:pos => 3).destroy
+          MultipleColumnsOrderable.where(pos: 3).destroy
           expect(positions).to eq([0, 1, 2, 3])
         end
       end
 
       describe 'inserting' do
-        let(:newbie){ MultipleColumnsOrderable.create! }
+        let(:newbie) { MultipleColumnsOrderable.create! }
 
         before { @serial_no = newbie.serial_no }
 
@@ -1128,7 +1085,7 @@ describe Mongoid::Orderable do
 
       describe 'movement' do
         it 'higher from top' do
-          record = MultipleColumnsOrderable.where(:pos => 0).first
+          record = MultipleColumnsOrderable.where(pos: 0).first
           position = record.serial_no
           record.move_position_higher!
           expect(positions).to eq([0, 1, 2, 3, 4])
@@ -1137,7 +1094,7 @@ describe Mongoid::Orderable do
         end
 
         it 'higher from bottom' do
-          record = MultipleColumnsOrderable.where(:pos => 4).first
+          record = MultipleColumnsOrderable.where(pos: 4).first
           position = record.serial_no
           record.move_position_higher!
           expect(positions).to eq([0, 1, 2, 3, 4])
@@ -1146,7 +1103,7 @@ describe Mongoid::Orderable do
         end
 
         it 'higher from middle' do
-          record = MultipleColumnsOrderable.where(:pos => 3).first
+          record = MultipleColumnsOrderable.where(pos: 3).first
           position = record.serial_no
           record.move_position_higher!
           expect(positions).to eq([0, 1, 2, 3, 4])
@@ -1155,7 +1112,7 @@ describe Mongoid::Orderable do
         end
 
         it 'lower from top' do
-          record = MultipleColumnsOrderable.where(:pos => 0).first
+          record = MultipleColumnsOrderable.where(pos: 0).first
           position = record.serial_no
           record.move_position_lower!
           expect(positions).to eq([0, 1, 2, 3, 4])
@@ -1164,7 +1121,7 @@ describe Mongoid::Orderable do
         end
 
         it 'lower from bottom' do
-          record = MultipleColumnsOrderable.where(:pos => 4).first
+          record = MultipleColumnsOrderable.where(pos: 4).first
           position = record.serial_no
           record.move_position_lower!
           expect(positions).to eq([0, 1, 2, 3, 4])
@@ -1173,7 +1130,7 @@ describe Mongoid::Orderable do
         end
 
         it 'lower from middle' do
-          record = MultipleColumnsOrderable.where(:pos => 3).first
+          record = MultipleColumnsOrderable.where(pos: 3).first
           position = record.serial_no
           record.move_position_lower!
           expect(positions).to eq([0, 1, 2, 3, 4])
@@ -1183,85 +1140,81 @@ describe Mongoid::Orderable do
       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
+          @record1 = MultipleColumnsOrderable.where(pos: 0).first
+          @record2 = MultipleColumnsOrderable.where(pos: 1).first
+          @record3 = MultipleColumnsOrderable.where(pos: 2).first
+          @record4 = MultipleColumnsOrderable.where(pos: 3).first
+          @record5 = 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)
+        it 'should return the lower/higher item on the list for next_item/previous_item' do
+          expect(@record1.next_position_item).to eq(@record2)
+          expect(@record3.next_position_item).to eq(@record4)
+          expect(@record5.next_position_item).to eq(nil)
+          expect(@record1.prev_position_item).to eq(nil)
+          expect(@record3.prev_position_item).to eq(@record2)
+          expect(@record5.prev_position_item).to eq(@record4)
         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])
+        it 'should return a collection of items lower/higher on the list for next_items/previous_items' do
+          expect(@record1.next_position_items.to_a).to eq([@record2, @record3, @record4, @record5])
+          expect(@record3.next_position_items.to_a).to eq([@record4, @record5])
+          expect(@record5.next_position_items.to_a).to eq([])
+          expect(@record1.previous_position_items.to_a).to eq([])
+          expect(@record3.previous_position_items.to_a).to eq([@record1, @record2])
+          expect(@record5.previous_position_items.to_a).to eq([@record1, @record2, @record3, @record4])
         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 }
+        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) }
+      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
+          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
+          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
+          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 = 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 = 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 = 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)
@@ -1269,32 +1222,30 @@ describe Mongoid::Orderable do
       end
 
       describe 'scope movement' do
-
-        let(:record){ MultipleColumnsOrderable.where(:group_id => 2, :groups => 2).first }
+        let(:record) { MultipleColumnsOrderable.where(group_id: 2, groups: 2).first }
 
         it 'to a new scope group' do
-          record.update_attributes :group_id => 3
+          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
+            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.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.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)
@@ -1305,8 +1256,7 @@ describe Mongoid::Orderable do
       if defined?(Mongoid::IdentityMap)
 
         context 'when identity map is enabled' do
-
-          let(:record){ MultipleColumnsOrderable.where(:group_id => 2, :groups => 2).first }
+          let(:record) { MultipleColumnsOrderable.where(group_id: 2, groups: 2).first }
 
           before do
             Mongoid.identity_map_enabled = true
@@ -1316,13 +1266,13 @@ describe Mongoid::Orderable do
           after { Mongoid.identity_map_enabled = false }
 
           it 'to a new scope group' do
-            record.update_attributes :group_id => 3
+            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.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)
@@ -1331,31 +1281,30 @@ describe Mongoid::Orderable do
       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
+          @record1 = MultipleColumnsOrderable.where(group_id: 2, groups: 1).first
+          @record2 = MultipleColumnsOrderable.where(group_id: 2, groups: 2).first
+          @record3 = MultipleColumnsOrderable.where(group_id: 2, groups: 3).first
+          @record4 = MultipleColumnsOrderable.where(group_id: 1, groups: 1).first
+          @record5 = 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)
+        it 'should return the lower/higher item on the list for next_item/previous_item' do
+          expect(@record1.next_groups_item).to eq(@record2)
+          expect(@record4.next_groups_item).to eq(@record5)
+          expect(@record3.next_groups_item).to eq(nil)
+          expect(@record1.prev_groups_item).to eq(nil)
+          expect(@record3.prev_groups_item).to eq(@record2)
+          expect(@record5.prev_groups_item).to eq(@record4)
         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])
+        it 'should return a collection of items lower/higher on the list for next_items/previous_items' do
+          expect(@record1.next_groups_items.to_a).to eq([@record2, @record3])
+          expect(@record3.next_groups_items.to_a).to eq([])
+          expect(@record4.next_groups_items.to_a).to eq([@record5])
+          expect(@record1.previous_groups_items.to_a).to eq([])
+          expect(@record3.previous_groups_items.to_a).to eq([@record1, @record2])
+          expect(@record5.previous_groups_items.to_a).to eq([@record4])
         end
       end
     end
@@ -1363,22 +1312,22 @@ describe Mongoid::Orderable do
 
   describe MultipleScopedOrderable do
     before :each do
-      Apple.delete_all; Orange.delete_all;
+      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
+      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
@@ -1409,5 +1358,4 @@ describe Mongoid::Orderable do
       end
     end
   end
-
 end