mongoid-audit_log 0.3.0 → 0.6.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 7c64fb48b393df395b00f96fd8f804df26a8c361
-  data.tar.gz: 63e4405ba7cd83a09bb306fd569ec1beec6d6e10
+SHA256:
+  metadata.gz: 61de8364fc9a0e8554f5c421560717892f0031b3034fc6978df71de6f106d87d
+  data.tar.gz: '053874e715158f7623cf52121bce0aad06696517c9abaffe1c9891ecc67011c0'
 SHA512:
-  metadata.gz: 8a3d0d35183456d3d385340d9343be542293dd280f4c7e8e7fea8c3e0b738df4799144a7bb032edc7afd78b01dd1a2528a2df4b2bde6f9594b24d379b1a57f62
-  data.tar.gz: ba9e4830088d3e14add3950bd29ea7f4f182136752db49235599aa76862d69ec5b7d075529e63b4e499ccbeebffc5a20b9ea92f642b253d35375bb054649b17a
+  metadata.gz: 32c4792b0a76084ad7c3c6f493be3caf796000facb5b82fc0fe4b7948fc85a10c062b85f7dfc5f503fd051d890b50bb6b4d008ec44adb651e0e43431671b6b7c
+  data.tar.gz: 04ed8d08325d4a606764a39e5ac9134381883324ced95b70f3cd4915a8cba28dce0a517694f59110a33837f8a8e680011de25d2d5b610b287210551c6d9c3c86

data/README.md

@@ -44,6 +44,11 @@ If you want to log the user who made the change, pass that user to the record me
 Mongoid::AuditLog.record(current_user) do
   Model.create!
 end
+
+# or
+
+Mongoid::AuditLog.current_modifier = current_user
+Mongoid::AuditLog.enable
 ```
 
 A basic implementation in a Rails app might look something like:
@@ -123,6 +128,46 @@ model.audit_log_entries.first.create? # => true
 model.audit_log_entries.first.model_attributes # => {"name"=>"foo bar"}
 ```
 
+### Restoring
+
+You can restore models for `Mongoid::AuditLog::Entry` instances for deletions.
+This works for both root and embedded documents.
+
+Examples:
+```ruby
+model = Model.create!(:name => 'foo bar')
+Mongoid::AuditLog.record { model.destroy }
+
+entry = Mongoid::AuditLog::Entry.first
+entry.restore!
+
+model == Model.find_by(name: 'foo bar') # => true
+```
+
+It's possible to end up in a situation where a destroy entry cannot be restored, e.g. an entry deleting an embedded document for a root document that's already been deleted. In these scenarios, `Mongoid::AuditLog::Restore::InvalidRestore` will be raised.
+
+### Disabling
+
+The `AuditLog` module provides methods to included classes to allow explicit disabling or enabling of logging. This can be useful if a model includes the mixin indirectly through another mixin or inheritance.
+
+```ruby
+class Parent
+  include Mongoid::Document
+  include Mongoid::AuditLog
+end
+
+class Child < Parent
+  disable_audit_log
+end
+
+class Grandchild < Child
+  enable_audit_log
+end
+
+Parent.audit_log_enabled? # => true
+Child.audit_log_enabled? # => false
+Grandchild.audit_log_enabled? # => true
+```
 
 ## Contributing
 

data/lib/mongoid/audit_log.rb

@@ -2,7 +2,7 @@ require "mongoid/audit_log/version"
 require "mongoid/audit_log/config"
 require "mongoid/audit_log/entry"
 require "mongoid/audit_log/changes"
-require "mongoid/audit_log/embedded_changes"
+require "mongoid/audit_log/restore"
 
 module Mongoid
   module AuditLog
@@ -14,30 +14,54 @@ module Mongoid
 
       AuditLog.actions.each do |action|
         send("before_#{action}") do
-          set_audit_log_changes if AuditLog.recording?
+          set_audit_log_changes if record_audit_log?
         end
 
         send("after_#{action}") do
-          save_audit_log_entry(action) if AuditLog.recording?
+          save_audit_log_entry(action) if record_audit_log?
         end
       end
     end
 
+    class_methods do
+      def enable_audit_log
+        @audit_log_enabled = true
+      end
+
+      def disable_audit_log
+        @audit_log_enabled = false
+      end
+
+      def audit_log_enabled?
+        !defined?(@audit_log_enabled) || @audit_log_enabled
+      end
+    end
+
     def self.record(modifier = nil)
-      Thread.current[:mongoid_audit_log_recording] = true
-      Thread.current[:mongoid_audit_log_modifier] = modifier
+      already_recording = recording?
+      enable unless already_recording
+      self.current_modifier = modifier
       yield
     ensure
-      Thread.current[:mongoid_audit_log_recording] = nil
-      Thread.current[:mongoid_audit_log_modifier] = nil
+      disable unless already_recording
+      self.current_modifier = nil
+    end
+
+    def self.enable
+      Thread.current[:mongoid_audit_log_recording] = true
     end
 
     def self.disable
-      tmp = Thread.current[:mongoid_audit_log_recording]
+      already_recording = recording?
       Thread.current[:mongoid_audit_log_recording] = false
-      yield
-    ensure
-      Thread.current[:mongoid_audit_log_recording] = tmp
+
+      if block_given?
+        begin
+          yield
+        ensure
+          Thread.current[:mongoid_audit_log_recording] = already_recording
+        end
+      end
     end
 
     def self.recording?
@@ -48,6 +72,14 @@ module Mongoid
       Thread.current[:mongoid_audit_log_modifier]
     end
 
+    def self.current_modifier=(modifier)
+      Thread.current[:mongoid_audit_log_modifier] = modifier
+    end
+
+    def record_audit_log?
+      AuditLog.recording? && self.class.audit_log_enabled?
+    end
+
     private
 
     def set_audit_log_changes
@@ -61,14 +93,14 @@ module Mongoid
           :audited_type => self.class,
           :audited_id => id,
           :tracked_changes => @_audit_log_changes.all,
-          :model_attributes => attributes.dup,
+          :model_attributes => attributes.deep_dup,
           :document_path => traverse_association_chain
         )
       end
     end
 
     def traverse_association_chain(node = self, current_relation = nil)
-      relation = node.embedded? ? node.metadata_name.to_s : nil
+      relation = node.embedded? ? node.association_name.to_s : nil
       list = node._parent ? traverse_association_chain(node._parent, relation) : []
       list << { class_name: node.class.name, id: node.id, relation: current_relation }
       list

data/lib/mongoid/audit_log/changes.rb

@@ -61,7 +61,17 @@ module Mongoid
       private
 
       def embedded_changes
-        @embedded_changes ||= Mongoid::AuditLog::EmbeddedChanges.new(model).all
+        @embedded_changes ||= model.embedded_relations.inject({}) do |memo, t|
+          name = t.first
+          embedded = model.send(name)
+          changes = Mongoid::AuditLog::Changes.extract_from(embedded)
+
+          if embedded.present? && changes.present?
+            memo[name] = changes
+          end
+
+          memo
+        end
       end
     end
   end

data/lib/mongoid/audit_log/entry.rb

@@ -9,8 +9,13 @@ module Mongoid
       field :modifier_id, :type => String
       field :model_attributes, :type => Hash
       field :document_path, :type => Array
+      field :restored, :type => Boolean, default: false
 
-      belongs_to :audited, :polymorphic => true
+      if Gem::Version.new(Mongoid::VERSION) < Gem::Version.new('6.0.0.beta')
+        belongs_to :audited, :polymorphic => true
+      else
+        belongs_to :audited, :polymorphic => true, :optional => true
+      end
 
       index({ :audited_id => 1, :audited_type => 1 })
       index({ :modifier_id => 1 })
@@ -28,7 +33,9 @@ module Mongoid
 
       def valid?(*)
         result = super
-        self.modifier = Mongoid::AuditLog.current_modifier if result
+        if result && modifier.blank?
+          self.modifier = Mongoid::AuditLog.current_modifier
+        end
         result
       end
 
@@ -37,7 +44,7 @@ module Mongoid
                         nil
                       else
                         klass = Mongoid::AuditLog.modifier_class_name.constantize
-                        klass.find(modifier_id)
+                        klass.find(modifier_id) rescue nil
                       end
       end
 
@@ -56,6 +63,8 @@ module Mongoid
       end
 
       def audited
+        return nil if audited_type.blank? || audited_id.blank?
+
         if for_embedded_doc?
           lookup_from_document_path
         else
@@ -68,12 +77,23 @@ module Mongoid
         return audited if root.blank?
 
         if for_embedded_doc?
-          root['class_name'].constantize.find(root['id'])
+          root['class_name'].constantize.where(id: root['id']).first
         else
           audited
         end
       end
 
+      def restore!
+        raise Restore::InvalidRestore if restored? || !destroy?
+
+        Restore.new(self).perform
+        update_attributes!(:restored => true)
+      end
+
+      def restorable?
+        destroy? && !restored? && Restore.new(self).valid?
+      end
+
       def respond_to?(sym, *args)
         key = sym.to_s
         (model_attributes.present? && model_attributes.has_key?(key)) || super
@@ -103,7 +123,7 @@ module Mongoid
                              end
                            end
 
-          if path['relation'].blank?
+          if path['relation'].blank? || relation_match.blank?
             return relation_match
           else
             relation_match.send(path['relation'])

data/lib/mongoid/audit_log/restore.rb

@@ -0,0 +1,94 @@
+module Mongoid
+  module AuditLog
+    class Restore
+      class DuplicateError < StandardError; end
+      class InvalidRestore < StandardError; end
+
+      attr_reader :entry
+      delegate :name, to: :restored
+      delegate :for_embedded_doc?, to: :entry
+
+      def initialize(entry)
+        @entry = entry
+      end
+
+      def valid?
+        !entry.for_embedded_doc? || restored_root.present?
+      end
+
+      def perform
+        restored.attributes = attributes
+        restored.save!
+      end
+
+      def attributes
+        @attributes ||=
+          begin
+            attrs = entry.model_attributes.deep_dup
+            restored.send(:process_localized_attributes, model_class, attrs)
+            attrs
+          end
+      end
+
+      def model_class
+        entry.audited_type.constantize
+      end
+
+      def restored
+        @restored ||=
+          if entry.for_embedded_doc?
+            find_embedded_restored
+          else
+            find_root_restored
+          end
+      end
+
+      def find_root_restored
+        model_class.new
+      end
+
+      def find_embedded_restored
+        raise InvalidRestore if restored_root.blank?
+
+        last_path = document_path.last
+        metadata = restored_root.class.reflect_on_association(last_path['relation'])
+        relation = restored_root.send(last_path['relation'])
+
+        if metadata.is_a?(Association::Embedded::EmbedsMany)
+          relation.build
+        elsif relation.present?
+          raise DuplicateError
+        else
+          restored_root.send("build_#{metadata.name}")
+        end
+      end
+
+      def restored_root
+        document_path.reduce(entry.root) do |current, path|
+          match = if document_path_matches?(path, current)
+                    current
+                  elsif current.respond_to?(:detect)
+                    current.detect do |model|
+                      document_path_matches?(path, model)
+                    end
+                  end
+
+          if path == document_path.last
+            return match
+          else
+            match.send(path['relation'])
+          end
+        end
+      end
+
+      def document_path
+        # don't need last because that entry represents the deleted doc
+        entry.document_path[0..-2]
+      end
+
+      def document_path_matches?(path, object)
+        object.class.name == path['class_name'] && object.id == path['id']
+      end
+    end
+  end
+end

data/lib/mongoid/audit_log/version.rb

@@ -1,5 +1,5 @@
 module Mongoid
   module AuditLog
-    VERSION = "0.3.0"
+    VERSION = "0.6.1"
   end
 end

data/mongoid-audit_log.gemspec

@@ -21,8 +21,8 @@ Gem::Specification.new do |spec|
   spec.required_ruby_version     = ">= 1.9.2"
   spec.required_rubygems_version = ">= 1.3.6"
 
-  spec.add_runtime_dependency "mongoid", [">= 4.0"]
+  spec.add_runtime_dependency "mongoid", [">= 7.0"]
 
-  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "bundler"
   spec.add_development_dependency "rake"
 end

data/spec/mongoid/audit_log/entry_spec.rb

@@ -68,11 +68,24 @@ module Mongoid
         end
       end
 
+      describe '#valid?' do
+        it 'does not override a manually set modifier' do
+          entry = Entry.new(:modifier_id => user.id)
+          entry.valid?
+          entry.modifier.should == user
+        end
+      end
+
       describe '#modifier' do
         it 'finds the modifier based on the configured class' do
           entry = Entry.new(:modifier_id => user.id)
           entry.modifier.should == user
         end
+
+        it 'can handle a missing modifier' do
+          entry = Entry.new(:modifier_id => 'foo')
+          entry.modifier.should be_nil
+        end
       end
 
       describe '#audited' do
@@ -84,6 +97,10 @@ module Mongoid
           entry = Entry.desc(:created_at).first
           entry.audited.should == option
         end
+
+        it 'returns nil if the audited info is blank' do
+          Entry.new.audited.should be_nil
+        end
       end
 
       describe '#modifier_id=' do
@@ -121,6 +138,85 @@ module Mongoid
           entry.other.should == nil
         end
       end
+
+      describe '#root' do
+        it 'returns nil if cannot be found' do
+          product = Product.create!(:name => 'Foo bar')
+          AuditLog.record { product.variants.create! }
+
+          entry = Entry.desc(:created_at).first
+          product.destroy
+          entry.root.should be_nil
+        end
+      end
+
+      describe '#restore!' do
+        it 'marks the entry as restored' do
+          product = Product.create!(:name => 'Foo bar')
+          AuditLog.record { product.destroy }
+
+          entry = Entry.desc(:created_at).first
+          entry.restore!
+          entry.should be_restored
+        end
+
+        it 'raises InvalidRestore if already restored' do
+          product = Product.create!(:name => 'Foo bar')
+          AuditLog.record { product.destroy }
+
+          entry = Entry.desc(:created_at).first
+          entry.restore!
+
+          expect { entry.restore! }.to raise_error(Restore::InvalidRestore)
+        end
+
+        it 'raises InvalidRestore if not a destroy' do
+          product = Product.create!(:name => 'Foo bar')
+          AuditLog.record { product.variants.create! }
+
+          entry = Entry.desc(:created_at).first
+          expect { entry.restore! }.to raise_error(Restore::InvalidRestore)
+        end
+
+        it 'raises InvalidRestore if the root is blank' do
+          product = Product.create!(:name => 'Foo bar')
+          product.variants.create!
+          AuditLog.record { product.variants.first.destroy }
+          product.destroy
+
+          entry = Entry.desc(:created_at).first
+          expect { entry.restore! }.to raise_error(Restore::InvalidRestore)
+        end
+      end
+
+      describe '#restorable?' do
+        it 'is false if already restored' do
+          product = Product.create!(:name => 'Foo bar')
+          AuditLog.record { product.destroy }
+
+          entry = Entry.desc(:created_at).first
+          entry.restore!
+          entry.should_not be_restorable
+        end
+
+        it 'is false if not a destroy' do
+          product = Product.create!(:name => 'Foo bar')
+          AuditLog.record { product.variants.create! }
+
+          entry = Entry.desc(:created_at).first
+          entry.should_not be_restorable
+        end
+
+        it 'is false is root is blank' do
+          product = Product.create!(:name => 'Foo bar')
+          product.variants.create!
+          AuditLog.record { product.variants.first.destroy }
+          product.destroy
+
+          entry = Entry.desc(:created_at).first
+          entry.should_not be_restorable
+        end
+      end
     end
   end
 end

data/spec/mongoid/audit_log/restore_spec.rb

@@ -0,0 +1,81 @@
+require 'spec_helper'
+
+module Mongoid
+  module AuditLog
+    describe Restore do
+      before(:all) do
+        class ::First
+          include Mongoid::Document
+          include Mongoid::AuditLog
+
+          field :name, type: String, localize: true
+          embeds_many :seconds
+        end
+
+        class ::Second
+          include Mongoid::Document
+          include Mongoid::AuditLog
+
+          field :name, type: String, localize: true
+          embedded_in :first
+          embeds_many :thirds
+        end
+
+        class ::Third
+          include Mongoid::Document
+          include Mongoid::AuditLog
+
+          field :name, type: String, localize: true
+          embedded_in :second
+        end
+      end
+
+      after(:all) do
+        [:First, :Second, :Third].each { |c| Object.send(:remove_const, c) }
+      end
+
+      describe '.perform' do
+        it 'restores a root document' do
+          root = First.create!(name: 'Foo')
+          Mongoid::AuditLog.record { root.destroy }
+          restore = Restore.new(Mongoid::AuditLog::Entry.first)
+          restore.perform
+
+          restore.restored.should be_persisted
+          First.count.should == 1
+          restore.restored.should == First.first
+          restore.restored.name.should == 'Foo'
+        end
+
+        it 'restores an embedded array document' do
+          root = First.create!(name: 'Foo', seconds: [{ name: 'Bar' }])
+          Mongoid::AuditLog.record { root.seconds.first.destroy }
+          restore = Restore.new(Mongoid::AuditLog::Entry.first)
+          restore.perform
+          root.reload
+
+          restore.restored.should be_persisted
+          root.seconds.length.should == 1
+          root.seconds.first.should == restore.restored
+          root.seconds.first.name.should == 'Bar'
+        end
+
+        it 'restores a nested array document' do
+          root = First.create!(
+            name: 'Foo',
+            seconds: [{ name: 'Bar', thirds: [{ name: 'Baz' }] }]
+          )
+          Mongoid::AuditLog.record { root.seconds.first.thirds.first.destroy }
+          restore = Restore.new(Mongoid::AuditLog::Entry.first)
+          restore.perform
+          root.reload
+
+          restore.restored.should be_persisted
+          root.seconds.first.thirds.length.should == 1
+          root.seconds.first.thirds.first.should == restore.restored
+          root.seconds.first.thirds.first.name.should == 'Baz'
+        end
+      end
+    end
+  end
+end

data/spec/mongoid/audit_log_spec.rb

@@ -16,6 +16,8 @@ module Mongoid
         field :sku, :type => String
         embedded_in :product
       end
+
+      AuditLog.disable
     end
 
     after(:all) do
@@ -23,6 +25,10 @@ module Mongoid
       Object.send(:remove_const, :Variant)
     end
 
+    after(:each) do
+      Product.enable_audit_log
+    end
+
     describe '.record' do
       it 'does not save an entry if not recording' do
         product = Product.create!
@@ -95,8 +101,31 @@ module Mongoid
       end
     end
 
+    describe '.enable' do
+      after(:each) do
+        AuditLog.disable
+      end
+
+      it 'starts recording' do
+        AuditLog.enable
+
+        product = Product.create!(:name => 'Foo bar')
+        product.audit_log_entries.count.should == 1
+      end
+    end
+
     describe '.disable' do
-      it 'can disable recording' do
+      it 'stops recording' do
+        AuditLog.enable
+        AuditLog.disable
+
+        product = Product.create!(:name => 'Foo bar')
+        product.audit_log_entries.should be_empty
+      end
+
+      it 'can disable recording for a block' do
+        AuditLog.disable
+
         AuditLog.record do
           product = Product.create!(:name => 'Foo bar')
 
@@ -173,6 +202,15 @@ module Mongoid
           entry.document_path.second['id'].should == variant.id
           entry.document_path.second['relation'].should == nil
         end
+
+        it 'does not record if model disables logging' do
+          product = Product.create!(:name => 'Foo bar')
+          product.audit_log_entries.count.should eq(1)
+
+          Product.disable_audit_log
+          product.update!(name: 'Foo bar baz')
+          product.audit_log_entries.count.should eq(1)
+        end
       end
 
       context 'update' do
@@ -256,5 +294,56 @@ module Mongoid
         end
       end
     end
+
+    describe '.disable_audit_log' do
+      it 'disables recording for model' do
+        AuditLog.record do
+          product = Product.create!(name: 'Foo bar')
+          product.audit_log_entries.count.should eq(1)
+
+          Product.disable_audit_log
+          product.record_audit_log?.should be_false
+
+          product.update!(name: 'Bar foo')
+          product.audit_log_entries.count.should eq(1)
+        end
+      end
+    end
+
+    describe '.enable_audit_log' do
+      it 'enables recording for model' do
+        AuditLog.record do
+          Product.disable_audit_log
+
+          product = Product.create!(name: 'Foo bar')
+          product.audit_log_entries.count.should eq(0)
+
+          Product.enable_audit_log
+          product.record_audit_log?.should be_true
+
+          product.update!(name: 'Bar foo')
+          product.audit_log_entries.count.should eq(1)
+        end
+      end
+    end
+
+    describe '#record_audit_log?' do
+      it 'returns true while recording' do
+        Product.new.record_audit_log?.should be_false
+
+        AuditLog.record do
+          Product.new.record_audit_log?.should be_true
+        end
+      end
+
+      it 'returns false when audit log is disabled' do
+        Product.disable_audit_log
+        Product.new.record_audit_log?.should be_false
+
+        AuditLog.record do
+          Product.new.record_audit_log?.should be_false
+        end
+      end
+    end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mongoid-audit_log
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.6.1
 platform: ruby
 authors:
 - Ben Crouse
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-08-17 00:00:00.000000000 Z
+date: 2020-09-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: mongoid
@@ -16,28 +16,28 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '4.0'
+        version: '7.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '4.0'
+        version: '7.0'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.3'
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.3'
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -68,12 +68,13 @@ files:
 - lib/mongoid/audit_log.rb
 - lib/mongoid/audit_log/changes.rb
 - lib/mongoid/audit_log/config.rb
-- lib/mongoid/audit_log/embedded_changes.rb
 - lib/mongoid/audit_log/entry.rb
+- lib/mongoid/audit_log/restore.rb
 - lib/mongoid/audit_log/version.rb
 - mongoid-audit_log.gemspec
 - spec/mongoid/audit_log/changes_spec.rb
 - spec/mongoid/audit_log/entry_spec.rb
+- spec/mongoid/audit_log/restore_spec.rb
 - spec/mongoid/audit_log_spec.rb
 - spec/spec_helper.rb
 - spec/support/models.rb
@@ -96,8 +97,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: 1.3.6
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.5.1
+rubygems_version: 3.0.3
 signing_key: 
 specification_version: 4
 summary: No fancy versioning, undo, redo, etc. Just saves changes to Mongoid models
@@ -105,7 +105,7 @@ summary: No fancy versioning, undo, redo, etc. Just saves changes to Mongoid mod
 test_files:
 - spec/mongoid/audit_log/changes_spec.rb
 - spec/mongoid/audit_log/entry_spec.rb
+- spec/mongoid/audit_log/restore_spec.rb
 - spec/mongoid/audit_log_spec.rb
 - spec/spec_helper.rb
 - spec/support/models.rb
-has_rdoc: 

data/lib/mongoid/audit_log/embedded_changes.rb

@@ -1,33 +0,0 @@
-module Mongoid
-  module AuditLog
-    class EmbeddedChanges
-      attr_reader :model
-
-      def initialize(model)
-        @model = model
-      end
-
-      def relations
-        model.relations.inject({}) do |memo, t|
-          name, relation = *t
-          memo[name] = relation if relation.embedded?
-          memo
-        end
-      end
-
-      def all
-        @all ||= relations.inject({}) do |memo, t|
-          name = t.first
-          embedded = model.send(name)
-          changes = Mongoid::AuditLog::Changes.extract_from(embedded)
-
-          if embedded.present? && changes.present?
-            memo[name] = changes
-          end
-
-          memo
-        end
-      end
-    end
-  end
-end