mongoid-history 0.5.0 → 0.6.0

data/lib/mongoid/history/attributes/base.rb

@@ -0,0 +1,31 @@
+module Mongoid
+  module History
+    module Attributes
+      class Base
+        attr_reader :trackable
+
+        def initialize(trackable)
+          @trackable = trackable
+        end
+
+        private
+
+        def trackable_class
+          @trackable_class ||= trackable.class
+        end
+
+        def aliased_fields
+          @aliased_fields ||= trackable_class.aliased_fields
+        end
+
+        def changes_method
+          trackable_class.history_trackable_options[:changes_method]
+        end
+
+        def changes
+          trackable.send(changes_method)
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/history/attributes/create.rb

@@ -0,0 +1,52 @@
+module Mongoid
+  module History
+    module Attributes
+      class Create < ::Mongoid::History::Attributes::Base
+        def attributes
+          @attributes = {}
+          trackable.attributes.each do |k, v|
+            next unless trackable_class.tracked_field?(k, :create)
+            modified = if changes[k]
+                         changes[k].class == Array ? changes[k].last : changes[k]
+                       else
+                         v
+                       end
+            @attributes[k] = [nil, modified]
+          end
+          insert_embeds_one_changes
+          insert_embeds_many_changes
+          @attributes
+        end
+
+        private
+
+        def insert_embeds_one_changes
+          trackable_class.tracked_embeds_one.each do |rel|
+            rel_class = trackable_class.embeds_one_class(rel)
+            paranoia_field = Mongoid::History.trackable_class_settings(rel_class)[:paranoia_field]
+            paranoia_field = rel_class.aliased_fields.key(paranoia_field) || paranoia_field
+            permitted_attrs = trackable_class.tracked_embeds_one_attributes(rel)
+            rel = aliased_fields.key(rel) || rel
+            obj = trackable.send(rel)
+            next if !obj || (obj.respond_to?(paranoia_field) && obj.public_send(paranoia_field).present?)
+            @attributes[rel] = [nil, obj.attributes.slice(*permitted_attrs)]
+          end
+        end
+
+        def insert_embeds_many_changes
+          trackable_class.tracked_embeds_many.each do |rel|
+            rel_class = trackable_class.embeds_many_class(rel)
+            paranoia_field = Mongoid::History.trackable_class_settings(rel_class)[:paranoia_field]
+            paranoia_field = rel_class.aliased_fields.key(paranoia_field) || paranoia_field
+            permitted_attrs = trackable_class.tracked_embeds_many_attributes(rel)
+            rel = aliased_fields.key(rel) || rel
+            @attributes[rel] = [nil,
+                                trackable.send(rel)
+                                .reject { |obj| obj.respond_to?(paranoia_field) && obj.public_send(paranoia_field).present? }
+                                .map { |obj| obj.attributes.slice(*permitted_attrs) }]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/history/attributes/destroy.rb

@@ -0,0 +1,36 @@
+module Mongoid
+  module History
+    module Attributes
+      class Destroy < ::Mongoid::History::Attributes::Base
+        def attributes
+          @attributes = {}
+          trackable.attributes.each { |k, v| @attributes[k] = [v, nil] if trackable_class.tracked_field?(k, :destroy) }
+          insert_embeds_one_changes
+          insert_embeds_many_changes
+          @attributes
+        end
+
+        private
+
+        def insert_embeds_one_changes
+          trackable_class.tracked_embeds_one
+            .map { |rel| aliased_fields.key(rel) || rel }
+            .each do |rel|
+              permitted_attrs = trackable_class.tracked_embeds_one_attributes(rel)
+              obj = trackable.send(rel)
+              @attributes[rel] = [obj.attributes.slice(*permitted_attrs), nil] if obj
+            end
+        end
+
+        def insert_embeds_many_changes
+          trackable_class.tracked_embeds_many
+            .map { |rel| aliased_fields.key(rel) || rel }
+            .each do |rel|
+              permitted_attrs = trackable_class.tracked_embeds_many_attributes(rel)
+              @attributes[rel] = [trackable.send(rel).map { |obj| obj.attributes.slice(*permitted_attrs) }, nil]
+            end
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/history/attributes/update.rb

@@ -0,0 +1,43 @@
+module Mongoid
+  module History
+    module Attributes
+      class Update < ::Mongoid::History::Attributes::Base
+        def attributes
+          @attributes = {}
+          changes.each do |k, v|
+            if trackable_class.tracked_embeds_one?(k)
+              insert_embeds_one_changes(k, v)
+            elsif trackable_class.tracked_embeds_many?(k)
+              insert_embeds_many_changes(k, v)
+            elsif trackable_class.tracked?(k, :update)
+              @attributes[k] = v
+            end
+          end
+          @attributes
+        end
+
+        private
+
+        def insert_embeds_one_changes(relation, value)
+          relation = trackable_class.database_field_name(relation)
+          permitted_attrs = trackable_class.tracked_embeds_one_attributes(relation)
+          relation_class = trackable_class.embeds_one_class(relation)
+          paranoia_field = Mongoid::History.trackable_class_settings(relation_class)[:paranoia_field]
+          @attributes[relation] = []
+          @attributes[relation][0] = value[0][paranoia_field].present? ? {} : value[0].slice(*permitted_attrs)
+          @attributes[relation][1] = value[1][paranoia_field].present? ? {} : value[1].slice(*permitted_attrs)
+        end
+
+        def insert_embeds_many_changes(relation, value)
+          relation = trackable_class.database_field_name(relation)
+          permitted_attrs = trackable_class.tracked_embeds_many_attributes(relation)
+          relation_class = trackable_class.embeds_many_class(relation)
+          paranoia_field = Mongoid::History.trackable_class_settings(relation_class)[:paranoia_field]
+          @attributes[relation] = []
+          @attributes[relation][0] = value[0].reject { |rel| rel[paranoia_field].present? }.map { |v_attrs| v_attrs.slice(*permitted_attrs) }
+          @attributes[relation][1] = value[1].reject { |rel| rel[paranoia_field].present? }.map { |v_attrs| v_attrs.slice(*permitted_attrs) }
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/history/options.rb

@@ -0,0 +1,153 @@
+module Mongoid
+  module History
+    class Options
+      attr_reader :trackable, :options
+
+      def initialize(trackable)
+        @trackable = trackable
+      end
+
+      def scope
+        trackable.collection_name.to_s.singularize.to_sym
+      end
+
+      def parse(options = {})
+        @options = default_options.merge(options)
+        prepare_skipped_fields
+        parse_tracked_fields_and_relations
+        @options
+      end
+
+      private
+
+      def default_options
+        @default_options ||=
+          { on: :all,
+            except: [:created_at, :updated_at],
+            tracker_class_name: nil,
+            modifier_field: :modifier,
+            version_field: :version,
+            changes_method: :changes,
+            scope: scope,
+            track_create: false,
+            track_update: true,
+            track_destroy: false }
+      end
+
+      # Sets the :except attributes and relations in `options` to be an [ Array <String> ]
+      # The attribute names and relations are stored by their `database_field_name`s
+      # Removes the `nil` and duplicate entries from skipped attributes/relations list
+      def prepare_skipped_fields
+        # normalize :except fields to an array of database field strings
+        @options[:except] = Array(options[:except])
+        @options[:except] = options[:except].map { |field| trackable.database_field_name(field) }.compact.uniq
+      end
+
+      def parse_tracked_fields_and_relations
+        # case `options[:on]`
+        # when `posts: [:id, :title]`, then it will convert it to `[[:posts, [:id, :title]]]`
+        # when `:foo`, then `[:foo]`
+        # when `[:foo, { posts: [:id, :title] }]`, then return as is
+        @options[:on] = Array(options[:on])
+
+        # # :all is just an alias to :fields for now, to support existing users of `mongoid-history`
+        # # In future, :all will track all the fields and relations of trackable class
+        if options[:on].include?(:all)
+          warn "[DEPRECATION] Use :fields instead of :all to track all fields in class #{trackable}.\n\
+            Going forward, :all will track all the fields and relations for the class"
+        end
+
+        @options[:on] = options[:on].map { |opt| (opt == :all) ? :fields : opt }
+
+        if options[:on].include?(:fields)
+          @options[:on] = options[:on].reject { |opt| opt == :fields }
+          @options[:on] = options[:on] | trackable.fields.keys.map(&:to_sym) - reserved_fields.map(&:to_sym)
+        end
+
+        @options[:fields] = []
+        @options[:dynamic] = []
+        @options[:relations] = { embeds_one: {}, embeds_many: {} }
+
+        options[:on].each do |option|
+          field = get_database_field_name(option)
+          field_options = get_field_options(option)
+          categorize_tracked_option(field, field_options)
+        end
+      end
+
+      # Returns the database_field_name key for tracked option
+      #
+      # @param [ String | Symbol | Array | Hash ] option The field or relation name to track
+      #
+      # @return [ String ] the database field name for tracked option
+      def get_database_field_name(option)
+        key = if option.is_a?(Hash)
+                option.keys.first
+              elsif option.is_a?(Array)
+                option.first
+              end
+        trackable.database_field_name(key || option)
+      end
+
+      # Returns the tracked attributes for embedded relations, otherwise `nil`
+      #
+      # @param [ String | Symbol | Array | Hash ] option The field or relation name to track
+      #
+      # @return [ nil | Array <String | Symbol> ] the list of tracked fields for embedded relation
+      def get_field_options(option)
+        if option.is_a?(Hash)
+          option.values.first
+        elsif option.is_a?(Array)
+          option.last
+        end
+      end
+
+      # Tracks the passed option under:
+      #   `fields`
+      #   `dynamic`
+      #   `relations -> embeds_one` or
+      #   `relations -> embeds_many`
+      #
+      # @param [ String ] field The database field name of field or relation to track
+      # @param [ nil | Array <String | Symbol> ] field_options The tracked fields for embedded relations
+      def categorize_tracked_option(field, field_options = nil)
+        return if options[:except].include?(field)
+        return if reserved_fields.include?(field)
+
+        field_options = Array(field_options)
+
+        if trackable.embeds_one?(field)
+          track_embeds_one(field, field_options)
+        elsif trackable.embeds_many?(field)
+          track_embeds_many(field, field_options)
+        elsif trackable.fields.keys.include?(field)
+          @options[:fields] << field
+        else
+          @options[:dynamic] << field
+        end
+      end
+
+      def track_embeds_one(field, field_options)
+        relation_class = trackable.embeds_one_class(field)
+        @options[:relations][:embeds_one][field] = if field_options.blank?
+                                                     relation_class.fields.keys
+                                                   else
+                                                     %w(_id) | field_options.map { |opt| relation_class.database_field_name(opt) }
+                                                   end
+      end
+
+      def track_embeds_many(field, field_options)
+        relation_class = trackable.embeds_many_class(field)
+        @options[:relations][:embeds_many][field] = if field_options.blank?
+                                                      relation_class.fields.keys
+                                                    else
+                                                      %w(_id) | field_options.map { |opt| relation_class.database_field_name(opt) }
+                                                    end
+      end
+
+      def reserved_fields
+        @reserved_fields ||= ['_id', '_type', options[:version_field].to_s, "#{options[:modifier_field]}_id"]
+      end
+    end
+  end
+end

data/lib/mongoid/history/trackable.rb

@@ -5,30 +5,10 @@ module Mongoid
 
       module ClassMethods
         def track_history(options = {})
-          scope_name = collection_name.to_s.singularize.to_sym
-          default_options = {
-            on: :all,
-            except: [:created_at, :updated_at],
-            modifier_field: :modifier,
-            version_field: :version,
-            changes_method: :changes,
-            scope: scope_name,
-            track_create: false,
-            track_update: true,
-            track_destroy: false
-          }
-
-          options = default_options.merge(options)
+          extend EmbeddedMethods
 
-          # normalize :except fields to an array of database field strings
-          options[:except] = [options[:except]] unless options[:except].is_a? Array
-          options[:except] = options[:except].map { |field| database_field_name(field) }.compact.uniq
-
-          # normalize :on fields to either :all or an array of database field strings
-          if options[:on] != :all
-            options[:on] = [options[:on]] unless options[:on].is_a? Array
-            options[:on] = options[:on].map { |field| database_field_name(field) }.compact.uniq
-          end
+          options_parser = Mongoid::History::Options.new(self)
+          options = options_parser.parse(options)
 
           field options[:version_field].to_sym, type: Integer
 
@@ -47,11 +27,19 @@ module Mongoid
           before_destroy :track_destroy if options[:track_destroy]
 
           Mongoid::History.trackable_class_options ||= {}
-          Mongoid::History.trackable_class_options[scope_name] = options
+          Mongoid::History.trackable_class_options[options_parser.scope] = options
+        end
+
+        def history_settings(options = {})
+          options = Mongoid::History.default_settings.merge(options.symbolize_keys)
+          options = options.slice(*Mongoid::History.default_settings.keys)
+          options[:paranoia_field] = aliased_fields[options[:paranoia_field].to_s] || options[:paranoia_field].to_s
+          Mongoid::History.trackable_settings ||= {}
+          Mongoid::History.trackable_settings[name.to_sym] = options
         end
 
         def track_history?
-          Mongoid::History.enabled? && Thread.current[track_history_flag] != false
+          Mongoid::History.enabled? && Mongoid::History.store[track_history_flag] != false
         end
 
         def dynamic_enabled?
@@ -59,20 +47,25 @@ module Mongoid
         end
 
         def disable_tracking(&_block)
-          Thread.current[track_history_flag] = false
+          Mongoid::History.store[track_history_flag] = false
           yield
         ensure
-          Thread.current[track_history_flag] = true
+          Mongoid::History.store[track_history_flag] = true
         end
 
         def track_history_flag
           "mongoid_history_#{name.underscore}_trackable_enabled".to_sym
         end
+
+        def tracker_class
+          klass = history_trackable_options[:tracker_class_name] || Mongoid::History.tracker_class_name
+          klass.is_a?(Class) ? klass : klass.to_s.camelize.constantize
+        end
       end
 
       module MyInstanceMethods
         def history_tracks
-          @history_tracks ||= Mongoid::History.tracker_class.where(
+          @history_tracks ||= self.class.tracker_class.where(
             scope: related_scope,
             association_chain: association_hash
           ).asc(:version)
@@ -212,21 +205,15 @@ module Mongoid
         end
 
         def modified_attributes_for_update
-          @modified_attributes_for_update ||= send(history_trackable_options[:changes_method]).select { |k, _| self.class.tracked_field?(k, :update) }
+          @modified_attributes_for_update ||= Mongoid::History::Attributes::Update.new(self).attributes
         end
 
         def modified_attributes_for_create
-          @modified_attributes_for_create ||= attributes.inject({}) do |h, (k, v)|
-            h[k] = [nil, v]
-            h
-          end.select { |k, _| self.class.tracked_field?(k, :create) }
+          @modified_attributes_for_create ||= Mongoid::History::Attributes::Create.new(self).attributes
         end
 
         def modified_attributes_for_destroy
-          @modified_attributes_for_destroy ||= attributes.inject({}) do |h, (k, v)|
-            h[k] = [v, nil]
-            h
-          end.select { |k, _| self.class.tracked_field?(k, :destroy) }
+          @modified_attributes_for_destroy ||= Mongoid::History::Attributes::Destroy.new(self).attributes
         end
 
         def history_tracker_attributes(action)
@@ -286,13 +273,99 @@ module Mongoid
           if track_history_for_action?(action)
             current_version = (send(history_trackable_options[:version_field]) || 0) + 1
             send("#{history_trackable_options[:version_field]}=", current_version)
-            Mongoid::History.tracker_class.create!(history_tracker_attributes(action.to_sym).merge(version: current_version, action: action.to_s, trackable: self))
+            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
         end
       end
 
+      module EmbeddedMethods
+        # Indicates whether there is an Embedded::One relation for the given embedded field.
+        #
+        # @param [ String | Symbol ] embed The name of the embedded 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
+        end
+
+        # Return the class for embeds_one relation
+        #
+        # @param [ String ] field The database field name for embedded relation
+        #
+        # @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
+        end
+
+        # Indicates whether there is an Embedded::Many relation for the given embedded field.
+        #
+        # @param [ String | Symbol ] embed 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
+        end
+
+        # Return the class for embeds_many relation
+        #
+        # @param [ String ] field The database field name for embedded relation
+        #
+        # @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
+        end
+
+        # Retrieves the database representation of an embedded field name, in case the :store_as option is used.
+        #
+        # @param [ String | Symbol ] embed The name or alias of the embedded field
+        #
+        # @return [ String ] the database name of the embedded field
+        def embedded_alias(embed)
+          embedded_aliases[embed]
+        end
+
+        protected
+
+        # 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
+            h
+          end
+        end
+
+        def relation_of(embed)
+          meta = reflect_on_association(embedded_alias(embed))
+          meta ? meta.relation : nil
+        end
+      end
+
       module SingletonMethods
+        # Whether or not the field or embedded relation should be tracked.
+        #
+        # @param [ String | Symbol ] field_or_relation The name or alias of the field OR the name of embedded relation
+        # @param [ String | Symbol ] action The optional action name (:create, :update, or :destroy)
+        #
+        # @return [ Boolean ] whether or not the field or embedded relation is tracked for the given action
+        def tracked?(field_or_relation, action = :update)
+          tracked_field?(field_or_relation, action) || tracked_relation?(field_or_relation)
+        end
+
         # Whether or not the field should be tracked.
         #
         # @param [ String | Symbol ] field The name or alias of the field
@@ -309,7 +382,9 @@ module Mongoid
         #
         # @return [ Boolean ] whether or not the field is dynamic
         def dynamic_field?(field)
-          dynamic_enabled? && !fields.keys.include?(database_field_name(field))
+          dynamic_enabled? &&
+            !fields.keys.include?(database_field_name(field)) &&
+            !embedded_relations.map { |_, v| v.key }.include?(database_field_name(field))
         end
 
         # Retrieves the list of tracked fields for a given action.
@@ -328,10 +403,7 @@ module Mongoid
         #
         # @return [ Array < String > ] the base list of tracked database field names
         def tracked_fields
-          @tracked_fields ||= begin
-            h = history_trackable_options
-            (h[:on] == :all ? fields.keys : h[:on]) - h[:except] - reserved_tracked_fields
-          end
+          @tracked_fields ||= history_trackable_options[:fields] + history_trackable_options[:dynamic]
         end
 
         # Retrieves the memoized list of reserved tracked fields, which are only included for certain actions.
@@ -341,52 +413,78 @@ module Mongoid
           @reserved_tracked_fields ||= ['_id', history_trackable_options[:version_field].to_s, "#{history_trackable_options[:modifier_field]}_id"]
         end
 
-        def history_trackable_options
-          @history_trackable_options ||= Mongoid::History.trackable_class_options[collection_name.to_s.singularize.to_sym]
+        # Whether or not the relation should be tracked.
+        #
+        # @param [ String | Symbol ] relation The name of the relation
+        #
+        # @return [ Boolean ] whether or not the relation is tracked
+        def tracked_relation?(relation)
+          tracked_embeds_one?(relation) || tracked_embeds_many?(relation)
         end
 
-        # Indicates whether there is an Embedded::One relation for the given embedded field.
+        # Whether or not the embeds_one relation should be tracked.
         #
-        # @param [ String | Symbol ] embed The name of the embedded field
+        # @param [ String | Symbol ] relation The name of the embeds_one relation
         #
-        # @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 [ Boolean ] whether or not the embeds_one relation is tracked
+        def tracked_embeds_one?(relation)
+          tracked_embeds_one.include?(database_field_name(relation))
         end
 
-        # Indicates whether there is an Embedded::Many relation for the given embedded field.
-        #
-        # @param [ String | Symbol ] embed The name of the embedded field
+        # Retrieves the memoized list of tracked embeds_one relations
         #
-        # @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 [ Array < String > ] the list of tracked embeds_one relations
+        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 }
+          end
         end
 
-        # Retrieves the database representation of an embedded field name, in case the :store_as option is used.
+        def tracked_embeds_one_attributes(relation)
+          history_trackable_options[:relations][:embeds_one][database_field_name(relation)]
+        end
+
+        # Whether or not the embeds_many relation should be tracked.
         #
-        # @param [ String | Symbol ] embed The name or alias of the embedded field
+        # @param [ String | Symbol ] relation The name of the embeds_many relation
         #
-        # @return [ String ] the database name of the embedded field
-        def embedded_alias(embed)
-          embedded_aliases[embed]
+        # @return [ Boolean ] whether or not the embeds_many relation is tracked
+        def tracked_embeds_many?(relation)
+          tracked_embeds_many.include?(database_field_name(relation))
         end
 
-        protected
-
-        # Retrieves the memoized hash of embedded aliases and their associated database representations.
+        # Retrieves the memoized list of tracked embeds_many relations
         #
-        # @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
-            h
+        # @return [ Array < String > ] the list of tracked embeds_many relations
+        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 }
           end
         end
 
-        def relation_of(embed)
-          meta = reflect_on_association(embedded_alias(embed))
-          meta ? meta.relation : nil
+        def tracked_embeds_many_attributes(relation)
+          history_trackable_options[:relations][:embeds_many][database_field_name(relation)]
+        end
+
+        def trackable_scope
+          collection_name.to_s.singularize.to_sym
+        end
+
+        def history_trackable_options
+          @history_trackable_options ||= Mongoid::History.trackable_class_options[trackable_scope]
+        end
+
+        def clear_trackable_memoization
+          @reserved_tracked_fields = nil
+          @history_trackable_options = nil
+          @trackable_settings = nil
+          @tracked_fields = nil
+          @tracked_embeds_one = nil
+          @tracked_embeds_many = nil
         end
       end
     end