mongoid-history 0.6.1 → 0.8.3

data/lib/mongoid/history/trackable.rb

@@ -5,16 +5,18 @@ module Mongoid
 
       module ClassMethods
         def track_history(options = {})
-          extend EmbeddedMethods
+          extend RelationMethods
 
-          options_parser = Mongoid::History::Options.new(self)
-          options = options_parser.parse(options)
+          history_options = Mongoid::History::Options.new(self, options)
 
-          field options[:version_field].to_sym, type: Integer
+          field history_options.options[:version_field].to_sym, type: Integer
 
-          belongs_to_modifier_options = { class_name: Mongoid::History.modifier_class_name }
-          belongs_to_modifier_options[:inverse_of] = options[:modifier_field_inverse_of] if options.key?(:modifier_field_inverse_of)
-          belongs_to options[:modifier_field].to_sym, belongs_to_modifier_options
+          unless history_options.options[:modifier_field].nil?
+            belongs_to_modifier_options = { class_name: Mongoid::History.modifier_class_name }
+            belongs_to_modifier_options[:inverse_of] = history_options.options[:modifier_field_inverse_of] if history_options.options.key?(:modifier_field_inverse_of)
+            belongs_to_modifier_options[:optional] = true if history_options.options[:modifier_field_optional] && Mongoid::Compatibility::Version.mongoid6_or_newer?
+            belongs_to history_options.options[:modifier_field].to_sym, belongs_to_modifier_options
+          end
 
           include MyInstanceMethods
           extend SingletonMethods
@@ -22,12 +24,16 @@ module Mongoid
           delegate :history_trackable_options, to: 'self.class'
           delegate :track_history?, to: 'self.class'
 
-          before_update :track_update if options[:track_update]
-          before_create :track_create if options[:track_create]
-          before_destroy :track_destroy if options[:track_destroy]
+          callback_options = history_options.options.slice(:if, :unless)
+          around_update :track_update, **callback_options if history_options.options[:track_update]
+          around_create :track_create, **callback_options if history_options.options[:track_create]
+          around_destroy :track_destroy, **callback_options if history_options.options[:track_destroy]
+
+          unless respond_to? :mongoid_history_options
+            class_attribute :mongoid_history_options, instance_accessor: false
+          end
 
-          Mongoid::History.trackable_class_options ||= {}
-          Mongoid::History.trackable_class_options[options_parser.scope] = options
+          self.mongoid_history_options = history_options
         end
 
         def history_settings(options = {})
@@ -46,13 +52,25 @@ module Mongoid
           Mongoid::Compatibility::Version.mongoid3? || (self < Mongoid::Attributes::Dynamic).present?
         end
 
-        def disable_tracking(&_block)
+        def disable_tracking
+          original_flag = Mongoid::History.store[track_history_flag]
           Mongoid::History.store[track_history_flag] = false
-          yield
+          yield if block_given?
         ensure
+          Mongoid::History.store[track_history_flag] = original_flag if block_given?
+        end
+
+        def enable_tracking
+          original_flag = Mongoid::History.store[track_history_flag]
           Mongoid::History.store[track_history_flag] = true
+          yield if block_given?
+        ensure
+          Mongoid::History.store[track_history_flag] = original_flag if block_given?
         end
 
+        alias disable_tracking! disable_tracking
+        alias enable_tracking! enable_tracking
+
         def track_history_flag
           "mongoid_history_#{name.underscore}_trackable_enabled".to_sym
         end
@@ -111,12 +129,12 @@ module Mongoid
           end
         end
 
-        def get_embedded(name)
-          send(self.class.embedded_alias(name))
+        def _get_relation(name)
+          send(self.class.relation_alias(name))
         end
 
-        def create_embedded(name, value)
-          send("create_#{self.class.embedded_alias(name)}!", value)
+        def _create_relation(name, value)
+          send("create_#{self.class.relation_alias(name)}!", value)
         end
 
         private
@@ -131,7 +149,7 @@ module Mongoid
             elsif options[:last]
               versions = history_tracks.limit(options[:last])
             else
-              fail 'Invalid options, please specify (:from / :to) keys or :last key.'
+              raise 'Invalid options, please specify (:from / :to) keys or :last key.'
             end
           else
             options_or_version = options_or_version.to_a if options_or_version.is_a?(Range)
@@ -154,8 +172,10 @@ module Mongoid
             scope = _parent.collection_name.to_s.singularize.to_sym if scope.is_a?(Array)
             if Mongoid::Compatibility::Version.mongoid3?
               scope = metadata.inverse_class_name.tableize.singularize.to_sym if metadata.present? && scope == metadata.as
-            else
+            elsif Mongoid::Compatibility::Version.mongoid6_or_older?
               scope = relation_metadata.inverse_class_name.tableize.singularize.to_sym if relation_metadata.present? && scope == relation_metadata.as
+            elsif Mongoid::Compatibility::Version.mongoid7_or_newer?
+              scope = _association.inverse_class_name.tableize.singularize.to_sym if _association.present? && scope == _association.as
             end
           end
 
@@ -170,15 +190,18 @@ module Mongoid
 
         def association_hash(node = self)
           # We prefer to look up associations through the parent record because
-          # we're assured, through the object creation, it'll exist. Whereas we're not guarenteed
+          # we're assured, through the object creation, it'll exist. Whereas we're not guaranteed
           # the child to parent (embedded_in, belongs_to) relation will be defined
           if node._parent
             meta = node._parent.relations.values.find do |relation|
               if Mongoid::Compatibility::Version.mongoid3?
                 relation.class_name == node.metadata.class_name.to_s && relation.name == node.metadata.name
-              else
+              elsif Mongoid::Compatibility::Version.mongoid6_or_older?
                 relation.class_name == node.relation_metadata.class_name.to_s &&
-                relation.name == node.relation_metadata.name
+                  relation.name == node.relation_metadata.name
+              elsif Mongoid::Compatibility::Version.mongoid7_or_newer?
+                relation.class_name == node._association.class_name.to_s &&
+                  relation.name == node._association.name
               end
             end
           end
@@ -219,11 +242,12 @@ module Mongoid
         def history_tracker_attributes(action)
           return @history_tracker_attributes if @history_tracker_attributes
 
+          modifier_field = history_trackable_options[:modifier_field]
           @history_tracker_attributes = {
             association_chain: traverse_association_chain,
-            scope: related_scope,
-            modifier: send(history_trackable_options[:modifier_field])
+            scope: related_scope
           }
+          @history_tracker_attributes[:modifier] = send(modifier_field) if modifier_field
 
           original, modified = transform_changes(modified_attributes_for_action(action))
 
@@ -232,16 +256,16 @@ module Mongoid
           @history_tracker_attributes
         end
 
-        def track_create
-          track_history_for_action(:create)
+        def track_create(&block)
+          track_history_for_action(:create, &block)
         end
 
-        def track_update
-          track_history_for_action(:update)
+        def track_update(&block)
+          track_history_for_action(:update, &block)
         end
 
-        def track_destroy
-          track_history_for_action(:destroy) unless destroyed?
+        def track_destroy(&block)
+          track_history_for_action(:destroy, &block) unless destroyed?
         end
 
         def clear_trackable_memoization
@@ -251,18 +275,49 @@ module Mongoid
           @history_tracks = nil
         end
 
+        # Transform hash of pair of changes into an `original` and `modified` hash
+        # Nested document keys (key name with dots) are expanded
+        #
+        # @param [Hash<Array>] changes
+        #
+        # @return [Array<Hash<?>,Hash<?>>] <description>
         def transform_changes(changes)
           original = {}
           modified = {}
-          changes.each_pair do |k, v|
-            o, m = v
-            original[k] = o unless o.nil?
-            modified[k] = m unless m.nil?
+          changes.each_pair do |k, modification_pair|
+            o, m = modification_pair
+            original.deep_merge!(expand_nested_document_key_value(k, o)) unless o.nil?
+            modified.deep_merge!(expand_nested_document_key_value(k, m)) unless m.nil?
           end
 
           [original, modified]
         end
 
+        # Handle nested document tracking of changes
+        #
+        # @example
+        #
+        #   expand_nested_document_key('embedded.document.changed_field', 'old'])
+        #   #=> { 'embedded' => {'document' => { 'changed_field' => 'old' }}}
+        #
+        # @param [String] document_key key with dots
+        # @param [?] value
+        #
+        # @return [Hash<String, ?>]
+        def expand_nested_document_key_value(document_key, value)
+          expanded_key = value
+          document_key.to_s.split('.').reverse.each do |key|
+            expanded_key = { key => expanded_key }
+          end
+          expanded_key
+        end
+
+        def increment_current_version
+          current_version = (send(history_trackable_options[:version_field]) || 0) + 1
+          send("#{history_trackable_options[:version_field]}=", current_version)
+          current_version
+        end
+
         protected
 
         def track_history_for_action?(action)
@@ -271,88 +326,106 @@ module Mongoid
 
         def track_history_for_action(action)
           if track_history_for_action?(action)
-            current_version = (send(history_trackable_options[:version_field]) || 0) + 1
-            send("#{history_trackable_options[:version_field]}=", current_version)
-            self.class.tracker_class.create!(history_tracker_attributes(action.to_sym).merge(version: current_version, action: action.to_s, trackable: self))
+            current_version = increment_current_version
+            last_track = self.class.tracker_class.create!(
+              history_tracker_attributes(action.to_sym)
+              .merge(version: current_version, action: action.to_s, trackable: self)
+            )
           end
+
           clear_trackable_memoization
+
+          begin
+            yield
+          rescue => e
+            if track_history_for_action?(action)
+              send("#{history_trackable_options[:version_field]}=", current_version - 1)
+              last_track.destroy
+            end
+            raise e
+          end
         end
       end
 
-      module EmbeddedMethods
-        # Indicates whether there is an Embedded::One relation for the given embedded field.
+      module RelationMethods
+        # Returns a relation class for the given field.
         #
-        # @param [ String | Symbol ] embed The name of the embedded field
+        # @param [ String | Symbol ] field The name of the field.
         #
-        # @return [ Boolean ] true if there is an Embedded::One relation for the given embedded field
-        def embeds_one?(embed)
-          relation_of(embed) == Mongoid::Relations::Embedded::One
+        # @return [ nil | Constant ] Class being related.
+        def relation_class_of(field)
+          meta = meta_of(field)
+          return meta.class_name.constantize if meta
         end
 
-        # Return the class for embeds_one relation
+        # Indicates whether there is an Embedded::One relation for the given embedded field.
         #
-        # @param [ String ] field The database field name for embedded relation
+        # @param [ String | Symbol ] embed The name of the embedded field.
         #
-        # @return [ nil | Constant ]
-        def embeds_one_class(field)
-          @embeds_one_class ||= {}
-          return @embeds_one_class[field] if @embeds_one_class.key?(field)
-          field_alias = aliased_fields.key(field)
-          relation = relations
-                     .select { |_, v| v.relation == Mongoid::Relations::Embedded::One }
-                     .detect { |rel_k, _| rel_k == field_alias }
-          @embeds_one_class[field] = relation && relation.last.class_name.constantize
+        # @return [ Boolean ] true if there is an Embedded::One relation for the given embedded field.
+        def embeds_one?(field)
+          relation_of(field) == if Mongoid::Compatibility::Version.mongoid7_or_newer?
+                                  Mongoid::Association::Embedded::EmbedsOne::Proxy
+                                else
+                                  Mongoid::Relations::Embedded::One
+                                end
         end
 
         # Indicates whether there is an Embedded::Many relation for the given embedded field.
         #
-        # @param [ String | Symbol ] embed The name of the embedded field
+        # @param [ String | Symbol ] field The name of the embedded field.
         #
-        # @return [ Boolean ] true if there is an Embedded::Many relation for the given embedded field
-        def embeds_many?(embed)
-          relation_of(embed) == Mongoid::Relations::Embedded::Many
+        # @return [ Boolean ] true if there is an Embedded::Many relation for the given embedded field.
+        def embeds_many?(field)
+          relation_of(field) == if Mongoid::Compatibility::Version.mongoid7_or_newer?
+                                  Mongoid::Association::Embedded::EmbedsMany::Proxy
+                                else
+                                  Mongoid::Relations::Embedded::Many
+                                end
         end
 
-        # Return the class for embeds_many relation
+        # Retrieves the database representation of an embedded field name, in case the :store_as option is used.
         #
-        # @param [ String ] field The database field name for embedded relation
+        # @param [ String | Symbol ] embed The name or alias of the embedded field.
         #
-        # @return [ nil | Constant ]
-        def embeds_many_class(field)
-          @embeds_many_class ||= {}
-          return @embeds_many_class[field] if @embeds_many_class.key?(field)
-          field_alias = aliased_fields.key(field)
-          relation = relations
-                     .select { |_, v| v.relation == Mongoid::Relations::Embedded::Many }
-                     .detect { |rel_k, _| rel_k == field_alias }
-          @embeds_many_class[field] = relation && relation.last.class_name.constantize
+        # @return [ String ] The database name of the embedded field.
+        def relation_alias(embed)
+          relation_aliases[embed]
         end
 
-        # Retrieves the database representation of an embedded field name, in case the :store_as option is used.
+        protected
+
+        # Return the reflected metadata for a relation.
         #
-        # @param [ String | Symbol ] embed The name or alias of the embedded field
+        # @param [ String ] field The database field name for a relation.
         #
-        # @return [ String ] the database name of the embedded field
-        def embedded_alias(embed)
-          embedded_aliases[embed]
+        # @return [ nil | Mongoid::Relations::Metadata ]
+        def meta_of(field)
+          @meta_of ||= {}
+          return @meta_of[field] if @meta_of.key?(field)
+          @meta_of[field] = reflect_on_association(relation_alias(field))
         end
 
-        protected
+        # Returns a relation for the given field.
+        #
+        # @param [ String | Symbol ] field The name of the field.
+        #
+        # @return [ nil | Constant ] Type of relation.
+        def relation_of(field)
+          meta = meta_of(field)
+          meta ? meta.relation : nil
+        end
 
         # Retrieves the memoized hash of embedded aliases and their associated database representations.
         #
         # @return [ Hash < String, String > ] hash of embedded aliases (keys) to database representations (values)
-        def embedded_aliases
-          @embedded_aliases ||= relations.inject(HashWithIndifferentAccess.new) do |h, (k, v)|
-            h[v[:store_as] || k] = k
+        def relation_aliases
+          @relation_aliases ||= relations.inject(HashWithIndifferentAccess.new) do |h, (k, v)|
+            store_as = Mongoid::Compatibility::Version.mongoid7_or_newer? ? v.store_as : v[:store_as]
+            h[store_as || k] = k
             h
           end
         end
-
-        def relation_of(embed)
-          meta = reflect_on_association(embedded_alias(embed))
-          meta ? meta.relation : nil
-        end
       end
 
       module SingletonMethods
@@ -414,7 +487,12 @@ module Mongoid
         #
         # @return [ Array < String > ] the list of reserved database field names
         def reserved_tracked_fields
-          @reserved_tracked_fields ||= ['_id', history_trackable_options[:version_field].to_s, "#{history_trackable_options[:modifier_field]}_id"]
+          @reserved_tracked_fields ||= begin
+                                         fields = ['_id', history_trackable_options[:version_field].to_s]
+                                         modifier_field = history_trackable_options[:modifier_field]
+                                         fields << "#{modifier_field}_id" if modifier_field
+                                         fields
+                                       end
         end
 
         def field_formats
@@ -445,8 +523,8 @@ module Mongoid
         def tracked_embeds_one
           @tracked_embeds_one ||= begin
             reflect_on_all_associations(:embeds_one)
-            .map(&:key)
-            .select { |rel| history_trackable_options[:relations][:embeds_one].include? rel }
+              .map(&:key)
+              .select { |rel| history_trackable_options[:relations][:embeds_one].include? rel }
           end
         end
 
@@ -469,8 +547,8 @@ module Mongoid
         def tracked_embeds_many
           @tracked_embeds_many ||= begin
             reflect_on_all_associations(:embeds_many)
-            .map(&:key)
-            .select { |rel| history_trackable_options[:relations][:embeds_many].include? rel }
+              .map(&:key)
+              .select { |rel| history_trackable_options[:relations][:embeds_many].include? rel }
           end
         end
 
@@ -483,7 +561,7 @@ module Mongoid
         end
 
         def history_trackable_options
-          @history_trackable_options ||= Mongoid::History.trackable_class_options[trackable_scope]
+          @history_trackable_options ||= mongoid_history_options.prepared
         end
 
         def clear_trackable_memoization
@@ -493,7 +571,11 @@ module Mongoid
           @tracked_fields = nil
           @tracked_embeds_one = nil
           @tracked_embeds_many = nil
-          @obfuscated_fields = nil
+        end
+
+        def inherited(subclass)
+          super
+          subclass.mongoid_history_options = Mongoid::History::Options.new(subclass, mongoid_history_options.options)
         end
       end
     end

data/lib/mongoid/history/tracker.rb

@@ -14,12 +14,16 @@ module Mongoid
         field :version,                 type: Integer
         field :action,                  type: String
         field :scope,                   type: String
-        belongs_to :modifier, class_name: Mongoid::History.modifier_class_name
+        modifier_options = {
+          class_name: Mongoid::History.modifier_class_name
+        }
+        modifier_options[:optional] = true if Mongoid::Compatibility::Version.mongoid6_or_newer?
+        belongs_to :modifier, modifier_options
 
         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)
@@ -50,7 +54,7 @@ module Mongoid
         undo_hash = affected.easy_unmerge(modified)
         undo_hash.easy_merge!(original)
         modifier_field = trackable.history_trackable_options[:modifier_field]
-        undo_hash[modifier_field] = modifier
+        undo_hash[modifier_field] = modifier if modifier_field
         (modified.keys - undo_hash.keys).each do |k|
           undo_hash[k] = nil
         end
@@ -61,7 +65,7 @@ module Mongoid
         redo_hash = affected.easy_unmerge(original)
         redo_hash.easy_merge!(modified)
         modifier_field = trackable.history_trackable_options[:modifier_field]
-        redo_hash[modifier_field] = modifier
+        redo_hash[modifier_field] = modifier if modifier_field
         localize_keys(redo_hash)
       end
 
@@ -175,12 +179,13 @@ module Mongoid
 
       def create_on_parent
         name = association_chain.last['name']
+
         if trackable_parent.class.embeds_one?(name)
-          trackable_parent.create_embedded(name, localize_keys(original))
+          trackable_parent._create_relation(name, localize_keys(original))
         elsif trackable_parent.class.embeds_many?(name)
-          trackable_parent.get_embedded(name).create!(localize_keys(original))
+          trackable_parent._get_relation(name).create!(localize_keys(original))
         else
-          fail 'This should never happen. Please report bug!'
+          raise 'This should never happen. Please report bug!'
         end
       end
 
@@ -201,11 +206,13 @@ module Mongoid
                   klass = name.classify.constantize
                   klass.unscoped.where(_id: node['id']).first
                 elsif doc.class.embeds_one?(name)
-                  doc.get_embedded(name)
+                  doc._get_relation(name)
                 elsif doc.class.embeds_many?(name)
-                  doc.get_embedded(name).unscoped.where(_id: node['id']).first
+                  doc._get_relation(name).unscoped.where(_id: node['id']).first
                 else
-                  fail 'This should never happen. Please report bug.'
+                  relation_klass = doc.class.relation_class_of(name) if doc
+                  relation_klass ||= 'nil'
+                  raise "Unexpected relation for field '#{name}': #{relation_klass}. This should never happen. Please report bug."
                 end
           documents << doc
           break if chain.empty?
@@ -215,9 +222,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