mongoid-history 0.6.1 → 0.7.0

data/lib/mongoid/history/tracker.rb

@@ -19,7 +19,7 @@ module Mongoid
         index(scope: 1)
         index(association_chain: 1)
 
-        Mongoid::History.tracker_class_name = name.tableize.singularize.to_sym
+        Mongoid::History.tracker_class_name ||= name.tableize.singularize.to_sym
       end
 
       def undo!(modifier = nil)
@@ -180,7 +180,7 @@ module Mongoid
         elsif trackable_parent.class.embeds_many?(name)
           trackable_parent.get_embedded(name).create!(localize_keys(original))
         else
-          fail 'This should never happen. Please report bug!'
+          raise 'This should never happen. Please report bug!'
         end
       end
 
@@ -205,7 +205,7 @@ module Mongoid
                 elsif doc.class.embeds_many?(name)
                   doc.get_embedded(name).unscoped.where(_id: node['id']).first
                 else
-                  fail 'This should never happen. Please report bug.'
+                  raise 'This should never happen. Please report bug.'
                 end
           documents << doc
           break if chain.empty?
@@ -215,9 +215,11 @@ module Mongoid
 
       def localize_keys(hash)
         klass = association_chain.first['name'].constantize
-        klass.localized_fields.keys.each do |name|
-          hash["#{name}_translations"] = hash.delete(name) if hash[name].present?
-        end if klass.respond_to?(:localized_fields)
+        if klass.respond_to?(:localized_fields)
+          klass.localized_fields.keys.each do |name|
+            hash["#{name}_translations"] = hash.delete(name) if hash[name].present?
+          end
+        end
         hash
       end
 

data/lib/mongoid/history/version.rb

@@ -1,5 +1,5 @@
 module Mongoid
   module History
-    VERSION = '0.6.1'
+    VERSION = '0.7.0'.freeze
   end
 end

data/spec/integration/embedded_in_polymorphic_spec.rb

@@ -68,7 +68,7 @@ describe Mongoid::History::Tracker do
                     track_create: true, # track document creation, default is false
                     track_update: true, # track document updates, default is true
                     track_destroy: false, # track document destruction, default is false
-                    scope: [:real_state, :company]
+                    scope: %i[real_state company]
     end
 
     class User

data/spec/integration/integration_spec.rb

@@ -18,7 +18,7 @@ describe Mongoid::History do
 
       accepts_nested_attributes_for :tags, allow_destroy: true
 
-      track_history on: [:title, :body], track_destroy: true
+      track_history on: %i[title body], track_destroy: true
     end
 
     class Comment
@@ -29,7 +29,7 @@ describe Mongoid::History do
       field :t, as: :title
       field :body
       embedded_in :commentable, polymorphic: true
-      track_history on: [:title, :body], scope: :post, track_create: true, track_destroy: true
+      track_history on: %i[title body], scope: :post, track_create: true, track_destroy: true
     end
 
     class Section
@@ -54,7 +54,7 @@ describe Mongoid::History do
       field :city
       field :country
       field :aliases, type: Array
-      track_history except: [:email, :updated_at]
+      track_history except: %i[email updated_at]
     end
 
     class Tag
@@ -229,14 +229,14 @@ describe Mongoid::History do
 
       it 'should track array changes' do
         aliases = user.aliases
-        user.update_attributes(aliases: %w(bob joe))
+        user.update_attributes(aliases: %w[bob joe])
         expect(user.history_tracks.first.original['aliases']).to eq(aliases)
         expect(user.history_tracks.first.modified['aliases']).to eq(user.aliases)
       end
 
       it 'should undo array changes' do
         aliases = user.aliases
-        user.update_attributes(aliases: %w(bob joe))
+        user.update_attributes(aliases: %w[bob joe])
         user.history_tracks.first.undo! nil
         expect(user.reload.aliases).to eq(aliases)
       end
@@ -323,12 +323,12 @@ describe Mongoid::History do
           expect(subject[:array]).to eq({ aliases: { remove: ['bob'], add: ['', 'bill', 'james'] } }.with_indifferent_access)
         end
         it 'should not track unmodified field' do
-          %w(add modify remove array).each do |edit|
+          %w[add modify remove array].each do |edit|
             expect(subject[edit][:address]).to be_nil
           end
         end
         it 'should not track untracked fields' do
-          %w(add modify remove array).each do |edit|
+          %w[add modify remove array].each do |edit|
             expect(subject[edit][:email]).to be_nil
           end
         end
@@ -639,7 +639,7 @@ describe Mongoid::History do
       describe 'undo' do
         { 'undo' => [nil], 'undo!' => [nil, :reload] }.each do |test_method, methods|
           methods.each do |method|
-            context "#{method || 'instance'}" do
+            context (method || 'instance').to_s do
               it 'recognizes :from, :to options' do
                 comment.send test_method, user, from: 4, to: 2
                 comment.send(method) if method
@@ -694,7 +694,7 @@ describe Mongoid::History do
 
       describe 'redo' do
         [nil, :reload].each do |method|
-          context "#{method || 'instance'}" do
+          context (method || 'instance').to_s do
             before :each do
               comment.update_attributes(title: 'Test5')
             end
@@ -919,7 +919,7 @@ describe Mongoid::History do
           track_history on: [:foo], changes_method: :my_changes
 
           def my_changes
-            { foo: %w(bar baz) }
+            { foo: %w[bar baz] }
           end
         end
       end

data/spec/integration/multi_relation_spec.rb

@@ -10,7 +10,7 @@ describe Mongoid::History::Tracker do
       belongs_to :user, inverse_of: :models
       has_and_belongs_to_many :external_users, class_name: 'User', inverse_of: :external_models
 
-      track_history on: [:name, :user, :external_user_ids], # track title and body fields only, default is :all
+      track_history on: %i[name user external_user_ids], # track title and body fields only, default is :all
                     modifier_field: :modifier, # adds "referenced_in :modifier" to track who made the change, default is :modifier
                     modifier_field_inverse_of: nil, # no inverse modifier relationship
                     version_field: :version, # adds "field :version, :type => Integer" to track current version, default is :version

data/spec/integration/multiple_trackers_spec.rb

@@ -0,0 +1,71 @@
+require 'spec_helper'
+
+describe Mongoid::History do
+  before :all do
+    Mongoid::History.tracker_class_name = nil
+
+    module MultipleTrackersSpec
+      class First
+        include Mongoid::Document
+        include Mongoid::History::Trackable
+
+        field :text, type: String
+        track_history on: [:text],
+                      track_create: true,
+                      track_update: true,
+                      track_destroy: true,
+                      tracker_class_name: :first_history_tracker
+      end
+
+      class Second
+        include Mongoid::Document
+        include Mongoid::History::Trackable
+
+        field :text, type: String
+        track_history on: [:text],
+                      track_create: true,
+                      track_update: true,
+                      track_destroy: true,
+                      tracker_class_name: :second_history_tracker
+      end
+    end
+
+    class FirstHistoryTracker
+      include Mongoid::History::Tracker
+    end
+
+    class SecondHistoryTracker
+      include Mongoid::History::Tracker
+    end
+  end
+
+  it 'should be possible to have different trackers for each class' do
+    expect(FirstHistoryTracker.count).to eq(0)
+    expect(SecondHistoryTracker.count).to eq(0)
+    expect(MultipleTrackersSpec::First.tracker_class).to be FirstHistoryTracker
+    expect(MultipleTrackersSpec::Second.tracker_class).to be SecondHistoryTracker
+
+    foo = MultipleTrackersSpec::First.new
+    foo.save
+
+    bar = MultipleTrackersSpec::Second.new
+    bar.save
+
+    expect(FirstHistoryTracker.count).to eq 1
+    expect(SecondHistoryTracker.count).to eq 1
+
+    foo.text = "I'm foo"
+    foo.save
+    bar.text = "I'm bar"
+    bar.save
+
+    expect(FirstHistoryTracker.count).to eq 2
+    expect(SecondHistoryTracker.count).to eq 2
+
+    foo.destroy
+    bar.destroy
+
+    expect(FirstHistoryTracker.count).to eq 3
+    expect(SecondHistoryTracker.count).to eq 3
+  end
+end

data/spec/integration/nested_embedded_polymorphic_documents_spec.rb

@@ -48,7 +48,7 @@ describe Mongoid::History::Tracker do
                     track_create: true,
                     track_update: true,
                     track_destroy: true,
-                    scope: [:modelone, :modeltwo]
+                    scope: %i[modelone modeltwo]
     end
 
     class EmbeddedTwo
@@ -64,7 +64,7 @@ describe Mongoid::History::Tracker do
                     track_create: true,
                     track_update: true,
                     track_destroy: true,
-                    scope: [:modelone, :modeltwo]
+                    scope: %i[modelone modeltwo]
     end
 
     class User

data/spec/integration/validation_failure_spec.rb

@@ -0,0 +1,63 @@
+require 'spec_helper'
+
+describe Mongoid::History::Tracker do
+  before :all do
+    class Element
+      include Mongoid::Document
+      include Mongoid::Timestamps
+      include Mongoid::History::Trackable
+
+      field :title
+      field :body
+
+      validates :title, presence: true
+
+      has_many :items, dependent: :restrict
+
+      track_history on: [:body], track_create: true, track_update: true, track_destroy: true
+    end
+
+    class Item
+      include Mongoid::Document
+      include Mongoid::Timestamps
+
+      belongs_to :element
+    end
+
+    class Prompt < Element
+    end
+
+    @persisted_history_options = Mongoid::History.trackable_class_options
+  end
+
+  before(:each) { Mongoid::History.trackable_class_options = @persisted_history_options }
+
+  it 'does not track delete when parent class validation fails' do
+    prompt = Prompt.new(title: 'first')
+    expect { prompt.save! }.to change(Tracker, :count).by(1)
+    expect do
+      expect { prompt.update_attributes!(title: nil, body: 'one') }
+        .to raise_error(Mongoid::Errors::Validations)
+    end.to change(Tracker, :count).by(0)
+  end
+
+  it 'does not track delete when parent class restrict dependency fails' do
+    prompt = Prompt.new(title: 'first')
+    prompt.items << Item.new
+    expect { prompt.save! }.to change(Tracker, :count).by(1)
+    expect(prompt.version).to eq(1)
+    expect do
+      expect { prompt.destroy }.to raise_error(Mongoid::Errors::DeleteRestriction)
+    end.to change(Tracker, :count).by(0)
+  end
+
+  it 'does not track delete when restrict dependency fails' do
+    elem = Element.new(title: 'first')
+    elem.items << Item.new
+    expect { elem.save! }.to change(Tracker, :count).by(1)
+    expect(elem.version).to eq(1)
+    expect do
+      expect { elem.destroy }.to raise_error(Mongoid::Errors::DeleteRestriction)
+    end.to change(Tracker, :count).by(0)
+  end
+end

data/spec/spec_helper.rb

@@ -19,7 +19,7 @@ RSpec.configure do |config|
   config.raise_errors_for_deprecations!
   config.before :all do
     Mongoid.logger.level = Logger::INFO
-    Mongo::Logger.logger.level = Logger::INFO if Mongoid::Compatibility::Version.mongoid5?
+    Mongo::Logger.logger.level = Logger::INFO if Mongoid::Compatibility::Version.mongoid5? || Mongoid::Compatibility::Version.mongoid6?
     Mongoid.belongs_to_required_by_default = false if Mongoid::Compatibility::Version.mongoid6?
   end
 end

data/spec/unit/attributes/base_spec.rb

@@ -108,7 +108,7 @@ describe Mongoid::History::Attributes::Base do
 
     context 'with permitted attributes' do
       before do
-        model_one.track_history on: { model_two: %i(foo) }
+        model_one.track_history on: { model_two: %i[foo] }
       end
 
       it 'should select only permitted attributes' do
@@ -119,7 +119,7 @@ describe Mongoid::History::Attributes::Base do
 
     context 'with attributes formatted via string' do
       before do
-        model_one.track_history on: { model_two: %i(foo) }, format: { model_two: { foo: '&%s&' } }
+        model_one.track_history on: { model_two: %i[foo] }, format: { model_two: { foo: '&%s&' } }
       end
 
       it 'should select obfuscate permitted attributes' do
@@ -130,7 +130,7 @@ describe Mongoid::History::Attributes::Base do
 
     context 'with attributes formatted via proc' do
       before do
-        model_one.track_history on: { model_two: %i(foo) }, format: { model_two: { foo: ->(v) { v.to_s * 2 } } }
+        model_one.track_history on: { model_two: %i[foo] }, format: { model_two: { foo: ->(v) { v.to_s * 2 } } }
       end
 
       it 'should select obfuscate permitted attributes' do

data/spec/unit/my_instance_methods_spec.rb

@@ -45,7 +45,7 @@ describe Mongoid::History::Trackable do
         embedded_in :model_one
       end
 
-      ModelOne.track_history(on: %i(foo emb_one emb_threes))
+      ModelOne.track_history(on: %i[foo emb_one emb_threes])
       @persisted_history_options = Mongoid::History.trackable_class_options
     end
     before(:each) { Mongoid::History.trackable_class_options = @persisted_history_options }

data/spec/unit/options_spec.rb

@@ -61,7 +61,7 @@ describe Mongoid::History::Options do
     describe '#default_options' do
       let(:expected_options) do
         { on: :all,
-          except: [:created_at, :updated_at],
+          except: %i[created_at updated_at],
           tracker_class_name: nil,
           modifier_field: :modifier,
           version_field: :version,
@@ -81,27 +81,27 @@ describe Mongoid::History::Options do
 
       context 'with field' do
         let(:value) { :foo }
-        it { expect(subject[:except]).to eq %w(foo) }
+        it { expect(subject[:except]).to eq %w[foo] }
       end
 
       context 'with array of fields' do
-        let(:value) { %i(foo) }
-        it { expect(subject[:except]).to eq %w(foo) }
+        let(:value) { %i[foo] }
+        it { expect(subject[:except]).to eq %w[foo] }
       end
 
       context 'with field alias' do
-        let(:value) { %i(foo bar) }
-        it { expect(subject[:except]).to eq %w(foo b) }
+        let(:value) { %i[foo bar] }
+        it { expect(subject[:except]).to eq %w[foo b] }
       end
 
       context 'with duplicate values' do
-        let(:value) { %i(foo bar b) }
-        it { expect(subject[:except]).to eq %w(foo b) }
+        let(:value) { %i[foo bar b] }
+        it { expect(subject[:except]).to eq %w[foo b] }
       end
 
       context 'with blank values' do
-        let(:value) { %i(foo) | [nil] }
-        it { expect(subject[:except]).to eq %w(foo) }
+        let(:value) { %i[foo] | [nil] }
+        it { expect(subject[:except]).to eq %w[foo] }
       end
     end
 
@@ -128,8 +128,8 @@ describe Mongoid::History::Options do
     describe '#parse_tracked_fields_and_relations' do
       context 'when options not passed' do
         let(:expected_options) do
-          { on: %i(foo b),
-            except: %w(created_at updated_at),
+          { on: %i[foo b],
+            except: %w[created_at updated_at],
             tracker_class_name: nil,
             modifier_field: :modifier,
             version_field: :version,
@@ -138,7 +138,7 @@ describe Mongoid::History::Options do
             track_create: false,
             track_update: true,
             track_destroy: false,
-            fields: %w(foo b),
+            fields: %w[foo b],
             dynamic: [],
             relations: { embeds_one: {}, embeds_many: {} },
             format: {} }
@@ -154,114 +154,114 @@ describe Mongoid::History::Options do
 
           context 'with field' do
             let(:value) { :foo }
-            it { expect(subject[:on]).to eq %i(foo) }
-            it { expect(subject[:fields]).to eq %w(foo) }
+            it { expect(subject[:on]).to eq %i[foo] }
+            it { expect(subject[:fields]).to eq %w[foo] }
           end
 
           context 'with array of fields' do
-            let(:value) { %i(foo) }
-            it { expect(subject[:on]).to eq %i(foo) }
-            it { expect(subject[:fields]).to eq %w(foo) }
+            let(:value) { %i[foo] }
+            it { expect(subject[:on]).to eq %i[foo] }
+            it { expect(subject[:fields]).to eq %w[foo] }
           end
 
           context 'with embeds_one relation attributes' do
-            let(:value) { { emb_one: %i(f_em_foo) } }
-            it { expect(subject[:on]).to eq [[:emb_one, %i(f_em_foo)]] }
+            let(:value) { { emb_one: %i[f_em_foo] } }
+            it { expect(subject[:on]).to eq [[:emb_one, %i[f_em_foo]]] }
           end
 
           context 'with fields and embeds_one relation attributes' do
-            let(:value) { [:foo, emb_one: %i(f_em_foo)] }
-            it { expect(subject[:on]).to eq [:foo, emb_one: %i(f_em_foo)] }
+            let(:value) { [:foo, emb_one: %i[f_em_foo]] }
+            it { expect(subject[:on]).to eq [:foo, emb_one: %i[f_em_foo]] }
           end
 
           context 'with :all' do
             let(:value) { :all }
-            it { expect(subject[:on]).to eq %i(foo b) }
+            it { expect(subject[:on]).to eq %i[foo b] }
           end
 
           context 'with :fields' do
             let(:value) { :fields }
-            it { expect(subject[:on]).to eq %i(foo b) }
+            it { expect(subject[:on]).to eq %i[foo b] }
           end
 
           describe '#categorize_tracked_option' do
             context 'with skipped field' do
-              let(:options) { { on: %i(foo bar), except: :foo } }
-              it { expect(subject[:fields]).to eq %w(b) }
+              let(:options) { { on: %i[foo bar], except: :foo } }
+              it { expect(subject[:fields]).to eq %w[b] }
             end
 
             context 'with skipped embeds_one relation' do
-              let(:options) { { on: %i(fields emb_one emb_two), except: :emb_one } }
-              it { expect(subject[:relations][:embeds_one]).to eq('emtw' => %w(_id f_em_baz)) }
+              let(:options) { { on: %i[fields emb_one emb_two], except: :emb_one } }
+              it { expect(subject[:relations][:embeds_one]).to eq('emtw' => %w[_id f_em_baz]) }
             end
 
             context 'with skipped embeds_many relation' do
-              let(:options) { { on: %i(fields emb_threes emb_fours), except: :emb_threes } }
-              it { expect(subject[:relations][:embeds_many]).to eq('emfs' => %w(_id f_em_baz)) }
+              let(:options) { { on: %i[fields emb_threes emb_fours], except: :emb_threes } }
+              it { expect(subject[:relations][:embeds_many]).to eq('emfs' => %w[_id f_em_baz]) }
             end
 
             context 'with reserved field' do
-              let(:options) { { on: %i(_id _type foo deleted_at) } }
-              it { expect(subject[:fields]).to eq %w(foo) }
+              let(:options) { { on: %i[_id _type foo deleted_at] } }
+              it { expect(subject[:fields]).to eq %w[foo] }
             end
 
             context 'when embeds_one attribute passed' do
               let(:options) { { on: { emb_one: :f_em_foo } } }
-              it { expect(subject[:relations][:embeds_one]).to eq('emb_one' => %w(_id f_em_foo)) }
+              it { expect(subject[:relations][:embeds_one]).to eq('emb_one' => %w[_id f_em_foo]) }
             end
 
             context 'when embeds_one attributes array passed' do
-              let(:options) { { on: { emb_one: %i(f_em_foo) } } }
-              it { expect(subject[:relations][:embeds_one]).to eq('emb_one' => %w(_id f_em_foo)) }
+              let(:options) { { on: { emb_one: %i[f_em_foo] } } }
+              it { expect(subject[:relations][:embeds_one]).to eq('emb_one' => %w[_id f_em_foo]) }
             end
 
             context 'when embeds_many attribute passed' do
               let(:options) { { on: { emb_threes: :f_em_foo } } }
-              it { expect(subject[:relations][:embeds_many]).to eq('emb_threes' => %w(_id f_em_foo)) }
+              it { expect(subject[:relations][:embeds_many]).to eq('emb_threes' => %w[_id f_em_foo]) }
             end
 
             context 'when embeds_many attributes array passed' do
-              let(:options) { { on: { emb_threes: %i(f_em_foo) } } }
-              it { expect(subject[:relations][:embeds_many]).to eq('emb_threes' => %w(_id f_em_foo)) }
+              let(:options) { { on: { emb_threes: %i[f_em_foo] } } }
+              it { expect(subject[:relations][:embeds_many]).to eq('emb_threes' => %w[_id f_em_foo]) }
             end
 
             context 'when embeds_one attributes not passed' do
               let(:options) { { on: :emb_one } }
-              it { expect(subject[:relations][:embeds_one]).to eq('emb_one' => %w(_id f_em_foo fmb)) }
+              it { expect(subject[:relations][:embeds_one]).to eq('emb_one' => %w[_id f_em_foo fmb]) }
             end
 
             context 'when embeds_many attributes not passed' do
               let(:options) { { on: :emb_threes } }
-              it { expect(subject[:relations][:embeds_many]).to eq('emb_threes' => %w(_id f_em_foo fmb)) }
+              it { expect(subject[:relations][:embeds_many]).to eq('emb_threes' => %w[_id f_em_foo fmb]) }
             end
 
             context 'when embeds_one attribute alias passed' do
-              let(:options) { { on: { emb_one: %i(f_em_bar) } } }
-              it { expect(subject[:relations][:embeds_one]).to eq('emb_one' => %w(_id fmb)) }
+              let(:options) { { on: { emb_one: %i[f_em_bar] } } }
+              it { expect(subject[:relations][:embeds_one]).to eq('emb_one' => %w[_id fmb]) }
             end
 
             context 'when embeds_many attribute alias passed' do
-              let(:options) { { on: { emb_threes: %i(f_em_bar) } } }
-              it { expect(subject[:relations][:embeds_many]).to eq('emb_threes' => %w(_id fmb)) }
+              let(:options) { { on: { emb_threes: %i[f_em_bar] } } }
+              it { expect(subject[:relations][:embeds_many]).to eq('emb_threes' => %w[_id fmb]) }
             end
 
             context 'with field alias' do
               let(:options) { { on: :bar } }
-              it { expect(subject[:fields]).to eq %w(b) }
+              it { expect(subject[:fields]).to eq %w[b] }
             end
 
             context 'with dynamic field name' do
               let(:options) { { on: :my_field } }
-              it { expect(subject[:dynamic]).to eq %w(my_field) }
+              it { expect(subject[:dynamic]).to eq %w[my_field] }
             end
 
             context 'with relations' do
               let(:options) { { on: :embedded_relations } }
               it do
-                expect(subject[:relations]).to eq(embeds_many: { 'emb_threes' => %w(_id f_em_foo fmb),
-                                                                 'emfs'       => %w(_id f_em_baz) },
-                                                  embeds_one: { 'emb_one'    => %w(_id f_em_foo fmb),
-                                                                'emtw'       => %w(_id f_em_baz) })
+                expect(subject[:relations]).to eq(embeds_many: { 'emb_threes' => %w[_id f_em_foo fmb],
+                                                                 'emfs'       => %w[_id f_em_baz] },
+                                                  embeds_one: { 'emb_one'    => %w[_id f_em_foo fmb],
+                                                                'emtw'       => %w[_id f_em_baz] })
               end
             end
           end
@@ -308,8 +308,8 @@ describe Mongoid::History::Options do
         end
 
         describe '#remove_reserved_fields' do
-          let(:options) { { on: [:_id, :_type, :foo, :version, :modifier_id] } }
-          it { expect(subject[:fields]).to eq %w(foo) }
+          let(:options) { { on: %i[_id _type foo version modifier_id] } }
+          it { expect(subject[:fields]).to eq %w[foo] }
           it { expect(subject[:dynamic]).to eq [] }
         end
       end