mongoid-history 0.8.0 → 0.8.5

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

@@ -1,45 +1,104 @@
-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] = format_field(k, v) unless v.all?(&:blank?)
-            end
-          end
-          @attributes
-        end
-
-        private
-
-        def insert_embeds_one_changes(relation, value)
-          relation = trackable_class.database_field_name(relation)
-          relation_class = trackable_class.embeds_one_class(relation)
-          paranoia_field = Mongoid::History.trackable_class_settings(relation_class)[:paranoia_field]
-          original_value = value[0][paranoia_field].present? ? {} : format_embeds_one_relation(relation, value[0])
-          modified_value = value[1][paranoia_field].present? ? {} : format_embeds_one_relation(relation, value[1])
-          return if original_value == modified_value
-          @attributes[relation] = [original_value, modified_value]
-        end
-
-        def insert_embeds_many_changes(relation, value)
-          relation = trackable_class.database_field_name(relation)
-          relation_class = trackable_class.embeds_many_class(relation)
-          paranoia_field = Mongoid::History.trackable_class_settings(relation_class)[:paranoia_field]
-          original_value = value[0].reject { |rel| rel[paranoia_field].present? }
-                                   .map { |v_attrs| format_embeds_many_relation(relation, v_attrs) }
-          modified_value = value[1].reject { |rel| rel[paranoia_field].present? }
-                                   .map { |v_attrs| format_embeds_many_relation(relation, v_attrs) }
-          return if original_value == modified_value
-          @attributes[relation] = [original_value, modified_value]
-        end
-      end
-    end
-  end
-end
+module Mongoid
+  module History
+    module Attributes
+      class Update < ::Mongoid::History::Attributes::Base
+        # @example when both an attribute `foo` and a child's attribute `nested_bar.baz` are changed
+        #
+        #   {
+        #     'foo' => ['foo_before_changes', 'foo_after_changes']
+        #     'nested_bar.baz' => ['nested_bar_baz_before_changes', 'nested_bar_baz_after_changes']
+        #     }
+        #   }
+        #
+        # @return [Hash<String, Array<(?,?)>>] Hash of changes
+        def attributes
+          changes_from_parent.deep_merge(changes_from_children)
+        end
+
+        private
+
+        def changes_from_parent
+          parent_changes = {}
+          changes.each do |k, v|
+            change_value = begin
+              if trackable_class.tracked_embeds_one?(k)
+                embeds_one_changes_from_parent(k, v)
+              elsif trackable_class.tracked_embeds_many?(k)
+                embeds_many_changes_from_parent(k, v)
+              elsif trackable_class.tracked?(k, :update)
+                { k => format_field(k, v) } unless v.all?(&:blank?)
+              end
+            end
+            parent_changes.merge!(change_value) if change_value.present?
+          end
+          parent_changes
+        end
+
+        def changes_from_children
+          embeds_one_changes_from_embedded_documents
+        end
+
+        # Retrieve the list of changes applied directly to the nested documents
+        #
+        # @example when a child's name is changed from "todd" to "mario"
+        #
+        #   child = Child.new(name: 'todd')
+        #   Parent.create(child: child)
+        #   child.name = "Mario"
+        #
+        #   embeds_one_changes_from_embedded_documents # when called from "Parent"
+        #   # => { "child.name"=>["todd", "mario"] }
+        #
+        # @return [Hash<String, Array<(?,?)>] changes of embeds_ones from embedded documents
+        def embeds_one_changes_from_embedded_documents
+          embedded_doc_changes = {}
+          trackable_class.tracked_embeds_one.each do |rel|
+            rel_class = trackable_class.relation_class_of(rel)
+            paranoia_field = Mongoid::History.trackable_class_settings(rel_class)[:paranoia_field]
+            paranoia_field = rel_class.aliased_fields.key(paranoia_field) || paranoia_field
+            rel = aliased_fields.key(rel) || rel
+            obj = trackable.send(rel)
+            next if !obj || (obj.respond_to?(paranoia_field) && obj.public_send(paranoia_field).present?)
+
+            obj.changes.each do |k, v|
+              embedded_doc_changes["#{rel}.#{k}"] = [v.first, v.last]
+            end
+          end
+          embedded_doc_changes
+        end
+
+        # @param [String] relation
+        # @param [String] value
+        #
+        # @return [Hash<String, Array<(?,?)>>]
+        def embeds_one_changes_from_parent(relation, value)
+          relation = trackable_class.database_field_name(relation)
+          relation_class = trackable_class.relation_class_of(relation)
+          paranoia_field = Mongoid::History.trackable_class_settings(relation_class)[:paranoia_field]
+          original_value = value[0][paranoia_field].present? ? {} : format_embeds_one_relation(relation, value[0])
+          modified_value = value[1][paranoia_field].present? ? {} : format_embeds_one_relation(relation, value[1])
+          return if original_value == modified_value
+
+          { relation => [original_value, modified_value] }
+        end
+
+        # @param [String] relation
+        # @param [String] value
+        #
+        # @return [Hash<Array<(?,?)>>]
+        def embeds_many_changes_from_parent(relation, value)
+          relation = trackable_class.database_field_name(relation)
+          relation_class = trackable_class.relation_class_of(relation)
+          paranoia_field = Mongoid::History.trackable_class_settings(relation_class)[:paranoia_field]
+          original_value = value[0].reject { |rel| rel[paranoia_field].present? }
+                                   .map { |v_attrs| format_embeds_many_relation(relation, v_attrs) }
+          modified_value = value[1].reject { |rel| rel[paranoia_field].present? }
+                                   .map { |v_attrs| format_embeds_many_relation(relation, v_attrs) }
+          return if original_value == modified_value
+
+          { relation => [original_value, modified_value] }
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/history/options.rb

@@ -1,179 +1,177 @@
-module Mongoid
-  module History
-    class Options
-      attr_reader :trackable, :options
-
-      def initialize(trackable, opts = {})
-        @trackable = trackable
-        @options = default_options.merge(opts)
-      end
-
-      def scope
-        trackable.collection_name.to_s.singularize.to_sym
-      end
-
-      def prepared
-        @prepared ||= begin
-          prepare_skipped_fields
-          prepare_formatted_fields
-          parse_tracked_fields_and_relations
-          options
-        end
-      end
-
-      private
-
-      def default_options
-        @default_options ||=
-          { on: :all,
-            except: %i[created_at updated_at],
-            tracker_class_name: nil,
-            modifier_field: :modifier,
-            version_field: :version,
-            changes_method: :changes,
-            scope: scope,
-            track_create: true,
-            track_update: true,
-            track_destroy: true,
-            format: nil }
-      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 prepare_formatted_fields
-        formats = {}
-
-        if options[:format].class == Hash
-          options[:format].each do |field, format|
-            next if field.nil?
-
-            field = trackable.database_field_name(field)
-
-            if format.class == Hash && trackable.embeds_many?(field)
-              relation_class = trackable.embeds_many_class(field)
-              formats[field] = format.inject({}) { |a, e| a.merge(relation_class.database_field_name(e.first) => e.last) }
-            elsif format.class == Hash && trackable.embeds_one?(field)
-              relation_class = trackable.embeds_one_class(field)
-              formats[field] = format.inject({}) { |a, e| a.merge(relation_class.database_field_name(e.first) => e.last) }
-            else
-              formats[field] = format
-            end
-          end
-        end
-
-        options[:format] = formats
-      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])
-
-        @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
-
-        if options[:on].include?(:embedded_relations)
-          @options[:on] = options[:on].reject { |opt| opt == :embedded_relations }
-          @options[:on] = options[:on] | trackable.embedded_relations.keys
-        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
+module Mongoid
+  module History
+    class Options
+      attr_reader :trackable, :options
+
+      def initialize(trackable, opts = {})
+        @trackable = trackable
+        @options = default_options.merge(opts)
+      end
+
+      def scope
+        trackable.collection_name.to_s.singularize.to_sym
+      end
+
+      def prepared
+        return @prepared if @prepared
+        @prepared = options.dup
+        prepare_skipped_fields
+        prepare_formatted_fields
+        parse_tracked_fields_and_relations
+        @prepared
+      end
+
+      private
+
+      def default_options
+        { on: :all,
+          except: %i[created_at updated_at],
+          tracker_class_name: nil,
+          modifier_field: :modifier,
+          version_field: :version,
+          changes_method: :changes,
+          scope: scope,
+          track_create: true,
+          track_update: true,
+          track_destroy: true,
+          format: nil }
+      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
+        @prepared[:except] = Array(@prepared[:except])
+        @prepared[:except] = @prepared[:except].map { |field| trackable.database_field_name(field) }.compact.uniq
+      end
+
+      def prepare_formatted_fields
+        formats = {}
+
+        if @prepared[:format].class == Hash
+          @prepared[:format].each do |field, format|
+            next if field.nil?
+
+            field = trackable.database_field_name(field)
+
+            if format.class == Hash && trackable.embeds_many?(field)
+              relation_class = trackable.relation_class_of(field)
+              formats[field] = format.inject({}) { |a, e| a.merge(relation_class.database_field_name(e.first) => e.last) }
+            elsif format.class == Hash && trackable.embeds_one?(field)
+              relation_class = trackable.relation_class_of(field)
+              formats[field] = format.inject({}) { |a, e| a.merge(relation_class.database_field_name(e.first) => e.last) }
+            else
+              formats[field] = format
+            end
+          end
+        end
+
+        @prepared[:format] = formats
+      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
+        @prepared[:on] = Array(@prepared[:on])
+
+        @prepared[:on] = @prepared[:on].map { |opt| opt == :all ? :fields : opt }
+
+        if @prepared[:on].include?(:fields)
+          @prepared[:on] = @prepared[:on].reject { |opt| opt == :fields }
+          @prepared[:on] = @prepared[:on] | trackable.fields.keys.map(&:to_sym) - reserved_fields.map(&:to_sym)
+        end
+
+        if @prepared[:on].include?(:embedded_relations)
+          @prepared[:on] = @prepared[:on].reject { |opt| opt == :embedded_relations }
+          @prepared[:on] = @prepared[:on] | trackable.embedded_relations.keys
+        end
+
+        @prepared[:fields] = []
+        @prepared[:dynamic] = []
+        @prepared[:relations] = { embeds_one: {}, embeds_many: {} }
+
+        @prepared[:on].each do |option|
+          if option.is_a?(Hash)
+            option.each { |k, v| split_and_categorize(k => v) }
+          else
+            split_and_categorize(option)
+          end
+        end
+      end
+
+      def split_and_categorize(field_and_options)
+        field = get_database_field_name(field_and_options)
+        field_options = get_field_options(field_and_options)
+        categorize_tracked_option(field, field_options)
+      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 @prepared[:except].include?(field)
+        return if reserved_fields.include?(field)
+
+        field_options = Array(field_options)
+
+        if trackable.embeds_one?(field)
+          track_relation(field, :embeds_one, field_options)
+        elsif trackable.embeds_many?(field)
+          track_relation(field, :embeds_many, field_options)
+        elsif trackable.fields.keys.include?(field)
+          @prepared[:fields] << field
+        else
+          @prepared[:dynamic] << field
+        end
+      end
+
+      def track_relation(field, kind, field_options)
+        relation_class = trackable.relation_class_of(field)
+        @prepared[:relations][kind][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', @prepared[:version_field].to_s, "#{@prepared[:modifier_field]}_id"]
+      end
+    end
+  end
+end