paper_trail 4.0.0 → 5.1.0

data/spec/models/version_spec.rb

@@ -1,6 +1,6 @@
-require 'rails_helper'
+require "rails_helper"
 
-describe PaperTrail::Version, :type => :model do
+describe PaperTrail::Version, type: :model do
   it "should include the `VersionConcern` module to get base functionality" do
     expect(PaperTrail::Version).to include(PaperTrail::VersionConcern)
   end
@@ -13,8 +13,8 @@ describe PaperTrail::Version, :type => :model do
     it { is_expected.to have_db_column(:object).of_type(:text) }
     it { is_expected.to have_db_column(:created_at).of_type(:datetime) }
 
-    describe "object_changes column", :versioning => true do
-      let(:widget) { Widget.create!(:name => 'Dashboard') }
+    describe "object_changes column", versioning: true do
+      let(:widget) { Widget.create!(name: "Dashboard") }
       let(:value) { widget.versions.last.object_changes }
 
       context "serializer is YAML" do
@@ -43,7 +43,7 @@ describe PaperTrail::Version, :type => :model do
 
   describe "Methods" do
     describe "Instance" do
-      subject { PaperTrail::Version.new(attributes) rescue PaperTrail::Version.new }
+      subject { PaperTrail::Version.new }
 
       describe '#paper_trail_originator' do
         it { is_expected.to respond_to(:paper_trail_originator) }
@@ -56,12 +56,12 @@ describe PaperTrail::Version, :type => :model do
           end
         end
 
-        context "Has previous version", :versioning => true do
-          let(:name) { Faker::Name.name }
-          let(:widget) { Widget.create!(:name => Faker::Name.name) }
+        context "Has previous version", versioning: true do
+          let(:name) { FFaker::Name.name }
+          let(:widget) { Widget.create!(name: FFaker::Name.name) }
           before do
-            widget.versions.first.update_attributes!(:whodunnit => name)
-            widget.update_attributes!(:name => Faker::Name.first_name)
+            widget.versions.first.update_attributes!(whodunnit: name)
+            widget.update_attributes!(name: FFaker::Name.first_name)
           end
           subject { widget.versions.last }
 
@@ -76,13 +76,13 @@ describe PaperTrail::Version, :type => :model do
       describe "#originator" do
         it { is_expected.to respond_to(:originator) }
 
-        it 'should set the invoke `paper_trail_originator`' do
+        it "should set the invoke `paper_trail_originator`" do
           allow(ActiveSupport::Deprecation).to receive(:warn)
           is_expected.to receive(:paper_trail_originator)
           subject.originator
         end
 
-        it 'should display a deprecation warning' do
+        it "should display a deprecation warning" do
           expect(ActiveSupport::Deprecation).to receive(:warn).
             with(/Use paper_trail_originator instead of originator/)
           subject.originator
@@ -90,9 +90,10 @@ describe PaperTrail::Version, :type => :model do
       end
 
       describe '#terminator' do
-        it { is_expected.to respond_to(:terminator) }
+        let(:attributes) { { whodunnit: FFaker::Name.first_name } }
+        subject { PaperTrail::Version.new attributes }
 
-        let(:attributes) { {:whodunnit => Faker::Name.first_name} }
+        it { is_expected.to respond_to(:terminator) }
 
         it "is an alias for the `whodunnit` attribute" do
           expect(subject.terminator).to eq(attributes[:whodunnit])
@@ -110,10 +111,10 @@ describe PaperTrail::Version, :type => :model do
 
     describe "Class" do
       column_overrides = [false]
-      if ENV['DB'] == 'postgres' && ::ActiveRecord::VERSION::MAJOR >= 4
-        column_overrides << 'json'
+      if ENV["DB"] == "postgres" && ::ActiveRecord::VERSION::MAJOR >= 4
+        column_overrides << "json"
         # 'jsonb' column types are only supported for ActiveRecord 4.2+
-        column_overrides << 'jsonb' if ::ActiveRecord::VERSION::STRING >= '4.2'
+        column_overrides << "jsonb" if ::ActiveRecord::VERSION::STRING >= "4.2"
       end
 
       column_overrides.shuffle.each do |override|
@@ -121,9 +122,13 @@ describe PaperTrail::Version, :type => :model do
           before do
             if override
               ActiveRecord::Base.connection.execute("SAVEPOINT pgtest;")
-              %w[object object_changes].each do |column|
-                ActiveRecord::Base.connection.execute("ALTER TABLE versions DROP COLUMN #{column};")
-                ActiveRecord::Base.connection.execute("ALTER TABLE versions ADD COLUMN #{column} #{override};")
+              %w(object object_changes).each do |column|
+                ActiveRecord::Base.connection.execute(
+                  "ALTER TABLE versions DROP COLUMN #{column};"
+                )
+                ActiveRecord::Base.connection.execute(
+                  "ALTER TABLE versions ADD COLUMN #{column} #{override};"
+                )
               end
               PaperTrail::Version.reset_column_information
             end
@@ -140,92 +145,131 @@ describe PaperTrail::Version, :type => :model do
 
             context "invalid arguments" do
               it "should raise an error" do
-                expect { PaperTrail::Version.where_object(:foo) }.to raise_error(ArgumentError)
-                expect { PaperTrail::Version.where_object([]) }.to raise_error(ArgumentError)
+                expect {
+                  PaperTrail::Version.where_object(:foo)
+                }.to raise_error(ArgumentError)
+                expect {
+                  PaperTrail::Version.where_object([])
+                }.to raise_error(ArgumentError)
               end
             end
 
-            context "valid arguments", :versioning => true do
+            context "valid arguments", versioning: true do
               let(:widget) { Widget.new }
-              let(:name) { Faker::Name.first_name }
+              let(:name) { FFaker::Name.first_name }
               let(:int) { rand(10) + 1 }
 
               before do
-                widget.update_attributes!(:name => name, :an_integer => int)
-                widget.update_attributes!(:name => 'foobar', :an_integer => 100)
-                widget.update_attributes!(:name => Faker::Name.last_name, :an_integer => 15)
+                widget.update_attributes!(name: name, an_integer: int)
+                widget.update_attributes!(name: "foobar", an_integer: 100)
+                widget.update_attributes!(name: FFaker::Name.last_name, an_integer: 15)
               end
 
               context "`serializer == YAML`" do
-                specify { expect(PaperTrail.serializer).to be PaperTrail::Serializers::YAML }
+                specify do
+                  expect(PaperTrail.serializer).to be PaperTrail::Serializers::YAML
+                end
 
                 it "should be able to locate versions according to their `object` contents" do
-                  expect(PaperTrail::Version.where_object(:name => name)).to eq([widget.versions[1]])
-                  expect(PaperTrail::Version.where_object(:an_integer => 100)).to eq([widget.versions[2]])
+                  expect(
+                    PaperTrail::Version.where_object(name: name)
+                  ).to eq([widget.versions[1]])
+                  expect(
+                    PaperTrail::Version.where_object(an_integer: 100)
+                  ).to eq([widget.versions[2]])
                 end
               end
 
-              context "`serializer == JSON`" do
-                before(:all) { PaperTrail.serializer = PaperTrail::Serializers::JSON }
-                specify { expect(PaperTrail.serializer).to be PaperTrail::Serializers::JSON }
+              context "JSON serializer" do
+                before(:all) do
+                  PaperTrail.serializer = PaperTrail::Serializers::JSON
+                end
+
+                specify do
+                  expect(PaperTrail.serializer).to be PaperTrail::Serializers::JSON
+                end
 
                 it "should be able to locate versions according to their `object` contents" do
-                  expect(PaperTrail::Version.where_object(:name => name)).to eq([widget.versions[1]])
-                  expect(PaperTrail::Version.where_object(:an_integer => 100)).to eq([widget.versions[2]])
+                  expect(
+                    PaperTrail::Version.where_object(name: name)
+                  ).to eq([widget.versions[1]])
+                  expect(
+                    PaperTrail::Version.where_object(an_integer: 100)
+                  ).to eq([widget.versions[2]])
                 end
 
-                after(:all) { PaperTrail.serializer = PaperTrail::Serializers::YAML }
+                after(:all) do
+                  PaperTrail.serializer = PaperTrail::Serializers::YAML
+                end
               end
             end
           end
 
           describe '#where_object_changes' do
-            it { expect(PaperTrail::Version).to respond_to(:where_object_changes) }
-
             context "invalid arguments" do
               it "should raise an error" do
-                expect { PaperTrail::Version.where_object_changes(:foo) }.to raise_error(ArgumentError)
-                expect { PaperTrail::Version.where_object_changes([]) }.to raise_error(ArgumentError)
+                expect {
+                  PaperTrail::Version.where_object_changes(:foo)
+                }.to raise_error(ArgumentError)
+                expect {
+                  PaperTrail::Version.where_object_changes([])
+                }.to raise_error(ArgumentError)
               end
             end
 
-            context "valid arguments", :versioning => true do
+            context "valid arguments", versioning: true do
               let(:widget) { Widget.new }
-              let(:name) { Faker::Name.first_name }
+              let(:name) { FFaker::Name.first_name }
               let(:int) { rand(5) + 2 }
 
               before do
-                widget.update_attributes!(:name => name, :an_integer => 0)
-                widget.update_attributes!(:name => 'foobar', :an_integer => 77)
-                widget.update_attributes!(:name => Faker::Name.last_name, :an_integer => int)
+                widget.update_attributes!(name: name, an_integer: 0)
+                widget.update_attributes!(name: "foobar", an_integer: 77)
+                widget.update_attributes!(name: FFaker::Name.last_name, an_integer: int)
               end
 
-              context "`serializer == YAML`" do
+              context "YAML serializer" do
                 specify { expect(PaperTrail.serializer).to be PaperTrail::Serializers::YAML }
 
-                it "should be able to locate versions according to their `object_changes` contents" do
-                  expect(widget.versions.where_object_changes(:name => name)).to eq(widget.versions[0..1])
-                  expect(widget.versions.where_object_changes(:an_integer => 77)).to eq(widget.versions[1..2])
-                  expect(widget.versions.where_object_changes(:an_integer => int)).to eq([widget.versions.last])
+                it "locates versions according to their `object_changes` contents" do
+                  expect(
+                    widget.versions.where_object_changes(name: name)
+                  ).to eq(widget.versions[0..1])
+                  expect(
+                    widget.versions.where_object_changes(an_integer: 77)
+                  ).to eq(widget.versions[1..2])
+                  expect(
+                    widget.versions.where_object_changes(an_integer: int)
+                  ).to eq([widget.versions.last])
                 end
 
-                it "should be able to handle queries for multiple attributes" do
-                  expect(widget.versions.where_object_changes(:an_integer => 77, :name => 'foobar')).to eq(widget.versions[1..2])
+                it "handles queries for multiple attributes" do
+                  expect(
+                    widget.versions.where_object_changes(an_integer: 77, name: "foobar")
+                  ).to eq(widget.versions[1..2])
                 end
               end
 
-              context "`serializer == JSON`" do
+              context "JSON serializer" do
                 before(:all) { PaperTrail.serializer = PaperTrail::Serializers::JSON }
                 specify { expect(PaperTrail.serializer).to be PaperTrail::Serializers::JSON }
 
-                it "should be able to locate versions according to their `object_changes` contents" do
-                  expect(widget.versions.where_object_changes(:name => name)).to eq(widget.versions[0..1])
-                  expect(widget.versions.where_object_changes(:an_integer => 77)).to eq(widget.versions[1..2])
-                  expect(widget.versions.where_object_changes(:an_integer => int)).to eq([widget.versions.last])
+                it "locates versions according to their `object_changes` contents" do
+                  expect(
+                    widget.versions.where_object_changes(name: name)
+                  ).to eq(widget.versions[0..1])
+                  expect(
+                    widget.versions.where_object_changes(an_integer: 77)
+                  ).to eq(widget.versions[1..2])
+                  expect(
+                    widget.versions.where_object_changes(an_integer: int)
+                  ).to eq([widget.versions.last])
                 end
 
-                it "should be able to handle queries for multiple attributes" do
-                  expect(widget.versions.where_object_changes(:an_integer => 77, :name => 'foobar')).to eq(widget.versions[1..2])
+                it "handles queries for multiple attributes" do
+                  expect(
+                    widget.versions.where_object_changes(an_integer: 77, name: "foobar")
+                  ).to eq(widget.versions[1..2])
                 end
 
                 after(:all) { PaperTrail.serializer = PaperTrail::Serializers::YAML }

data/spec/models/widget_spec.rb

@@ -1,63 +1,66 @@
-require 'rails_helper'
+require "rails_helper"
 
-describe Widget, :type => :model do
-  describe '`be_versioned` matcher' do
+describe Widget, type: :model do
+  describe "`be_versioned` matcher" do
     it { is_expected.to be_versioned }
   end
 
-  let(:widget) { Widget.create! :name => 'Bob', :an_integer => 1 }
+  let(:widget) { Widget.create! name: "Bob", an_integer: 1 }
 
-  describe '`have_a_version_with` matcher', :versioning => true do
+  describe "`have_a_version_with` matcher", versioning: true do
     before do
-      widget.update_attributes!(:name => 'Leonard', :an_integer => 1 )
-      widget.update_attributes!(:name => 'Tom')
-      widget.update_attributes!(:name => 'Bob')
+      widget.update_attributes!(name: "Leonard", an_integer: 1)
+      widget.update_attributes!(name: "Tom")
+      widget.update_attributes!(name: "Bob")
     end
 
     it "is possible to do assertions on versions" do
-       expect(widget).to have_a_version_with :name => 'Leonard', :an_integer => 1
-       expect(widget).to have_a_version_with :an_integer => 1
-       expect(widget).to have_a_version_with :name => 'Tom'
+      expect(widget).to have_a_version_with name: "Leonard", an_integer: 1
+      expect(widget).to have_a_version_with an_integer: 1
+      expect(widget).to have_a_version_with name: "Tom"
     end
   end
 
-  describe "`versioning` option" do
-    context :enabled, :versioning => true do
-      it 'should enable versioning for models wrapped within a block' do
+  describe "versioning option" do
+    context "enabled", versioning: true do
+      it "should enable versioning" do
         expect(widget.versions.size).to eq(1)
       end
     end
 
-    context '`disabled` (default)' do
-      it 'should not enable versioning for models wrapped within a block not marked to used versioning' do
+    context "disabled (default)" do
+      it "should not enable versioning" do
         expect(widget.versions.size).to eq(0)
       end
     end
   end
 
-  describe "Callbacks", :versioning => true do
+  describe "Callbacks", versioning: true do
     describe :before_save do
-      context ':on => :update' do
-        before { widget.update_attributes!(:name => 'Foobar') }
+      context ":on => :update" do
+        before { widget.update_attributes!(name: "Foobar") }
 
         subject { widget.versions.last.reify }
 
-        it "should reset the value for the timestamp attrs for update so that value gets updated properly" do
-          expect { subject.save! }.to change(subject, :updated_at)
+        it "resets value for timestamp attrs for update so that value gets updated properly" do
+          # Travel 1 second because MySQL lacks sub-second resolution
+          Timecop.travel(1) do
+            expect { subject.save! }.to change(subject, :updated_at)
+          end
         end
       end
     end
 
     describe :after_create do
-      let(:widget) { Widget.create!(:name => 'Foobar', :created_at => Time.now - 1.week) }
+      let(:widget) { Widget.create!(name: "Foobar", created_at: Time.now - 1.week) }
 
-      it "corresponding version should use the widget's `created_at`" do
-        expect(widget.versions.last.created_at.to_i).to eq(widget.created_at.to_i)
+      it "corresponding version should use the widget's `updated_at`" do
+        expect(widget.versions.last.created_at.to_i).to eq(widget.updated_at.to_i)
       end
     end
 
     describe :after_update do
-      before { widget.update_attributes!(:name => 'Foobar', :updated_at => Time.now + 1.week) }
+      before { widget.update_attributes!(name: "Foobar", updated_at: Time.now + 1.week) }
 
       subject { widget.versions.last.reify }
 
@@ -87,13 +90,13 @@ describe Widget, :type => :model do
     end
 
     describe :after_rollback do
-      let(:rolled_back_name) { 'Big Moo' }
+      let(:rolled_back_name) { "Big Moo" }
 
       before do
         begin
           widget.transaction do
-            widget.update_attributes!(:name => rolled_back_name)
-            widget.update_attributes!(:name => Widget::EXCLUDED_NAME)
+            widget.update_attributes!(name: rolled_back_name)
+            widget.update_attributes!(name: Widget::EXCLUDED_NAME)
           end
         rescue ActiveRecord::RecordInvalid
           widget.reload
@@ -102,31 +105,47 @@ describe Widget, :type => :model do
         end
       end
 
-      it 'does not create an event for changes that did not happen' do
+      it "does not create an event for changes that did not happen" do
         widget.versions.map(&:changeset).each do |changeset|
-          expect(changeset.fetch('name', [])).to_not include(rolled_back_name)
+          expect(changeset.fetch("name", [])).to_not include(rolled_back_name)
         end
       end
+
+      it "has not yet loaded the assocation" do
+        expect(widget.versions).to_not be_loaded
+      end
     end
   end
 
-  describe "Association", :versioning => true do
+  describe "Association", versioning: true do
     describe "sort order" do
       it "should sort by the timestamp order from the `VersionConcern`" do
         expect(widget.versions.to_sql).to eq(
-          widget.versions.reorder(PaperTrail::Version.timestamp_sort_order).to_sql)
+          widget.versions.reorder(PaperTrail::Version.timestamp_sort_order).to_sql
+        )
+      end
+    end
+  end
+
+  if defined?(ActiveRecord::IdentityMap) && ActiveRecord::IdentityMap.respond_to?(:without)
+    describe "IdentityMap", versioning: true do
+      it "should not clobber the IdentityMap when reifying" do
+        widget.update_attributes name: "Henry", created_at: Time.now - 1.day
+        widget.update_attributes name: "Harry"
+        expect(ActiveRecord::IdentityMap).to receive(:without).once
+        widget.versions.last.reify
       end
     end
   end
 
   describe "Methods" do
-    describe "Instance", :versioning => true do
+    describe "Instance", versioning: true do
       describe '#paper_trail_originator' do
         it { is_expected.to respond_to(:paper_trail_originator) }
 
         describe "return value" do
-          let(:orig_name) { Faker::Name.name }
-          let(:new_name) { Faker::Name.name }
+          let(:orig_name) { FFaker::Name.name }
+          let(:new_name) { FFaker::Name.name }
           before { PaperTrail.whodunnit = orig_name }
 
           context "accessed from live model instance" do
@@ -134,16 +153,16 @@ describe Widget, :type => :model do
 
             it "should return the originator for the model at a given state" do
               expect(widget.paper_trail_originator).to eq(orig_name)
-              widget.whodunnit(new_name) { |w| w.update_attributes(:name => 'Elizabeth') }
+              widget.whodunnit(new_name) { |w| w.update_attributes(name: "Elizabeth") }
               expect(widget.paper_trail_originator).to eq(new_name)
             end
           end
 
           context "accessed from a reified model instance" do
             before do
-              widget.update_attributes(:name => 'Andy')
+              widget.update_attributes(name: "Andy")
               PaperTrail.whodunnit = new_name
-              widget.update_attributes(:name => 'Elizabeth')
+              widget.update_attributes(name: "Elizabeth")
             end
 
             context "default behavior (no `options[:dup]` option passed in)" do
@@ -159,7 +178,7 @@ describe Widget, :type => :model do
             end
 
             context "creating a new instance (`options[:dup] == true`)" do
-              let(:reified_widget) { widget.versions[1].reify(:dup => true) }
+              let(:reified_widget) { widget.versions[1].reify(dup: true) }
 
               it "should return the appropriate originator" do
                 expect(reified_widget.paper_trail_originator).to eq(orig_name)
@@ -178,13 +197,13 @@ describe Widget, :type => :model do
 
         it { is_expected.to respond_to(:originator) }
 
-        it 'should set the invoke `paper_trail_originator`' do
+        it "should set the invoke `paper_trail_originator`" do
           allow(::ActiveSupport::Deprecation).to receive(:warn)
           is_expected.to receive(:paper_trail_originator)
           subject.originator
         end
 
-        it 'should display a deprecation warning' do
+        it "should display a deprecation warning" do
           expect(::ActiveSupport::Deprecation).to receive(:warn).
             with(/Use paper_trail_originator instead of originator/)
           subject.originator
@@ -196,7 +215,7 @@ describe Widget, :type => :model do
 
         context "Timestamp argument is AFTER object has been destroyed" do
           before do
-            widget.update_attribute(:name, 'foobar')
+            widget.update_attribute(:name, "foobar")
             widget.destroy
           end
 
@@ -211,13 +230,15 @@ describe Widget, :type => :model do
 
         context "no block given" do
           it "should raise an error" do
-            expect { widget.whodunnit('Ben') }.to raise_error(ArgumentError, 'expected to receive a block')
+            expect {
+              widget.whodunnit("Ben")
+            }.to raise_error(ArgumentError, "expected to receive a block")
           end
         end
 
         context "block given" do
-          let(:orig_name) { Faker::Name.name }
-          let(:new_name) { Faker::Name.name }
+          let(:orig_name) { FFaker::Name.name }
+          let(:new_name) { FFaker::Name.name }
 
           before do
             PaperTrail.whodunnit = orig_name
@@ -227,19 +248,23 @@ describe Widget, :type => :model do
           it "should modify value of `PaperTrail.whodunnit` while executing the block" do
             widget.whodunnit(new_name) do
               expect(PaperTrail.whodunnit).to eq(new_name)
-              widget.update_attributes(:name => 'Elizabeth')
+              widget.update_attributes(name: "Elizabeth")
             end
             expect(widget.versions.last.whodunnit).to eq(new_name)
           end
 
-          it "should revert the value of `PaperTrail.whodunnit` to it's previous value after executing the block" do
-            widget.whodunnit(new_name) { |w| w.update_attributes(:name => 'Elizabeth') }
-            expect(PaperTrail.whodunnit).to eq(orig_name)
+          context "after executing the block" do
+            it "reverts value of whodunnit to previous value" do
+              widget.whodunnit(new_name) { |w| w.update_attributes(name: "Elizabeth") }
+              expect(PaperTrail.whodunnit).to eq(orig_name)
+            end
           end
 
           context "error within block" do
-            it "should ensure that the whodunnit value still reverts to it's previous value" do
-              expect { widget.whodunnit(new_name) { raise } }.to raise_error
+            it "still reverts the whodunnit value to previous value" do
+              expect {
+                widget.whodunnit(new_name) { raise }
+              }.to raise_error(RuntimeError)
               expect(PaperTrail.whodunnit).to eq(orig_name)
             end
           end
@@ -251,13 +276,19 @@ describe Widget, :type => :model do
 
         it "creates a version" do
           count = widget.versions.size
-          widget.touch_with_version
+          # Travel 1 second because MySQL lacks sub-second resolution
+          Timecop.travel(1) do
+            widget.touch_with_version
+          end
           expect(widget.versions.size).to eq(count + 1)
         end
 
         it "increments the `:updated_at` timestamp" do
           time_was = widget.updated_at
-          widget.touch_with_version
+          # Travel 1 second because MySQL lacks sub-second resolution
+          Timecop.travel(1) do
+            widget.touch_with_version
+          end
           expect(widget.updated_at).to be > time_was
         end
       end
@@ -275,7 +306,7 @@ describe Widget, :type => :model do
       describe '#paper_trail_off!' do
         it { is_expected.to respond_to(:paper_trail_off!) }
 
-        it 'should set the `paper_trail_enabled_for_model?` to `false`' do
+        it "should set the `paper_trail_enabled_for_model?` to `false`" do
           expect(subject.paper_trail_enabled_for_model?).to be true
           subject.paper_trail_off!
           expect(subject.paper_trail_enabled_for_model?).to be false
@@ -287,7 +318,7 @@ describe Widget, :type => :model do
 
         it { is_expected.to respond_to(:paper_trail_on!) }
 
-        it 'should set the `paper_trail_enabled_for_model?` to `true`' do
+        it "should set the `paper_trail_enabled_for_model?` to `true`" do
           expect(subject.paper_trail_enabled_for_model?).to be false
           subject.paper_trail_on!
           expect(subject.paper_trail_enabled_for_model?).to be true

data/spec/modules/paper_trail_spec.rb

@@ -1,6 +1,6 @@
-require 'rails_helper'
+require "rails_helper"
 
-describe PaperTrail, :type => :module, :versioning => true do
+describe PaperTrail, type: :module, versioning: true do
   describe '#config' do
     it { is_expected.to respond_to(:config) }
 

data/spec/modules/version_concern_spec.rb

@@ -1,30 +1,29 @@
-require 'rails_helper'
+require "rails_helper"
 
 describe PaperTrail::VersionConcern do
+  before(:all) { require "support/alt_db_init" }
 
-  before(:all) { require 'support/alt_db_init' }
-
-  it 'allows included class to have different connections' do
+  it "allows included class to have different connections" do
     expect(Foo::Version.connection).not_to eq(Bar::Version.connection)
   end
 
-  it 'allows custom version class to share connection with superclass' do
+  it "allows custom version class to share connection with superclass" do
     expect(Foo::Version.connection).to eq(Foo::Document.connection)
     expect(Bar::Version.connection).to eq(Bar::Document.connection)
   end
 
-  it 'can be used with class_name option' do
-    expect(Foo::Document.version_class_name).to eq('Foo::Version')
-    expect(Bar::Document.version_class_name).to eq('Bar::Version')
+  it "can be used with class_name option" do
+    expect(Foo::Document.version_class_name).to eq("Foo::Version")
+    expect(Bar::Document.version_class_name).to eq("Bar::Version")
   end
 
-  describe 'persistence', :versioning => true do
+  describe "persistence", versioning: true do
     before do
-      @foo_doc = Foo::Document.create!(:name => 'foobar')
-      @bar_doc = Bar::Document.create!(:name => 'raboof')
+      @foo_doc = Foo::Document.create!(name: "foobar")
+      @bar_doc = Bar::Document.create!(name: "raboof")
     end
 
-    it 'should store versions in the correct corresponding db location' do
+    it "should store versions in the correct corresponding db location" do
       expect(@foo_doc.versions.first).to be_instance_of(Foo::Version)
       expect(@bar_doc.versions.first).to be_instance_of(Bar::Version)
     end

data/spec/modules/version_number_spec.rb

@@ -1,7 +1,6 @@
-require 'spec_helper'
+require "spec_helper"
 
 describe PaperTrail::VERSION do
-
   describe "Constants" do
     subject { PaperTrail::VERSION }
 
@@ -29,11 +28,11 @@ describe PaperTrail::VERSION do
 
       it "should join the numbers into a period separated string" do
         expect(subject::STRING).to eq(
-          [subject::MAJOR, subject::MINOR, subject::TINY, subject::PRE].compact.join('.'))
+          [subject::MAJOR, subject::MINOR, subject::TINY, subject::PRE].compact.join(".")
+        )
       end
     end
   end
-
 end
 
 describe PaperTrail do