acts-as-taggable-on-mongoid 6.0.1.5 → 6.1.1.7

data/lib/acts_as_taggable_on_mongoid/taggable.rb

@@ -34,6 +34,18 @@ module ActsAsTaggableOnMongoid
       #     can be used.  If custom options like `parse` or `parser` are to be used for the default, the value
       #     must be passed in as an array with a hash as the last value.  Like list setters, parsing is assumed.
       #     Example:  default: ["this, is, a, list", parser: ActsAsTaggableOnMongoid::GenericParser]
+      #   * tagger
+      #     Multiple variants
+      #
+      #     true - If simply the value `true`, the tag list supports owners.  No default owner will be used when
+      #            setting or accessing tag_lists
+      #     Hash - A hash of values defining default options for the tag list:
+      #            * default_tagger
+      #              A symbol of a method on the taggable object that owns the HashList which is used to determine
+      #              the default owner for a list if an owner is not specified.
+      #            * tag_list_uses_default_tagger
+      #              true/false indicating if a non-owner method that returns a tag_list should assume the default_tagger
+      #              or return items with no owner.
 
       ##
       # This is an alias for calling <tt>acts_as_taggable_on :tags</tt>.
@@ -111,8 +123,8 @@ module ActsAsTaggableOnMongoid
          ActsAsTaggableOnMongoid::Taggable::TaggedWith,
          # include Collection - not sure we will need as done here.  Need to think more on this one.
          # include Cache - TODO: Add this.
-         # include Ownership - TODO: Add this.
          # include Related - TODO: Add this.
+         ActsAsTaggableOnMongoid::Taggable::TaggerRelation,
          ActsAsTaggableOnMongoid::Taggable::ListTags].each do |include_module|
           include include_module unless included_modules.include?(include_module)
         end

data/lib/acts_as_taggable_on_mongoid/taggable/changeable.rb

@@ -40,9 +40,9 @@ module ActsAsTaggableOnMongoid
         tag_types.each_value do |tag_definition|
           tag_list_name = tag_definition.tag_list_name
 
-          next unless changed_attributes.key? tag_list_name
+          next unless public_send("#{tag_list_name}_changed?")
 
-          changed_values[tag_list_name] = [changed_attributes[tag_list_name], public_send(tag_list_name)]
+          changed_values[tag_list_name] = public_send("#{tag_list_name}_change")
         end
 
         changed_values
@@ -60,11 +60,12 @@ module ActsAsTaggableOnMongoid
       private
 
       def attribute_will_change!(attribute_name)
-        return super if tag_types.none? { |_tag_name, tag_definition| tag_definition.tag_list_name.to_s == attribute_name.to_s }
+        tag_definition = tag_types.detect { |_tag_name, tag_def| tag_def.tag_list_name.to_s == attribute_name.to_s }&.last
+        return super if tag_definition.blank?
 
         return if changed_attributes.key?(attribute_name)
 
-        changed_attributes[attribute_name] = public_send(attribute_name)&.dup
+        changed_attributes[attribute_name] = tag_list_cache_on(tag_definition)&.dup
       end
     end
   end

data/lib/acts_as_taggable_on_mongoid/taggable/core.rb

@@ -40,14 +40,99 @@ module ActsAsTaggableOnMongoid
         end
       end
 
-      def apply_pre_processed_defaults
-        super
+      def apply_post_processed_defaults
+        defaults = super
 
-        set_tag_list_defaults
+        defaults |= set_tag_list_defaults
+
+        defaults
       end
 
       private
 
+      def set_tag_list(tag_definition, new_tags)
+        dup_tags        = Array.wrap(new_tags).dup
+        options         = dup_tags.extract_options!.dup
+        options[:parse] = options.fetch(:parse) { true }
+
+        new_list          = tag_definition.parse(*dup_tags, options)
+        new_list.taggable = self
+        new_list.tagger   = tag_definition.tag_list_default_tagger(self) unless options.key?(:tagger)
+
+        mark_tag_list_changed(new_list)
+        tag_list_set(new_list)
+      end
+
+      def get_tag_list_change(tag_definition)
+        tag_list_name = tag_definition.tag_list_name
+
+        return nil unless public_send("#{tag_list_name}_changed?")
+
+        changed_value = new_record? ? tag_definition.default_tagger_tag_list(self) : changed_attributes[tag_list_name]
+        current_value = tag_list_cache_on(tag_definition)
+
+        return nil if (changed_value <=> current_value)&.zero?
+
+        tag_list_change_value(tag_definition, changed_value, current_value)
+      end
+
+      def tag_list_change_value(tag_definition, changed_value, current_value)
+        if tag_definition.tagger?
+          [changed_value.dup, current_value.dup]
+        else
+          [changed_value[nil].dup, current_value[nil].dup]
+        end
+      end
+
+      def get_tag_list_changed(tag_definition)
+        tag_list_name = tag_definition.tag_list_name
+
+        return false unless changed_attributes.key?(tag_list_name)
+
+        changed_value = new_record? ? tag_definition.default_tagger_tag_list(self) : changed_attributes[tag_list_name]
+        current_value = tag_list_cache_on(tag_definition)
+
+        !(changed_value <=> current_value)&.zero?
+      end
+
+      def get_tag_list_was(tag_definition)
+        default_tagger = tag_definition.tag_list_default_tagger(self)
+        return tag_definition.default_tagger_tag_list(self)[default_tagger].dup if new_record?
+
+        tag_list_name = tag_definition.tag_list_name
+
+        if public_send "#{tag_list_name}_changed?"
+          changed_attributes[tag_list_name][default_tagger].dup
+        else
+          public_send(tag_list_name).dup
+        end
+      end
+
+      def get_tag_lists_was(tag_definition)
+        return tag_definition.default_tagger_tag_list(self).dup if new_record?
+
+        tag_list_name = tag_definition.tag_list_name
+
+        if public_send "#{tag_list_name}_changed?"
+          changed_attributes[tag_list_name].dup
+        else
+          public_send(tag_definition.tagger_tag_lists_name).dup
+        end
+      end
+
+      def get_tagger_list_was(tag_definition, tagger)
+        return nil unless tag_definition.tagger?
+        return tag_definition.default_tagger_tag_list(self)[tagger].dup if new_record?
+
+        tag_list_name = tag_definition.tag_list_name
+
+        if public_send "#{tag_list_name}_changed?"
+          changed_attributes[tag_list_name][tagger].dup
+        else
+          public_send(tag_definition.tagger_tag_list_name, tagger).dup
+        end
+      end
+
       def tag_list_cache_set_on(tag_definition)
         variable_name = tag_definition.tag_list_variable_name
 
@@ -66,35 +151,57 @@ module ActsAsTaggableOnMongoid
         # end
 
         instance_variable_get(variable_name) ||
-            tag_list_set(ActsAsTaggableOnMongoid::TagList.new(tag_definition, tags_on(tag_definition).map(&:tag_name)))
+            tagger_tag_list_set(tagger_tag_list_from_taggings(tag_definition, all_tags_on(tag_definition)))
+      end
+
+      def tagger_tag_list_from_taggings(tag_definition, taggings)
+        tagger_tag_list = ActsAsTaggableOnMongoid::TaggerTagList.new(tag_definition, self)
+
+        taggings.each do |tagging|
+          tagger_tag_list[tagging.tagger].silent_concat [tagging.tag_name]
+        end
+
+        tagger_tag_list
       end
 
       def tag_list_on(tag_definition)
         # add_custom_context(tag_definition)
 
-        tag_list_cache_on(tag_definition)
+        tag_list_cache_on(tag_definition)[tag_definition.tag_list_default_tagger(self)]
       end
 
       def all_tags_list_on(tag_definition)
-        variable_name   = tag_definition.all_tag_list_variable_name
-        cached_variable = instance_variable_get(variable_name)
-
-        return cached_variable if instance_variable_defined?(variable_name) && cached_variable
-
-        instance_variable_set(variable_name, ActsAsTaggableOnMongoid::TagList.new(tag_definition, all_tags_on(tag_definition).map(&:name)).freeze)
+        tag_list_on(tag_definition).flatten
       end
 
       ##
       # Returns all tags of a given context
       def all_tags_on(tag_definition)
-        tag_definition.tags_table.for_tag(tag_definition).to_a
+        scope = public_send(tag_definition.taggings_name).where(context: tag_definition.tag_type)
+
+        # when preserving tag order, return tags in created order
+        # if we added the order to the association this would always apply
+        scope = scope.order_by(*tag_definition.taggings_order) if tag_definition.preserve_tag_order?
+
+        scope
       end
 
       ##
       # Returns all tags that are not owned of a given context
       def tags_on(tag_definition)
-        # scope = public_send(tag_definition.taggings_name).where(context: tag_definition.tag_type, tagger_id: nil)
-        scope = public_send(tag_definition.taggings_name).where(context: tag_definition.tag_type)
+        scope = public_send(tag_definition.taggings_name).where(context: tag_definition.tag_type, :tagger_id.exists => false)
+
+        # when preserving tag order, return tags in created order
+        # if we added the order to the association this would always apply
+        scope = scope.order_by(*tag_definition.taggings_order) if tag_definition.preserve_tag_order?
+
+        scope
+      end
+
+      ##
+      # Returns all tags that are owned by a given tagger of a given context
+      def tagger_tags_on(tagger, tag_definition)
+        scope = public_send(tag_definition.taggings_name).where(context: tag_definition.tag_type, tagger: tagger)
 
         # when preserving tag order, return tags in created order
         # if we added the order to the association this would always apply
@@ -105,41 +212,56 @@ module ActsAsTaggableOnMongoid
 
       def mark_tag_list_changed(new_list)
         tag_definition   = new_list.tag_definition
-        current_tag_list = public_send(tag_definition.tag_list_name)
+        current_tag_list = tag_list_cache_on(tag_definition)
 
-        if (tag_definition.preserve_tag_order? && new_list != current_tag_list) ||
-            new_list.sort != current_tag_list.sort
-          current_tag_list.notify_will_change
-        end
+        return if current_tag_list == new_list
+
+        current_tag_list.notify_will_change
+      end
+
+      def tagger_tag_list_set(new_list)
+        instance_variable_set(new_list.tag_definition.tag_list_variable_name, new_list)
       end
 
       def tag_list_set(new_list)
         # add_custom_context(tag_definition, owner)
 
         new_list.taggable = self
+        tag_definition    = new_list.tag_definition
+        tagger_tag_list   = ActsAsTaggableOnMongoid::TaggerTagList.new(tag_definition, self)
 
-        instance_variable_set(new_list.tag_definition.tag_list_variable_name, new_list)
+        tagger_tag_list[new_list.tagger] = new_list
+
+        instance_variable_set(tag_definition.tag_list_variable_name, tagger_tag_list)
       end
 
       ##
       # Find existing tags or create non-existing tags
-      def load_tags(tag_definition, tag_list)
-        tag_definition.tags_table.find_or_create_all_with_like_by_name(tag_definition, tag_list)
+      def load_tags(tag_definition, tagger_tag_list)
+        tag_definition.tags_table.find_or_create_tagger_list_with_like_by_name(tag_definition, tagger_tag_list)
       end
 
       def set_tag_list_defaults
-        return unless new_record?
+        return [] unless new_record?
 
+        defaulted_values = []
         tag_types.each_value do |tag_definition|
-          default = tag_definition.default
+          next if instance_variable_defined?(tag_definition.tag_list_variable_name)
+
+          default = tag_definition.taggable_default(self)
           next unless default.present?
 
-          tag_list_name = tag_definition.tag_list_name
-          next if public_send(tag_list_name).present?
+          set_default_value(tag_definition, default)
 
-          public_send("#{tag_list_name}=", default)
-          changed_attributes.delete tag_list_name
+          defaulted_values << tag_definition.tag_list_name
         end
+
+        defaulted_values
+      end
+
+      def set_default_value(tag_definition, default)
+        public_send(tag_definition.tagger_tag_lists_name)[default.tagger] = default
+        changed_attributes.delete tag_definition.tag_list_name
       end
 
       def save_tags
@@ -167,11 +289,11 @@ module ActsAsTaggableOnMongoid
       end
 
       def extract_tag_list_changes(tag_definition)
-        tag_list = tag_list_cache_on(tag_definition).uniq
+        tag_list = tag_list_cache_on(tag_definition)
 
         # Find existing tags or create non-existing tags:
         tags         = find_or_create_tags_from_list_with_context(tag_definition, tag_list)
-        current_tags = tags_on(tag_definition).map(&:tag).compact
+        current_tags = all_tags_on(tag_definition)
 
         tag_list_diff = ActsAsTaggableOnMongoid::Taggable::Utils::TagListDiff.new tag_definition: tag_definition,
                                                                                   tags:           tags,
@@ -210,10 +332,10 @@ module ActsAsTaggableOnMongoid
       #       end
       #     end
       #
-      # @param [Array<String>] tag_list Tags to find or create
-      # @param [Symbol] context The tag context for the tag_list
-      def find_or_create_tags_from_list_with_context(tag_definition, tag_list)
-        load_tags(tag_definition, tag_list)
+      # @param [Array<String>] tagger_tag_list Tags to find or create grouped by tagger
+      # @param [Symbol] tag_definition The tag context for the tag_list
+      def find_or_create_tags_from_list_with_context(tag_definition, tagger_tag_list)
+        load_tags(tag_definition, tagger_tag_list)
       end
     end
   end

data/lib/acts_as_taggable_on_mongoid/taggable/tag_type_definition.rb

@@ -13,27 +13,20 @@ module ActsAsTaggableOnMongoid
       attr_reader :owner,
                   :tag_type
 
+      include ActsAsTaggableOnMongoid::Taggable::TagTypeDefinition::ListMethods
       include ActsAsTaggableOnMongoid::Taggable::TagTypeDefinition::Attributes
       include ActsAsTaggableOnMongoid::Taggable::TagTypeDefinition::Names
       include ActsAsTaggableOnMongoid::Taggable::TagTypeDefinition::Changeable
 
       def initialize(owner, tag_type, options = {})
-        options = options.dup
+        options = ActsAsTaggableOnMongoid::Taggable::TagTypeDefinition.extract_tag_definition_options(options)
 
-        options.assert_valid_keys(:parser,
-                                  :preserve_tag_order,
-                                  :cached_in_model,
-                                  :force_lowercase,
-                                  :force_parameterize,
-                                  :remove_unused_tags,
-                                  :tags_table,
-                                  :taggings_table,
-                                  :default)
-
-        self.default_value = options.delete(:default)
+        default_option = options.delete(:default)
 
         save_options(options)
 
+        self.default_value = default_option
+
         @owner    = owner
         @tag_type = tag_type
       end
@@ -48,7 +41,7 @@ module ActsAsTaggableOnMongoid
                       tags_table
                       taggings_table].each_with_object({}) { |dup_key, opts_hash| opts_hash[dup_key] = tag_definition.public_send(dup_key) }
 
-        dup_hash[:default] = [tag_definition.default, parse: false]
+        dup_hash[:default] = tag_definition.default.dup
 
         ActsAsTaggableOnMongoid::Taggable::TagTypeDefinition.new klass,
                                                                  tag_definition.tag_type,
@@ -155,55 +148,41 @@ module ActsAsTaggableOnMongoid
       def add_tag_list
         add_list_getter
         add_list_setter
+        add_tag_list_from
+        add_tagger_tag_list
+        add_tagger_tag_lists
         add_all_list_getter
         add_list_exists
+
+        add_tag_list_change_methods
+      end
+
+      def add_tag_list_change_methods
         add_list_change
         add_list_changed
         add_changed_from_default?
         add_will_change
         add_get_was
+        add_get_lists_was
+        add_tagger_get_was
         add_reset_list
         add_reset_to_default
       end
 
-      def add_list_getter
-        tag_definition = self
-        tag_list_name  = tag_definition.tag_list_name
-
-        owner.taggable_mixin.module_eval do
-          define_method(tag_list_name) do
-            tag_list_on tag_definition
-          end
-
-          alias_method "#{tag_list_name}_before_type_cast".to_sym, tag_list_name.to_sym
-        end
-      end
-
-      def add_list_setter
-        tag_definition = self
-
-        owner.taggable_mixin.module_eval do
-          define_method("#{tag_definition.tag_list_name}=") do |new_tags|
-            dup_tags        = Array.wrap(new_tags).dup
-            options         = dup_tags.extract_options!.dup
-            options[:parse] = options.fetch(:parse) { true }
-
-            new_list = tag_definition.parse(*dup_tags, options)
-
-            mark_tag_list_changed(new_list)
-            tag_list_set(new_list)
-          end
-        end
-      end
-
-      def add_all_list_getter
-        tag_definition = self
+      def self.extract_tag_definition_options(options)
+        options = options.dup
 
-        owner.taggable_mixin.module_eval do
-          define_method(tag_definition.all_tag_list_name) do
-            all_tags_list_on tag_definition
-          end
-        end
+        options.assert_valid_keys(:parser,
+                                  :preserve_tag_order,
+                                  :cached_in_model,
+                                  :force_lowercase,
+                                  :force_parameterize,
+                                  :remove_unused_tags,
+                                  :tags_table,
+                                  :taggings_table,
+                                  :default,
+                                  :tagger)
+        options
       end
 
       private

data/lib/acts_as_taggable_on_mongoid/taggable/tag_type_definition/attributes.rb

@@ -3,11 +3,7 @@
 module ActsAsTaggableOnMongoid
   module Taggable
     class TagTypeDefinition
-      # This module extracts out the basic configuration type attributes of the tag definition.
-      #
-      # All attributes are based off of the Configuration class and in fact will default to
-      # the corresponding value in the configuration if not explicitly specified/set when the
-      # tag is defined.
+      # This module defines methods used to evaluate the attributes of the Tag Type Definition
       module Attributes
         attr_reader :cached_in_model,
                     :default
@@ -62,14 +58,69 @@ module ActsAsTaggableOnMongoid
         alias force_parameterize? force_parameterize
         alias remove_unused_tags? remove_unused_tags
 
+        def tagger?
+          instance_variable_defined?(:@tagger)
+        end
+
+        def tag_list_uses_default_tagger?
+          return false if !tagger? || default_tagger_method.blank?
+
+          tagger_params.fetch(:tag_list_uses_default_tagger) { false }
+        end
+
+        def default_tagger_method
+          return nil unless tagger?
+
+          tagger_params[:default_tagger]
+        end
+
+        # :reek:FeatureEnvy
+        # :reek:DuplicateMethodCall
+        def taggable_default(taggable)
+          default_list = default
+
+          return unless default_list.present?
+
+          default_list          = default_list.dup
+          default_list.taggable = taggable
+          default_list.tagger   = default_list.tagger
+
+          default_list
+        end
+
+        def default_tagger(taggable)
+          return nil if default_tagger_method.nil?
+          return nil if taggable.blank?
+
+          taggable.public_send(default_tagger_method)
+        end
+
+        def tag_list_default_tagger(taggable)
+          return nil unless tag_list_uses_default_tagger?
+
+          default_tagger(taggable)
+        end
+
         private
 
+        def tagger_params
+          return @tagger_params if defined?(@tagger_params)
+
+          params = instance_variable_get(:@tagger)
+
+          @tagger_params = if tagger? && params.is_a?(Hash)
+                             params.with_indifferent_access
+                           else
+                             HashWithIndifferentAccess.new
+                           end
+        end
+
         def default_value=(value)
           dup_value       = Array.wrap(value).dup
           options         = dup_value.extract_options!.dup
           options[:parse] = options.fetch(:parse) { true }
 
-          @default = ActsAsTaggableOnMongoid::TagList.new self, dup_value, options
+          @default = ActsAsTaggableOnMongoid::TagList.new self, *dup_value, options
         end
       end
     end