mongoid-slug 4.0.0 → 5.0.0

data/spec/mongoid/index_spec.rb

@@ -1,34 +1,32 @@
-#encoding: utf-8
-require "spec_helper"
+# encoding: utf-8
+require 'spec_helper'
 
 describe Mongoid::Slug::Index do
-
   let(:scope_key)     { nil }
   let(:by_model_type) { false }
   subject { Mongoid::Slug::Index.build_index(scope_key, by_model_type) }
 
-  context "when scope_key is set" do
+  context 'when scope_key is set' do
     let(:scope_key) { :foo }
 
-    context "when by_model_type is true" do
+    context 'when by_model_type is true' do
       let(:by_model_type) { true }
-      it { should eq [{:_slugs=>1, :foo=>1, :_type=>1}, {}] }
+      it { is_expected.to eq [{ _slugs: 1, foo: 1, _type: 1 }, {}] }
     end
 
-    context "when by_model_type is false" do
-      it { should eq [{:_slugs=>1, :foo=>1}, {:unique=>true, :sparse=>true}] }
+    context 'when by_model_type is false' do
+      it { is_expected.to eq [{ _slugs: 1, foo: 1 }, { unique: true, sparse: true }] }
     end
   end
 
-  context "when scope_key is not set" do
-
-    context "when by_model_type is true" do
+  context 'when scope_key is not set' do
+    context 'when by_model_type is true' do
       let(:by_model_type) { true }
-      it { should eq [{:_slugs=>1, :_type=>1}, {}] }
+      it { is_expected.to eq [{ _slugs: 1, _type: 1 }, {}] }
     end
 
-    context "when by_model_type is false" do
-      it { should eq [{:_slugs=>1}, {:unique=>true, :sparse=>true}] }
+    context 'when by_model_type is false' do
+      it { is_expected.to eq [{ _slugs: 1 }, { unique: true, sparse: true }] }
     end
   end
 end

data/spec/mongoid/paranoia_spec.rb

@@ -1,169 +1,157 @@
-#encoding: utf-8
-require "spec_helper"
-
-describe "Mongoid::Paranoia with Mongoid::Slug" do
-
-  let(:paranoid_doc)    { ParanoidDocument.create!(:title => "slug") }
-  let(:paranoid_doc_2)  { ParanoidDocument.create!(:title => "slug") }
-  let(:paranoid_perm)   { ParanoidPermanent.create!(:title => "slug") }
-  let(:paranoid_perm_2) { ParanoidPermanent.create!(:title => "slug") }
-  let(:non_paranoid_doc){ Article.create!(:title => "slug") }
-  subject{ paranoid_doc }
-
-  describe ".paranoid?" do
-
-    context "when Mongoid::Paranoia is included" do
+# encoding: utf-8
+require 'spec_helper'
+
+describe 'Mongoid::Paranoia with Mongoid::Slug' do
+  let(:paranoid_doc)    { ParanoidDocument.create!(title: 'slug') }
+  let(:paranoid_doc_2)  { ParanoidDocument.create!(title: 'slug') }
+  let(:paranoid_perm)   { ParanoidPermanent.create!(title: 'slug') }
+  let(:paranoid_perm_2) { ParanoidPermanent.create!(title: 'slug') }
+  let(:non_paranoid_doc) { Article.create!(title: 'slug') }
+  subject { paranoid_doc }
+
+  describe '.paranoid?' do
+    context 'when Mongoid::Paranoia is included' do
       subject { paranoid_doc.class }
-      its(:is_paranoid_doc?){ should be_truthy }
+      its(:is_paranoid_doc?) { should be_truthy }
     end
 
-    context "when Mongoid::Paranoia not included" do
+    context 'when Mongoid::Paranoia not included' do
       subject { non_paranoid_doc.class }
-      its(:is_paranoid_doc?){ should be_falsey }
+      its(:is_paranoid_doc?) { should be_falsey }
     end
   end
 
-  describe "#paranoid_deleted?" do
-
-    context "when Mongoid::Paranoia is included" do
-
-      context "when not destroyed" do
-        its(:paranoid_deleted?){ should be_falsey }
+  describe '#paranoid_deleted?' do
+    context 'when Mongoid::Paranoia is included' do
+      context 'when not destroyed' do
+        its(:paranoid_deleted?) { should be_falsey }
       end
 
-      context "when destroyed" do
+      context 'when destroyed' do
         before { subject.destroy }
-        its(:paranoid_deleted?){ should be_truthy }
+        its(:paranoid_deleted?) { should be_truthy }
       end
     end
 
-    context "when Mongoid::Paranoia not included" do
+    context 'when Mongoid::Paranoia not included' do
       subject { non_paranoid_doc }
-      its(:paranoid_deleted?){ should be_falsey }
+      its(:paranoid_deleted?) { should be_falsey }
     end
   end
 
-  describe "restore callbacks" do
-
-    context "when Mongoid::Paranoia is included" do
+  describe 'restore callbacks' do
+    context 'when Mongoid::Paranoia is included' do
       subject { paranoid_doc.class }
-      it { should respond_to(:before_restore) }
-      it { should respond_to(:after_restore) }
+      it { is_expected.to respond_to(:before_restore) }
+      it { is_expected.to respond_to(:after_restore) }
     end
 
-    context "when Mongoid::Paranoia not included" do
-      it { should_not respond_to(:before_restore) }
-      it { should_not respond_to(:after_restore) }
+    context 'when Mongoid::Paranoia not included' do
+      it { is_expected.not_to respond_to(:before_restore) }
+      it { is_expected.not_to respond_to(:after_restore) }
     end
   end
 
-  describe "index" do
+  describe 'index' do
     before  { ParanoidDocument.create_indexes }
     after   { ParanoidDocument.remove_indexes }
     subject { ParanoidDocument }
 
-    it_should_behave_like "has an index", { _slugs: 1 }, { unique: true, sparse: true }
+    it_should_behave_like 'has an index', { _slugs: 1 }, unique: true, sparse: true
   end
 
-  shared_examples_for "paranoid slugs" do
-
-    context "querying" do
-
-      it "returns paranoid_doc for correct slug" do
-        subject.class.find(subject.slug).should eq(subject)
+  shared_examples_for 'paranoid slugs' do
+    context 'querying' do
+      it 'returns paranoid_doc for correct slug' do
+        expect(subject.class.find(subject.slug)).to eq(subject)
       end
     end
 
-    context "delete (callbacks not fired)" do
-
+    context 'delete (callbacks not fired)' do
       before { subject.delete }
 
-      it "retains slug value" do
-        subject.slug.should eq "slug"
-        subject.class.unscoped.find("slug").should eq subject
+      it 'retains slug value' do
+        expect(subject.slug).to eq 'slug'
+        expect(subject.class.unscoped.find('slug')).to eq subject
       end
     end
 
-    context "destroy" do
-
+    context 'destroy' do
       before { subject.destroy }
 
-      it "unsets slug value when destroyed" do
-        subject._slugs.should eq []
-        subject.slug.should be_nil
+      it 'unsets slug value when destroyed' do
+        expect(subject._slugs).to eq []
+        expect(subject.slug).to be_nil
       end
 
-      it "persists the removed slug" do
-        subject.reload._slugs.should eq []
-        subject.reload.slug.should be_nil
+      it 'persists the removed slug' do
+        expect(subject.reload._slugs).to eq []
+        expect(subject.reload.slug).to be_nil
       end
 
-      it "persists the removed slug in the database" do
-        subject.class.unscoped.exists(_slugs: false).first.should eq subject
-        expect{subject.class.unscoped.find("slug")}.to raise_error(Mongoid::Errors::DocumentNotFound)
+      it 'persists the removed slug in the database' do
+        expect(subject.class.unscoped.exists(_slugs: false).first).to eq subject
+        expect { subject.class.unscoped.find('slug') }.to raise_error(Mongoid::Errors::DocumentNotFound)
       end
 
-      context "when saving the doc again" do
-
+      context 'when saving the doc again' do
         before { subject.save }
 
-        it "should have the default slug value" do
-          subject._slugs.should eq []
-          subject.slug.should be_nil
+        it 'should have the default slug value' do
+          expect(subject._slugs).to eq []
+          expect(subject.slug).to be_nil
         end
 
-        it "the slug remains unset in the database" do
-          subject.class.unscoped.exists(_slugs: false).first.should eq subject
-          expect{subject.class.unscoped.find("slug")}.to raise_error(Mongoid::Errors::DocumentNotFound)
+        it 'the slug remains unset in the database' do
+          expect(subject.class.unscoped.exists(_slugs: false).first).to eq subject
+          expect { subject.class.unscoped.find('slug') }.to raise_error(Mongoid::Errors::DocumentNotFound)
         end
       end
     end
 
-    context "restore" do
-
+    context 'restore' do
       before do
         subject.destroy
         subject.restore
       end
 
-      it "resets slug value when restored" do
-        subject.slug.should eq "slug"
-        subject.reload.slug.should eq "slug"
+      it 'resets slug value when restored' do
+        expect(subject.slug).to eq 'slug'
+        expect(subject.reload.slug).to eq 'slug'
       end
     end
 
-    context "multiple documents" do
-
-      it "new documents should be able to use the slug of destroyed documents" do
-        subject.slug.should eq "slug"
+    context 'multiple documents' do
+      it 'new documents should be able to use the slug of destroyed documents' do
+        expect(subject.slug).to eq 'slug'
         subject.destroy
-        subject.reload.slug.should be_nil
-        other_doc.slug.should eq "slug"
+        expect(subject.reload.slug).to be_nil
+        expect(other_doc.slug).to eq 'slug'
         subject.restore
-        subject.slug.should eq "slug-1"
-        subject.reload.slug.should eq "slug-1"
+        expect(subject.slug).to eq 'slug-1'
+        expect(subject.reload.slug).to eq 'slug-1'
       end
 
-      it "should allow multiple documents to be destroyed without index conflict" do
-        subject.slug.should eq "slug"
+      it 'should allow multiple documents to be destroyed without index conflict' do
+        expect(subject.slug).to eq 'slug'
         subject.destroy
-        subject.reload.slug.should be_nil
-        other_doc.slug.should eq "slug"
+        expect(subject.reload.slug).to be_nil
+        expect(other_doc.slug).to eq 'slug'
         other_doc.destroy
-        other_doc.reload.slug.should be_nil
+        expect(other_doc.reload.slug).to be_nil
       end
     end
   end
 
-  context "non-permanent slug" do
+  context 'non-permanent slug' do
     subject { paranoid_doc }
     let(:other_doc) { paranoid_doc_2 }
-    it_behaves_like "paranoid slugs"
+    it_behaves_like 'paranoid slugs'
   end
 
-  context "permanent slug" do
+  context 'permanent slug' do
     subject { paranoid_perm }
     let(:other_doc) { paranoid_perm_2 }
-    it_behaves_like "paranoid slugs"
+    it_behaves_like 'paranoid slugs'
   end
 end

data/spec/mongoid/slug_spec.rb

@@ -1,510 +1,503 @@
-#encoding: utf-8
-require "spec_helper"
+# encoding: utf-8
+require 'spec_helper'
 
 module Mongoid
   describe Slug do
     let(:book) do
-      Book.create(:title => "A Thousand Plateaus")
+      Book.create(title: 'A Thousand Plateaus')
     end
 
-    context "should not persist incorrect slugs" do
-      it "slugs should not be generated from invalid documents" do
+    context 'should not persist incorrect slugs' do
+      it 'slugs should not be generated from invalid documents' do
+        # this will fail now
+        x = IncorrectSlugPersistence.create!(name: 'test')
+        expect(x.slug).to eq('test')
 
-        #this will fail now
-        x = IncorrectSlugPersistence.create!(name: "test")
-        x.slug.should == 'test'
-
-        #I believe this will now fail
+        # I believe this will now fail
         x.name = 'te'
         x.valid?
-        x.slug.should_not == 'te'
+        expect(x.slug).not_to eq('te')
 
-        #I believe this will persist the 'te'
+        # I believe this will persist the 'te'
         x.name = 'testb'
         x.save!
-
       end
 
       it "doesn't persist blank strings" do
-        book = Book.create!(:title => "")
-        book.reload.slugs.should be_empty
+        book = Book.create!(title: '')
+        expect(book.reload.slugs).to be_empty
       end
-
     end
 
-    context "when option skip_id_check is used with UUID _id " do
+    context 'when option skip_id_check is used with UUID _id ' do
       let(:entity0) do
-        Entity.create(:_id => UUID.generate, :name => 'Pelham 1 2 3', :user_edited_variation => 'pelham-1-2-3')
+        Entity.create(_id: UUID.generate, name: 'Pelham 1 2 3', user_edited_variation: 'pelham-1-2-3')
       end
       let(:entity1) do
-        Entity.create(:_id => UUID.generate, :name => 'Jackson 5', :user_edited_variation => 'jackson-5')
+        Entity.create(_id: UUID.generate, name: 'Jackson 5', user_edited_variation: 'jackson-5')
       end
       let(:entity2) do
-        Entity.create(:_id => UUID.generate, :name => 'Jackson 5', :user_edited_variation => 'jackson-5')
+        Entity.create(_id: UUID.generate, name: 'Jackson 5', user_edited_variation: 'jackson-5')
       end
 
-      it "generates a unique slug by appending a counter to duplicate text" do
-        entity0.to_param.should eql "pelham-1-2-3"
+      it 'generates a unique slug by appending a counter to duplicate text' do
+        expect(entity0.to_param).to eql 'pelham-1-2-3'
 
-        5.times{ |x|
-          dup = Entity.create(:_id => UUID.generate, :name => entity0.name, :user_edited_variation => entity0.user_edited_variation)
-          dup.to_param.should eql "pelham-1-2-3-#{x.succ}"
-        }
+        5.times do |x|
+          dup = Entity.create(_id: UUID.generate, name: entity0.name, user_edited_variation: entity0.user_edited_variation)
+          expect(dup.to_param).to eql "pelham-1-2-3-#{x.succ}"
+        end
       end
 
-      it "allows the user to edit the sluggable field" do
-        entity1.to_param.should eql "jackson-5"
-        entity2.to_param.should eql "jackson-5-1"
-        entity2.user_edited_variation = "jackson-5-indiana"
+      it 'allows the user to edit the sluggable field' do
+        expect(entity1.to_param).to eql 'jackson-5'
+        expect(entity2.to_param).to eql 'jackson-5-1'
+        entity2.user_edited_variation = 'jackson-5-indiana'
         entity2.save
-        entity2.to_param.should eql "jackson-5-indiana"
+        expect(entity2.to_param).to eql 'jackson-5-indiana'
       end
 
-      it "allows users to edit the sluggable field" do
-        entity1.to_param.should eql "jackson-5"
-        entity2.to_param.should eql "jackson-5-1"
-        entity2.user_edited_variation = "jackson-5-indiana"
+      it 'allows users to edit the sluggable field' do
+        expect(entity1.to_param).to eql 'jackson-5'
+        expect(entity2.to_param).to eql 'jackson-5-1'
+        entity2.user_edited_variation = 'jackson-5-indiana'
         entity2.save
-        entity2.to_param.should eql "jackson-5-indiana"
+        expect(entity2.to_param).to eql 'jackson-5-indiana'
       end
 
-      it "it restores the slug if the editing user tries to use an existing slug" do
-        entity1.to_param.should eql "jackson-5"
-        entity2.to_param.should eql "jackson-5-1"
-        entity2.user_edited_variation = "jackson-5"
+      it 'it restores the slug if the editing user tries to use an existing slug' do
+        expect(entity1.to_param).to eql 'jackson-5'
+        expect(entity2.to_param).to eql 'jackson-5-1'
+        entity2.user_edited_variation = 'jackson-5'
         entity2.save
-        entity2.to_param.should eql "jackson-5-1"
+        expect(entity2.to_param).to eql 'jackson-5-1'
       end
 
-      it "does not force an appended counter on a plain string" do
-        entity = Entity.create(:_id => UUID.generate, :name => 'Adele', :user_edited_variation => 'adele')
-        entity.to_param.should eql "adele"
+      it 'does not force an appended counter on a plain string' do
+        entity = Entity.create(_id: UUID.generate, name: 'Adele', user_edited_variation: 'adele')
+        expect(entity.to_param).to eql 'adele'
       end
     end
 
-    context "when the object is top-level" do
-
-      it "generates a slug" do
-        book.to_param.should eql "a-thousand-plateaus"
+    context 'when the object is top-level' do
+      it 'generates a slug' do
+        expect(book.to_param).to eql 'a-thousand-plateaus'
       end
 
-      it "updates the slug" do
-        book.title = "Anti Oedipus"
+      it 'updates the slug' do
+        book.title = 'Anti Oedipus'
         book.save
-        book.to_param.should eql "anti-oedipus"
+        expect(book.to_param).to eql 'anti-oedipus'
       end
 
-      it "generates a unique slug by appending a counter to duplicate text" do
-        15.times{ |x|
-          dup = Book.create(:title => book.title)
-          dup.to_param.should eql "a-thousand-plateaus-#{x+1}"
-        }
+      it 'generates a unique slug by appending a counter to duplicate text' do
+        15.times do |x|
+          dup = Book.create(title: book.title)
+          expect(dup.to_param).to eql "a-thousand-plateaus-#{x + 1}"
+        end
       end
 
-      it "does not allow a BSON::ObjectId as use for a slug" do
+      it 'does not allow a BSON::ObjectId as use for a slug' do
         bson_id = Mongoid::Slug.mongoid3? ? Moped::BSON::ObjectId.new.to_s : BSON::ObjectId.new.to_s
-        bad = Book.create(:title => bson_id)
-        bad.slugs.should_not include(bson_id)
+        bad = Book.create(title: bson_id)
+        expect(bad.slugs).not_to include(bson_id)
       end
 
-      it "does not update slug if slugged fields have not changed" do
+      it 'does not update slug if slugged fields have not changed' do
         book.save
-        book.to_param.should eql "a-thousand-plateaus"
+        expect(book.to_param).to eql 'a-thousand-plateaus'
       end
 
-      it "does not change slug if slugged fields have changed but generated slug is identical" do
-        book.title = "a thousand plateaus"
+      it 'does not change slug if slugged fields have changed but generated slug is identical' do
+        book.title = 'a thousand plateaus'
         book.save
-        book.to_param.should eql "a-thousand-plateaus"
+        expect(book.to_param).to eql 'a-thousand-plateaus'
       end
 
-      context "using find" do
-        it "finds by id as string" do
-          Book.find(book.id.to_s).should eql book
+      context 'using find' do
+        it 'finds by id as string' do
+          expect(Book.find(book.id.to_s)).to eql book
         end
 
-        it "finds by id as array of strings" do
-          Book.find([book.id.to_s]).should eql [book]
+        it 'finds by id as array of strings' do
+          expect(Book.find([book.id.to_s])).to eql [book]
         end
 
-        it "finds by id as BSON::ObjectId" do
-          Book.find(book.id).should eql book
+        it 'finds by id as BSON::ObjectId' do
+          expect(Book.find(book.id)).to eql book
         end
 
-        it "finds by id as an array of BSON::ObjectIds" do
-          Book.find([book.id]).should eql [book]
+        it 'finds by id as an array of BSON::ObjectIds' do
+          expect(Book.find([book.id])).to eql [book]
         end
 
-        it "returns an empty array if given an empty array" do
-          Book.find([]).should eql []
+        it 'returns an empty array if given an empty array' do
+          expect(Book.find([])).to eql []
         end
       end
     end
 
-    context "when the object is embedded" do
+    context 'when the object is embedded' do
       let(:subject) do
-        book.subjects.create(:name => "Psychoanalysis")
+        book.subjects.create(name: 'Psychoanalysis')
       end
 
-      it "generates a slug" do
-        subject.to_param.should eql "psychoanalysis"
+      it 'generates a slug' do
+        expect(subject.to_param).to eql 'psychoanalysis'
       end
 
-      it "updates the slug" do
-        subject.name = "Schizoanalysis"
+      it 'updates the slug' do
+        subject.name = 'Schizoanalysis'
         subject.save
-        subject.to_param.should eql "schizoanalysis"
+        expect(subject.to_param).to eql 'schizoanalysis'
       end
 
-      it "generates a unique slug by appending a counter to duplicate text" do
-        dup = book.subjects.create(:name => subject.name)
-        dup.to_param.should eql "psychoanalysis-1"
+      it 'generates a unique slug by appending a counter to duplicate text' do
+        dup = book.subjects.create(name: subject.name)
+        expect(dup.to_param).to eql 'psychoanalysis-1'
       end
 
-      it "does not allow a BSON::ObjectId as use for a slug" do
-        bad = book.subjects.create(:name => "4ea0389f0364313d79104fb3")
-        bad.slugs.should_not eql "4ea0389f0364313d79104fb3"
+      it 'does not allow a BSON::ObjectId as use for a slug' do
+        bad = book.subjects.create(name: '4ea0389f0364313d79104fb3')
+        expect(bad.slugs).not_to eql '4ea0389f0364313d79104fb3'
       end
 
-      it "does not update slug if slugged fields have not changed" do
+      it 'does not update slug if slugged fields have not changed' do
         subject.save
-        subject.to_param.should eql "psychoanalysis"
+        expect(subject.to_param).to eql 'psychoanalysis'
       end
 
-      it "does not change slug if slugged fields have changed but generated slug is identical" do
-        subject.name = "PSYCHOANALYSIS"
-        subject.to_param.should eql "psychoanalysis"
+      it 'does not change slug if slugged fields have changed but generated slug is identical' do
+        subject.name = 'PSYCHOANALYSIS'
+        expect(subject.to_param).to eql 'psychoanalysis'
       end
 
-      context "using find" do
-        it "finds by id as string" do
-          book.subjects.find(subject.id.to_s).should eql subject
+      context 'using find' do
+        it 'finds by id as string' do
+          expect(book.subjects.find(subject.id.to_s)).to eql subject
         end
 
-        it "finds by id as array of strings" do
-          book.subjects.find([subject.id.to_s]).should eql [subject]
+        it 'finds by id as array of strings' do
+          expect(book.subjects.find([subject.id.to_s])).to eql [subject]
         end
 
-        it "finds by id as BSON::ObjectId" do
-          book.subjects.find(subject.id).should eql subject
+        it 'finds by id as BSON::ObjectId' do
+          expect(book.subjects.find(subject.id)).to eql subject
         end
 
-        it "finds by id as an array of BSON::ObjectIds" do
-          book.subjects.find([subject.id]).should eql [subject]
+        it 'finds by id as an array of BSON::ObjectIds' do
+          expect(book.subjects.find([subject.id])).to eql [subject]
         end
 
-        it "returns an empty array if given an empty array" do
-          book.subjects.find([]).should eql []
+        it 'returns an empty array if given an empty array' do
+          expect(book.subjects.find([])).to eql []
         end
       end
-
     end
 
-    context "when the object is embedded in another embedded object" do
+    context 'when the object is embedded in another embedded object' do
       let(:person) do
-        Person.create(:name => "John Doe")
+        Person.create(name: 'John Doe')
       end
 
       let(:relationship) do
-        person.relationships.create(:name => "Engagement")
+        person.relationships.create(name: 'Engagement')
       end
 
       let(:partner) do
-        relationship.partners.create(:name => "Jane Smith")
+        relationship.partners.create(name: 'Jane Smith')
       end
 
-      it "generates a slug" do
-        partner.to_param.should eql "jane-smith"
+      it 'generates a slug' do
+        expect(partner.to_param).to eql 'jane-smith'
       end
 
-      it "updates the slug" do
-        partner.name = "Jane Doe"
+      it 'updates the slug' do
+        partner.name = 'Jane Doe'
         partner.save
-        partner.to_param.should eql "jane-doe"
+        expect(partner.to_param).to eql 'jane-doe'
       end
 
-      it "generates a unique slug by appending a counter to duplicate text" do
-        dup = relationship.partners.create(:name => partner.name)
-        dup.to_param.should eql "jane-smith-1"
+      it 'generates a unique slug by appending a counter to duplicate text' do
+        dup = relationship.partners.create(name: partner.name)
+        expect(dup.to_param).to eql 'jane-smith-1'
       end
 
-      it "does not allow a BSON::ObjectId as use for a slug" do
-        bad = relationship.partners.create(:name => "4ea0389f0364313d79104fb3")
-        bad.slugs.should_not eql "4ea0389f0364313d79104fb3"
+      it 'does not allow a BSON::ObjectId as use for a slug' do
+        bad = relationship.partners.create(name: '4ea0389f0364313d79104fb3')
+        expect(bad.slugs).not_to eql '4ea0389f0364313d79104fb3'
       end
 
-      it "does not update slug if slugged fields have not changed" do
+      it 'does not update slug if slugged fields have not changed' do
         partner.save
-        partner.to_param.should eql "jane-smith"
+        expect(partner.to_param).to eql 'jane-smith'
       end
 
-      it "does not change slug if slugged fields have changed but generated slug is identical" do
-        partner.name = "JANE SMITH"
-        partner.to_param.should eql "jane-smith"
+      it 'does not change slug if slugged fields have changed but generated slug is identical' do
+        partner.name = 'JANE SMITH'
+        expect(partner.to_param).to eql 'jane-smith'
       end
 
-      it "scopes by parent object" do
-        affair = person.relationships.create(:name => "Affair")
-        lover = affair.partners.create(:name => partner.name)
-        lover.to_param.should eql partner.to_param
+      it 'scopes by parent object' do
+        affair = person.relationships.create(name: 'Affair')
+        lover = affair.partners.create(name: partner.name)
+        expect(lover.to_param).to eql partner.to_param
       end
 
-      context "using find" do
-        it "finds by id as string" do
-          relationship.partners.find(partner.id.to_s).should eql partner
+      context 'using find' do
+        it 'finds by id as string' do
+          expect(relationship.partners.find(partner.id.to_s)).to eql partner
         end
 
-        it "finds by id as array of strings" do
-          relationship.partners.find([partner.id.to_s]).should eql [partner]
+        it 'finds by id as array of strings' do
+          expect(relationship.partners.find([partner.id.to_s])).to eql [partner]
         end
 
-        it "finds by id as BSON::ObjectId" do
-          relationship.partners.find(partner.id).should eql partner
+        it 'finds by id as BSON::ObjectId' do
+          expect(relationship.partners.find(partner.id)).to eql partner
         end
 
-        it "finds by id as an array of BSON::ObjectIds" do
-          relationship.partners.find([partner.id]).should eql [partner]
+        it 'finds by id as an array of BSON::ObjectIds' do
+          expect(relationship.partners.find([partner.id])).to eql [partner]
         end
 
-        it "returns an empty array if given an empty array" do
-          relationship.partners.find([]).should eql []
+        it 'returns an empty array if given an empty array' do
+          expect(relationship.partners.find([])).to eql []
         end
       end
-
     end
 
-    context "when the slug is composed of multiple fields" do
+    context 'when the slug is composed of multiple fields' do
       let!(:author) do
         Author.create(
-          :first_name => "Gilles",
-          :last_name  => "Deleuze")
+          first_name: 'Gilles',
+          last_name: 'Deleuze')
       end
 
-      it "generates a slug" do
-        author.to_param.should eql "gilles-deleuze"
+      it 'generates a slug' do
+        expect(author.to_param).to eql 'gilles-deleuze'
       end
 
-      it "updates the slug" do
-        author.first_name = "Félix"
-        author.last_name  = "Guattari"
+      it 'updates the slug' do
+        author.first_name = 'Félix'
+        author.last_name  = 'Guattari'
         author.save
-        author.to_param.should eql "felix-guattari"
+        expect(author.to_param).to eql 'felix-guattari'
       end
 
-      it "generates a unique slug by appending a counter to duplicate text" do
+      it 'generates a unique slug by appending a counter to duplicate text' do
         dup = Author.create(
-          :first_name => author.first_name,
-          :last_name  => author.last_name)
-        dup.to_param.should eql "gilles-deleuze-1"
+          first_name: author.first_name,
+          last_name: author.last_name)
+        expect(dup.to_param).to eql 'gilles-deleuze-1'
 
         dup2 = Author.create(
-          :first_name => author.first_name,
-          :last_name  => author.last_name)
+          first_name: author.first_name,
+          last_name: author.last_name)
 
         dup.save
-        dup2.to_param.should eql "gilles-deleuze-2"
+        expect(dup2.to_param).to eql 'gilles-deleuze-2'
       end
 
-      it "does not allow a BSON::ObjectId as use for a slug" do
-        bad = Author.create(:first_name => "4ea0389f0364",
-                            :last_name => "313d79104fb3")
-        bad.to_param.should_not eql "4ea0389f0364313d79104fb3"
+      it 'does not allow a BSON::ObjectId as use for a slug' do
+        bad = Author.create(first_name: '4ea0389f0364',
+                            last_name: '313d79104fb3')
+        expect(bad.to_param).not_to eql '4ea0389f0364313d79104fb3'
       end
 
-      it "does not update slug if slugged fields have changed but generated slug is identical" do
-        author.last_name = "DELEUZE"
+      it 'does not update slug if slugged fields have changed but generated slug is identical' do
+        author.last_name = 'DELEUZE'
         author.save
-        author.to_param.should eql "gilles-deleuze"
+        expect(author.to_param).to eql 'gilles-deleuze'
       end
     end
 
-    context "when :as is passed as an argument" do
+    context 'when :as is passed as an argument' do
       let!(:person) do
-        Person.create(:name => "John Doe")
+        Person.create(name: 'John Doe')
       end
 
-      it "sets an alternative slug field name" do
-        person.should respond_to(:_slugs)
-        person.slugs.should eql ["john-doe"]
+      it 'sets an alternative slug field name' do
+        expect(person).to respond_to(:_slugs)
+        expect(person.slugs).to eql ['john-doe']
       end
 
       it 'defines #slug' do
-        person.should respond_to :slugs
+        expect(person).to respond_to :slugs
       end
 
       it 'defines #slug_changed?' do
-        person.should respond_to :_slugs_changed?
+        expect(person).to respond_to :_slugs_changed?
       end
 
       it 'defines #slug_was' do
-        person.should respond_to :_slugs_was
+        expect(person).to respond_to :_slugs_was
       end
     end
 
-    context "when :permanent is passed as an argument" do
+    context 'when :permanent is passed as an argument' do
       let(:person) do
-        Person.create(:name => "John Doe")
+        Person.create(name: 'John Doe')
       end
 
-      it "does not update the slug when the slugged fields change" do
-        person.name = "Jane Doe"
+      it 'does not update the slug when the slugged fields change' do
+        person.name = 'Jane Doe'
         person.save
-        person.to_param.should eql "john-doe"
+        expect(person.to_param).to eql 'john-doe'
       end
     end
 
-    context "when :history is passed as an argument" do
+    context 'when :history is passed as an argument' do
       let(:book) do
-        Book.create(:title => "Book Title")
+        Book.create(title: 'Book Title')
       end
 
       before(:each) do
-        book.title = "Other Book Title"
+        book.title = 'Other Book Title'
         book.save
       end
 
       it "saves the old slug in the owner's history" do
-        book.slugs.should include("book-title")
+        expect(book.slugs).to include('book-title')
       end
 
-      it "generates a unique slug by appending a counter to duplicate text" do
-        dup = Book.create(:title => "Book Title")
-        dup.to_param.should eql "book-title-1"
+      it 'generates a unique slug by appending a counter to duplicate text' do
+        dup = Book.create(title: 'Book Title')
+        expect(dup.to_param).to eql 'book-title-1'
       end
 
-      it "does not allow a BSON::ObjectId as use for a slug" do
-        bad = Book.create(:title => "4ea0389f0364313d79104fb3")
-        bad.to_param.should_not eql "4ea0389f0364313d79104fb3"
+      it 'does not allow a BSON::ObjectId as use for a slug' do
+        bad = Book.create(title: '4ea0389f0364313d79104fb3')
+        expect(bad.to_param).not_to eql '4ea0389f0364313d79104fb3'
       end
 
-      it "ensures no duplicate values are stored in history" do
-        book.update_attributes :title => 'Book Title'
-        book.update_attributes :title => 'Foo'
-        book.slugs.find_all { |slug| slug == 'book-title' }.size.should eql 1
+      it 'ensures no duplicate values are stored in history' do
+        book.update_attributes title: 'Book Title'
+        book.update_attributes title: 'Foo'
+        expect(book.slugs.find_all { |slug| slug == 'book-title' }.size).to eql 1
       end
     end
 
-    context "when slug is scoped by a reference association" do
+    context 'when slug is scoped by a reference association' do
       let(:author) do
-        book.authors.create(:first_name => "Gilles", :last_name  => "Deleuze")
+        book.authors.create(first_name: 'Gilles', last_name: 'Deleuze')
       end
 
-      it "scopes by parent object" do
-        book2 = Book.create(:title => "Anti Oedipus")
+      it 'scopes by parent object' do
+        book2 = Book.create(title: 'Anti Oedipus')
         dup = book2.authors.create(
-          :first_name => author.first_name,
-          :last_name => author.last_name
+          first_name: author.first_name,
+          last_name: author.last_name
         )
-        dup.to_param.should eql author.to_param
+        expect(dup.to_param).to eql author.to_param
       end
 
-      it "generates a unique slug by appending a counter to duplicate text" do
+      it 'generates a unique slug by appending a counter to duplicate text' do
         dup = book.authors.create(
-          :first_name => author.first_name,
-          :last_name  => author.last_name)
-        dup.to_param.should eql "gilles-deleuze-1"
+          first_name: author.first_name,
+          last_name: author.last_name)
+        expect(dup.to_param).to eql 'gilles-deleuze-1'
       end
 
-      it "does not allow a BSON::ObjectId as use for a slug" do
-        bad = book.authors.create(:first_name => "4ea0389f0364",
-                                  :last_name => "313d79104fb3")
-        bad.to_param.should_not eql "4ea0389f0364313d79104fb3"
+      it 'does not allow a BSON::ObjectId as use for a slug' do
+        bad = book.authors.create(first_name: '4ea0389f0364',
+                                  last_name: '313d79104fb3')
+        expect(bad.to_param).not_to eql '4ea0389f0364313d79104fb3'
       end
 
-      context "with an irregular association name" do
+      context 'with an irregular association name' do
         let(:character) do
           # well we've got to make up something... :-)
-          author.characters.create(:name => "Oedipus")
+          author.characters.create(name: 'Oedipus')
         end
 
         let!(:author2) do
           Author.create(
-            :first_name => "Sophocles",
-            :last_name => "son of Sophilos"
+            first_name: 'Sophocles',
+            last_name: 'son of Sophilos'
           )
         end
 
-        it "scopes by parent object provided that inverse_of is specified" do
-          dup = author2.characters.create(:name => character.name)
-          dup.to_param.should eql character.to_param
+        it 'scopes by parent object provided that inverse_of is specified' do
+          dup = author2.characters.create(name: character.name)
+          expect(dup.to_param).to eql character.to_param
         end
       end
     end
 
     context "when slug is scoped by one of the class's own fields" do
       let!(:magazine) do
-        Magazine.create(:title  => "Big Weekly", :publisher_id => "abc123")
+        Magazine.create(title: 'Big Weekly', publisher_id: 'abc123')
       end
 
-      it "should scope by local field" do
-        magazine.to_param.should eql "big-weekly"
-        magazine2 = Magazine.create(:title => "Big Weekly", :publisher_id => "def456")
-        magazine2.to_param.should eql magazine.to_param
+      it 'should scope by local field' do
+        expect(magazine.to_param).to eql 'big-weekly'
+        magazine2 = Magazine.create(title: 'Big Weekly', publisher_id: 'def456')
+        expect(magazine2.to_param).to eql magazine.to_param
       end
 
-      it "should generate a unique slug by appending a counter to duplicate text" do
-        dup = Magazine.create(:title  => "Big Weekly", :publisher_id => "abc123")
-        dup.to_param.should eql "big-weekly-1"
+      it 'should generate a unique slug by appending a counter to duplicate text' do
+        dup = Magazine.create(title: 'Big Weekly', publisher_id: 'abc123')
+        expect(dup.to_param).to eql 'big-weekly-1'
       end
 
-      it "does not allow a BSON::ObjectId as use for a slug" do
-        bad = Magazine.create(:title  => "4ea0389f0364313d79104fb3", :publisher_id => "abc123")
-        bad.to_param.should_not eql "4ea0389f0364313d79104fb3"
+      it 'does not allow a BSON::ObjectId as use for a slug' do
+        bad = Magazine.create(title: '4ea0389f0364313d79104fb3', publisher_id: 'abc123')
+        expect(bad.to_param).not_to eql '4ea0389f0364313d79104fb3'
       end
-
     end
 
-    context "when #slug is given a block" do
+    context 'when #slug is given a block' do
       let(:caption) do
-        Caption.create(:my_identity => "Edward Hopper (American, 1882-1967)",
-                       :title    => "Soir Bleu, 1914",
-                       :medium   => "Oil on Canvas")
+        Caption.create(my_identity: 'Edward Hopper (American, 1882-1967)',
+                       title: 'Soir Bleu, 1914',
+                       medium: 'Oil on Canvas')
       end
 
-      it "generates a slug" do
-        caption.to_param.should eql "edward-hopper-soir-bleu-1914"
+      it 'generates a slug' do
+        expect(caption.to_param).to eql 'edward-hopper-soir-bleu-1914'
       end
 
-      it "updates the slug" do
-        caption.title = "Road in Maine, 1914"
+      it 'updates the slug' do
+        caption.title = 'Road in Maine, 1914'
         caption.save
-        caption.to_param.should eql "edward-hopper-road-in-maine-1914"
+        expect(caption.to_param).to eql 'edward-hopper-road-in-maine-1914'
       end
 
-      it "does not change slug if slugged fields have changed but generated slug is identical" do
-        caption.my_identity = "Edward Hopper"
+      it 'does not change slug if slugged fields have changed but generated slug is identical' do
+        caption.my_identity = 'Edward Hopper'
         caption.save
-        caption.to_param.should eql "edward-hopper-soir-bleu-1914"
+        expect(caption.to_param).to eql 'edward-hopper-soir-bleu-1914'
       end
     end
 
-    context "when slugged field contains non-ASCII characters" do
-      it "slugs Cyrillic characters" do
-        book.title = "Капитал"
+    context 'when slugged field contains non-ASCII characters' do
+      it 'slugs Cyrillic characters' do
+        book.title = 'Капитал'
         book.save
-        book.to_param.should eql "kapital"
+        expect(book.to_param).to eql 'kapital'
       end
 
-      it "slugs Greek characters" do
-        book.title = "Ελλάδα"
+      it 'slugs Greek characters' do
+        book.title = 'Ελλάδα'
         book.save
-        book.to_param.should eql "ellada"
+        expect(book.to_param).to eql 'ellada'
       end
 
-      it "slugs Chinese characters" do
-        book.title = "中文"
+      it 'slugs Chinese characters' do
+        book.title = '中文'
         book.save
-        book.to_param.should eql "zhong-wen"
+        expect(book.to_param).to eql 'zhong-wen'
       end
 
-      it "slugs non-ASCII Latin characters" do
-        book.title = "Paul Cézanne"
+      it 'slugs non-ASCII Latin characters' do
+        book.title = 'Paul Cézanne'
         book.save
-        book.to_param.should eql "paul-cezanne"
+        expect(book.to_param).to eql 'paul-cezanne'
       end
     end
 
-    context "when indexes are created" do
+    context 'when indexes are created' do
       before do
         Author.create_indexes
         Book.create_indexes
@@ -521,225 +514,228 @@ module Mongoid
         BookPolymorphic.remove_indexes
       end
 
-      context "when slug is not scoped by a reference association" do
+      context 'when slug is not scoped by a reference association' do
         subject { Book }
-        it_should_behave_like "has an index", { _slugs: 1 }, { unique: true, sparse: true }
+        it_should_behave_like 'has an index', { _slugs: 1 }, unique: true, sparse: true
       end
 
-      context "when slug is scoped by a reference association" do
+      context 'when slug is scoped by a reference association' do
         subject { Author }
-        it_should_behave_like "does not have an index", { _slugs: 1 }
+        it_should_behave_like 'does not have an index', _slugs: 1
       end
 
-      context "for subclass scope" do
-        context "when slug is not scoped by a reference association" do
+      context 'for subclass scope' do
+        context 'when slug is not scoped by a reference association' do
           subject { BookPolymorphic }
-          it_should_behave_like "has an index", { _type: 1, _slugs: 1 }, { unique: nil, sparse: nil }
+          it_should_behave_like 'has an index', { _type: 1, _slugs: 1 }, unique: nil, sparse: nil
         end
 
-        context "when slug is scoped by a reference association" do
+        context 'when slug is scoped by a reference association' do
           subject { AuthorPolymorphic }
-          it_should_behave_like "does not have an index", { _type: 1, _slugs: 1 }
+          it_should_behave_like 'does not have an index', _type: 1, _slugs: 1
         end
 
-        context "when the object has STI" do
-          it "scopes by the subclass" do
+        context 'when the object has STI' do
+          it 'scopes by the subclass' do
             b = BookPolymorphic.create!(title: 'Book')
-            b.slug.should == 'book'
+            expect(b.slug).to eq('book')
 
             b2 = BookPolymorphic.create!(title: 'Book')
-            b2.slug.should == 'book-1'
+            expect(b2.slug).to eq('book-1')
 
             c = ComicBookPolymorphic.create!(title: 'Book')
-            c.slug.should == 'book'
+            expect(c.slug).to eq('book')
 
             c2 = ComicBookPolymorphic.create!(title: 'Book')
-            c2.slug.should == 'book-1'
+            expect(c2.slug).to eq('book-1')
 
-            BookPolymorphic.find('book').should == b
-            BookPolymorphic.find('book-1').should == b2
-            ComicBookPolymorphic.find('book').should == c
-            ComicBookPolymorphic.find('book-1').should == c2
+            expect(BookPolymorphic.find('book')).to eq(b)
+            expect(BookPolymorphic.find('book-1')).to eq(b2)
+            expect(ComicBookPolymorphic.find('book')).to eq(c)
+            expect(ComicBookPolymorphic.find('book-1')).to eq(c2)
           end
         end
       end
     end
 
-    context "for reserved words" do
-      context "when the :reserve option is used on the model" do
-        it "does not use the reserved slugs" do
-          friend1 = Friend.create(:name => "foo")
-          friend1.slugs.should_not include("foo")
-          friend1.slugs.should include("foo-1")
+    context 'for reserved words' do
+      context 'when the :reserve option is used on the model' do
+        it 'does not use the reserved slugs' do
+          friend1 = Friend.create(name: 'foo')
+          expect(friend1.slugs).not_to include('foo')
+          expect(friend1.slugs).to include('foo-1')
 
-          friend2 = Friend.create(:name => "bar")
-          friend2.slugs.should_not include("bar")
-          friend2.slugs.should include("bar-1")
+          friend2 = Friend.create(name: 'bar')
+          expect(friend2.slugs).not_to include('bar')
+          expect(friend2.slugs).to include('bar-1')
 
-          friend3 = Friend.create(:name => "en")
-          friend3.slugs.should_not include("en")
-          friend3.slugs.should include("en-1")
+          friend3 = Friend.create(name: 'en')
+          expect(friend3.slugs).not_to include('en')
+          expect(friend3.slugs).to include('en-1')
         end
 
-        it "should start with concatenation -1" do
-          friend1 = Friend.create(:name => "foo")
-          friend1.slugs.should include("foo-1")
-          friend2 = Friend.create(:name => "foo")
-          friend2.slugs.should include("foo-2")
+        it 'should start with concatenation -1' do
+          friend1 = Friend.create(name: 'foo')
+          expect(friend1.slugs).to include('foo-1')
+          friend2 = Friend.create(name: 'foo')
+          expect(friend2.slugs).to include('foo-2')
         end
 
-        ["new", "edit"].each do |word|
+        %w(new edit).each do |word|
           it "should overwrite the default reserved words allowing the word '#{word}'" do
-            friend = Friend.create(:name => word)
-            friend.slugs.should include word
+            friend = Friend.create(name: word)
+            expect(friend.slugs).to include word
           end
         end
       end
-      context "when the model does not have any reserved words set" do
-        ["new", "edit"].each do |word|
+      context 'when the model does not have any reserved words set' do
+        %w(new edit).each do |word|
           it "does not use the default reserved word '#{word}'" do
-            book = Book.create(:title => word)
-            book.slugs.should_not include word
-            book.slugs.should include("#{word}-1")
+            book = Book.create(title: word)
+            expect(book.slugs).not_to include word
+            expect(book.slugs).to include("#{word}-1")
           end
         end
       end
     end
 
-    context "when the object has STI" do
-      it "scopes by the superclass" do
-        book = Book.create(:title => "Anti Oedipus")
-        comic_book = ComicBook.create(:title => "Anti Oedipus")
-        comic_book.slugs.should_not eql(book.slugs)
+    context 'when the object has STI' do
+      it 'scopes by the superclass' do
+        book = Book.create(title: 'Anti Oedipus')
+        comic_book = ComicBook.create(title: 'Anti Oedipus')
+        expect(comic_book.slugs).not_to eql(book.slugs)
       end
 
-      it "scopes by the subclass" do
-        book = BookPolymorphic.create(:title => "Anti Oedipus")
-        comic_book = ComicBookPolymorphic.create(:title => "Anti Oedipus")
-        comic_book.slugs.should eql(book.slugs)
+      it 'scopes by the subclass' do
+        book = BookPolymorphic.create(title: 'Anti Oedipus')
+        comic_book = ComicBookPolymorphic.create(title: 'Anti Oedipus')
+        expect(comic_book.slugs).to eql(book.slugs)
 
-        BookPolymorphic.find(book.slug).should == book
-        ComicBookPolymorphic.find(comic_book.slug).should == comic_book
+        expect(BookPolymorphic.find(book.slug)).to eq(book)
+        expect(ComicBookPolymorphic.find(comic_book.slug)).to eq(comic_book)
       end
     end
 
-    context "when slug defined on alias of field" do
-      it "should use accessor, not alias" do
-        pseudonim  = Alias.create(:author_name => "Max Stirner")
-        pseudonim.slugs.should include("max-stirner")
+    context 'when slug defined on alias of field' do
+      it 'should use accessor, not alias' do
+        pseudonim = Alias.create(author_name: 'Max Stirner')
+        expect(pseudonim.slugs).to include('max-stirner')
       end
     end
 
-    describe "#to_param" do
-      context "when called on a new record" do
+    describe '#to_param' do
+      context 'when called on a new record' do
         let(:book) { Book.new }
 
-        it "should return nil" do
-          book.to_param.should be_nil
+        it 'should return nil' do
+          expect(book.to_param).to be_nil
         end
 
-        it "should not persist the record" do
+        it 'should not persist the record' do
           book.to_param
-          book.should_not be_persisted
+          expect(book).not_to be_persisted
         end
-
       end
 
-      context "when called on an existing record with no slug" do
-        let!(:book_no_title) { Book.create() }
+      context 'when called on an existing record with no slug' do
+        let!(:book_no_title) { Book.create }
 
         before do
-          Book.collection.insert(:title => "Proust and Signs")
+          if Mongoid::Compatibility::Version.mongoid5?
+            Book.collection.insert_one(title: 'Proust and Signs')
+          else
+            Book.collection.insert(title: 'Proust and Signs')
+          end
         end
 
-        it "should return the id if there is no slug" do
+        it 'should return the id if there is no slug' do
           book = Book.first
-          book.to_param.should == book.id.to_s
-          book.reload.slugs.should be_empty
+          expect(book.to_param).to eq(book.id.to_s)
+          expect(book.reload.slugs).to be_empty
         end
 
-        it "should not persist the record" do
-          book_no_title.to_param.should == book_no_title._id.to_s
+        it 'should not persist the record' do
+          expect(book_no_title.to_param).to eq(book_no_title._id.to_s)
         end
       end
     end
 
-    describe "#_slugs_changed?" do
+    describe '#_slugs_changed?' do
       before do
-        Book.create(:title => "A Thousand Plateaus")
+        Book.create(title: 'A Thousand Plateaus')
       end
 
       let(:book) { Book.first }
 
-      it "is initially unchanged" do
-        book._slugs_changed?.should be_falsey
+      it 'is initially unchanged' do
+        expect(book._slugs_changed?).to be_falsey
       end
 
-      it "tracks changes" do
-        book.slugs = ["Anti Oedipus"]
-        book._slugs_changed?.should be_truthy
+      it 'tracks changes' do
+        book.slugs = ['Anti Oedipus']
+        expect(book._slugs_changed?).to be_truthy
       end
     end
 
-    describe "when regular expression matches, but document does not" do
-      let!(:book_1) { Book.create(:title => "book-1") }
-      let!(:book_2) { Book.create(:title => "book") }
-      let!(:book_3) { Book.create(:title => "book") }
+    describe 'when regular expression matches, but document does not' do
+      let!(:book_1) { Book.create(title: 'book-1') }
+      let!(:book_2) { Book.create(title: 'book') }
+      let!(:book_3) { Book.create(title: 'book') }
 
-      it "book_2 should have the user supplied title without -1 after it" do
-        book_2.to_param.should eql "book"
+      it 'book_2 should have the user supplied title without -1 after it' do
+        expect(book_2.to_param).to eql 'book'
       end
 
-      it "book_3 should have a generated slug" do
-        book_3.to_param.should eql "book-2"
+      it 'book_3 should have a generated slug' do
+        expect(book_3.to_param).to eql 'book-2'
       end
     end
 
-    context "when the slugged field is set manually" do
-      context "when it set to a non-empty string" do
-        it "respects the provided slug" do
-          book = Book.create(:title => "A Thousand Plateaus", :slugs => ["not-what-you-expected"])
-          book.to_param.should eql "not-what-you-expected"
+    context 'when the slugged field is set manually' do
+      context 'when it set to a non-empty string' do
+        it 'respects the provided slug' do
+          book = Book.create(title: 'A Thousand Plateaus', slugs: ['not-what-you-expected'])
+          expect(book.to_param).to eql 'not-what-you-expected'
         end
 
-        it "ensures uniqueness" do
-          book1 = Book.create(:title => "A Thousand Plateaus", :slugs => ["not-what-you-expected"])
-          book2 = Book.create(:title => "A Thousand Plateaus", :slugs => ["not-what-you-expected"])
-          book2.to_param.should eql "not-what-you-expected-1"
+        it 'ensures uniqueness' do
+          Book.create(title: 'A Thousand Plateaus', slugs: ['not-what-you-expected'])
+          book2 = Book.create(title: 'A Thousand Plateaus', slugs: ['not-what-you-expected'])
+          expect(book2.to_param).to eql 'not-what-you-expected-1'
         end
 
-        it "updates the slug when a new one is passed in" do
-          book = Book.create(:title => "A Thousand Plateaus", :slugs => ["not-what-you-expected"])
-          book.slugs = ["not-it-either"]
+        it 'updates the slug when a new one is passed in' do
+          book = Book.create(title: 'A Thousand Plateaus', slugs: ['not-what-you-expected'])
+          book.slugs = ['not-it-either']
           book.save
-          book.to_param.should eql "not-it-either"
+          expect(book.to_param).to eql 'not-it-either'
         end
 
-        it "updates the slug when a new one is appended" do
-          book = Book.create(:title => "A Thousand Plateaus", :slugs => ["not-what-you-expected"])
-          book.slugs.push "not-it-either"
+        it 'updates the slug when a new one is appended' do
+          book = Book.create(title: 'A Thousand Plateaus', slugs: ['not-what-you-expected'])
+          book.slugs.push 'not-it-either'
           book.save
-          book.to_param.should eql "not-it-either"
+          expect(book.to_param).to eql 'not-it-either'
         end
 
-        it "updates the slug to a unique slug when a new one is appended" do
-          book1 = Book.create(:title => "Sleepyhead")
-          book2 = Book.create(:title => "A Thousand Plateaus")
-          book2.slugs.push "sleepyhead"
+        it 'updates the slug to a unique slug when a new one is appended' do
+          Book.create(title: 'Sleepyhead')
+          book2 = Book.create(title: 'A Thousand Plateaus')
+          book2.slugs.push 'sleepyhead'
           book2.save
-          book2.to_param.should eql "sleepyhead-1"
+          expect(book2.to_param).to eql 'sleepyhead-1'
         end
       end
 
-      context "when it is set to an empty string" do
-        it "generate a new one" do
-          book = Book.create(:title => "A Thousand Plateaus")
-          book.to_param.should eql "a-thousand-plateaus"
+      context 'when it is set to an empty string' do
+        it 'generate a new one' do
+          book = Book.create(title: 'A Thousand Plateaus')
+          expect(book.to_param).to eql 'a-thousand-plateaus'
         end
       end
     end
 
-    context "slug can be localized" do
+    context 'slug can be localized' do
       before(:each) do
         @old_locale = I18n.locale
       end
@@ -748,147 +744,149 @@ module Mongoid
         I18n.locale = @old_locale
       end
 
-      it "generates a new slug for each localization" do
+      it 'generates a new slug for each localization' do
         page = PageSlugLocalized.new
-        page.title = "Title on English"
+        page.title = 'Title on English'
         page.save
-        page.slug.should eql "title-on-english"
+        expect(page.slug).to eql 'title-on-english'
         I18n.locale = :nl
-        page.title = "Title on Netherlands"
+        page.title = 'Title on Netherlands'
         page.save
-        page.slug.should eql "title-on-netherlands"
+        expect(page.slug).to eql 'title-on-netherlands'
       end
 
-      it "returns _id if no slug" do
+      it 'returns _id if no slug' do
         page = PageSlugLocalized.new
-        page.title = "Title on English"
+        page.title = 'Title on English'
         page.save
-        page.slug.should eql "title-on-english"
+        expect(page.slug).to eql 'title-on-english'
         I18n.locale = :nl
-        page.slug.should eql page._id.to_s
+        expect(page.slug).to eql page._id.to_s
       end
 
-      it "fallbacks if slug not localized yet" do
+      it 'fallbacks if slug not localized yet' do
         page = PageSlugLocalized.new
-        page.title = "Title on English"
+        page.title = 'Title on English'
         page.save
-        page.slug.should eql "title-on-english"
+        expect(page.slug).to eql 'title-on-english'
         I18n.locale = :nl
-        page.slug.should eql page._id.to_s
+        expect(page.slug).to eql page._id.to_s
 
         # Turn on i18n fallback
-        require "i18n/backend/fallbacks"
+        require 'i18n/backend/fallbacks'
         I18n::Backend::Simple.send(:include, I18n::Backend::Fallbacks)
-        ::I18n.fallbacks[:nl] = [ :nl, :en ]
-        page.slug.should eql "title-on-english"
+        ::I18n.fallbacks[:nl] = [:nl, :en]
+        expect(page.slug).to eql 'title-on-english'
         fallback_slug = page.slug
 
-        fallback_page = PageSlugLocalized.find(fallback_slug) rescue nil
-        fallback_page.should eq(page)
+        fallback_page = begin
+                          PageSlugLocalized.find(fallback_slug)
+                        rescue
+                          nil
+                        end
+        expect(fallback_page).to eq(page)
 
         # Restore fallback for next tests
-        ::I18n.fallbacks[:nl] = [ :nl ]
+        ::I18n.fallbacks[:nl] = [:nl]
       end
 
-      it "returns a default slug if not localized" do
+      it 'returns a default slug if not localized' do
         page = PageLocalize.new
-        page.title = "Title on English"
+        page.title = 'Title on English'
         page.save
-        page.slug.should eql "title-on-english"
+        expect(page.slug).to eql 'title-on-english'
         I18n.locale = :nl
-        page.title = "Title on Netherlands"
-        page.slug.should eql "title-on-english"
+        page.title = 'Title on Netherlands'
+        expect(page.slug).to eql 'title-on-english'
         page.save
-        page.slug.should eql "title-on-netherlands"
+        expect(page.slug).to eql 'title-on-netherlands'
       end
 
-      it "slugs properly when translations are set directly" do
+      it 'slugs properly when translations are set directly' do
         page = PageSlugLocalized.new
-        page.title_translations = {"en" => "Title on English", "nl" => "Title on Netherlands"}
+        page.title_translations = { 'en' => 'Title on English', 'nl' => 'Title on Netherlands' }
         page.save
-        page["_slugs"].should == {"en" => ["title-on-english"], "nl" => ["title-on-netherlands"]}
+        expect(page['_slugs']).to eq('en' => ['title-on-english'], 'nl' => ['title-on-netherlands'])
       end
 
-      it "exact same title multiple langauges" do
+      it 'exact same title multiple langauges' do
         page = PageSlugLocalized.new
-        page.title_translations = {"en" => "Title on English", "nl" => "Title on English"}
+        page.title_translations = { 'en' => 'Title on English', 'nl' => 'Title on English' }
         page.save
-        page["_slugs"].should == {"en" => ["title-on-english"], "nl" => ["title-on-english"]}
+        expect(page['_slugs']).to eq('en' => ['title-on-english'], 'nl' => ['title-on-english'])
 
-        page = PageSlugLocalized.create(title_translations: {"en" => "Title on English2", "nl" => "Title on English2"})
-        page["_slugs"].should == {"en" => ["title-on-english2"], "nl" => ["title-on-english2"]}
+        page = PageSlugLocalized.create(title_translations: { 'en' => 'Title on English2', 'nl' => 'Title on English2' })
+        expect(page['_slugs']).to eq('en' => ['title-on-english2'], 'nl' => ['title-on-english2'])
       end
 
-
-
-      it "does not produce duplicate slugs" do
+      it 'does not produce duplicate slugs' do
         old_locale = I18n.locale
 
         # Using a default locale of en.
         page = PageSlugLocalized.new
-        page.title = "Title on English"
+        page.title = 'Title on English'
         page.save
-        I18n.locale = "nl"
-        page.title = "Title on Netherlands"
+        I18n.locale = 'nl'
+        page.title = 'Title on Netherlands'
         page.save
-        page.title_translations.should == {"en" => "Title on English", "nl" => "Title on Netherlands"}
+        expect(page.title_translations).to eq('en' => 'Title on English', 'nl' => 'Title on Netherlands')
 
         I18n.locale = old_locale
-        page.title = "Title on English"
-        page.title_translations.should == {"en" => "Title on English", "nl" => "Title on Netherlands"}
-        page["_slugs"].should == {"en" => ["title-on-english"], "nl" => ["title-on-netherlands"]}
+        page.title = 'Title on English'
+        expect(page.title_translations).to eq('en' => 'Title on English', 'nl' => 'Title on Netherlands')
+        expect(page['_slugs']).to eq('en' => ['title-on-english'], 'nl' => ['title-on-netherlands'])
       end
 
-      it "does not produce duplicate slugs when one has changed" do
+      it 'does not produce duplicate slugs when one has changed' do
         old_locale = I18n.locale
 
         # Using a default locale of en.
         page = PageSlugLocalized.new
-        page.title = "Title on English"
+        page.title = 'Title on English'
         page.save
-        I18n.locale = "nl"
-        page.title = "Title on Netherlands"
+        I18n.locale = 'nl'
+        page.title = 'Title on Netherlands'
         page.save
-        page.title_translations.should == {"en" => "Title on English", "nl" => "Title on Netherlands"}
+        expect(page.title_translations).to eq('en' => 'Title on English', 'nl' => 'Title on Netherlands')
 
         I18n.locale = old_locale
-        page.title = "Modified Title on English"
+        page.title = 'Modified Title on English'
         page.save
-        page.title_translations.should == {"en" => "Modified Title on English",
-                                           "nl" => "Title on Netherlands"}
-        page["_slugs"].should == {"en" => ["modified-title-on-english"],
-                                  "nl" => ["title-on-netherlands"]}
+        expect(page.title_translations).to eq('en' => 'Modified Title on English',
+                                              'nl' => 'Title on Netherlands')
+        expect(page['_slugs']).to eq('en' => ['modified-title-on-english'],
+                                     'nl' => ['title-on-netherlands'])
       end
 
-      it "does not produce duplicate slugs when transactions are set directly" do
+      it 'does not produce duplicate slugs when transactions are set directly' do
         page = PageSlugLocalized.new
-        page.title_translations = {"en" => "Title on English", "nl" => "Title on Netherlands"}
+        page.title_translations = { 'en' => 'Title on English', 'nl' => 'Title on Netherlands' }
         page.save
-        page.title_translations = {"en" => "Title on English", "nl" => "Title on Netherlands"}
+        page.title_translations = { 'en' => 'Title on English', 'nl' => 'Title on Netherlands' }
         page.save
-        page["_slugs"].should == {"en" => ["title-on-english"], "nl" => ["title-on-netherlands"]}
+        expect(page['_slugs']).to eq('en' => ['title-on-english'], 'nl' => ['title-on-netherlands'])
       end
 
-      it "does not produce duplicate slugs when transactions are set directly and one has changed" do
+      it 'does not produce duplicate slugs when transactions are set directly and one has changed' do
         page = PageSlugLocalized.new
-        page.title_translations = {"en" => "Title on English", "nl" => "Title on Netherlands"}
+        page.title_translations = { 'en' => 'Title on English', 'nl' => 'Title on Netherlands' }
         page.save
-        page.title_translations = {"en" => "Modified Title on English",
-                                   "nl" => "Title on Netherlands"}
+        page.title_translations = { 'en' => 'Modified Title on English',
+                                    'nl' => 'Title on Netherlands' }
         page.save
-        page["_slugs"].should == {"en" => ["modified-title-on-english"],
-                                  "nl" => ["title-on-netherlands"]}
+        expect(page['_slugs']).to eq('en' => ['modified-title-on-english'],
+                                     'nl' => ['title-on-netherlands'])
       end
 
-      it "works with a custom slug strategy" do
+      it 'works with a custom slug strategy' do
         page = PageSlugLocalizedCustom.new
-        page.title = "a title for the slug"
+        page.title = 'a title for the slug'
         page.save
-        page["_slugs"].should == {"en" => ["a-title-for-the-slug"], "nl"=>["a-title-for-the-slug"]}
+        expect(page['_slugs']).to eq('en' => ['a-title-for-the-slug'], 'nl' => ['a-title-for-the-slug'])
       end
     end
 
-    context "slug can be localized when using history" do
+    context 'slug can be localized when using history' do
       before(:each) do
         @old_locale = I18n.locale
       end
@@ -897,126 +895,129 @@ module Mongoid
         I18n.locale = @old_locale
       end
 
-      it "generate a new slug for each localization and keep history" do
+      it 'generate a new slug for each localization and keep history' do
         old_locale = I18n.locale
 
         page = PageSlugLocalizedHistory.new
-        page.title = "Title on English"
+        page.title = 'Title on English'
         page.save
-        page.slug.should eql "title-on-english"
+        expect(page.slug).to eql 'title-on-english'
         I18n.locale = :nl
-        page.title = "Title on Netherlands"
+        page.title = 'Title on Netherlands'
         page.save
-        page.slug.should eql "title-on-netherlands"
+        expect(page.slug).to eql 'title-on-netherlands'
         I18n.locale = old_locale
-        page.title = "Modified title on English"
+        page.title = 'Modified title on English'
         page.save
-        page.slug.should eql "modified-title-on-english"
-        page.slug.should include("title-on-english")
+        expect(page.slug).to eql 'modified-title-on-english'
+        expect(page.slug).to include('title-on-english')
         I18n.locale = :nl
-        page.title = "Modified title on Netherlands"
+        page.title = 'Modified title on Netherlands'
         page.save
-        page.slug.should eql "modified-title-on-netherlands"
-        page.slug.should include("title-on-netherlands")
+        expect(page.slug).to eql 'modified-title-on-netherlands'
+        expect(page.slug).to include('title-on-netherlands')
       end
 
-      it "returns _id if no slug" do
+      it 'returns _id if no slug' do
         page = PageSlugLocalizedHistory.new
-        page.title = "Title on English"
+        page.title = 'Title on English'
         page.save
-        page.slug.should eql "title-on-english"
+        expect(page.slug).to eql 'title-on-english'
         I18n.locale = :nl
-        page.slug.should eql page._id.to_s
+        expect(page.slug).to eql page._id.to_s
       end
 
-      it "fallbacks if slug not localized yet" do
+      it 'fallbacks if slug not localized yet' do
         page = PageSlugLocalizedHistory.new
-        page.title = "Title on English"
+        page.title = 'Title on English'
         page.save
-        page.slug.should eql "title-on-english"
+        expect(page.slug).to eql 'title-on-english'
         I18n.locale = :nl
-        page.slug.should eql page._id.to_s
+        expect(page.slug).to eql page._id.to_s
 
         # Turn on i18n fallback
-        require "i18n/backend/fallbacks"
+        require 'i18n/backend/fallbacks'
         I18n::Backend::Simple.send(:include, I18n::Backend::Fallbacks)
-        ::I18n.fallbacks[:nl] = [ :nl, :en ]
-        page.slug.should eql "title-on-english"
+        ::I18n.fallbacks[:nl] = [:nl, :en]
+        expect(page.slug).to eql 'title-on-english'
         fallback_slug = page.slug
 
-        fallback_page = PageSlugLocalizedHistory.find(fallback_slug) rescue nil
-        fallback_page.should eq(page)
+        fallback_page = begin
+                          PageSlugLocalizedHistory.find(fallback_slug)
+                        rescue
+                          nil
+                        end
+        expect(fallback_page).to eq(page)
       end
 
-      it "slugs properly when translations are set directly" do
+      it 'slugs properly when translations are set directly' do
         page = PageSlugLocalizedHistory.new
-        page.title_translations = {"en" => "Title on English", "nl" => "Title on Netherlands"}
+        page.title_translations = { 'en' => 'Title on English', 'nl' => 'Title on Netherlands' }
         page.save
-        page.title_translations = {"en" => "Modified Title on English",
-                                   "nl" => "Modified Title on Netherlands"}
+        page.title_translations = { 'en' => 'Modified Title on English',
+                                    'nl' => 'Modified Title on Netherlands' }
         page.save
-        page["_slugs"].should == {"en" => ["title-on-english", "modified-title-on-english"],
-                                  "nl" => ["title-on-netherlands", "modified-title-on-netherlands"]}
+        expect(page['_slugs']).to eq('en' => ['title-on-english', 'modified-title-on-english'],
+                                     'nl' => ['title-on-netherlands', 'modified-title-on-netherlands'])
       end
 
-      it "does not produce duplicate slugs" do
+      it 'does not produce duplicate slugs' do
         old_locale = I18n.locale
 
         # Using a default locale of en.
         page = PageSlugLocalizedHistory.new
-        page.title = "Title on English"
+        page.title = 'Title on English'
         page.save
-        I18n.locale = "nl"
-        page.title = "Title on Netherlands"
+        I18n.locale = 'nl'
+        page.title = 'Title on Netherlands'
         page.save
-        page.title_translations.should == {"en" => "Title on English", "nl" => "Title on Netherlands"}
+        expect(page.title_translations).to eq('en' => 'Title on English', 'nl' => 'Title on Netherlands')
 
         I18n.locale = old_locale
-        page.title = "Title on English"
-        page.title_translations.should == {"en" => "Title on English", "nl" => "Title on Netherlands"}
-        page["_slugs"].should == {"en" => ["title-on-english"], "nl" => ["title-on-netherlands"]}
+        page.title = 'Title on English'
+        expect(page.title_translations).to eq('en' => 'Title on English', 'nl' => 'Title on Netherlands')
+        expect(page['_slugs']).to eq('en' => ['title-on-english'], 'nl' => ['title-on-netherlands'])
       end
 
-      it "does not produce duplicate slugs when one has changed" do
+      it 'does not produce duplicate slugs when one has changed' do
         old_locale = I18n.locale
 
         # Using a default locale of en.
         page = PageSlugLocalizedHistory.new
-        page.title = "Title on English"
+        page.title = 'Title on English'
         page.save
-        I18n.locale = "nl"
-        page.title = "Title on Netherlands"
+        I18n.locale = 'nl'
+        page.title = 'Title on Netherlands'
         page.save
-        page.title_translations.should == {"en" => "Title on English", "nl" => "Title on Netherlands"}
+        expect(page.title_translations).to eq('en' => 'Title on English', 'nl' => 'Title on Netherlands')
 
         I18n.locale = old_locale
-        page.title = "Modified Title on English"
+        page.title = 'Modified Title on English'
         page.save
-        page.title_translations.should == {"en" => "Modified Title on English",
-                                           "nl" => "Title on Netherlands"}
-        page["_slugs"].should == {"en" => ["title-on-english", "modified-title-on-english"],
-                                  "nl" => ["title-on-netherlands"]}
+        expect(page.title_translations).to eq('en' => 'Modified Title on English',
+                                              'nl' => 'Title on Netherlands')
+        expect(page['_slugs']).to eq('en' => ['title-on-english', 'modified-title-on-english'],
+                                     'nl' => ['title-on-netherlands'])
       end
 
-      it "does not produce duplicate slugs when transactions are set directly" do
+      it 'does not produce duplicate slugs when transactions are set directly' do
         page = PageSlugLocalizedHistory.new
-        page.title_translations = {"en" => "Title on English", "nl" => "Title on Netherlands"}
+        page.title_translations = { 'en' => 'Title on English', 'nl' => 'Title on Netherlands' }
         page.save
-        page.title_translations = {"en" => "Title on English", "nl" => "Title on Netherlands"}
+        page.title_translations = { 'en' => 'Title on English', 'nl' => 'Title on Netherlands' }
         page.save
-        page["_slugs"].should == {"en" => ["title-on-english"], "nl" => ["title-on-netherlands"]}
+        expect(page['_slugs']).to eq('en' => ['title-on-english'], 'nl' => ['title-on-netherlands'])
       end
 
-      it "does not produce duplicate slugs when transactions are set directly and one has changed" do
+      it 'does not produce duplicate slugs when transactions are set directly and one has changed' do
         page = PageSlugLocalizedHistory.new
-        page.title_translations = {"en" => "Title on English", "nl" => "Title on Netherlands"}
+        page.title_translations = { 'en' => 'Title on English', 'nl' => 'Title on Netherlands' }
         page.save
-        page.title_translations = {"en" => "Modified Title on English", "nl" => "Title on Netherlands"}
+        page.title_translations = { 'en' => 'Modified Title on English', 'nl' => 'Title on Netherlands' }
         page.save
-        page["_slugs"].should == {"en" => ["title-on-english", "modified-title-on-english"],
-                                  "nl" => ["title-on-netherlands"]}
+        expect(page['_slugs']).to eq('en' => ['title-on-english', 'modified-title-on-english'],
+                                     'nl' => ['title-on-netherlands'])
       end
-
     end
   end
 end